The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Record-level sharing 5: one row access policy for queries, events and writes (#27068)
Félix Malfait46362ca1e86d
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.tsindex c28efcc1198..a90b0d9f90d 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts@@ -2,62 +2,41 @@import { Injectable } from '@nestjs/common';+import { isNonEmptyString } from '@sniptt/guards';+import groupBy from 'lodash.groupby';import { type ObjectRecordEvent } from 'twenty-shared/database-events';import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';-import { assertUnreachable, isDefined } from 'twenty-shared/utils';-import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-shared/utils';import { In, MoreThanOrEqual } from 'typeorm';-import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';-import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';-import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';import { RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';+import {+ evaluateRowAccessPolicy,+ type RowAccessEvaluationContext,+} from 'src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util';import {type EventRecordSnapshot,resolveEventRecordSnapshots,} from 'src/engine/core-modules/record-share/utils/resolve-event-record-snapshots.util';-import { resolveNamedPrincipalIds } from 'src/engine/core-modules/record-share/utils/resolve-named-principal-ids.util';-import { resolveRecordIdsRestrictedForPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util';-import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';-import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';-import { shouldEnforceRecordShareExceptions } from 'src/engine/core-modules/record-share/utils/should-enforce-record-share-exceptions.util';-import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';-import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/core-modules/record-share/constants/max-inherited-readability-depth.constant';-import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';-import { type InheritedReadabilityChildrenParent } from 'src/engine/core-modules/record-share/types/inherited-readability-children-parent.type';-import { type InheritedReadabilityColumnParent } from 'src/engine/core-modules/record-share/types/inherited-readability-column-parent.type';-import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/types/row-access-policy.type';+import { type InheritedReadabilityParentExpression } from 'src/engine/twenty-orm/types/row-access-policy.type';+import { buildRowAccessPolicy } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';-import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';import { isChildRecordBoundAtDeletion } from 'src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util';-import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';-import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';-import { isOpenWhenDetachedObject } from 'src/engine/core-modules/record-share/utils/is-open-when-detached-object.util';import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';-type ReadabilityMaps = {- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;- flatFieldMetadataMapsOrm: FlatEntityMaps<OrmFlatFieldMetadata>;-};+type ColumnParentExpression = Extract<+ InheritedReadabilityParentExpression,+ { kind: 'column' }+>;-type SnapshotEvaluation = {- workspaceId: string;- objectMetadata: FlatObjectMetadata;- snapshots: EventRecordSnapshot[];- subject: RowAccessPolicySubject;- depth: number;- maps?: ReadabilityMaps;-};--type SnapshotEvaluationInContext = SnapshotEvaluation & {- maps: ReadabilityMaps;-};--type FetchRecordShares = () => Promise<RecordShare[]>;+type ChildrenParentExpression = Extract<+ InheritedReadabilityParentExpression,+ { kind: 'children' }+>;type SnapshotIdsThroughParent = {readableSnapshotIds: Set<string>;@@ -72,320 +51,154 @@ export class RecordAccessPolicyService {private readonly recordShareStorageService: RecordShareStorageService,) {}- // Mirrors the query gate: role read, then the row-level filter on the event snapshot, then the share gate.+ // A subject receives the records a query would return it: the event+ // snapshots are run through the same row access policy as its queries.buildEventRecordAccessGate({workspaceId,objectMetadata,events,}: WorkspaceEventBatch<ObjectRecordEvent>): EventRecordAccessGate {- let recordSharesPromise: Promise<RecordShare[]> | undefined;- const fetchRecordShares: FetchRecordShares = () =>- (recordSharesPromise ??= this.recordShareStorageService.findByRecordIds({- workspaceId,- objectMetadataId: objectMetadata.id,- recordIds: events.map((event) => event.recordId),- }));-- return {- resolveAdmittedRecordIds: async (subject) => {- const eventSnapshots = resolveEventRecordSnapshots(events);- const snapshots = await this.resolveSnapshotsReadableByRole({- workspaceId,- objectMetadata,- snapshots: eventSnapshots,- subject,- depth: 0,- });-- const admittedSnapshotIds =- snapshots.length === 0- ? new Set<string>()- : await this.resolveSnapshotIdsAdmittedByRecordShareGate(- {- workspaceId,- objectMetadata,- snapshots,- subject,- depth: 0,- },- fetchRecordShares,- );-- return new Set([- ...admittedSnapshotIds,- ...(await this.resolveSnapshotIdsGrantedBeyondRole(- { workspaceId, objectMetadata, snapshots: eventSnapshots, subject },- fetchRecordShares,- )),- ]);- },- };- }-- private async resolveSnapshotsReadableByRole({- workspaceId,- objectMetadata,- snapshots,- subject,- maps,- }: SnapshotEvaluation): Promise<EventRecordSnapshot[]> {- if (snapshots.length === 0) {- return [];- }-- if (- isDefined(subject.objectsPermissions) &&- !isObjectOperationPermitted({- objectMetadata,- operationType: 'select',- objectsPermissions: subject.objectsPermissions,- })- ) {- return [];- }-- const rowLevelPermissionRecordFilter =- subject.resolveRowLevelPermissionRecordFilter(objectMetadata);-- if (- !isDefined(rowLevelPermissionRecordFilter) ||- Object.keys(rowLevelPermissionRecordFilter).length === 0- ) {- return snapshots;- }-- const flatFieldMetadataMaps =- maps?.flatFieldMetadataMapsOrm ??- (- await this.workspaceCacheService.getOrRecompute(workspaceId, [- 'flatFieldMetadataMapsOrm',- ])- ).flatFieldMetadataMapsOrm;-- return snapshots.filter((snapshot) =>- isRecordMatchingRLSRowLevelPermissionPredicate({- record: snapshot,- filter: rowLevelPermissionRecordFilter,- flatObjectMetadata: objectMetadata,- flatFieldMetadataMaps,- shouldIgnoreSoftDeleteDefaultFilter: true,- }),- );- }-- private async resolveSnapshotIdsAdmittedByRecordShareGate(- evaluation: SnapshotEvaluation,- fetchRecordShares: FetchRecordShares,- ): Promise<Set<string>> {- const { objectMetadata, snapshots, subject } = evaluation;- const gateKind = resolveRecordShareGateKind({- readability: objectMetadata.readability,- isOwningApplication: subject.isOwningApplication(objectMetadata),- });-- switch (gateKind) {- case 'open':- return (await this.areRecordShareExceptionsEnforced(evaluation))- ? this.resolveSnapshotIdsNotRestrictedForSubject(- evaluation,- fetchRecordShares,- )- : new Set(snapshots.map((snapshot) => snapshot.id));- case 'deny':- return new Set();- case 'private':- return this.resolveSnapshotIdsSharedWithSubject(- evaluation,- fetchRecordShares,- );- case 'inherited':- return new Set([- ...(await this.resolveSnapshotIdsSharedWithSubject(- evaluation,- fetchRecordShares,- )),- ...(await this.resolveSnapshotIdsReadableThroughParents({- ...evaluation,- })),- ]);- default:- return assertUnreachable(gateKind);- }- }-- // A record shared by name reaches its recipients whatever their role or row- // filter says about the object, as the row access policy does- private async resolveSnapshotIdsGrantedBeyondRole(- {- workspaceId,- objectMetadata,- snapshots,- subject,- }: Omit<SnapshotEvaluation, 'depth'>,- fetchRecordShares: FetchRecordShares,- ): Promise<Set<string>> {- const namedPrincipalIds = resolveNamedPrincipalIds(subject);-- if (- snapshots.length === 0 ||- namedPrincipalIds.length === 0 ||- !isRecordGrantBeyondRoleAllowed({- flatObjectMetadata: objectMetadata,- operationType: 'select',- isRecordSharingEnabled: await this.isRecordSharingEnabled(workspaceId),- })- ) {- return new Set();- }-- const grantedRecordIds = resolveRecordIdsSharedWithPrincipals({- recordShares: await fetchRecordShares(),- principalIds: namedPrincipalIds,- accessLevels: resolveRequiredRecordShareAccessLevels('select'),- });-- return new Set(- snapshots- .map((snapshot) => snapshot.id)- .filter((snapshotId) => grantedRecordIds.has(snapshotId)),- );- }-- private async isRecordSharingEnabled(workspaceId: string): Promise<boolean> {- const { featureFlagsMap } = await this.workspaceCacheService.getOrRecompute(- workspaceId,- ['featureFlagsMap'],- );-- return (- featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ?? false- );- }-- private async areRecordShareExceptionsEnforced({- workspaceId,- objectMetadata,- subject,- }: SnapshotEvaluation): Promise<boolean> {- return shouldEnforceRecordShareExceptions({- flatObjectMetadata: objectMetadata,- isRecordSharingEnabled: await this.isRecordSharingEnabled(workspaceId),- canAccessAllRecords: subject.canAccessAllRecords,- });- }-- private async resolveSnapshotIdsNotRestrictedForSubject(- { snapshots, subject }: SnapshotEvaluation,- fetchRecordShares: FetchRecordShares,- ): Promise<Set<string>> {- const snapshotIds = snapshots.map((snapshot) => snapshot.id);-- if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {- return new Set(snapshotIds);- }-- const restrictedRecordIds = resolveRecordIdsRestrictedForPrincipals({- recordShares: await fetchRecordShares(),- principalIds: subject.principalIds,- accessLevels: resolveRequiredRecordShareAccessLevels('select'),- });-- return new Set(- snapshotIds.filter((snapshotId) => !restrictedRecordIds.has(snapshotId)),- );- }-- private async resolveSnapshotIdsSharedWithSubject(- { snapshots, subject }: SnapshotEvaluation,- fetchRecordShares: FetchRecordShares,- ): Promise<Set<string>> {- const snapshotIds = snapshots.map((snapshot) => snapshot.id);-- if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {- return new Set(snapshotIds);- }-- const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({- recordShares: await fetchRecordShares(),- principalIds: subject.principalIds,- accessLevels: resolveRequiredRecordShareAccessLevels('select'),- });-- return new Set(- snapshotIds.filter((snapshotId) => sharedRecordIds.has(snapshotId)),- );- }-- private async resolveSnapshotIdsReadableThroughParents(- evaluation: SnapshotEvaluation,- ): Promise<Set<string>> {- const { workspaceId, objectMetadata, maps } = evaluation;-- if (!isDefined(maps)) {- const loadedMaps = await this.workspaceCacheService.getOrRecompute(- workspaceId,- ['flatObjectMetadataMaps', 'flatFieldMetadataMapsOrm'],+ // One lookup per object for the whole batch: operands only ever ask for+ // records of the batch, so later calls are served from what was fetched+ const recordSharesByRecordIdByObject = new Map<+ string,+ Map<string, Promise<RecordShare[]>>+ >();+ const fetchRecordShares = async ({+ objectMetadataId,+ recordIds,+ }: {+ objectMetadataId: string;+ recordIds: string[];+ }) => {+ const recordSharesByRecordId =+ recordSharesByRecordIdByObject.get(objectMetadataId) ??+ new Map<string, Promise<RecordShare[]>>();++ recordSharesByRecordIdByObject.set(+ objectMetadataId,+ recordSharesByRecordId,);- return this.workspaceOrmManager.executeInWorkspaceContext(- () =>- this.resolveSnapshotIdsReadableThroughParents({- ...evaluation,- maps: loadedMaps,- }),- buildSystemAuthContext(workspaceId),+ const uniqueRecordIds = [...new Set(recordIds)];+ const missingRecordIds = uniqueRecordIds.filter(+ (recordId) => !recordSharesByRecordId.has(recordId),);- }- const parents = resolveInheritedReadabilityParents({- flatObjectMetadata: objectMetadata,- flatFieldMetadataMaps: maps.flatFieldMetadataMapsOrm,- flatObjectMetadataMaps: maps.flatObjectMetadataMaps,- });- const readableSnapshotIds = new Set<string>();- const attachedSnapshotIds = new Set<string>();-- for (const parent of parents) {- const snapshotIdsThroughParent =- parent.kind === 'column'- ? await this.resolveSnapshotIdsReadableThroughColumnParent({- ...evaluation,- maps,- parent,- })- : await this.resolveSnapshotIdsReadableThroughChildren({- ...evaluation,- maps,- parent,- });-- for (const readableId of snapshotIdsThroughParent.readableSnapshotIds) {- readableSnapshotIds.add(readableId);+ if (missingRecordIds.length > 0) {+ const groupedRecordShares = this.recordShareStorageService+ .findByRecordIds({+ workspaceId,+ objectMetadataId,+ recordIds: missingRecordIds,+ })+ .then((recordShares) =>+ groupBy(recordShares, (recordShare) => recordShare.recordId),+ );++ for (const recordId of missingRecordIds) {+ recordSharesByRecordId.set(+ recordId,+ groupedRecordShares.then(+ (recordSharesOfRecord) => recordSharesOfRecord[recordId] ?? [],+ ),+ );+ }}- for (const attachedId of snapshotIdsThroughParent.attachedSnapshotIds) {- attachedSnapshotIds.add(attachedId);- }- }+ const recordSharesPerRecord = await Promise.all(+ uniqueRecordIds.map(+ (recordId) => recordSharesByRecordId.get(recordId) ?? [],+ ),+ );- if (isOpenWhenDetachedObject(objectMetadata)) {- for (const snapshot of evaluation.snapshots) {- if (!attachedSnapshotIds.has(snapshot.id)) {- readableSnapshotIds.add(snapshot.id);- }- }- }+ return recordSharesPerRecord.flat();+ };- return readableSnapshotIds;+ return {+ resolveAdmittedRecordIds: async (subject) => {+ const {+ flatObjectMetadataMaps,+ flatFieldMetadataMapsOrm,+ featureFlagsMap,+ } = await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMapsOrm',+ 'featureFlagsMap',+ ]);+ const context: RowAccessEvaluationContext<EventRecordSnapshot> = {+ flatFieldMetadataMaps: flatFieldMetadataMapsOrm,+ shouldIgnoreSoftDeleteDefaultFilter: true,+ fetchRecordShares,+ // Parents and children are only reached through their tables+ resolveRecordIdsReadableThroughParents: ({ expression, records }) =>+ this.workspaceOrmManager.executeInWorkspaceContext(async () => {+ const readableSnapshotIds = new Set<string>();+ const attachedSnapshotIds = new Set<string>();++ for (const parent of expression.parents) {+ const throughParent =+ parent.kind === 'column'+ ? await this.resolveSnapshotIdsReadableThroughColumnParent({+ parent,+ snapshots: records,+ })+ : await this.resolveSnapshotIdsReadableThroughChildren({+ parent,+ snapshots: records,+ isOpenWhenDetached: expression.isOpenWhenDetached,+ context,+ });++ throughParent.readableSnapshotIds.forEach((id) =>+ readableSnapshotIds.add(id),+ );+ throughParent.attachedSnapshotIds.forEach((id) =>+ attachedSnapshotIds.add(id),+ );+ }++ if (expression.isOpenWhenDetached) {+ for (const record of records) {+ if (!attachedSnapshotIds.has(record.id)) {+ readableSnapshotIds.add(record.id);+ }+ }+ }++ return readableSnapshotIds;+ }, buildSystemAuthContext(workspaceId)),+ };++ return evaluateRowAccessPolicy({+ policy: buildRowAccessPolicy({+ subject,+ environment: {+ flatObjectMetadataMaps,+ flatFieldMetadataMaps: flatFieldMetadataMapsOrm,+ isRecordSharingEnabled:+ featureFlagsMap[+ FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED+ ] ?? false,+ },+ tableAlias: objectMetadata.nameSingular,+ flatObjectMetadata: objectMetadata,+ operationType: 'select',+ depth: 0,+ }),+ records: resolveEventRecordSnapshots(events),+ context,+ });+ },+ };}private async resolveSnapshotIdsReadableThroughColumnParent({- snapshots,- subject,- depth,parent,- }: SnapshotEvaluationInContext & {- parent: InheritedReadabilityColumnParent;+ snapshots,+ }: {+ parent: ColumnParentExpression;+ snapshots: EventRecordSnapshot[];}): Promise<SnapshotIdsThroughParent> {const parentIdBySnapshotId = new Map(snapshots.flatMap((snapshot) => {@@ -394,12 +207,15 @@ export class RecordAccessPolicyService {return isNonEmptyString(parentId) ? [[snapshot.id, parentId]] : [];}),);- const readableParentIds = await this.selectReadableRecordIds({- objectMetadata: parent.parentFlatObjectMetadata,- recordIds: [...new Set(parentIdBySnapshotId.values())],- subject,- depth: depth + 1,- });+ const readableParentIds = await this.workspaceOrmManager+ .getRepository(parent.parentFlatObjectMetadata.nameSingular, {+ shouldBypassPermissionChecks: true,+ })+ .findRecordIdsAdmittedByRowAccessPolicy({+ recordIds: [...new Set(parentIdBySnapshotId.values())],+ policy: parent.policy,+ tableAlias: parent.parentTableAlias,+ });return {readableSnapshotIds: new Set(@@ -412,15 +228,15 @@ export class RecordAccessPolicyService {}private async resolveSnapshotIdsReadableThroughChildren({- workspaceId,- objectMetadata,- snapshots,- subject,- depth,- maps,parent,- }: SnapshotEvaluationInContext & {- parent: InheritedReadabilityChildrenParent;+ snapshots,+ isOpenWhenDetached,+ context,+ }: {+ parent: ChildrenParentExpression;+ snapshots: EventRecordSnapshot[];+ isOpenWhenDetached: boolean;+ context: RowAccessEvaluationContext<EventRecordSnapshot>;}): Promise<SnapshotIdsThroughParent> {const childNameSingular = parent.childFlatObjectMetadata.nameSingular;const capturedChildSnapshotsBySnapshotId = new Map(@@ -468,12 +284,12 @@ export class RecordAccessPolicyService {.select(['id', parent.childJoinColumnName]).where({ [parent.childJoinColumnName]: In(liveSnapshotIds) }).getMany<ObjectRecord>({ noFormatting: true });- const readableChildIds = await this.selectReadableRecordIds({- objectMetadata: parent.childFlatObjectMetadata,- recordIds: childRows.map((childRow) => String(childRow.id)),- subject,- depth: depth + 1,- });+ const readableChildIds =+ await childRepository.findRecordIdsAdmittedByRowAccessPolicy({+ recordIds: childRows.map((childRow) => String(childRow.id)),+ policy: parent.policy,+ tableAlias: parent.childTableAlias,+ });for (const childRow of childRows) {const snapshotId = String(childRow[parent.childJoinColumnName]);@@ -491,10 +307,7 @@ export class RecordAccessPolicyService {isDefined(snapshot.deletedAt),);- if (- isOpenWhenDetachedObject(objectMetadata) &&- trashedSnapshots.length > 0- ) {+ if (isOpenWhenDetached && trashedSnapshots.length > 0) {const snapshotById = new Map(trashedSnapshots.map((snapshot) => [snapshot.id, snapshot]),);@@ -505,7 +318,8 @@ export class RecordAccessPolicyService {),),);- // Rows trashed along with the record still attach it, as in the query gate; rows trashed earlier do not.+ // A row trashed along with the record still attaches it, as in the+ // query gate; rows trashed before any of these records cannotconst trashedChildRows = await childRepository.createQueryBuilder().select(['id', parent.childJoinColumnName, 'deletedAt'])@@ -533,13 +347,10 @@ export class RecordAccessPolicyService {}}- const readableCapturedChildIds = await this.resolveReadableSnapshotIds({- workspaceId,- objectMetadata: parent.childFlatObjectMetadata,- snapshots: [...capturedChildSnapshotsBySnapshotId.values()].flat(),- subject,- depth: depth + 1,- maps,+ const readableCapturedChildIds = await evaluateRowAccessPolicy({+ policy: parent.policy,+ records: [...capturedChildSnapshotsBySnapshotId.values()].flat(),+ context,});for (const [@@ -557,75 +368,4 @@ export class RecordAccessPolicyService {return { readableSnapshotIds, attachedSnapshotIds };}-- private async resolveReadableSnapshotIds(- evaluation: SnapshotEvaluationInContext,- ): Promise<Set<string>> {- const { workspaceId, objectMetadata, depth } = evaluation;-- if (depth > MAX_INHERITED_READABILITY_DEPTH) {- return new Set();- }-- const candidateSnapshots =- await this.resolveSnapshotsReadableByRole(evaluation);-- if (candidateSnapshots.length === 0) {- return new Set();- }-- return this.resolveSnapshotIdsAdmittedByRecordShareGate(- { ...evaluation, snapshots: candidateSnapshots },- () =>- this.recordShareStorageService.findByRecordIds({- workspaceId,- objectMetadataId: objectMetadata.id,- recordIds: candidateSnapshots.map((snapshot) => snapshot.id),- }),- );- }-- private async selectReadableRecordIds({- objectMetadata,- recordIds,- subject,- depth,- }: {- objectMetadata: FlatObjectMetadata;- recordIds: string[];- subject: RowAccessPolicySubject;- depth: number;- }): Promise<Set<string>> {- if (recordIds.length === 0) {- return new Set();- }-- const repository = this.workspaceOrmManager.getRepository(- objectMetadata.nameSingular,- { shouldBypassPermissionChecks: true },- );- const policy = repository.buildRowAccessPolicy({- subject,- operationType: 'select',- depth,- });-- switch (policy.kind) {- case 'open':- return new Set(recordIds);- case 'denied':- return new Set();- case 'gated': {- const rows = await repository- .createQueryBuilder()- .select(['id'])- .where({ id: In(recordIds) })- .withDeleted()- .andWhere(policy.condition.sql, policy.condition.parameters)- .getMany<ObjectRecord>({ noFormatting: true });-- return new Set(rows.map((row) => String(row.id)));- }- }- }}diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.tsindex cd22142c122..94008c04dc1 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts@@ -14,7 +14,7 @@ import {RecordSharePrincipalType,RecordShareRowCause,} from 'twenty-shared/types';-import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';+import { isDefined } from 'twenty-shared/utils';import { type UserWorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { NotFoundError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';@@ -709,20 +709,13 @@ export class RecordSharingService {},operationType: 'select',});- const isRecordReachable =- policy.kind === 'open' ||- (policy.kind === 'gated' &&- isNonEmptyArray(- await repository- .createQueryBuilder()- .select(['id'])- .where({ id: recordId })- .withDeleted()- .andWhere(policy.condition.sql, policy.condition.parameters)- .getMany<ObjectRecord>({ noFormatting: true }),- ));-- if (!isRecordReachable) {+ const reachableRecordIds =+ await repository.findRecordIdsAdmittedByRowAccessPolicy({+ recordIds: [recordId],+ policy,+ });++ if (!reachableRecordIds.has(recordId)) {throw new RecordShareException(`Principal ${principal.principalId} cannot see record ${recordId} through its role`,RecordShareExceptionCode.INVALID_SHARE_WITH,diff --git a/packages/twenty-server/src/engine/core-modules/record-share/types/record-share-grant.type.ts b/packages/twenty-server/src/engine/core-modules/record-share/types/record-share-grant.type.tsnew file mode 100644index 00000000000..6d1e04a9a79--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-share/types/record-share-grant.type.ts@@ -0,0 +1,8 @@+/* @license Enterprise */++import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';++export type RecordShareGrant = Pick<+ RecordShare,+ 'recordId' | 'principalId' | 'accessLevel'+>;diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.tsindex 44e4caf4504..c335d405e66 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts@@ -20,7 +20,7 @@ const countOccurrences = (haystack: string, needle: string): number =>const build = (parents: InheritedReadabilityParentCondition[],- { isOpenWhenDetached }: { isOpenWhenDetached?: boolean } = {},+ { isOpenWhenDetached = false }: { isOpenWhenDetached?: boolean } = {},) =>buildInheritedReadabilityCondition({tableAlias: 'attachment',diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/evaluate-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/evaluate-row-access-policy.util.spec.tsnew file mode 100644index 00000000000..bef301516bf--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/evaluate-row-access-policy.util.spec.ts@@ -0,0 +1,215 @@+/* @license Enterprise */++import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import { FieldMetadataType, RecordShareAccessLevel } from 'twenty-shared/types';++import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';+import {+ evaluateRowAccessPolicy,+ type RowAccessEvaluationContext,+ type RowAccessRecord,+} from 'src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util';+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';+import {+ type RecordShareExpressionTarget,+ type RowAccessExpression,+} from 'src/engine/twenty-orm/types/row-access-policy.type';++const MEMBER_ID = 'member-1';++const statusField = getFlatFieldMetadataMock({+ objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,+ type: FieldMetadataType.TEXT,+ name: 'status',+ universalIdentifier: 'company-status-field-universal-id',+});++const flatObjectMetadata = {+ ...COMPANY_FLAT_OBJECT_MOCK,+ fieldIds: [statusField.id],+};++const flatFieldMetadataMaps = addFlatEntityToFlatEntityMapsOrThrow({+ flatEntity: statusField,+ flatEntityMaps:+ createEmptyFlatEntityMaps() as FlatEntityMaps<FlatFieldMetadata>,+});++const shareTarget: RecordShareExpressionTarget = {+ tableAlias: 'company',+ objectMetadataId: flatObjectMetadata.id,+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],+ accessLevels: [+ RecordShareAccessLevel.READ,+ RecordShareAccessLevel.READ_WRITE,+ ],+};++const activeFilter: RowAccessExpression = {+ kind: 'roleFilter',+ tableAlias: 'company',+ flatObjectMetadata,+ recordFilter: { status: { eq: 'active' } },+ condition: { sql: 'TRUE', parameters: {} },+};++const records: RowAccessRecord[] = [+ { id: 'active-shared', status: 'active', deletedAt: null },+ { id: 'active-private', status: 'active', deletedAt: null },+ { id: 'archived-shared', status: 'archived', deletedAt: null },+];++const recordShares: RecordShareGrant[] = [+ {+ recordId: 'active-shared',+ principalId: MEMBER_ID,+ accessLevel: RecordShareAccessLevel.READ,+ },+ {+ recordId: 'archived-shared',+ principalId: MEMBER_ID,+ accessLevel: RecordShareAccessLevel.READ_WRITE,+ },+ {+ recordId: 'active-private',+ principalId: EVERYONE_PRINCIPAL_ID,+ accessLevel: RecordShareAccessLevel.NONE,+ },+];++const buildContext = (+ overrides: Partial<RowAccessEvaluationContext<RowAccessRecord>> = {},+): RowAccessEvaluationContext<RowAccessRecord> => ({+ flatFieldMetadataMaps,+ shouldIgnoreSoftDeleteDefaultFilter: false,+ fetchRecordShares: jest.fn(async ({ recordIds }) =>+ recordShares.filter((recordShare) =>+ recordIds.includes(recordShare.recordId),+ ),+ ),+ resolveRecordIdsReadableThroughParents: jest.fn(+ async () => new Set<string>(),+ ),+ ...overrides,+});++const evaluate = (expression: RowAccessExpression, context = buildContext()) =>+ evaluateRowAccessPolicy({+ policy: { kind: 'gated', expression },+ records,+ context,+ });++describe('evaluateRowAccessPolicy', () => {+ it('admits every record when open and none when denied', async () => {+ const context = buildContext();++ expect(+ await evaluateRowAccessPolicy({+ policy: { kind: 'open' },+ records,+ context,+ }),+ ).toEqual(new Set(records.map((record) => record.id)));+ expect(+ await evaluateRowAccessPolicy({+ policy: { kind: 'denied' },+ records,+ context,+ }),+ ).toEqual(new Set());+ });++ it('matches role filters on the record values', async () => {+ expect(await evaluate(activeFilter)).toEqual(+ new Set(['active-shared', 'active-private']),+ );+ });++ it('admits records shared with the principals', async () => {+ expect(await evaluate({ kind: 'recordShared', ...shareTarget })).toEqual(+ new Set(['active-shared', 'archived-shared']),+ );+ });++ it('keeps out records restricted for everyone', async () => {+ expect(+ await evaluate({ kind: 'recordNotRestricted', ...shareTarget }),+ ).toEqual(new Set(['active-shared', 'archived-shared']));+ });++ it('only fetches shares for records still in play after an and', async () => {+ const context = buildContext();++ expect(+ await evaluate(+ {+ kind: 'and',+ operands: [activeFilter, { kind: 'recordShared', ...shareTarget }],+ },+ context,+ ),+ ).toEqual(new Set(['active-shared']));+ expect(context.fetchRecordShares).toHaveBeenCalledWith({+ objectMetadataId: flatObjectMetadata.id,+ recordIds: ['active-shared', 'active-private'],+ });+ });++ it('admits through either operand of an or, asking later operands only about records not yet admitted', async () => {+ const context = buildContext();++ expect(+ await evaluate(+ {+ kind: 'or',+ operands: [+ {+ kind: 'and',+ operands: [+ activeFilter,+ { kind: 'recordNotRestricted', ...shareTarget },+ ],+ },+ { kind: 'recordShared', ...shareTarget },+ ],+ },+ context,+ ),+ ).toEqual(new Set(['active-shared', 'archived-shared']));+ expect(context.fetchRecordShares).toHaveBeenLastCalledWith({+ objectMetadataId: flatObjectMetadata.id,+ recordIds: ['active-private', 'archived-shared'],+ });+ });++ it('asks parents only about records not shared directly', async () => {+ const context = buildContext({+ resolveRecordIdsReadableThroughParents: jest.fn(+ async () => new Set(['active-private']),+ ),+ });++ expect(+ await evaluate(+ {+ kind: 'inheritedReadability',+ parents: [],+ isOpenWhenDetached: false,+ ...shareTarget,+ },+ context,+ ),+ ).toEqual(new Set(['active-shared', 'archived-shared', 'active-private']));+ expect(context.resolveRecordIdsReadableThroughParents).toHaveBeenCalledWith(+ expect.objectContaining({+ records: [expect.objectContaining({ id: 'active-private' })],+ }),+ );+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.tsindex 91830476c69..e1ef209bbad 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts@@ -112,6 +112,16 @@ describe('resolveRecordIdsRestrictedForPrincipals', () => {});it('should not let another everyone row lift a restriction', () => {+ const applicationEveryoneShare: RecordShare = {+ ...buildShare(+ 'restricted',+ EVERYONE_PRINCIPAL_ID,+ RecordShareAccessLevel.FULL,+ ),+ rowCause: RecordShareRowCause.APPLICATION,+ sourceId: 'application-1',+ };+expect(resolveRecordIdsRestrictedForPrincipals({recordShares: [@@ -120,15 +130,7 @@ describe('resolveRecordIdsRestrictedForPrincipals', () => {EVERYONE_PRINCIPAL_ID,RecordShareAccessLevel.NONE,),- {- ...buildShare(- 'restricted',- EVERYONE_PRINCIPAL_ID,- RecordShareAccessLevel.FULL,- ),- rowCause: RecordShareRowCause.APPLICATION,- sourceId: 'application-1',- },+ applicationEveryoneShare,],principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],accessLevels: SELECT_ACCESS_LEVELS,diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.tsindex d33a23b990b..6b489a5d630 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts@@ -4,7 +4,7 @@ import { type RecordShareAccessLevel } from 'twenty-shared/types';import { type ObjectLiteral } from 'typeorm';import {- type RowAccessPolicy,+ type CompiledRowAccessPolicy,type SqlCondition,} from 'src/engine/twenty-orm/types/row-access-policy.type';import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';@@ -16,14 +16,14 @@ export type InheritedReadabilityParentCondition =joinColumnName: string;parentTableAlias: string;parentTableExpression: string;- policy: RowAccessPolicy;+ policy: CompiledRowAccessPolicy;}| {kind: 'children';childTableAlias: string;childTableExpression: string;childJoinColumnName: string;- policy: RowAccessPolicy;+ policy: CompiledRowAccessPolicy;};const buildChildLinkBoundCondition = ({@@ -61,7 +61,7 @@ export const buildInheritedReadabilityCondition = ({recordShareTableExpression,principalIds,accessLevels,- isOpenWhenDetached = false,+ isOpenWhenDetached,}: {tableAlias: string;objectMetadataId: string;@@ -69,7 +69,7 @@ export const buildInheritedReadabilityCondition = ({recordShareTableExpression: string;principalIds: string[];accessLevels: RecordShareAccessLevel[];- isOpenWhenDetached?: boolean;+ isOpenWhenDetached: boolean;}): SqlCondition => {const parameters: ObjectLiteral = {};const quotedTableAlias = escapeIdentifier(tableAlias);diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util.tssimilarity index 70%rename from packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util.tsrename to packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util.tsindex 1b6ff733858..3bbbe06b435 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util.ts@@ -2,19 +2,18 @@import { isNonEmptyArray } from 'twenty-shared/utils';-import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';import { resolveNamedPrincipalIds } from 'src/engine/core-modules/record-share/utils/resolve-named-principal-ids.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';import {+ type RowAccessExpression,type RowAccessPolicyContext,type RowAccessPolicyTarget,- type SqlCondition,} from 'src/engine/twenty-orm/types/row-access-policy.type';-export const buildNamedRecordGrantCondition = (- { subject, environment }: RowAccessPolicyContext,+export const buildNamedRecordGrantExpression = (+ { subject }: Pick<RowAccessPolicyContext, 'subject'>,{ tableAlias, flatObjectMetadata, operationType }: RowAccessPolicyTarget,-): SqlCondition | undefined => {+): RowAccessExpression | undefined => {const principalIds = resolveNamedPrincipalIds(subject);const accessLevels = resolveRequiredRecordShareAccessLevels(operationType);@@ -22,12 +21,12 @@ export const buildNamedRecordGrantCondition = (return undefined;}- return buildRecordShareCondition({+ return {+ kind: 'recordShared',+ isUncorrelated: true,tableAlias,- recordShareTableExpression: environment.recordShareTableExpression,objectMetadataId: flatObjectMetadata.id,principalIds,accessLevels,- isUncorrelated: true,- });+ };};diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.tsindex 7c106776504..6fbf4be42a3 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts@@ -6,17 +6,12 @@ import { assertUnreachable, isDefined } from 'twenty-shared/utils';import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/core-modules/record-share/constants/max-inherited-readability-depth.constant';import { type InheritedReadabilityParent } from 'src/engine/core-modules/record-share/types/inherited-readability-parent.type';-import {- buildInheritedReadabilityCondition,- type InheritedReadabilityParentCondition,-} from 'src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util';-import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';-import { buildRecordShareExceptionCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util';import { isOpenWhenDetachedObject } from 'src/engine/core-modules/record-share/utils/is-open-when-detached-object.util';import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';import { shouldEnforceRecordShareExceptions } from 'src/engine/core-modules/record-share/utils/should-enforce-record-share-exceptions.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';import {+ type InheritedReadabilityParentExpression,type RowAccessPolicy,type RowAccessPolicyContext,type RowAccessPolicyTarget,@@ -98,13 +93,12 @@ const buildOwnRecordShareGate = (return {kind: 'gated',- condition: buildRecordShareCondition({+ expression: {+ kind: 'recordShared',tableAlias: target.tableAlias,- recordShareTableExpression:- context.environment.recordShareTableExpression,objectMetadataId: target.flatObjectMetadata.id,...principals,- }),+ },};};@@ -120,13 +114,12 @@ const buildRecordShareExceptionGate = (return {kind: 'gated',- condition: buildRecordShareExceptionCondition({+ expression: {+ kind: 'recordNotRestricted',tableAlias: target.tableAlias,- recordShareTableExpression:- context.environment.recordShareTableExpression,objectMetadataId: target.flatObjectMetadata.id,...principals,- }),+ },};};@@ -176,33 +169,31 @@ const buildInheritedReadabilityGate = ({return {kind: 'gated',- condition: buildInheritedReadabilityCondition({+ expression: {+ kind: 'inheritedReadability',tableAlias,objectMetadataId: flatObjectMetadata.id,+ ...principals,+ isOpenWhenDetached,parents: parents.map((parent) =>- buildInheritedReadabilityParentCondition({+ buildInheritedReadabilityParentExpression({context,target,parent,buildParentPolicy,}),),- recordShareTableExpression:- context.environment.recordShareTableExpression,- ...principals,- isOpenWhenDetached,- }),+ },};};-const buildInheritedReadabilityParentCondition = ({- context,+const buildInheritedReadabilityParentExpression = ({target: { tableAlias, operationType, depth },parent,buildParentPolicy,}: RecordShareGateArgs & {parent: InheritedReadabilityParent;-}): InheritedReadabilityParentCondition => {+}): InheritedReadabilityParentExpression => {if (parent.kind === 'column') {const parentTableAlias = `${tableAlias}_${parent.joinColumnName}`;@@ -210,9 +201,7 @@ const buildInheritedReadabilityParentCondition = ({kind: 'column',joinColumnName: parent.joinColumnName,parentTableAlias,- parentTableExpression: context.environment.resolveTableExpression(- parent.parentFlatObjectMetadata.id,- ),+ parentFlatObjectMetadata: parent.parentFlatObjectMetadata,policy: buildParentPolicy({tableAlias: parentTableAlias,flatObjectMetadata: parent.parentFlatObjectMetadata,@@ -227,10 +216,8 @@ const buildInheritedReadabilityParentCondition = ({return {kind: 'children',childTableAlias,- childTableExpression: context.environment.resolveTableExpression(- parent.childFlatObjectMetadata.id,- ),childJoinColumnName: parent.childJoinColumnName,+ childFlatObjectMetadata: parent.childFlatObjectMetadata,policy: buildParentPolicy({tableAlias: childTableAlias,flatObjectMetadata: parent.childFlatObjectMetadata,diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util.tsnew file mode 100644index 00000000000..a2c9893217d--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util.ts@@ -0,0 +1,188 @@+/* @license Enterprise */++import { assertUnreachable } from 'twenty-shared/utils';++import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';+import { resolveRecordIdsRestrictedForPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util';+import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';+import {+ type RowAccessExpression,+ type RowAccessPolicy,+} from 'src/engine/twenty-orm/types/row-access-policy.type';+import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';++export type RowAccessRecord = { id: string } & Record<string, unknown>;++type InheritedReadabilityExpression = Extract<+ RowAccessExpression,+ { kind: 'inheritedReadability' }+>;++export type RowAccessEvaluationContext<TRecord extends RowAccessRecord> = {+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+ shouldIgnoreSoftDeleteDefaultFilter: boolean;+ fetchRecordShares: (args: {+ objectMetadataId: string;+ recordIds: string[];+ }) => Promise<RecordShareGrant[]>;+ // Parents live in other tables, so whoever holds the records resolves them+ resolveRecordIdsReadableThroughParents: (args: {+ expression: InheritedReadabilityExpression;+ records: TRecord[];+ }) => Promise<Set<string>>;+};++// The in-memory counterpart of compileRowAccessPolicy: both read the same+// policy, so a record admitted by a query is admitted here and vice versa+export const evaluateRowAccessPolicy = async <TRecord extends RowAccessRecord>({+ policy,+ records,+ context,+}: {+ policy: RowAccessPolicy;+ records: TRecord[];+ context: RowAccessEvaluationContext<TRecord>;+}): Promise<Set<string>> => {+ switch (policy.kind) {+ case 'open':+ return new Set(records.map((record) => record.id));+ case 'denied':+ return new Set();+ case 'gated':+ return evaluateRowAccessExpression({+ expression: policy.expression,+ records,+ context,+ });+ default:+ return assertUnreachable(policy);+ }+};++const evaluateRowAccessExpression = async <TRecord extends RowAccessRecord>({+ expression,+ records,+ context,+}: {+ expression: RowAccessExpression;+ records: TRecord[];+ context: RowAccessEvaluationContext<TRecord>;+}): Promise<Set<string>> => {+ if (records.length === 0) {+ return new Set();+ }++ const recordIds = records.map((record) => record.id);++ switch (expression.kind) {+ case 'and': {+ let admittedRecords = records;++ for (const operand of expression.operands) {+ const admittedIds = await evaluateRowAccessExpression({+ expression: operand,+ records: admittedRecords,+ context,+ });++ admittedRecords = admittedRecords.filter((record) =>+ admittedIds.has(record.id),+ );+ }++ return new Set(admittedRecords.map((record) => record.id));+ }+ case 'or': {+ const admittedIds = new Set<string>();++ for (const operand of expression.operands) {+ const remainingRecords = records.filter(+ (record) => !admittedIds.has(record.id),+ );+ const operandAdmittedIds = await evaluateRowAccessExpression({+ expression: operand,+ records: remainingRecords,+ context,+ });++ for (const admittedId of operandAdmittedIds) {+ admittedIds.add(admittedId);+ }+ }++ return admittedIds;+ }+ case 'roleFilter': {+ const matchingRecordIds = records+ .filter((record) =>+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record,+ filter: expression.recordFilter,+ flatObjectMetadata: expression.flatObjectMetadata,+ flatFieldMetadataMaps: context.flatFieldMetadataMaps,+ shouldIgnoreSoftDeleteDefaultFilter:+ context.shouldIgnoreSoftDeleteDefaultFilter,+ }),+ )+ .map((record) => record.id);++ return new Set(matchingRecordIds);+ }+ case 'recordShared': {+ const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({+ recordShares: await context.fetchRecordShares({+ objectMetadataId: expression.objectMetadataId,+ recordIds,+ }),+ principalIds: expression.principalIds,+ accessLevels: expression.accessLevels,+ });++ const admittedRecordIds = recordIds.filter((id) =>+ sharedRecordIds.has(id),+ );++ return new Set(admittedRecordIds);+ }+ case 'recordNotRestricted': {+ const restrictedRecordIds = resolveRecordIdsRestrictedForPrincipals({+ recordShares: await context.fetchRecordShares({+ objectMetadataId: expression.objectMetadataId,+ recordIds,+ }),+ principalIds: expression.principalIds,+ accessLevels: expression.accessLevels,+ });++ const admittedRecordIds = recordIds.filter(+ (id) => !restrictedRecordIds.has(id),+ );++ return new Set(admittedRecordIds);+ }+ case 'inheritedReadability': {+ const sharedRecordIds = await evaluateRowAccessExpression({+ expression: {+ kind: 'recordShared',+ tableAlias: expression.tableAlias,+ objectMetadataId: expression.objectMetadataId,+ principalIds: expression.principalIds,+ accessLevels: expression.accessLevels,+ },+ records,+ context,+ });+ const readableThroughParentIds =+ await context.resolveRecordIdsReadableThroughParents({+ expression,+ records: records.filter((record) => !sharedRecordIds.has(record.id)),+ });++ return new Set([...sharedRecordIds, ...readableThroughParentIds]);+ }+ default:+ return assertUnreachable(expression);+ }+};diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.tsindex 9f05ec547de..a0bf6f2a09a 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts@@ -3,7 +3,7 @@import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';import { type RecordShareAccessLevel } from 'twenty-shared/types';-import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';// Mirrors buildRecordShareExceptionCondition for records already in memory@@ -12,7 +12,7 @@ export const resolveRecordIdsRestrictedForPrincipals = ({principalIds,accessLevels,}: {- recordShares: RecordShare[];+ recordShares: RecordShareGrant[];principalIds: string[];accessLevels: RecordShareAccessLevel[];}): Set<string> => {diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.tsindex eff44f61040..c89e1c54e3b 100644--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts@@ -2,14 +2,14 @@import { type RecordShareAccessLevel } from 'twenty-shared/types';-import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';export const resolveRecordIdsSharedWithPrincipals = ({recordShares,principalIds,accessLevels,}: {- recordShares: RecordShare[];+ recordShares: RecordShareGrant[];principalIds: string[];accessLevels: RecordShareAccessLevel[];}): Set<string> =>diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.tsindex fd4a24d14c5..58cb1f1aa02 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts@@ -61,6 +61,8 @@ describe('webhook mandatory visibility', () => {]) {getOrRecompute.mockResolvedValue({flatObjectMetadataMaps,+ flatFieldMetadataMapsOrm: maps,+ featureFlagsMap: {},flatWebhookMaps: {...maps,byUniversalIdentifier: {diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.tsindex 51bfef2fcd3..292cea9a361 100644--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts@@ -118,8 +118,6 @@ describe('ObjectRecordEventPublisher', () => {getRepository: jest.Mock;};- const companyObjectMetadata: FlatObjectMetadata = COMPANY_FLAT_OBJECT_MOCK;-const companyNameField = getFlatFieldMetadataMock({objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,type: FieldMetadataType.TEXT,@@ -129,9 +127,29 @@ describe('ObjectRecordEventPublisher', () => {workspaceId,});- const mockFlatFieldMetadataMaps = buildFlatFieldMetadataMaps([- companyNameField,- ]);+ const rowLevelPermissionFilteredFields = [+ 'status',+ 'assigneeId',+ 'locale',+ ].map((name) =>+ getFlatFieldMetadataMock({+ objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,+ type: FieldMetadataType.TEXT,+ name,+ label: name,+ universalIdentifier: `company-${name}-field-universal-id`,+ workspaceId,+ }),+ );++ const companyFields = [companyNameField, ...rowLevelPermissionFilteredFields];++ const companyObjectMetadata: FlatObjectMetadata = {+ ...COMPANY_FLAT_OBJECT_MOCK,+ fieldIds: companyFields.map((field) => field.id),+ };++ const mockFlatFieldMetadataMaps = buildFlatFieldMetadataMaps(companyFields);const mockUserWorkspaceRoleMap: Record<string, string> = {[userWorkspaceId]: roleId,@@ -218,6 +236,8 @@ describe('ObjectRecordEventPublisher', () => {},flatFieldMetadataMaps:overrides.flatFieldMetadataMaps ?? mockFlatFieldMetadataMaps,+ flatFieldMetadataMapsOrm:+ overrides.flatFieldMetadataMaps ?? mockFlatFieldMetadataMaps,userWorkspaceRoleMap:overrides.userWorkspaceRoleMap ?? mockUserWorkspaceRoleMap,rolesPermissions: overrides.rolesPermissions ?? mockRolesPermissions,diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.tsindex 93deb209b7d..fa75592349f 100644--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts@@ -6,12 +6,10 @@ import {} from 'twenty-shared/constants';import { type ObjectRecordEvent } from 'twenty-shared/database-events';import {- FeatureFlagKey,Nullable,ObjectRecord,type ObjectsPermissions,type ObjectsPermissionsByRoleId,- type RecordGqlOperationFilter,type RecordGqlOperationSignature,} from 'twenty-shared/types';import {@@ -39,7 +37,6 @@ import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadaimport { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';-import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';import { omitInheritedReadabilityChildRecords } from 'src/engine/core-modules/record-share/utils/omit-inherited-readability-child-records.util';import { omitRestrictedFieldsFromEvent } from 'src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util';import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';@@ -69,7 +66,6 @@ type StreamPermissionsContext = {rolesPermissions: ObjectsPermissionsByRoleId;roleIdsWithAllRecordsAccess: string[];flatApplicationMaps: FlatApplicationCacheMaps;- isRecordSharingEnabled: boolean;};@Injectable()@@ -187,20 +183,6 @@ export class ObjectRecordEventPublisher {return;}- const objectPermissions =- objectsPermissions[workspaceEventBatch.objectMetadata.id];- // The access gate then admits only the records named for the subscriber- // beyond their role and row filter- const isGrantBeyondRoleAllowed = isRecordGrantBeyondRoleAllowed({- flatObjectMetadata: workspaceEventBatch.objectMetadata,- operationType: 'select',- isRecordSharingEnabled: permissionsContext.isRecordSharingEnabled,- });-- if (!objectPermissions?.canReadObjectRecords && !isGrantBeyondRoleAllowed) {- return;- }-const objectNameSingular = workspaceEventBatch.objectMetadata.nameSingular;if (@@ -226,16 +208,6 @@ export class ObjectRecordEventPublisher {}),};- const subscriberRLSFilter = isGrantBeyondRoleAllowed- ? null- : this.buildSubscriberRLSFilter(- subscriberAuthContext,- roleIds,- workspaceEventBatch.objectMetadata,- permissionsContext,- flatWorkspaceMemberMaps,- );-const admittedRecordIds =await eventRecordAccessGate.resolveAdmittedRecordIds(this.buildSubscriberRowAccessPolicySubject({@@ -247,7 +219,13 @@ export class ObjectRecordEventPublisher {}),);- const restrictedFields = objectPermissions?.restrictedFields ?? {};+ if (admittedRecordIds.size === 0) {+ return;+ }++ const restrictedFields =+ objectsPermissions[workspaceEventBatch.objectMetadata.id]+ ?.restrictedFields ?? {};for (const event of workspaceEventBatch.events) {const { action } = parseEventNameOrThrow(workspaceEventBatch.name);@@ -282,7 +260,6 @@ export class ObjectRecordEventPublisher {const matchedQueryIds = this.getMatchingObjectRecordQueryIds({queries: streamData.queries,event: filteredEvent,- subscriberRLSFilter,objectMetadata: workspaceEventBatch.objectMetadata,flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,});@@ -466,33 +443,6 @@ export class ObjectRecordEventPublisher {return computePermissionIntersection(allRolePermissions);}- private buildSubscriberRLSFilter(- subscriberAuthContext: SerializableAuthContext,- roleIds: string[],- objectMetadata: FlatObjectMetadata,- permissionsContext: {- flatRowLevelPermissionPredicateMaps: FlatRowLevelPermissionPredicateMaps;- flatRowLevelPermissionPredicateGroupMaps: FlatRowLevelPermissionPredicateGroupMaps;- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;- },- flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps,- ): RecordGqlOperationFilter | null {- const workspaceMember = isDefined(subscriberAuthContext.workspaceMemberId)- ? flatWorkspaceMemberMaps.byId[subscriberAuthContext.workspaceMemberId]- : undefined;-- return buildRowLevelPermissionRecordFilter({- flatRowLevelPermissionPredicateMaps:- permissionsContext.flatRowLevelPermissionPredicateMaps,- flatRowLevelPermissionPredicateGroupMaps:- permissionsContext.flatRowLevelPermissionPredicateGroupMaps,- flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,- objectMetadata,- roleIds,- workspaceMember,- });- }-private buildWorkspaceMemberIdByUserId(flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps,): Map<string, string> {@@ -567,13 +517,20 @@ export class ObjectRecordEventPublisher {isDefined(objectMetadata.applicationId) &&subscriberAuthContext.applicationId === objectMetadata.applicationId,resolveRowLevelPermissionRecordFilter: (objectMetadata) => {- const recordFilter = this.buildSubscriberRLSFilter(- subscriberAuthContext,- roleIds,+ const recordFilter = buildRowLevelPermissionRecordFilter({+ flatRowLevelPermissionPredicateMaps:+ permissionsContext.flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps:+ permissionsContext.flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,objectMetadata,- permissionsContext,- flatWorkspaceMemberMaps,- );+ roleIds,+ workspaceMember: isDefined(subscriberAuthContext.workspaceMemberId)+ ? flatWorkspaceMemberMaps.byId[+ subscriberAuthContext.workspaceMemberId+ ]+ : undefined,+ });return isDefined(recordFilter) && Object.keys(recordFilter).length > 0? recordFilter@@ -585,13 +542,11 @@ export class ObjectRecordEventPublisher {private getMatchingObjectRecordQueryIds({queries,event,- subscriberRLSFilter,objectMetadata,flatFieldMetadataMaps,}: {queries: Record<string, RecordOrMetadataGqlOperationSignature>;event: ObjectRecordSubscriptionEvent;- subscriberRLSFilter: RecordGqlOperationFilter | null;objectMetadata: FlatObjectMetadata;flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;}): string[] {@@ -606,7 +561,6 @@ export class ObjectRecordEventPublisher {this.isQueryMatchingObjectRecordEvent({operationSignature,event,- subscriberRLSFilter,objectMetadata,flatFieldMetadataMaps,})@@ -621,13 +575,11 @@ export class ObjectRecordEventPublisher {private isQueryMatchingObjectRecordEvent({operationSignature,event,- subscriberRLSFilter,objectMetadata,flatFieldMetadataMaps,}: {operationSignature: RecordGqlOperationSignature;event: ObjectRecordSubscriptionEvent;- subscriberRLSFilter: RecordGqlOperationFilter | null;objectMetadata: FlatObjectMetadata;flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;}): boolean {@@ -650,20 +602,6 @@ export class ObjectRecordEventPublisher {event.action === DatabaseEventAction.DELETED ||event.action === DatabaseEventAction.RESTORED;- if (- isDefined(subscriberRLSFilter) &&- Object.keys(subscriberRLSFilter).length > 0 &&- !isRecordMatchingRLSRowLevelPermissionPredicate({- record: deliveredRecord,- filter: subscriberRLSFilter,- flatObjectMetadata: objectMetadata,- flatFieldMetadataMaps,- shouldIgnoreSoftDeleteDefaultFilter,- })- ) {- return false;- }-const queryFilter = operationSignature.variables?.filter ?? {};if (Object.keys(queryFilter).length === 0) {@@ -697,7 +635,6 @@ export class ObjectRecordEventPublisher {rolesPermissions,roleIdsWithAllRecordsAccess,flatApplicationMaps,- featureFlagsMap,} = await this.workspaceCacheService.getOrRecompute(workspaceId, ['flatRowLevelPermissionPredicateMaps','flatRowLevelPermissionPredicateGroupMaps',@@ -706,7 +643,6 @@ export class ObjectRecordEventPublisher {'rolesPermissions','roleIdsWithAllRecordsAccess','flatApplicationMaps',- 'featureFlagsMap',]);return {@@ -717,9 +653,6 @@ export class ObjectRecordEventPublisher {rolesPermissions,roleIdsWithAllRecordsAccess,flatApplicationMaps,- isRecordSharingEnabled:- featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ??- false,};}}diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.tsindex 4eb5fc06084..e58e7b2beec 100644--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts@@ -38,13 +38,23 @@ import { type InheritedReadabilityColumnParent } from 'src/engine/core-modules/rimport { type InheritedReadabilityParent } from 'src/engine/core-modules/record-share/types/inherited-readability-parent.type';import { type InheritedReadabilityParentLink } from 'src/engine/core-modules/record-share/types/inherited-readability-parent-link.type';import {+ type RowAccessExpression,type RowAccessPolicy,+ type RowAccessCompilationEnvironment,type RowAccessPolicyEnvironment,type RowAccessPolicySubject,+ type SqlCondition,} from 'src/engine/twenty-orm/types/row-access-policy.type';+import { compileRowAccessExpression } from 'src/engine/twenty-orm/utils/compile-row-access-policy.util';import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';import { buildRowAccessPolicy } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';-import { buildNamedRecordGrantCondition } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util';+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';+import {+ evaluateRowAccessPolicy,+ type RowAccessEvaluationContext,+ type RowAccessRecord,+} from 'src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util';+import { isRowAccessExpressionReadingRoleFilter } from 'src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util';import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';@@ -1056,9 +1066,13 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {updatedColumns: insertedColumns,});- this.validateRLSPredicatesForWrittenRecords(- this.formatResult<ObjectRecord[]>(formattedRecords),- );+ validateRLSPredicatesForRecords({+ records: this.formatResult<ObjectRecord[]>(formattedRecords),+ objectMetadata: this.options.flatObjectMetadata,+ internalContext: this.options.internalContext,+ authContext: this.options.authContext,+ shouldBypassPermissionChecks: this.options.shouldBypassPermissionChecks,+ });await this.validateInheritedParentsAreWritableOrThrow({writtenRecords: formattedRecords,@@ -1213,13 +1227,11 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {}await this.validateRLSPredicatesForUpdatedRecords(- this.formatResult<ObjectRecord[]>(- setColumnsByInputIndex.flatMap((setColumns, index) =>- rawBeforeByInputIndex[index].map((record) => ({- ...record,- ...setColumns,- })),- ),+ setColumnsByInputIndex.flatMap((setColumns, index) =>+ rawBeforeByInputIndex[index].map((rawRecordBefore) => ({+ rawRecordBefore,+ setColumns,+ })),),);@@ -1700,9 +1712,10 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {if (kind === 'update' && isDefined(setColumns)) {await this.validateRLSPredicatesForUpdatedRecords(- this.formatResult<ObjectRecord[]>(- recordsBefore.map((record) => ({ ...record, ...setColumns })),- ),+ recordsBefore.map((rawRecordBefore) => ({+ rawRecordBefore,+ setColumns,+ })),);}@@ -1910,83 +1923,121 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {});}- // A record shared by name for editing stays editable whatever the row- // filter of the role says, as the row access policy let it through+ // An update must not move a record out of the update policy. Records it+ // did not admit before are left to the update query, which skips themprivate async validateRLSPredicatesForUpdatedRecords(- records: ObjectRecord[],+ updates: {+ rawRecordBefore: ObjectRecord;+ setColumns: Record<string, unknown>;+ }[],): Promise<void> {- const recordIdsGrantedForUpdate =- await this.findRecordIdsGrantedForUpdateByName(- records.map((record) => record.id).filter(isDefined),- );+ if (this.options.shouldBypassPermissionChecks) {+ return;+ }- this.validateRLSPredicatesForWrittenRecords(- records.filter(- (record) =>- !isDefined(record.id) || !recordIdsGrantedForUpdate.has(record.id),- ),- 'Updated record does not satisfy row-level security constraints of your current role',- );- }+ const policy = this.buildRowAccessPolicy({+ subject: this.resolveRowAccessPolicySubject(),+ operationType: 'update',+ });- private async findRecordIdsGrantedForUpdateByName(- recordIds: string[],- ): Promise<Set<string>> {+ // Without a role filter the policy reads nothing an update can change:+ // shares are keyed by id and parents are checked on their ownif (- this.options.shouldBypassPermissionChecks ||- recordIds.length === 0 ||- !isRecordGrantBeyondRoleAllowed({- flatObjectMetadata: this.options.flatObjectMetadata,- operationType: 'update',- isRecordSharingEnabled: this.isRecordSharingEnabled,- })+ policy.kind !== 'gated' ||+ !isRowAccessExpressionReadingRoleFilter(policy.expression)) {- return new Set();+ return;}- const tableAlias = this.options.tableShape.nameSingular;- const namedRecordGrantCondition = buildNamedRecordGrantCondition(- {- subject: this.resolveRowAccessPolicySubject(),- environment: this.resolveRowAccessPolicyEnvironment(),- },- {- tableAlias,- flatObjectMetadata: this.options.flatObjectMetadata,- operationType: 'update',- depth: 0,- },+ const context = this.buildWriteRowAccessEvaluationContext(+ updates.map(({ rawRecordBefore }) => String(rawRecordBefore.id)),);+ const evaluate = (records: ObjectRecord[]) =>+ evaluateRowAccessPolicy({+ policy,+ records: this.formatResult<ObjectRecord[]>(records).filter(+ (record): record is RowAccessRecord => isNonEmptyString(record.id),+ ),+ context,+ });- if (!isDefined(namedRecordGrantCondition)) {- return new Set();+ const admittedRecordIdsBefore = await evaluate(+ updates.map(({ rawRecordBefore }) => rawRecordBefore),+ );+ const admittedRecordIdsAfter = await evaluate(+ updates+ .filter(({ rawRecordBefore }) =>+ admittedRecordIdsBefore.has(String(rawRecordBefore.id)),+ )+ .map(({ rawRecordBefore, setColumns }) => ({+ ...rawRecordBefore,+ ...setColumns,+ })),+ );++ if (+ [...admittedRecordIdsBefore].some((id) => !admittedRecordIdsAfter.has(id))+ ) {+ throw new TwentyOrmException(+ 'Updated record does not satisfy row-level security constraints of your current role',+ TwentyOrmExceptionCode.RLS_VALIDATION_FAILED,+ );}+ }- const grantedRecords = await this.buildIdsEventSnapshotQueryBuilder(- recordIds,- )- .select(['id'])- .andWhere(- namedRecordGrantCondition.sql,- namedRecordGrantCondition.parameters,- )- .getMany<ObjectRecord>({ noFormatting: true });+ private buildWriteRowAccessEvaluationContext(+ recordIds: string[],+ ): RowAccessEvaluationContext<RowAccessRecord> {+ const recordShareGrantsByObjectMetadataId = new Map<+ string,+ Promise<RecordShareGrant[]>+ >();++ return {+ flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,+ shouldIgnoreSoftDeleteDefaultFilter: false,+ fetchRecordShares: async ({+ objectMetadataId,+ recordIds: requestedRecordIds,+ }) => {+ const recordShareGrants =+ recordShareGrantsByObjectMetadataId.get(objectMetadataId) ??+ this.findRecordShareGrants({ objectMetadataId, recordIds });++ recordShareGrantsByObjectMetadataId.set(+ objectMetadataId,+ recordShareGrants,+ );- return new Set(grantedRecords.map((record) => String(record.id)));+ const requestedRecordIdSet = new Set(requestedRecordIds);++ return (await recordShareGrants).filter((recordShareGrant) =>+ requestedRecordIdSet.has(recordShareGrant.recordId),+ );+ },+ // Writes check parents before and after through+ // validateInheritedParentsAreWritableOrThrow, so this branch only has to+ // leave the rest of the policy to decide+ resolveRecordIdsReadableThroughParents: async ({ records }) =>+ new Set(records.map((record) => record.id)),+ };}- private validateRLSPredicatesForWrittenRecords(- records: ObjectRecord[],- errorMessage?: string,- ): void {- validateRLSPredicatesForRecords({- records,- objectMetadata: this.options.flatObjectMetadata,- internalContext: this.options.internalContext,- authContext: this.options.authContext,- shouldBypassPermissionChecks: this.options.shouldBypassPermissionChecks,- ...(isDefined(errorMessage) ? { errorMessage } : {}),- });+ private async findRecordShareGrants({+ objectMetadataId,+ recordIds,+ }: {+ objectMetadataId: string;+ recordIds: string[];+ }): Promise<RecordShareGrant[]> {+ if (recordIds.length === 0) {+ return [];+ }++ return this.executeRaw<RecordShareGrant>(+ `SELECT "recordId", "principalId", "accessLevel" FROM ${this.resolveRowAccessPolicyEnvironment().recordShareTableExpression} WHERE "objectMetadataId" = :objectMetadataId AND "recordId" = ANY(:recordIds) AND "deletedAt" IS NULL`,+ { objectMetadataId, recordIds },+ );}private emitMutationEvent({@@ -2163,7 +2214,11 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {return;case 'gated':- this.addConditionForAlias({ queryBuilder, alias, ...policy.condition });+ this.addConditionForAlias({+ queryBuilder,+ alias,+ ...this.compileRowAccessExpression(policy.expression),+ });return;default:@@ -2171,6 +2226,47 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {}}+ // Records already in hand, deleted ones included, filtered by a policy;+ // the alias must be the one the policy was built with+ async findRecordIdsAdmittedByRowAccessPolicy({+ recordIds,+ policy,+ tableAlias = this.options.tableShape.nameSingular,+ }: {+ recordIds: string[];+ policy: RowAccessPolicy;+ tableAlias?: string;+ }): Promise<Set<string>> {+ if (recordIds.length === 0 || policy.kind === 'denied') {+ return new Set();+ }++ if (policy.kind === 'open') {+ return new Set(recordIds);+ }++ const condition = this.compileRowAccessExpression(policy.expression);+ const admittedRecords = await this.buildBypassingEventSelectQueryBuilder(+ tableAlias,+ )+ .where({ id: In(recordIds) })+ .withDeleted()+ .select(['id'])+ .andWhere(condition.sql, condition.parameters)+ .getMany<ObjectRecord>({ noFormatting: true });++ return new Set(admittedRecords.map((record) => String(record.id)));+ }++ private compileRowAccessExpression(+ expression: RowAccessExpression,+ ): SqlCondition {+ return compileRowAccessExpression({+ expression,+ environment: this.resolveRowAccessPolicyEnvironment(),+ });+ }+// Whether the role alone permits the operation, regardless of any record// grant that may reach beyond itisObjectOperationPermittedByRole(operationType: OperationType): boolean {@@ -2260,7 +2356,8 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {};}- private resolveRowAccessPolicyEnvironment(): RowAccessPolicyEnvironment {+ private resolveRowAccessPolicyEnvironment(): RowAccessPolicyEnvironment &+ RowAccessCompilationEnvironment {return {flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,flatObjectMetadataMaps:diff --git a/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.tsindex da891d76d9f..719c056a411 100644--- a/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts+++ b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts@@ -3,6 +3,7 @@ import { type ObjectLiteral } from 'typeorm';import {type ObjectsPermissions,type RecordGqlOperationFilter,+ type RecordShareAccessLevel,} from 'twenty-shared/types';import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';@@ -13,7 +14,60 @@ import { type WorkspaceRelationShape } from 'src/engine/twenty-orm/table-shape/texport type SqlCondition = { sql: string; parameters: ObjectLiteral };+// One description of who may access which rows, compiled to SQL for queries+// and evaluated on records in memory for writes and events, so both always+// decide the same way+export type RowAccessExpression =+ | { kind: 'and'; operands: RowAccessExpression[] }+ | { kind: 'or'; operands: RowAccessExpression[] }+ | {+ kind: 'roleFilter';+ tableAlias: string;+ flatObjectMetadata: FlatObjectMetadata;+ recordFilter: RecordGqlOperationFilter;+ condition: SqlCondition;+ }+ | ({+ kind: 'recordShared';+ // Compiled as a grant list read once, so it can be ORed with an indexed filter+ isUncorrelated?: boolean;+ } & RecordShareExpressionTarget)+ | ({ kind: 'recordNotRestricted' } & RecordShareExpressionTarget)+ | ({+ kind: 'inheritedReadability';+ parents: InheritedReadabilityParentExpression[];+ isOpenWhenDetached: boolean;+ } & RecordShareExpressionTarget);++export type RecordShareExpressionTarget = {+ tableAlias: string;+ objectMetadataId: string;+ principalIds: string[];+ accessLevels: RecordShareAccessLevel[];+};++export type InheritedReadabilityParentExpression =+ | {+ kind: 'column';+ joinColumnName: string;+ parentTableAlias: string;+ parentFlatObjectMetadata: FlatObjectMetadata;+ policy: RowAccessPolicy;+ }+ | {+ kind: 'children';+ childTableAlias: string;+ childJoinColumnName: string;+ childFlatObjectMetadata: FlatObjectMetadata;+ policy: RowAccessPolicy;+ };+export type RowAccessPolicy =+ | { kind: 'open' }+ | { kind: 'denied' }+ | { kind: 'gated'; expression: RowAccessExpression };++export type CompiledRowAccessPolicy =| { kind: 'open' }| { kind: 'denied' }| { kind: 'gated'; condition: SqlCondition };@@ -32,9 +86,12 @@ export type RowAccessPolicySubject = {export type RowAccessPolicyEnvironment = {flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+ isRecordSharingEnabled: boolean;+};++export type RowAccessCompilationEnvironment = {recordShareTableExpression: string;resolveTableExpression: (objectMetadataId: string) => string;- isRecordSharingEnabled: boolean;};export type RowAccessPolicyContext = {diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.tsindex 0fb2d6bff94..a4429d65cc9 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts@@ -9,10 +9,12 @@ import {import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';import {+ type RowAccessCompilationEnvironment,type RowAccessPolicyEnvironment,type RowAccessPolicySubject,} from 'src/engine/twenty-orm/types/row-access-policy.type';import { buildRowAccessPolicy } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';+import { compileRowAccessPolicy } from 'src/engine/twenty-orm/utils/compile-row-access-policy.util';import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';@@ -54,7 +56,8 @@ const person = buildObject({readability: MetadataReadability.PRIVATE,});-const environment: RowAccessPolicyEnvironment = {+const environment: RowAccessPolicyEnvironment &+ RowAccessCompilationEnvironment = {flatFieldMetadataMaps: { byId: {} } as never,flatObjectMetadataMaps: { byId: {} } as never,recordShareTableExpression: '"workspace"."recordShare"',@@ -63,6 +66,16 @@ const environment: RowAccessPolicyEnvironment = {isRecordSharingEnabled: false,};+const buildCompiledRowAccessPolicy = (+ args: Parameters<typeof buildRowAccessPolicy>[0] & {+ environment: typeof environment;+ },+) =>+ compileRowAccessPolicy({+ policy: buildRowAccessPolicy(args),+ environment: args.environment,+ });+const readEverything: RowAccessPolicySubject = {isSystemContext: false,objectsPermissions: undefined,@@ -76,7 +89,7 @@ const build = (subject: RowAccessPolicySubject,flatObjectMetadata: FlatObjectMetadata,) =>- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject,environment,tableAlias: flatObjectMetadata.nameSingular,@@ -125,7 +138,7 @@ describe('buildRowAccessPolicy', () => {(readability) => {for (const operationType of ['select', 'update', 'delete'] as const) {expect(- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject: {...readEverything,isSystemContext: true,@@ -163,7 +176,7 @@ describe('buildRowAccessPolicy', () => {id: 'company',readability: MetadataReadability.OPEN,});- const policy = buildRowAccessPolicy({+ const policy = buildCompiledRowAccessPolicy({subject: readEverything,environment: { ...environment, isRecordSharingEnabled: true },tableAlias: 'company',@@ -181,7 +194,7 @@ describe('buildRowAccessPolicy', () => {it('lifts the restrictions of an OPEN object for a subject with access to all records', () => {expect(- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject: { ...readEverything, canAccessAllRecords: true },environment: { ...environment, isRecordSharingEnabled: true },tableAlias: 'note',@@ -200,7 +213,7 @@ describe('buildRowAccessPolicy', () => {it('keeps an OPEN system object open when record sharing is enabled', () => {expect(- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject: readEverything,environment: { ...environment, isRecordSharingEnabled: true },tableAlias: 'note',@@ -213,7 +226,7 @@ describe('buildRowAccessPolicy', () => {it('leaves an OPEN object open to inserts when record sharing is enabled', () => {expect(- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject: readEverything,environment: { ...environment, isRecordSharingEnabled: true },tableAlias: 'note',@@ -234,7 +247,7 @@ describe('buildRowAccessPolicy', () => {subject: RowAccessPolicySubject,operationType: 'select' | 'update' | 'delete' = 'select',) =>- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject,environment: sharingEnvironment,tableAlias: 'company',@@ -316,7 +329,7 @@ describe('buildRowAccessPolicy', () => {it('keeps the role limits when the object restricts sharing to the role', () => {expect(- buildRowAccessPolicy({+ buildCompiledRowAccessPolicy({subject: withoutObjectPermission,environment: sharingEnvironment,tableAlias: 'company',@@ -412,7 +425,7 @@ describe('buildRowAccessPolicy', () => {},},]);- const policy = buildRowAccessPolicy({+ const policy = buildCompiledRowAccessPolicy({subject: readEverything,environment,tableAlias: 'attachment',@@ -428,7 +441,7 @@ describe('buildRowAccessPolicy', () => {);it('keeps private records gated regardless of the sharing UI flag', () => {- const policy = buildRowAccessPolicy({+ const policy = buildCompiledRowAccessPolicy({subject: readEverything,environment,tableAlias: 'person',diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.tsindex d971b33d86e..ebb4ecb5dc6 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts@@ -142,6 +142,16 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {},),createMockFlatFieldMetadata('users-id', 'users', FieldMetadataType.ARRAY),+ createMockFlatFieldMetadata(+ 'created-by-id',+ 'createdBy',+ FieldMetadataType.ACTOR,+ ),+ createMockFlatFieldMetadata(+ 'emails-id',+ 'emails',+ FieldMetadataType.EMAILS,+ ),];const flatObjectMetadata = createMockFlatObjectMetadata(@@ -161,6 +171,15 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {},companyId: 'company-1',users: ['user-1', 'user-2'],+ createdBy: {+ source: 'MANUAL',+ name: 'Jane Doe',+ workspaceMemberId: 'member-1',+ },+ emails: {+ primaryEmail: '[email protected]',+ additionalEmails: ['[email protected]'],+ },deletedAt: null,id: 'record-1',createdAt: new Date().toISOString(),@@ -288,26 +307,154 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {expect(result).toBe(false);});- it('matches composite address filters using at least one sub-field', () => {- const result = isRecordMatchingRLSRowLevelPermissionPredicate({- record: baseRecord,- filter: {- address: {- addressStreet1: {- eq: 'Main Street',+ it.each([+ ['London', false],+ ['Paris', true],+ ])(+ 'requires every composite sub-field to match, as SQL does (city %s)',+ (addressCity, expected) => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: baseRecord,+ filter: {+ address: {+ addressStreet1: { eq: 'Main Street' },+ addressCity: { eq: addressCity },+ },},- addressCity: {- eq: 'London',+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(expected);+ },+ );++ it('never matches a composite sub-field it cannot read', () => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: baseRecord,+ filter: {+ address: {+ addressCity: { eq: 'Paris' },+ addressPlanet: { eq: 'Earth' },},+ } as RecordGqlOperationFilter,+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(false);+ });++ it.each([+ ['the creator', 'member-1', true],+ ['another member', 'member-2', false],+ ])(+ 'matches an actor on its workspace member, for %s',+ (_, workspaceMemberId, expected) => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: baseRecord,+ filter: {+ createdBy: { workspaceMemberId: { eq: workspaceMemberId } },+ },+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(expected);+ },+ );++ it('treats a null actor source as no constraint', () => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: baseRecord,+ filter: {+ createdBy: { source: null, name: { eq: 'Jane Doe' } },+ } as RecordGqlOperationFilter,+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(true);+ });++ it.each([+ ['%jane.doe%', true],+ ['%john%', false],+ ])('matches additional emails like %s', (like, expected) => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: baseRecord,+ filter: { emails: { additionalEmails: { like } } },+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(expected);+ });++ it('never lets a null JSON sub-field match a like pattern', () => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: {+ ...baseRecord,+ emails: { primaryEmail: '[email protected]', additionalEmails: null },},- },- flatObjectMetadata,- flatFieldMetadataMaps,- });+ filter: { emails: { additionalEmails: { like: '%null%' } } },+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(false);+ });- expect(result).toBe(true);+ it('matches address coordinates', () => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: {+ ...baseRecord,+ address: { ...baseRecord.address, addressLat: 48.85 },+ },+ filter: {+ address: { addressLat: { gte: 48 } },+ } as RecordGqlOperationFilter,+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(true);});+ it('treats null and empty sub-field filters as no constraint', () => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: baseRecord,+ filter: {+ name: { firstName: null, lastName: { eq: 'Doe' } },+ address: { addressLat: {}, addressCity: { eq: 'Paris' } },+ } as RecordGqlOperationFilter,+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(true);+ });++ it.each([+ ['createdBy', { context: { is: 'NULL' } }, true],+ ['createdBy', { context: { is: 'NOT_NULL' } }, false],+ ['address', { addressLat: { is: 'NULL' } }, true],+ ['address', { addressCity: { eq: 'Paris' } }, false],+ ['name', { firstName: { is: 'NULL' } }, true],+ ])(+ 'reads a null %s as null sub-fields for %j',+ (fieldName, subFieldFilter, expected) => {+ expect(+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: { ...baseRecord, [fieldName]: null },+ filter: { [fieldName]: subFieldFilter } as RecordGqlOperationFilter,+ flatObjectMetadata,+ flatFieldMetadataMaps,+ }),+ ).toBe(expected);+ },+ );+it('supports relation join column filters', () => {const result = isRecordMatchingRLSRowLevelPermissionPredicate({record: baseRecord,diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-row-access-expression-reading-role-filter.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-row-access-expression-reading-role-filter.util.spec.tsnew file mode 100644index 00000000000..36268579ffe--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-row-access-expression-reading-role-filter.util.spec.ts@@ -0,0 +1,52 @@+/* @license Enterprise */++import { RecordShareAccessLevel } from 'twenty-shared/types';++import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';+import { type RowAccessExpression } from 'src/engine/twenty-orm/types/row-access-policy.type';+import { isRowAccessExpressionReadingRoleFilter } from 'src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util';++const recordShared: RowAccessExpression = {+ kind: 'recordShared',+ tableAlias: 'company',+ objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,+ principalIds: ['member-1'],+ accessLevels: [RecordShareAccessLevel.READ_WRITE],+};++const roleFilter: RowAccessExpression = {+ kind: 'roleFilter',+ tableAlias: 'company',+ flatObjectMetadata: COMPANY_FLAT_OBJECT_MOCK,+ recordFilter: { name: { eq: 'Acme' } },+ condition: { sql: 'TRUE', parameters: {} },+};++describe('isRowAccessExpressionReadingRoleFilter', () => {+ it('finds a role filter nested in and/or', () => {+ expect(+ isRowAccessExpressionReadingRoleFilter({+ kind: 'or',+ operands: [{ kind: 'and', operands: [roleFilter] }, recordShared],+ }),+ ).toBe(true);+ });++ it('ignores expressions reading only shares', () => {+ expect(+ isRowAccessExpressionReadingRoleFilter({+ kind: 'and',+ operands: [+ recordShared,+ { ...recordShared, kind: 'recordNotRestricted' },+ {+ ...recordShared,+ kind: 'inheritedReadability',+ parents: [],+ isOpenWhenDetached: false,+ },+ ],+ }),+ ).toBe(false);+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.tsindex 8b2fc53fa85..0b250d39841 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts@@ -1,16 +1,15 @@import { isMetadataWritePermitted } from 'src/engine/twenty-orm/utils/is-metadata-write-permitted.util';import { isDefined } from 'twenty-shared/utils';-import { buildNamedRecordGrantCondition } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util';+import { buildNamedRecordGrantExpression } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util';import { buildRecordShareGate } from 'src/engine/core-modules/record-share/utils/build-record-share-gate.util';import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';import {+ type RowAccessExpression,type RowAccessPolicy,type RowAccessPolicyContext,type RowAccessPolicyTarget,- type SqlCondition,} from 'src/engine/twenty-orm/types/row-access-policy.type';-import { combineSqlConditions } from 'src/engine/twenty-orm/utils/combine-sql-conditions.util';import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';@@ -38,12 +37,12 @@ export const buildRowAccessPolicy = ({return { kind: 'denied' };}- const namedRecordGrantCondition = isRecordGrantBeyondRoleAllowed({+ const namedRecordGrant = isRecordGrantBeyondRoleAllowed({flatObjectMetadata: target.flatObjectMetadata,operationType: target.operationType,isRecordSharingEnabled: environment.isRecordSharingEnabled,})- ? buildNamedRecordGrantCondition(context, target)+ ? buildNamedRecordGrantExpression(context, target): undefined;if (@@ -54,8 +53,8 @@ export const buildRowAccessPolicy = ({objectsPermissions: subject.objectsPermissions,})) {- return isDefined(namedRecordGrantCondition)- ? { kind: 'gated', condition: namedRecordGrantCondition }+ return isDefined(namedRecordGrant)+ ? { kind: 'gated', expression: namedRecordGrant }: { kind: 'denied' };}@@ -70,35 +69,35 @@ export const buildRowAccessPolicy = ({return { kind: 'denied' };}- const rolePredicate = buildRolePredicate(context, target);- const conditions = [- rolePredicate,- recordShareGate.kind === 'gated' ? recordShareGate.condition : undefined,+ const roleFilter = buildRoleFilterExpression(context, target);+ const operands = [+ roleFilter,+ recordShareGate.kind === 'gated' ? recordShareGate.expression : undefined,].filter(isDefined);- if (conditions.length === 0) {+ if (operands.length === 0) {return { kind: 'open' };}- // The share gate already admits named grants, so only a role predicate- // keeps one out and needs the grant as an alternative- if (isDefined(rolePredicate) && isDefined(namedRecordGrantCondition)) {+ // The share gate already admits named grants, so only a role filter keeps+ // one out and needs the grant as an alternative+ if (isDefined(roleFilter) && isDefined(namedRecordGrant)) {return {kind: 'gated',- condition: combineSqlConditions(- [combineSqlConditions(conditions), namedRecordGrantCondition],- 'OR',- ),+ expression: {+ kind: 'or',+ operands: [{ kind: 'and', operands }, namedRecordGrant],+ },};}- return { kind: 'gated', condition: combineSqlConditions(conditions) };+ return { kind: 'gated', expression: { kind: 'and', operands } };};-const buildRolePredicate = (+const buildRoleFilterExpression = ({ subject, environment }: RowAccessPolicyContext,{ tableAlias, flatObjectMetadata }: RowAccessPolicyTarget,-): SqlCondition | undefined => {+): RowAccessExpression | undefined => {const recordFilter =subject.resolveRowLevelPermissionRecordFilter(flatObjectMetadata);@@ -106,12 +105,23 @@ const buildRolePredicate = (return undefined;}- return (- renderRowLevelPermissionFilterToSql({- recordFilter,- tableAlias,- objectMetadata: flatObjectMetadata,- flatFieldMetadataMaps: environment.flatFieldMetadataMaps,- }) ?? undefined- );+ const condition = renderRowLevelPermissionFilterToSql({+ recordFilter,+ tableAlias,+ objectMetadata: flatObjectMetadata,+ flatFieldMetadataMaps: environment.flatFieldMetadataMaps,+ });++ // A filter whose predicates all cancel out restricts nothing+ if (condition === null) {+ return undefined;+ }++ return {+ kind: 'roleFilter',+ tableAlias,+ flatObjectMetadata,+ recordFilter,+ condition,+ };};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/compile-row-access-policy.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/compile-row-access-policy.util.tsnew file mode 100644index 00000000000..7d95fbb72c7--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/compile-row-access-policy.util.ts@@ -0,0 +1,99 @@+import { assertUnreachable } from 'twenty-shared/utils';++import { buildInheritedReadabilityCondition } from 'src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util';+import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';+import { buildRecordShareExceptionCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util';+import {+ type CompiledRowAccessPolicy,+ type RowAccessExpression,+ type RowAccessPolicy,+ type RowAccessCompilationEnvironment,+ type SqlCondition,+} from 'src/engine/twenty-orm/types/row-access-policy.type';+import { combineSqlConditions } from 'src/engine/twenty-orm/utils/combine-sql-conditions.util';++export const compileRowAccessPolicy = ({+ policy,+ environment,+}: {+ policy: RowAccessPolicy;+ environment: RowAccessCompilationEnvironment;+}): CompiledRowAccessPolicy =>+ policy.kind === 'gated'+ ? {+ kind: 'gated',+ condition: compileRowAccessExpression({+ expression: policy.expression,+ environment,+ }),+ }+ : policy;++export const compileRowAccessExpression = ({+ expression,+ environment,+}: {+ expression: RowAccessExpression;+ environment: RowAccessCompilationEnvironment;+}): SqlCondition => {+ switch (expression.kind) {+ case 'and':+ case 'or':+ return combineSqlConditions(+ expression.operands.map((operand) =>+ compileRowAccessExpression({ expression: operand, environment }),+ ),+ expression.kind === 'or' ? 'OR' : 'AND',+ );+ case 'roleFilter':+ return expression.condition;+ case 'recordShared':+ return buildRecordShareCondition({+ ...expression,+ recordShareTableExpression: environment.recordShareTableExpression,+ });+ case 'recordNotRestricted':+ return buildRecordShareExceptionCondition({+ ...expression,+ recordShareTableExpression: environment.recordShareTableExpression,+ });+ case 'inheritedReadability':+ return buildInheritedReadabilityCondition({+ tableAlias: expression.tableAlias,+ objectMetadataId: expression.objectMetadataId,+ principalIds: expression.principalIds,+ accessLevels: expression.accessLevels,+ isOpenWhenDetached: expression.isOpenWhenDetached,+ recordShareTableExpression: environment.recordShareTableExpression,+ parents: expression.parents.map((parent) =>+ parent.kind === 'column'+ ? {+ kind: 'column',+ joinColumnName: parent.joinColumnName,+ parentTableAlias: parent.parentTableAlias,+ parentTableExpression: environment.resolveTableExpression(+ parent.parentFlatObjectMetadata.id,+ ),+ policy: compileRowAccessPolicy({+ policy: parent.policy,+ environment,+ }),+ }+ : {+ kind: 'children',+ childTableAlias: parent.childTableAlias,+ childJoinColumnName: parent.childJoinColumnName,+ childTableExpression: environment.resolveTableExpression(+ parent.childFlatObjectMetadata.id,+ ),+ policy: compileRowAccessPolicy({+ policy: parent.policy,+ environment,+ }),+ },+ ),+ });+ default:+ return assertUnreachable(expression);+ }+};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.tsindex 1f76bdf15d5..c9e6034962b 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts@@ -3,23 +3,17 @@import { isObject } from '@sniptt/guards';import {FieldMetadataType,- type ActorFilter,- type AddressFilter,type AndObjectRecordFilter,type ArrayFilter,type BooleanFilter,type CurrencyFilter,type DateFilter,- type EmailsFilter,type FloatFilter,- type FullNameFilter,type IsFilter,type LeafObjectRecordFilter,- type LinksFilter,type MultiSelectFilter,type NotObjectRecordFilter,type OrObjectRecordFilter,- type PhonesFilter,type RatingFilter,type RawJsonFilter,type RecordGqlOperationFilter,@@ -74,6 +68,115 @@ const isNotFilter = (filter: RecordGqlOperationFilter,): filter is NotObjectRecordFilter => 'not' in filter && !!filter.not;+type SubFieldMatcher = (subFieldFilter: object, value: unknown) => boolean;++const matchString: SubFieldMatcher = (subFieldFilter, value) =>+ isMatchingStringFilter({+ stringFilter: subFieldFilter as StringFilter,+ value: value as string,+ });++const matchRawJson: SubFieldMatcher = (subFieldFilter, value) =>+ isMatchingRawJsonFilter({+ rawJsonFilter: subFieldFilter as RawJsonFilter,+ value: value as string,+ });++const matchFloat: SubFieldMatcher = (subFieldFilter, value) =>+ isMatchingFloatFilter({+ floatFilter: subFieldFilter as FloatFilter,+ value: value as number,+ });++const matchSelect: SubFieldMatcher = (subFieldFilter, value) =>+ isMatchingSelectFilter({+ selectFilter: subFieldFilter as SelectFilter,+ value: value as string,+ });++const matchUuid: SubFieldMatcher = (subFieldFilter, value) =>+ isMatchingUUIDFilter({+ uuidFilter: subFieldFilter as UUIDFilter,+ value: value as string,+ });++// Row-level predicates can target sub-fields the GraphQL filter types omit,+// such as address coordinates, the actor context or the phone country code+const SUB_FIELD_MATCHERS_BY_COMPOSITE_TYPE: Partial<+ Record<FieldMetadataType, Record<string, SubFieldMatcher>>+> = {+ [FieldMetadataType.FULL_NAME]: {+ firstName: matchString,+ lastName: matchString,+ },+ [FieldMetadataType.ADDRESS]: {+ addressStreet1: matchString,+ addressStreet2: matchString,+ addressCity: matchString,+ addressState: matchString,+ addressCountry: matchString,+ addressPostcode: matchString,+ addressLat: matchFloat,+ addressLng: matchFloat,+ },+ [FieldMetadataType.LINKS]: {+ primaryLinkLabel: matchString,+ primaryLinkUrl: matchString,+ secondaryLinks: matchRawJson,+ },+ [FieldMetadataType.ACTOR]: {+ source: matchSelect,+ name: matchString,+ workspaceMemberId: matchUuid,+ context: matchRawJson,+ },+ [FieldMetadataType.EMAILS]: {+ primaryEmail: matchString,+ additionalEmails: matchRawJson,+ },+ [FieldMetadataType.PHONES]: {+ primaryPhoneNumber: matchString,+ primaryPhoneCountryCode: matchString,+ primaryPhoneCallingCode: matchString,+ additionalPhones: matchRawJson,+ },+};++// Sub-fields are ANDed as in SQL. An absent or empty sub-field filter is no+// constraint, one this matcher cannot read never matches, and a null+// sub-field, of a null composite too, only matches IS NULL+const isMatchingCompositeFilter = ({+ compositeFilter,+ compositeValue,+ subFieldMatchers,+}: {+ compositeFilter: Record<string, { is?: IsFilter } | null | undefined>;+ compositeValue: Record<string, unknown> | null | undefined;+ subFieldMatchers: Record<string, SubFieldMatcher>;+}): boolean =>+ Object.entries(compositeFilter).every(([subFieldName, subFieldFilter]) => {+ if (+ !isDefined(subFieldFilter) ||+ Object.keys(subFieldFilter).length === 0+ ) {+ return true;+ }++ const isMatching = subFieldMatchers[subFieldName];++ if (!isDefined(isMatching)) {+ return false;+ }++ const value = compositeValue?.[subFieldName];++ if (!isDefined(value)) {+ return subFieldFilter.is === 'NULL';+ }++ return isMatching(subFieldFilter, value);+ });+export const isRecordMatchingRLSRowLevelPermissionPredicate = ({record,filter,@@ -223,6 +326,17 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({);}+ const subFieldMatchers =+ SUB_FIELD_MATCHERS_BY_COMPOSITE_TYPE[objectMetadataField.type];++ if (isDefined(subFieldMatchers)) {+ return isMatchingCompositeFilter({+ compositeFilter: filterValue as Record<string, { is?: IsFilter }>,+ compositeValue: record[filterKey],+ subFieldMatchers,+ });+ }+const recordFieldValue = record[filterKey];if (!isDefined(recordFieldValue)) {@@ -275,65 +389,6 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({value: recordFieldValue,});}- case FieldMetadataType.FULL_NAME: {- const fullNameFilter = filterValue as FullNameFilter;-- return (- (fullNameFilter.firstName === undefined ||- isMatchingStringFilter({- stringFilter: fullNameFilter.firstName,- value: recordFieldValue.firstName,- })) &&- (fullNameFilter.lastName === undefined ||- isMatchingStringFilter({- stringFilter: fullNameFilter.lastName,- value: recordFieldValue.lastName,- }))- );- }- case FieldMetadataType.ADDRESS: {- const addressFilter = filterValue as AddressFilter;-- const keys = [- 'addressStreet1',- 'addressStreet2',- 'addressCity',- 'addressState',- 'addressCountry',- 'addressPostcode',- ] as const;-- return keys.some((key) => {- const value = addressFilter[key];-- if (value === undefined) {- return false;- }-- return isMatchingStringFilter({- stringFilter: value,- value: recordFieldValue[key],- });- });- }- case FieldMetadataType.LINKS: {- const linksFilter = filterValue as LinksFilter;-- const keys = ['primaryLinkLabel', 'primaryLinkUrl'] as const;-- return keys.some((key) => {- const value = linksFilter[key];-- if (value === undefined) {- return false;- }-- return isMatchingStringFilter({- stringFilter: value,- value: recordFieldValue[key],- });- });- }case FieldMetadataType.DATE:case FieldMetadataType.DATE_TIME: {return isMatchingDateFilter({@@ -366,54 +421,6 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({value: recordFieldValue,});}- case FieldMetadataType.ACTOR: {- const actorFilter = filterValue as ActorFilter;-- if (isDefined(actorFilter.source)) {- return isMatchingSelectFilter({- selectFilter: actorFilter.source,- value: recordFieldValue.source,- });- }-- return (- actorFilter.name === undefined ||- isMatchingStringFilter({- stringFilter: actorFilter.name,- value: recordFieldValue.name,- })- );- }- case FieldMetadataType.EMAILS: {- const emailsFilter = filterValue as EmailsFilter;-- if (emailsFilter.primaryEmail === undefined) {- return false;- }-- return isMatchingStringFilter({- stringFilter: emailsFilter.primaryEmail,- value: recordFieldValue.primaryEmail,- });- }- case FieldMetadataType.PHONES: {- const phonesFilter = filterValue as PhonesFilter;-- const keys: (keyof PhonesFilter)[] = ['primaryPhoneNumber'];-- return keys.some((key) => {- const value = phonesFilter[key];-- if (value === undefined) {- return false;- }-- return isMatchingStringFilter({- stringFilter: value,- value: recordFieldValue[key],- });- });- }case FieldMetadataType.RELATION:case FieldMetadataType.MORPH_RELATION: {const isJoinColumn =@@ -430,7 +437,7 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({return isMatchingUUIDFilter({uuidFilter: filterValue as UUIDFilter,- value: recordFieldValue?.id ?? null,+ value: recordFieldValue.id ?? null,});}case FieldMetadataType.TS_VECTOR: {diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util.tsnew file mode 100644index 00000000000..03d522dfccc--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util.ts@@ -0,0 +1,25 @@+/* @license Enterprise */++import { assertUnreachable } from 'twenty-shared/utils';++import { type RowAccessExpression } from 'src/engine/twenty-orm/types/row-access-policy.type';++// Parent policies are left out: writes check parents on their own through+// validateInheritedParentsAreWritableOrThrow+export const isRowAccessExpressionReadingRoleFilter = (+ expression: RowAccessExpression,+): boolean => {+ switch (expression.kind) {+ case 'and':+ case 'or':+ return expression.operands.some(isRowAccessExpressionReadingRoleFilter);+ case 'roleFilter':+ return true;+ case 'recordShared':+ case 'recordNotRestricted':+ case 'inheritedReadability':+ return false;+ default:+ return assertUnreachable(expression);+ }+};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.tsindex 8f04e09c278..7de247f9b0b 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts@@ -239,6 +239,11 @@ const renderCompositeFieldCondition = (const conditions = Object.entries(filterValue as Record<string, Record<string, unknown>>,).flatMap(([subFieldName, subFieldFilter]) => {+ // An absent sub-field filter is no constraint, as for the in-memory matcher+ if (!isDefined(subFieldFilter)) {+ return [];+ }+const isKnownSubField = compositeType.properties.some((property) => property.name === subFieldName,);diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.tsindex 0df499aec9c..62c2c8f9b42 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts@@ -21,7 +21,6 @@ type ValidateRLSPredicatesForRecordsArgs<T extends ObjectLiteral> = {internalContext: WorkspaceInternalContext;authContext: WorkspaceAuthContext;shouldBypassPermissionChecks: boolean;- errorMessage?: string;};export const validateRLSPredicatesForRecords = <T extends ObjectLiteral>({@@ -30,7 +29,6 @@ export const validateRLSPredicatesForRecords = <T extends ObjectLiteral>({internalContext,authContext,shouldBypassPermissionChecks,- errorMessage = 'Record does not satisfy row-level security constraints of your current role',}: ValidateRLSPredicatesForRecordsArgs<T>): void => {if (shouldBypassPermissionChecks) {return;@@ -56,7 +54,7 @@ export const validateRLSPredicatesForRecords = <T extends ObjectLiteral>({if (!matchesRLS) {throw new TwentyOrmException(- errorMessage,+ 'Record does not satisfy row-level security constraints of your current role',TwentyOrmExceptionCode.RLS_VALIDATION_FAILED,);}