The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Record sharing: inherited records follow the parent's complete access policy, in queries and events (#25925)
martmull85e02f6a4ce5
diff --git a/packages/twenty-docs/developers/extend/apps/data/objects.mdx b/packages/twenty-docs/developers/extend/apps/data/objects.mdxindex 3d0623e0b79..0089443ed83 100644--- a/packages/twenty-docs/developers/extend/apps/data/objects.mdx+++ b/packages/twenty-docs/developers/extend/apps/data/objects.mdx@@ -82,7 +82,13 @@ export default defineObject({- `openRecordIn` sets where records of this object open when clicked: `ObjectOpenRecordIn.USER_CHOICE` (the default, following each workspace member's own preference from Settings → Experience), `ObjectOpenRecordIn.SIDE_PANEL`, or `ObjectOpenRecordIn.RECORD_PAGE`. Pin it to `RECORD_PAGE` for records that need a full page to be usable, the way workflows and dashboards do, or to `SIDE_PANEL` for records that only make sense as a quick panel, the way calendar events do.- `writability` controls who may write records of the object at all, before role permissions apply: `MetadataWritability.OPEN` (the default — workspace roles decide), `MetadataWritability.APPLICATION` (only your app's own logic functions can create, update, or delete records; use this for configuration-like objects whose records grant behavior, so workspace members with broad record access cannot edit them through the API), or `MetadataWritability.SYSTEM` (reserved for platform-managed data). Reads are unaffected — this is enforced server-side, unlike `isUIEditable`, which only hides UI affordances. It also exists per field, where it can only be stricter than the object's level.- `readability` declares who may read records of the object: `MetadataReadability.OPEN` (the default — workspace roles decide), `MetadataReadability.PRIVATE` (only principals the record was shared with), `MetadataReadability.INHERITED` (whoever reads the parent record), `MetadataReadability.APPLICATION` (only your app's own logic functions) or `MetadataReadability.SYSTEM` (platform-managed data). `SYSTEM` is always enforced. `PRIVATE`, `INHERITED` and `APPLICATION` are enforced on workspaces where record sharing is enabled (`IS_RECORD_SHARING_ENABLED`); elsewhere they still behave like `OPEN`.-- `readabilityParentFieldUniversalIdentifiers` goes with `MetadataReadability.INHERITED`: the universal identifiers of the relation fields that lead to the parent records. A many-to-one field names the record the row points to, and declaring one field of a morph relation covers every target of that relation. A one-to-many field names a child object whose rows point back at the record, the join rows of a many-to-many relation: the record is then readable when at least one of those rows leads to a readable record, the way a note follows the people, companies and opportunities its note targets attach it to. Several parents combine as a union: one readable parent is enough. On top of that, an `INHERITED` record is readable through the share rows on the record itself exactly as a `PRIVATE` one is: its creator gets one when the record is created while record sharing is enabled, so whoever created a record keeps seeing it, and a record whose parent fields are all empty is visible to those it was shared with directly. An `INHERITED` object that names no usable parent field behaves like a `PRIVATE` one.+- `readabilityParentFieldUniversalIdentifiers` goes with `MetadataReadability.INHERITED`: the universal identifiers of the relation fields that lead to the parent records.+ - A many-to-one field names the record the row points to. Declaring one field of a morph relation covers every target of that relation.+ - A one-to-many field names a child object whose rows point back at the record, such as the join rows of a many-to-many relation. The record is then readable when at least one of those rows leads to a readable record: a note follows the people, companies and opportunities its note targets attach it to.+ - Several parents combine as a union: one readable parent is enough.+ - A parent grants access under its complete policy, the one a query of the parent applies: the reader's permission on the parent object, the row-level restrictions of their role and the parent's own readability. A record never shows through a parent its reader could not query. Subscriptions, webhooks, workflows and logic functions decide what an event of an `INHERITED` record reaches by that same policy.+ - The share rows on the record itself grant access exactly as on a `PRIVATE` record. Its creator gets one when the record is created while record sharing is enabled, so whoever created a record keeps seeing it, and a record whose parent fields are all empty is visible to those it was shared with directly.+ - An `INHERITED` object that names no usable parent field behaves like a `PRIVATE` one.- `color` sets the accent color of the object in the UI. Omit it and Twenty picks one for the object.- `imageIdentifierFieldMetadataUniversalIdentifier` names the field whose value is shown as the record avatar. Omit it to let Twenty pick the default.- `isLabelSyncedWithName`, on an object or on a field, keeps the API name in sync with the label when the label is edited in Settings. It defaults to `false`, so a renamed label leaves the name untouched.diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.tsindex dbb61207e30..811223df092 100644--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job.ts@@ -21,11 +21,14 @@ import {LogicFunctionTriggerJob,LogicFunctionTriggerJobData,} from 'src/engine/core-modules/logic-function/logic-function-trigger/jobs/logic-function-trigger.job';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { type RecordShare } from 'src/engine/record-share/types/record-share.type';import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';-import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';+import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';+import { buildRoleRowAccessPolicySubject } from 'src/engine/record-share/utils/build-role-row-access-policy-subject.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';@@ -40,15 +43,31 @@ export class CallDatabaseEventTriggerJobsJob {private readonly workspaceCacheService: WorkspaceCacheService,private readonly applicationJobEnqueueThrottlerService: ApplicationJobEnqueueThrottlerService,private readonly recordShareService: RecordShareService,+ private readonly recordAccessPolicyService: RecordAccessPolicyService,) {}@Process(CallDatabaseEventTriggerJobsJob.name)async handle(workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>) {- const { flatLogicFunctionMaps, flatApplicationMaps, featureFlagsMap } =- await this.workspaceCacheService.getOrRecompute(- workspaceEventBatch.workspaceId,- ['flatLogicFunctionMaps', 'flatApplicationMaps', 'featureFlagsMap'],- );+ const {+ flatLogicFunctionMaps,+ flatApplicationMaps,+ featureFlagsMap,+ rolesPermissions,+ flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps,+ } = await this.workspaceCacheService.getOrRecompute(+ workspaceEventBatch.workspaceId,+ [+ 'flatLogicFunctionMaps',+ 'flatApplicationMaps',+ 'featureFlagsMap',+ 'rolesPermissions',+ 'flatRowLevelPermissionPredicateMaps',+ 'flatRowLevelPermissionPredicateGroupMaps',+ 'flatFieldMetadataMaps',+ ],+ );const logicFunctionsWithDatabaseEventTrigger = Object.values(flatLogicFunctionMaps.byUniversalIdentifier,@@ -126,6 +145,24 @@ export class CallDatabaseEventTriggerJobsJob {application,isRecordShareGated,fetchRecordSharesByRecordId,+ resolveRecordIdsReadableThroughParents: () =>+ this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents(+ {+ workspaceId: workspaceEventBatch.workspaceId,+ objectMetadata: workspaceEventBatch.objectMetadata,+ records: resolveEventRecordSnapshots(+ workspaceEventBatch.events,+ ),+ subject: buildRoleRowAccessPolicySubject({+ roleId: application.defaultRoleId ?? undefined,+ owningApplicationId: application.id,+ rolesPermissions,+ flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps,+ }),+ },+ ),}),});@@ -169,11 +206,13 @@ export class CallDatabaseEventTriggerJobsJob {application,isRecordShareGated,fetchRecordSharesByRecordId,+ resolveRecordIdsReadableThroughParents,}: {workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;application: FlatApplication;isRecordShareGated: boolean;fetchRecordSharesByRecordId: () => Promise<Map<string, RecordShare[]>>;+ resolveRecordIdsReadableThroughParents: () => Promise<Set<string>>;}): Promise<WorkspaceEventBatch<ObjectRecordEvent>> {const recordShareGate = isRecordShareGated? await buildRecordShareGate({@@ -182,6 +221,7 @@ export class CallDatabaseEventTriggerJobsJob {workspaceEventBatch.objectMetadata.applicationId === application.id,principalIds: [EVERYONE_PRINCIPAL_ID, application.defaultRoleId],fetchRecordSharesByRecordId,+ resolveRecordIdsReadableThroughParents,}): null;@@ -192,7 +232,7 @@ export class CallDatabaseEventTriggerJobsJob {return {...workspaceEventBatch,events: workspaceEventBatch.events.filter((event) =>- isRecordSharedWithPrincipals({+ isRecordAdmittedByRecordShareGate({recordShareGate,recordId: event.recordId,accessLevels: resolveRequiredRecordShareAccessLevels('select'),diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.tsindex 3130cc88264..4b739d30043 100644--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/__tests__/transform-event-batch-to-event-payloads.spec.ts@@ -1,4 +1,7 @@-import type { ObjectRecordEvent } from 'twenty-shared/database-events';+import type {+ ObjectRecordDeleteEvent,+ ObjectRecordEvent,+} from 'twenty-shared/database-events';import { MAX_EVENTS_PER_TRIGGER_JOB } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant';import { transformEventBatchToEventPayloads } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads';@@ -816,3 +819,33 @@ describe('transformEventBatchToEventPayloads', () => {});});});++describe('transformEventBatchToEventPayloads with a deletion capture', () => {+ it('should not hand the child records captured with a deletion to the function', () => {+ const [jobData] = transformEventBatchToEventPayloads({+ workspaceEventBatch: createMockWorkspaceEventBatch({+ name: 'company.deleted',+ events: [+ createMockEvent({+ properties: {+ before: { id: 'record-1' },+ after: { id: 'record-1', deletedAt: '2026-09-15T00:00:00Z' },+ updatedFields: ['deletedAt'],+ diff: {},+ inheritedReadabilityChildRecords: { noteTarget: [] },+ } as ObjectRecordDeleteEvent['properties'],+ }),+ ],+ }),+ logicFunctions: [+ createMockLogicFunction({+ databaseEventTriggerSettings: { eventName: 'company.deleted' },+ }),+ ],+ });++ expect(+ (jobData.payload as { properties: object }).properties,+ ).not.toHaveProperty('inheritedReadabilityChildRecords');+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.tsindex f58364d8c8c..9a7185d6b7b 100644--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.ts+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/utils/transform-event-batch-to-event-payloads.ts@@ -7,6 +7,7 @@ import type { ObjectRecordEvent } from 'twenty-shared/database-events';import { type LogicFunctionTriggerJobData } from 'src/engine/core-modules/logic-function/logic-function-trigger/jobs/logic-function-trigger.job';import { MAX_EVENTS_PER_TRIGGER_JOB } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/constants/max-events-per-trigger-job.constant';import { type LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';+import { omitInheritedReadabilityChildRecords } from 'src/engine/record-share/utils/omit-inherited-readability-child-records.util';import type { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';export const transformEventBatchToEventPayloads = ({@@ -37,7 +38,10 @@ export const transformEventBatchToEventPayloads = ({result.push({logicFunctionId: logicFunction.id,workspaceId: logicFunction.workspaceId,- payload: { ...batchEventInfo, ...event },+ payload: {+ ...batchEventInfo,+ ...omitInheritedReadabilityChildRecords(event),+ },...buildAuthContext(event),});}@@ -56,7 +60,10 @@ export const transformEventBatchToEventPayloads = ({result.push({logicFunctionId: logicFunction.id,workspaceId: logicFunction.workspaceId,- payload: { ...batchEventInfo, events: eventsChunk },+ payload: {+ ...batchEventInfo,+ events: eventsChunk.map(omitInheritedReadabilityChildRecords),+ },...buildAuthContext(eventsChunk[0]),});}diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.tsindex 46d8d08ccdf..1a3fd96eb07 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts@@ -19,9 +19,12 @@ import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/typimport { type WorkspaceEventBatchForWebhook } from 'src/engine/metadata-modules/webhook/types/workspace-event-batch-for-webhook.type';import { computeWebhookOperationsToMatch } from 'src/engine/metadata-modules/webhook/utils/compute-webhook-operations-to-match.util';import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';+import { EVERYONE_ROW_ACCESS_POLICY_SUBJECT } from 'src/engine/record-share/constants/everyone-row-access-policy-subject.constant';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';const WEBHOOK_JOBS_CHUNK_SIZE = 20;@@ -34,6 +37,7 @@ export class CallWebhookJobsJob {private readonly messageQueueService: MessageQueueService,private readonly workspaceCacheService: WorkspaceCacheService,private readonly recordShareService: RecordShareService,+ private readonly recordAccessPolicyService: RecordAccessPolicyService,private readonly webhookRateLimitService: WebhookRateLimitService,) {}@@ -105,6 +109,17 @@ export class CallWebhookJobsJob {),}),),+ resolveRecordIdsReadableThroughParents: () =>+ this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents(+ {+ workspaceId: workspaceEventBatch.workspaceId,+ objectMetadata: flatObjectMetadata,+ records: resolveEventRecordSnapshots(+ workspaceEventBatch.events,+ ),+ subject: EVERYONE_ROW_ACCESS_POLICY_SUBJECT,+ },+ ),}): null;diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.tsindex 69afdd71292..642012378ef 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.ts@@ -317,6 +317,7 @@ describe('transformEventBatchToWebhookEvents', () => {recordShareGate: {recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),principalIds: [EVERYONE_PRINCIPAL_ID],+ recordIdsReadableThroughParents: new Set(),},});diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.tsindex a6d2dad2109..1912174a135 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts@@ -7,7 +7,7 @@ import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/typimport { type WorkspaceEventBatchForWebhook } from 'src/engine/metadata-modules/webhook/types/workspace-event-batch-for-webhook.type';import { transformEventToWebhookEvent } from 'src/engine/metadata-modules/webhook/utils/transform-event-to-webhook-event';import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';-import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';export const transformEventBatchToWebhookEvents = ({@@ -23,7 +23,7 @@ export const transformEventBatchToWebhookEvents = ({const events = isDefined(recordShareGate)? workspaceEventBatch.events.filter((event) =>- isRecordSharedWithPrincipals({+ isRecordAdmittedByRecordShareGate({recordShareGate,recordId: event.recordId,accessLevels: resolveRequiredRecordShareAccessLevels('select'),diff --git a/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.ts b/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.tsindex 59a1819b5b3..b7103cc82a0 100644--- a/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.ts+++ b/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.ts@@ -3,4 +3,5 @@ import { type RecordShareGate } from 'src/engine/record-share/types/record-shareexport const DENY_ALL_RECORD_SHARE_GATE: RecordShareGate = {recordSharesByRecordId: new Map(),principalIds: [],+ recordIdsReadableThroughParents: new Set(),};diff --git a/packages/twenty-server/src/engine/record-share/constants/everyone-row-access-policy-subject.constant.ts b/packages/twenty-server/src/engine/record-share/constants/everyone-row-access-policy-subject.constant.tsnew file mode 100644index 00000000000..4f5622e0f6a--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/constants/everyone-row-access-policy-subject.constant.ts@@ -0,0 +1,10 @@+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';++import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';++export const EVERYONE_ROW_ACCESS_POLICY_SUBJECT: RowAccessPolicySubject = {+ objectsPermissions: undefined,+ principalIds: [EVERYONE_PRINCIPAL_ID],+ isOwningApplication: () => false,+ resolveRowLevelPermissionRecordFilter: () => null,+};diff --git a/packages/twenty-server/src/engine/record-share/record-share.module.ts b/packages/twenty-server/src/engine/record-share/record-share.module.tsindex c52ac93a0c0..60aa168db08 100644--- a/packages/twenty-server/src/engine/record-share/record-share.module.ts+++ b/packages/twenty-server/src/engine/record-share/record-share.module.ts@@ -1,5 +1,6 @@import { Module } from '@nestjs/common';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { ShareWithService } from 'src/engine/record-share/services/share-with.service';import { TwentyOrmModule } from 'src/engine/twenty-orm/twenty-orm.module';@@ -7,7 +8,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache@Module({imports: [TwentyOrmModule, WorkspaceCacheModule],- providers: [RecordShareService, ShareWithService],- exports: [RecordShareService, ShareWithService],+ providers: [RecordShareService, ShareWithService, RecordAccessPolicyService],+ exports: [RecordShareService, ShareWithService, RecordAccessPolicyService],})export class RecordShareModule {}diff --git a/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.ts b/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.tsnew file mode 100644index 00000000000..1c2f8e98031--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.ts@@ -0,0 +1,374 @@+import { Injectable } from '@nestjs/common';++import { type ObjectRecord } from 'twenty-shared/types';+import { assertUnreachable, isDefined } from 'twenty-shared/utils';+import { isNonEmptyString } from '@sniptt/guards';+import { In } 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 { RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';+import { type EventRecordSnapshot } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';+import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';+import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/twenty-orm/constants/max-inherited-readability-depth.constant';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';+import { type InheritedReadabilityChildrenParent } from 'src/engine/twenty-orm/types/inherited-readability-children-parent.type';+import { type InheritedReadabilityColumnParent } from 'src/engine/twenty-orm/types/inherited-readability-column-parent.type';+import { type RowAccessPolicySubject } 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 { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';+import { resolveInheritedReadabilityParents } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util';+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';++type ReadabilityMaps = {+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+ flatFieldMetadataMapsOrm: FlatEntityMaps<OrmFlatFieldMetadata>;+};++type SnapshotEvaluation = {+ workspaceId: string;+ objectMetadata: FlatObjectMetadata;+ snapshots: EventRecordSnapshot[];+ subject: RowAccessPolicySubject;+ depth: number;+ maps: ReadabilityMaps;+};++@Injectable()+export class RecordAccessPolicyService {+ constructor(+ private readonly workspaceOrmManager: WorkspaceOrmManager,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly recordShareService: RecordShareService,+ ) {}++ async resolveRecordIdsReadableThroughParents({+ workspaceId,+ objectMetadata,+ records,+ subject,+ }: {+ workspaceId: string;+ objectMetadata: FlatObjectMetadata;+ records: EventRecordSnapshot[];+ subject: RowAccessPolicySubject;+ }): Promise<Set<string>> {+ if (records.length === 0) {+ return new Set();+ }++ const maps = await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMapsOrm',+ ]);++ return this.workspaceOrmManager.executeInWorkspaceContext(+ () =>+ this.resolveSnapshotIdsReadableThroughParents({+ workspaceId,+ objectMetadata,+ snapshots: records,+ subject,+ depth: 0,+ maps,+ }),+ buildSystemAuthContext(workspaceId),+ );+ }++ private async resolveSnapshotIdsReadableThroughParents(+ evaluation: SnapshotEvaluation,+ ): Promise<Set<string>> {+ const parents = resolveInheritedReadabilityParents({+ flatObjectMetadata: evaluation.objectMetadata,+ flatFieldMetadataMaps: evaluation.maps.flatFieldMetadataMapsOrm,+ flatObjectMetadataMaps: evaluation.maps.flatObjectMetadataMaps,+ });+ const readableSnapshotIds = new Set<string>();++ for (const parent of parents) {+ const readableIds =+ parent.kind === 'column'+ ? await this.resolveSnapshotIdsReadableThroughColumnParent({+ ...evaluation,+ parent,+ })+ : await this.resolveSnapshotIdsReadableThroughChildren({+ ...evaluation,+ parent,+ });++ for (const readableId of readableIds) {+ readableSnapshotIds.add(readableId);+ }+ }++ return readableSnapshotIds;+ }++ private async resolveSnapshotIdsReadableThroughColumnParent({+ snapshots,+ subject,+ depth,+ parent,+ }: SnapshotEvaluation & {+ parent: InheritedReadabilityColumnParent;+ }): Promise<Set<string>> {+ const parentIdBySnapshotId = new Map(+ snapshots.flatMap((snapshot) => {+ const parentId = snapshot[parent.joinColumnName];++ return isNonEmptyString(parentId) ? [[snapshot.id, parentId]] : [];+ }),+ );+ const readableParentIds = await this.selectReadableRecordIds({+ objectMetadata: parent.parentFlatObjectMetadata,+ recordIds: [...new Set(parentIdBySnapshotId.values())],+ subject,+ depth: depth + 1,+ });++ return new Set(+ [...parentIdBySnapshotId]+ .filter(([, parentId]) => readableParentIds.has(parentId))+ .map(([snapshotId]) => snapshotId),+ );+ }++ private async resolveSnapshotIdsReadableThroughChildren({+ workspaceId,+ snapshots,+ subject,+ depth,+ maps,+ parent,+ }: SnapshotEvaluation & {+ parent: InheritedReadabilityChildrenParent;+ }): Promise<Set<string>> {+ const childNameSingular = parent.childFlatObjectMetadata.nameSingular;+ const capturedChildSnapshotsBySnapshotId = new Map(+ snapshots.flatMap((snapshot) => {+ const capturedChildRecords =+ snapshot.inheritedReadabilityChildRecords?.[childNameSingular];++ return isDefined(capturedChildRecords)+ ? [+ [+ snapshot.id,+ capturedChildRecords.map(+ (childRecord): EventRecordSnapshot => ({+ ...childRecord,+ id: String(childRecord.id),+ }),+ ),+ ] as const,+ ]+ : [];+ }),+ );+ const liveSnapshotIds = snapshots+ .filter(+ (snapshot) => !capturedChildSnapshotsBySnapshotId.has(snapshot.id),+ )+ .map((snapshot) => snapshot.id);++ const readableSnapshotIds = new Set<string>();++ if (liveSnapshotIds.length > 0) {+ const childRows = await this.workspaceOrmManager+ .getRepository(childNameSingular, {+ shouldBypassPermissionChecks: true,+ })+ .createQueryBuilder()+ .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,+ });++ for (const childRow of childRows) {+ if (readableChildIds.has(String(childRow.id))) {+ readableSnapshotIds.add(String(childRow[parent.childJoinColumnName]));+ }+ }+ }++ const readableCapturedChildIds = await this.resolveReadableSnapshotIds({+ workspaceId,+ objectMetadata: parent.childFlatObjectMetadata,+ snapshots: [...capturedChildSnapshotsBySnapshotId.values()].flat(),+ subject,+ depth: depth + 1,+ maps,+ });++ for (const [+ snapshotId,+ capturedChildSnapshots,+ ] of capturedChildSnapshotsBySnapshotId) {+ if (+ capturedChildSnapshots.some((childSnapshot) =>+ readableCapturedChildIds.has(childSnapshot.id),+ )+ ) {+ readableSnapshotIds.add(snapshotId);+ }+ }++ return readableSnapshotIds;+ }++ private async resolveReadableSnapshotIds(+ evaluation: SnapshotEvaluation,+ ): Promise<Set<string>> {+ const { objectMetadata, snapshots, subject, depth, maps } = evaluation;++ if (snapshots.length === 0 || depth > MAX_INHERITED_READABILITY_DEPTH) {+ return new Set();+ }++ if (+ isDefined(subject.objectsPermissions) &&+ !isObjectOperationPermitted({+ objectMetadata,+ operationType: 'select',+ objectsPermissions: subject.objectsPermissions,+ })+ ) {+ return new Set();+ }++ const rowLevelPermissionRecordFilter =+ subject.resolveRowLevelPermissionRecordFilter(objectMetadata);+ const candidateSnapshots =+ isDefined(rowLevelPermissionRecordFilter) &&+ Object.keys(rowLevelPermissionRecordFilter).length > 0+ ? snapshots.filter((snapshot) =>+ isRecordMatchingRLSRowLevelPermissionPredicate({+ record: snapshot,+ filter: rowLevelPermissionRecordFilter,+ flatObjectMetadata: objectMetadata,+ flatFieldMetadataMaps: maps.flatFieldMetadataMapsOrm,+ shouldIgnoreSoftDeleteDefaultFilter: true,+ }),+ )+ : snapshots;+ const gateKind = resolveRecordShareGateKind({+ readability: objectMetadata.readability,+ isOwningApplication: subject.isOwningApplication(objectMetadata),+ });++ switch (gateKind) {+ case 'open':+ return new Set(candidateSnapshots.map((snapshot) => snapshot.id));+ case 'deny':+ return new Set();+ case 'private':+ return this.resolveSnapshotIdsSharedWithSubject({+ ...evaluation,+ snapshots: candidateSnapshots,+ });+ case 'inherited':+ return new Set([+ ...(await this.resolveSnapshotIdsSharedWithSubject({+ ...evaluation,+ snapshots: candidateSnapshots,+ })),+ ...(await this.resolveSnapshotIdsReadableThroughParents({+ ...evaluation,+ snapshots: candidateSnapshots,+ })),+ ]);+ default:+ return assertUnreachable(gateKind);+ }+ }++ private async resolveSnapshotIdsSharedWithSubject({+ workspaceId,+ objectMetadata,+ snapshots,+ subject,+ }: SnapshotEvaluation): Promise<Set<string>> {+ const snapshotIds = snapshots.map((snapshot) => snapshot.id);++ if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {+ return new Set(snapshotIds);+ }++ const recordShareGate = {+ recordSharesByRecordId: indexRecordSharesByRecordId(+ await this.recordShareService.findByRecordIds({+ workspaceId,+ objectMetadataId: objectMetadata.id,+ recordIds: snapshotIds,+ }),+ ),+ principalIds: subject.principalIds,+ recordIdsReadableThroughParents: new Set<string>(),+ };++ return new Set(+ snapshotIds.filter((recordId) =>+ isRecordAdmittedByRecordShareGate({+ recordShareGate,+ recordId,+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),+ }),+ ),+ );+ }++ private async selectReadableRecordIds({+ objectMetadata,+ recordIds,+ subject,+ depth = 0,+ }: {+ 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/record-share/types/record-share-gate.type.ts b/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.tsindex 5faa761f8f5..f219ca46a54 100644--- a/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.ts+++ b/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.ts@@ -3,4 +3,5 @@ import { type RecordShare } from 'src/engine/record-share/types/record-share.typexport type RecordShareGate = {recordSharesByRecordId: Map<string, RecordShare[]>;principalIds: string[];+ recordIdsReadableThroughParents: Set<string>;};diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.tsindex 840a2317d2c..ba947d0bc7c 100644--- a/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.ts+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.ts@@ -33,6 +33,7 @@ describe('buildRecordShareGate', () => {isOwningApplication: false,principalIds: ['member-1'],fetchRecordSharesByRecordId,+ resolveRecordIdsReadableThroughParents: async () => new Set(),});expect(gate).toBeNull();@@ -49,6 +50,7 @@ describe('buildRecordShareGate', () => {isOwningApplication: false,principalIds: ['member-1'],fetchRecordSharesByRecordId,+ resolveRecordIdsReadableThroughParents: async () => new Set(),});expect(gate).toBe(DENY_ALL_RECORD_SHARE_GATE);@@ -61,12 +63,16 @@ describe('buildRecordShareGate', () => {isOwningApplication: true,principalIds: [],fetchRecordSharesByRecordId: async () => new Map(),+ resolveRecordIdsReadableThroughParents: async () => new Set(),});expect(gate).toBeNull();});it('fetches the rows of a PRIVATE object and keeps each principal once', async () => {+ const resolveRecordIdsReadableThroughParents = jest.fn(+ async () => new Set<string>(),+ );const gate = await buildRecordShareGate({readability: MetadataReadability.PRIVATE,isOwningApplication: false,@@ -79,11 +85,52 @@ describe('buildRecordShareGate', () => {],fetchRecordSharesByRecordId: async () =>indexRecordSharesByRecordId([RECORD_SHARE]),+ resolveRecordIdsReadableThroughParents,});expect(gate).toEqual({recordSharesByRecordId: indexRecordSharesByRecordId([RECORD_SHARE]),principalIds: [EVERYONE_PRINCIPAL_ID, 'role-1'],+ recordIdsReadableThroughParents: new Set(),});+ expect(resolveRecordIdsReadableThroughParents).not.toHaveBeenCalled();+ });++ it('asks the parents of an INHERITED object on top of its own rows', async () => {+ const resolveRecordIdsReadableThroughParents = jest.fn(+ async () => new Set(['record-2']),+ );++ const gate = await buildRecordShareGate({+ readability: MetadataReadability.INHERITED,+ isOwningApplication: false,+ principalIds: [EVERYONE_PRINCIPAL_ID, 'member-1'],+ fetchRecordSharesByRecordId: async () =>+ indexRecordSharesByRecordId([RECORD_SHARE]),+ resolveRecordIdsReadableThroughParents,+ });++ expect(gate).toEqual({+ recordSharesByRecordId: indexRecordSharesByRecordId([RECORD_SHARE]),+ principalIds: [EVERYONE_PRINCIPAL_ID, 'member-1'],+ recordIdsReadableThroughParents: new Set(['record-2']),+ });+ });++ it('lets the owning application through an INHERITED object without asking', async () => {+ const resolveRecordIdsReadableThroughParents = jest.fn(+ async () => new Set(['record-2']),+ );++ const gate = await buildRecordShareGate({+ readability: MetadataReadability.INHERITED,+ isOwningApplication: true,+ principalIds: [],+ fetchRecordSharesByRecordId: async () => new Map(),+ resolveRecordIdsReadableThroughParents,+ });++ expect(gate).toBeNull();+ expect(resolveRecordIdsReadableThroughParents).not.toHaveBeenCalled();});});diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-admitted-by-record-share-gate.util.spec.tssimilarity index 93%rename from packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.tsrename to packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-admitted-by-record-share-gate.util.spec.tsindex ae4b2d6c316..e456c796b8d 100644--- a/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.ts+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-admitted-by-record-share-gate.util.spec.ts@@ -7,7 +7,7 @@ import {import { type RecordShare } from 'src/engine/record-share/types/record-share.type';import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';-import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';const OBJECT_METADATA_ID = 'object-metadata-1';@@ -86,17 +86,18 @@ const sharedRecordIds = ({accessLevels: RecordShareAccessLevel[];}) =>Object.values(RECORD_IDS).filter((recordId) =>- isRecordSharedWithPrincipals({+ isRecordAdmittedByRecordShareGate({recordShareGate: {recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),principalIds,+ recordIdsReadableThroughParents: new Set(),},recordId,accessLevels,}),);-describe('isRecordSharedWithPrincipals', () => {+describe('isRecordAdmittedByRecordShareGate', () => {it.each([{principals: 'the member, their role and everyone',@@ -158,10 +159,11 @@ describe('isRecordSharedWithPrincipals', () => {it('should ignore rows of another record with the same principal', () => {expect(- isRecordSharedWithPrincipals({+ isRecordAdmittedByRecordShareGate({recordShareGate: {recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),principalIds: [WORKSPACE_MEMBER_ID],+ recordIdsReadableThroughParents: new Set(),},recordId: RECORD_IDS.UNSHARED,accessLevels: [RecordShareAccessLevel.READ],diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.tsindex 6c3b714ab9d..6246ea33653 100644--- a/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts@@ -17,6 +17,11 @@ describe('resolveRecordShareGateKind', () => {{readability: MetadataReadability.INHERITED,isOwningApplication: false,+ expected: 'inherited',+ },+ {+ readability: MetadataReadability.INHERITED,+ isOwningApplication: true,expected: 'open',},{diff --git a/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.ts b/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.tsindex 954f6d1f4a9..ebc229366b1 100644--- a/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.ts+++ b/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.ts@@ -6,18 +6,18 @@ import { type RecordShare } from 'src/engine/record-share/types/record-share.typimport { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';-// The share rows are only worth fetching and indexing for a PRIVATE object, so-// the caller hands over how to get them and the gate kind decides whether to askexport const buildRecordShareGate = async ({readability,isOwningApplication,principalIds,fetchRecordSharesByRecordId,+ resolveRecordIdsReadableThroughParents,}: {readability: MetadataReadability;isOwningApplication: boolean;principalIds: (string | null | undefined)[];fetchRecordSharesByRecordId: () => Promise<Map<string, RecordShare[]>>;+ resolveRecordIdsReadableThroughParents: () => Promise<Set<string>>;}): Promise<RecordShareGate | null> => {const gateKind = resolveRecordShareGateKind({readability,@@ -30,6 +30,7 @@ export const buildRecordShareGate = async ({case 'deny':return DENY_ALL_RECORD_SHARE_GATE;case 'private':+ case 'inherited':return {recordSharesByRecordId: await fetchRecordSharesByRecordId(),principalIds: [@@ -40,6 +41,10 @@ export const buildRecordShareGate = async ({),),],+ recordIdsReadableThroughParents:+ gateKind === 'inherited'+ ? await resolveRecordIdsReadableThroughParents()+ : new Set(),};default:return assertUnreachable(gateKind);diff --git a/packages/twenty-server/src/engine/record-share/utils/build-role-row-access-policy-subject.util.ts b/packages/twenty-server/src/engine/record-share/utils/build-role-row-access-policy-subject.util.tsnew file mode 100644index 00000000000..b6ddc7a5821--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/build-role-row-access-policy-subject.util.ts@@ -0,0 +1,56 @@+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import { type ObjectsPermissionsByRoleId } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';+import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';+import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';+import { buildRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util';++export const buildRoleRowAccessPolicySubject = ({+ roleId,+ owningApplicationId,+ rolesPermissions,+ flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps,+}: {+ roleId: string | undefined;+ owningApplicationId: string | undefined;+ rolesPermissions: ObjectsPermissionsByRoleId;+ flatRowLevelPermissionPredicateMaps: FlatRowLevelPermissionPredicateMaps;+ flatRowLevelPermissionPredicateGroupMaps: FlatRowLevelPermissionPredicateGroupMaps;+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;+}): RowAccessPolicySubject => {+ const roleIds = isDefined(roleId) ? [roleId] : [];++ return {+ objectsPermissions: isDefined(roleId)+ ? rolesPermissions[roleId]+ : undefined,+ principalIds: [EVERYONE_PRINCIPAL_ID, ...roleIds],+ isOwningApplication: (objectMetadata) =>+ isDefined(owningApplicationId) &&+ objectMetadata.applicationId === owningApplicationId,+ resolveRowLevelPermissionRecordFilter: (objectMetadata) => {+ if (roleIds.length === 0) {+ return null;+ }++ const recordFilter = buildRowLevelPermissionRecordFilter({+ flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps,+ objectMetadata,+ roleIds,+ workspaceMember: undefined,+ });++ return isDefined(recordFilter) && Object.keys(recordFilter).length > 0+ ? recordFilter+ : null;+ },+ };+};diff --git a/packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.ts b/packages/twenty-server/src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util.tssimilarity index 82%rename from packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.tsrename to packages/twenty-server/src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util.tsindex 3084965a296..9a1c2ab2d7b 100644--- a/packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.ts+++ b/packages/twenty-server/src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util.ts@@ -2,7 +2,7 @@ import { type RecordShareAccessLevel } from 'twenty-shared/types';import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';-export const isRecordSharedWithPrincipals = ({+export const isRecordAdmittedByRecordShareGate = ({recordShareGate,recordId,accessLevels,@@ -11,6 +11,7 @@ export const isRecordSharedWithPrincipals = ({recordId: string;accessLevels: RecordShareAccessLevel[];}): boolean =>+ recordShareGate.recordIdsReadableThroughParents.has(recordId) ||(recordShareGate.recordSharesByRecordId.get(recordId) ?? []).some((recordShare) =>recordShareGate.principalIds.includes(recordShare.principalId) &&diff --git a/packages/twenty-server/src/engine/record-share/utils/omit-inherited-readability-child-records.util.ts b/packages/twenty-server/src/engine/record-share/utils/omit-inherited-readability-child-records.util.tsnew file mode 100644index 00000000000..1609c1a15d2--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/omit-inherited-readability-child-records.util.ts@@ -0,0 +1,18 @@+import { type ObjectRecordEvent } from 'twenty-shared/database-events';+import { isDefined } from 'twenty-shared/utils';++import { type InheritedReadabilityChildRecordsCarrier } from 'src/engine/twenty-orm/types/inherited-readability-child-records.type';++export const omitInheritedReadabilityChildRecords = <+ TEvent extends ObjectRecordEvent,+>(+ event: TEvent,+): TEvent => {+ const { inheritedReadabilityChildRecords, ...properties } =+ event.properties as TEvent['properties'] &+ InheritedReadabilityChildRecordsCarrier;++ return isDefined(inheritedReadabilityChildRecords)+ ? ({ ...event, properties } as TEvent)+ : event;+};diff --git a/packages/twenty-server/src/engine/record-share/utils/resolve-event-record-snapshots.util.ts b/packages/twenty-server/src/engine/record-share/utils/resolve-event-record-snapshots.util.tsnew file mode 100644index 00000000000..bd4eddf1991--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/resolve-event-record-snapshots.util.ts@@ -0,0 +1,29 @@+import {+ type ObjectRecordBaseEvent,+ type ObjectRecordEvent,+} from 'twenty-shared/database-events';++import {+ type InheritedReadabilityChildRecords,+ type InheritedReadabilityChildRecordsCarrier,+} from 'src/engine/twenty-orm/types/inherited-readability-child-records.type';++export type EventRecordSnapshot = {+ id: string;+ inheritedReadabilityChildRecords?: InheritedReadabilityChildRecords;+} & Record<string, unknown>;++export const resolveEventRecordSnapshots = (+ events: ObjectRecordEvent[],+): EventRecordSnapshot[] =>+ events.map((event) => {+ const properties = event.properties as ObjectRecordBaseEvent['properties'] &+ InheritedReadabilityChildRecordsCarrier;++ return {+ ...(properties.after ?? properties.before ?? {}),+ id: event.recordId,+ inheritedReadabilityChildRecords:+ properties.inheritedReadabilityChildRecords,+ };+ });diff --git a/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.ts b/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.tsindex 5a9bb02550a..65782de852f 100644--- a/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.ts+++ b/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.ts@@ -1,7 +1,7 @@import { MetadataReadability } from 'twenty-shared/types';import { assertUnreachable } from 'twenty-shared/utils';-export type RecordShareGateKind = 'open' | 'deny' | 'private';+export type RecordShareGateKind = 'open' | 'deny' | 'private' | 'inherited';export const resolveRecordShareGateKind = ({readability,@@ -12,7 +12,6 @@ export const resolveRecordShareGateKind = ({}): RecordShareGateKind => {switch (readability) {case MetadataReadability.OPEN:- case MetadataReadability.INHERITED:return 'open';case MetadataReadability.SYSTEM:return 'deny';@@ -20,6 +19,8 @@ export const resolveRecordShareGateKind = ({return isOwningApplication ? 'open' : 'deny';case MetadataReadability.PRIVATE:return isOwningApplication ? 'open' : 'private';+ case MetadataReadability.INHERITED:+ return isOwningApplication ? 'open' : 'inherited';default:assertUnreachable(readability);}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 7be339b1c72..35e9e409cb9 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@@ -24,6 +24,7 @@ import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-fieldimport { 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 FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { type RecordShare } from 'src/engine/record-share/types/record-share.type';import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';@@ -63,6 +64,7 @@ type MockObjectRecordEvent = {after?: object;updatedFields?: string[];diff?: object;+ inheritedReadabilityChildRecords?: object;};};@@ -110,6 +112,10 @@ describe('ObjectRecordEventPublisher', () => {const userWorkspaceId = 'test-user-workspace-id';const roleId = 'test-role-id';+ let mockRecordAccessPolicyService: {+ resolveRecordIdsReadableThroughParents: jest.Mock;+ };+const companyObjectMetadata: FlatObjectMetadata = COMPANY_FLAT_OBJECT_MOCK;const companyNameField = getFlatFieldMetadataMock({@@ -270,6 +276,12 @@ describe('ObjectRecordEventPublisher', () => {findByRecordIds: jest.fn().mockResolvedValue([]),};+ mockRecordAccessPolicyService = {+ resolveRecordIdsReadableThroughParents: jest+ .fn()+ .mockResolvedValue(new Set()),+ };+mockWorkspaceManyOrAllFlatEntityMapsCacheService = {getOrRecomputeManyOrAllFlatEntityMaps: jest.fn().mockResolvedValue({flatFieldMetadataMaps: mockFlatFieldMetadataMaps,@@ -319,6 +331,10 @@ describe('ObjectRecordEventPublisher', () => {provide: RecordShareService,useValue: mockRecordShareService,},+ {+ provide: RecordAccessPolicyService,+ useValue: mockRecordAccessPolicyService,+ },],}).compile();@@ -443,6 +459,89 @@ describe('ObjectRecordEventPublisher', () => {).not.toHaveBeenCalled();});+ it('should not resolve the records readable through parents for a stream whose queries target another object', async () => {+ const inheritedObjectMetadata: FlatObjectMetadata = {+ ...companyObjectMetadata,+ readability: MetadataReadability.INHERITED,+ };++ mockWorkspaceCacheService.getOrRecompute.mockImplementation(+ createCacheMock({+ featureFlagsMap: { [FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true },+ }),+ );+ mockEventStreamService.getStreamsData.mockResolvedValue(+ new Map([+ [+ streamChannelId,+ {+ ...mockStreamData,+ queries: {+ 'query-1': { objectNameSingular: 'person', variables: {} },+ },+ },+ ],+ ]) as Map<string, EventStreamData | undefined>,+ );++ await service.publish({+ name: 'company.created',+ workspaceId,+ objectMetadata: inheritedObjectMetadata,+ events: [createMockEvent()],+ } as WorkspaceEventBatch<never>);++ expect(+ mockRecordAccessPolicyService.resolveRecordIdsReadableThroughParents,+ ).not.toHaveBeenCalled();+ expect(+ mockSubscriptionService.publishToEventStream,+ ).not.toHaveBeenCalled();+ });++ it('should not forward the child records captured with a deletion to the stream', async () => {+ await service.publish({+ name: 'company.deleted',+ workspaceId,+ objectMetadata: companyObjectMetadata,+ events: [+ createMockEvent({+ properties: {+ before: { id: 'record-1', name: 'Test Company' },+ after: {+ id: 'record-1',+ name: 'Test Company',+ deletedAt: '2026-09-15T00:00:00.000Z',+ },+ updatedFields: ['deletedAt'],+ diff: {},+ inheritedReadabilityChildRecords: {+ noteTarget: [{ id: 'note-target-1', noteId: 'record-1' }],+ },+ },+ }),+ ],+ } as WorkspaceEventBatch<never>);++ const publishCall = (+ mockSubscriptionService.publishToEventStream as jest.Mock+ ).mock.calls[0][0];++ expect(+ publishCall.payload.objectRecordEventsWithQueryIds[0].objectRecordEvent+ .properties,+ ).toEqual({+ before: { id: 'record-1', name: 'Test Company' },+ after: {+ id: 'record-1',+ name: 'Test Company',+ deletedAt: '2026-09-15T00:00:00.000Z',+ },+ updatedFields: ['deletedAt'],+ diff: {},+ });+ });+it('should only publish events of a private object for records shared with the subscriber', async () => {const privateObjectMetadata: FlatObjectMetadata = {...companyObjectMetadata,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 8f5a1bc4811..0531c91f384 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@@ -39,12 +39,15 @@ import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-objectimport { UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map';import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';import { type RecordShare } from 'src/engine/record-share/types/record-share.type';import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';-import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';+import { omitInheritedReadabilityChildRecords } from 'src/engine/record-share/utils/omit-inherited-readability-child-records.util';+import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';@@ -58,6 +61,7 @@ import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/reimport { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';import { buildRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util';import { computePermissionIntersection } from 'src/engine/twenty-orm/utils/compute-permission-intersection.util';+import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';import { resolveRoleIdsForUser } from 'src/engine/twenty-orm/utils/resolve-role-ids-for-user.util';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';@@ -86,6 +90,7 @@ export class ObjectRecordEventPublisher {private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,private readonly commonSelectFieldsHelper: CommonSelectFieldsHelper,private readonly recordShareService: RecordShareService,+ private readonly recordAccessPolicyService: RecordAccessPolicyService,) {}async publish(@@ -165,10 +170,12 @@ export class ObjectRecordEventPublisher {}): Promise<Map<string, RecordShare[]>> {if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED] ||- resolveRecordShareGateKind({- readability: workspaceEventBatch.objectMetadata.readability,- isOwningApplication: false,- }) !== 'private'+ !['private', 'inherited'].includes(+ resolveRecordShareGateKind({+ readability: workspaceEventBatch.objectMetadata.readability,+ isOwningApplication: false,+ }),+ )) {return new Map();}@@ -224,13 +231,23 @@ export class ObjectRecordEventPublisher {return;}+ const objectNameSingular = workspaceEventBatch.objectMetadata.nameSingular;++ if (+ !Object.values(streamData.queries).some(+ (operationSignature) =>+ isRecordGqlOperationSignature(operationSignature) &&+ operationSignature.objectNameSingular === objectNameSingular,+ )+ ) {+ return;+ }+const matchedEvents: {queryIds: string[];objectRecordEvent: ObjectRecordSubscriptionEvent;}[] = [];- const objectNameSingular = workspaceEventBatch.objectMetadata.nameSingular;-const subscriberAuthContext: SerializableAuthContext = {...streamData.authContext,workspaceMemberId: this.resolveSubscriberWorkspaceMemberId({@@ -249,10 +266,12 @@ export class ObjectRecordEventPublisher {const subscriberRecordShareGate = await this.buildSubscriberRecordShareGate({+ workspaceEventBatch,subscriberAuthContext,roleIds,- objectMetadata: workspaceEventBatch.objectMetadata,- featureFlagsMap: permissionsContext.featureFlagsMap,+ objectsPermissions,+ permissionsContext,+ flatWorkspaceMemberMaps,recordSharesByRecordId,},);@@ -265,7 +284,7 @@ export class ObjectRecordEventPublisher {const eventWithObjectName: ObjectRecordSubscriptionEvent = {action,objectNameSingular,- ...event,+ ...omitInheritedReadabilityChildRecords(event),};const filteredEvent = this.filterRestrictedFieldsFromEvent(@@ -287,7 +306,7 @@ export class ObjectRecordEventPublisher {if (isDefined(subscriberRecordShareGate) &&- !isRecordSharedWithPrincipals({+ !isRecordAdmittedByRecordShareGate({recordShareGate: subscriberRecordShareGate,recordId: filteredEvent.recordId,accessLevels: resolveRequiredRecordShareAccessLevels('select'),@@ -557,34 +576,91 @@ export class ObjectRecordEventPublisher {}private async buildSubscriberRecordShareGate({+ workspaceEventBatch,subscriberAuthContext,roleIds,- objectMetadata,- featureFlagsMap,+ objectsPermissions,+ permissionsContext,+ flatWorkspaceMemberMaps,recordSharesByRecordId,}: {+ workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;subscriberAuthContext: SerializableAuthContext;roleIds: string[];- objectMetadata: FlatObjectMetadata;- featureFlagsMap: Record<FeatureFlagKey, boolean>;+ objectsPermissions: ObjectsPermissions;+ permissionsContext: StreamPermissionsContext;+ flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps;recordSharesByRecordId: Map<string, RecordShare[]>;}): Promise<RecordShareGate | null> {- if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {+ if (+ !permissionsContext.featureFlagsMap[+ FeatureFlagKey.IS_RECORD_SHARING_ENABLED+ ]+ ) {return null;}+ const { objectMetadata } = workspaceEventBatch;+ const subject = this.buildSubscriberRowAccessPolicySubject({+ subscriberAuthContext,+ roleIds,+ objectsPermissions,+ permissionsContext,+ flatWorkspaceMemberMaps,+ });+return buildRecordShareGate({readability: objectMetadata.readability,- isOwningApplication:- isDefined(objectMetadata.applicationId) &&- subscriberAuthContext.applicationId === objectMetadata.applicationId,+ isOwningApplication: subject.isOwningApplication(objectMetadata),+ principalIds: subject.principalIds ?? [],+ fetchRecordSharesByRecordId: async () => recordSharesByRecordId,+ resolveRecordIdsReadableThroughParents: () =>+ this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents({+ workspaceId: workspaceEventBatch.workspaceId,+ objectMetadata,+ records: resolveEventRecordSnapshots(workspaceEventBatch.events),+ subject,+ }),+ });+ }++ private buildSubscriberRowAccessPolicySubject({+ subscriberAuthContext,+ roleIds,+ objectsPermissions,+ permissionsContext,+ flatWorkspaceMemberMaps,+ }: {+ subscriberAuthContext: SerializableAuthContext;+ roleIds: string[];+ objectsPermissions: ObjectsPermissions;+ permissionsContext: StreamPermissionsContext;+ flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps;+ }): RowAccessPolicySubject {+ return {+ objectsPermissions,principalIds: [EVERYONE_PRINCIPAL_ID,subscriberAuthContext.workspaceMemberId,...roleIds,- ],- fetchRecordSharesByRecordId: async () => recordSharesByRecordId,- });+ ].filter(isDefined),+ isOwningApplication: (objectMetadata) =>+ isDefined(objectMetadata.applicationId) &&+ subscriberAuthContext.applicationId === objectMetadata.applicationId,+ resolveRowLevelPermissionRecordFilter: (objectMetadata) => {+ const recordFilter = this.buildSubscriberRLSFilter(+ subscriberAuthContext,+ roleIds,+ objectMetadata,+ permissionsContext,+ flatWorkspaceMemberMaps,+ );++ return isDefined(recordFilter) && Object.keys(recordFilter).length > 0+ ? recordFilter+ : null;+ },+ };}private filterRestrictedFieldsFromEvent(diff --git a/packages/twenty-server/src/engine/twenty-orm/constants/max-inherited-readability-depth.constant.ts b/packages/twenty-server/src/engine/twenty-orm/constants/max-inherited-readability-depth.constant.tsnew file mode 100644index 00000000000..2cd0c054c01--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/constants/max-inherited-readability-depth.constant.ts@@ -0,0 +1 @@+export const MAX_INHERITED_READABILITY_DEPTH = 3;diff --git a/packages/twenty-server/src/engine/twenty-orm/query-builder/__tests__/workspace-mutation-query-builder.spec.ts b/packages/twenty-server/src/engine/twenty-orm/query-builder/__tests__/workspace-mutation-query-builder.spec.tsindex 18277061074..caf64777622 100644--- a/packages/twenty-server/src/engine/twenty-orm/query-builder/__tests__/workspace-mutation-query-builder.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/query-builder/__tests__/workspace-mutation-query-builder.spec.ts@@ -93,7 +93,7 @@ const buildBuilders = ({};describe('WorkspaceMutationQueryBuilder', () => {- it('should build a soft delete that stamps deletedAt and updatedAt', () => {+ it('should build a soft delete that stamps deletedAt and updatedAt on live rows only', () => {const { selectQueryBuilder } = buildBuilders();const mutationQueryBuilder = selectQueryBuilder@@ -106,11 +106,28 @@ describe('WorkspaceMutationQueryBuilder', () => {expect(mutationQueryBuilder.getQuery()).toBe(`UPDATE "${SCHEMA_NAME}"."person" AS "person" ` +'SET "deletedAt" = CURRENT_TIMESTAMP, "updatedAt" = CURRENT_TIMESTAMP ' +- 'WHERE ("person"."id" IN (:...ids)) ' ++ 'WHERE (("person"."id" IN (:...ids))) AND "person"."deletedAt" IS NULL ' +'RETURNING "person"."id" AS "person_id", "person"."nameFirstName" AS "person_nameFirstName"',);});+ it('should let a soft delete reach rows already in the trash only after withDeleted', () => {+ const { selectQueryBuilder } = buildBuilders();++ const mutationQueryBuilder = selectQueryBuilder+ .where('"person"."id" IN (:...ids)', {+ ids: ['id-1', 'id-2'],+ })+ .withDeleted()+ .softDelete();++ expect(mutationQueryBuilder.getQuery()).toBe(+ `UPDATE "${SCHEMA_NAME}"."person" AS "person" ` ++ 'SET "deletedAt" = CURRENT_TIMESTAMP, "updatedAt" = CURRENT_TIMESTAMP ' ++ 'WHERE ("person"."id" IN (:...ids))',+ );+ });+it('should build a restore that clears deletedAt and stamps updatedAt', () => {const { selectQueryBuilder } = buildBuilders();diff --git a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.tsindex 76657f3298c..dfb41c1b86e 100644--- a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts+++ b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-mutation-query-builder.ts@@ -42,6 +42,7 @@ export class WorkspaceMutationQueryBuilder {private readonly context: MutationQueryBuilderContext;private readonly kind: MutationKind;private readonly whereClauses: WhereClause[];+ private readonly includeDeleted: boolean;private parameters: Record<string, unknown>;private setRecord: Record<string, unknown> = {};private returningColumns: string[] = [];@@ -51,12 +52,14 @@ export class WorkspaceMutationQueryBuilder {kind,context,whereClauses,+ includeDeleted,parameters,}: {alias: string;kind: MutationKind;context: MutationQueryBuilderContext;whereClauses: WhereClause[];+ includeDeleted: boolean;parameters: Record<string, unknown>;}) {this.alias = alias;@@ -64,6 +67,7 @@ export class WorkspaceMutationQueryBuilder {this.context = context;this.tableShape = context.tableShape;this.whereClauses = [...whereClauses];+ this.includeDeleted = includeDeleted;this.parameters = { ...parameters };}@@ -121,6 +125,7 @@ export class WorkspaceMutationQueryBuilder {kind: this.kind,setClauses,whereClauses: this.whereClauses,+ includeDeleted: this.includeDeleted,returningColumns: this.returningColumns,});diff --git a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.tsindex 8e6c197195e..916b4e602e6 100644--- a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts+++ b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts@@ -788,6 +788,7 @@ export class WorkspaceSelectQueryBuilder implements WhereExpressionLike {formatResult: this.context.formatResult,},whereClauses: this.whereClauses,+ includeDeleted: this.includeDeleted,parameters: this.parameters,});}diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/permissions.utils.ts b/packages/twenty-server/src/engine/twenty-orm/repository/permissions.utils.tsindex 8e98a492dfe..8e031087c27 100644--- a/packages/twenty-server/src/engine/twenty-orm/repository/permissions.utils.ts+++ b/packages/twenty-server/src/engine/twenty-orm/repository/permissions.utils.ts@@ -1,6 +1,5 @@import { isNonEmptyString } from '@sniptt/guards';import isEmpty from 'lodash.isempty';-import { STANDARD_OBJECTS } from 'twenty-shared/metadata';import {type ObjectsPermissions,type RestrictedFieldsPermissions,@@ -19,11 +18,10 @@ import {} from 'src/engine/metadata-modules/permissions/permissions.exception';import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';import { validateWritabilityOrThrow } from 'src/engine/twenty-orm/repository/validate-writability-or-throw.util';+import { isExemptFromObjectPermissions } from 'src/engine/twenty-orm/utils/is-exempt-from-object-permissions.util';+import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';import { getColumnNameToFieldMetadataIdMap } from 'src/engine/twenty-orm/utils/get-column-name-to-field-metadata-id.util';-const WORKSPACE_MEMBER_OBJECT_UNIVERSAL_IDENTIFIER =- STANDARD_OBJECTS.workspaceMember.universalIdentifier;-export type OperationType =| 'select'| 'insert'@@ -92,27 +90,28 @@ export const validateOperationIsPermittedOrThrow = ({authContext,});- const objectMetadataIsSystem = objectMetadata.isSystem === true;- const isWorkspaceMemberObject =- objectMetadata.universalIdentifier ===- WORKSPACE_MEMBER_OBJECT_UNIVERSAL_IDENTIFIER;-- // TODO: this should be improved, we may have more complex permission configuration for is system objects- if (objectMetadataIsSystem && !isWorkspaceMemberObject) {+ if (isExemptFromObjectPermissions(objectMetadata)) {return;}const permissionsForEntity = objectsPermissions[objectMetadataIdForEntity];+ if (+ !isDefined(permissionsForEntity) ||+ !isObjectOperationPermitted({+ objectMetadata,+ operationType,+ objectsPermissions,+ })+ ) {+ throw new PermissionsException(+ PermissionsExceptionMessage.PERMISSION_DENIED,+ PermissionsExceptionCode.PERMISSION_DENIED,+ );+ }+switch (operationType) {case 'select':- if (!permissionsForEntity?.canReadObjectRecords) {- throw new PermissionsException(- PermissionsExceptionMessage.PERMISSION_DENIED,- PermissionsExceptionCode.PERMISSION_DENIED,- );- }-validateReadFieldPermissionOrThrow({restrictedFields: permissionsForEntity.restrictedFields,selectedColumns,@@ -123,13 +122,6 @@ export const validateOperationIsPermittedOrThrow = ({});break;case 'insert':- if (!permissionsForEntity?.canUpdateObjectRecords) {- throw new PermissionsException(- PermissionsExceptionMessage.PERMISSION_DENIED,- PermissionsExceptionCode.PERMISSION_DENIED,- );- }-validateReadFieldPermissionOrThrow({restrictedFields: permissionsForEntity.restrictedFields,selectedColumns,@@ -162,13 +154,6 @@ export const validateOperationIsPermittedOrThrow = ({}break;case 'update':- if (!permissionsForEntity?.canUpdateObjectRecords) {- throw new PermissionsException(- PermissionsExceptionMessage.PERMISSION_DENIED,- PermissionsExceptionCode.PERMISSION_DENIED,- );- }-validateReadFieldPermissionOrThrow({restrictedFields: permissionsForEntity.restrictedFields,selectedColumns,@@ -188,13 +173,6 @@ export const validateOperationIsPermittedOrThrow = ({}break;case 'delete':- if (!permissionsForEntity?.canDestroyObjectRecords) {- throw new PermissionsException(- PermissionsExceptionMessage.PERMISSION_DENIED,- PermissionsExceptionCode.PERMISSION_DENIED,- );- }-validateReadFieldPermissionOrThrow({restrictedFields: permissionsForEntity.restrictedFields,selectedColumns,@@ -205,13 +183,6 @@ export const validateOperationIsPermittedOrThrow = ({break;case 'restore':case 'soft-delete':- if (!permissionsForEntity?.canSoftDeleteObjectRecords) {- throw new PermissionsException(- PermissionsExceptionMessage.PERMISSION_DENIED,- PermissionsExceptionCode.PERMISSION_DENIED,- );- }-validateReadFieldPermissionOrThrow({restrictedFields: permissionsForEntity.restrictedFields,selectedColumns,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 db6c618e183..5ae60f1254d 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@@ -6,7 +6,6 @@ import {MetadataReadability,type ObjectRecord,type ObjectsPermissions,- type RecordShareAccessLevel,} from 'twenty-shared/types';import { assertUnreachable, isDefined } from 'twenty-shared/utils';import {@@ -30,18 +29,18 @@ import {type OperationType,validateOperationIsPermittedOrThrow,} from 'src/engine/twenty-orm/repository/permissions.utils';-import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';+import { type InheritedReadabilityChildRecords } from 'src/engine/twenty-orm/types/inherited-readability-child-records.type';import { type InheritedReadabilityChildrenParent } from 'src/engine/twenty-orm/types/inherited-readability-children-parent.type';import { type InheritedReadabilityParent } from 'src/engine/twenty-orm/types/inherited-readability-parent.type';import { type InheritedReadabilityParentLink } from 'src/engine/twenty-orm/types/inherited-readability-parent-link.type';+import { type RowAccessPolicy } from 'src/engine/twenty-orm/types/row-access-policy.type';import {- buildInheritedReadabilityCondition,- type InheritedReadabilityChildGate,- type InheritedReadabilityParentCondition,- type InheritedReadabilityParentGate,-} from 'src/engine/twenty-orm/utils/build-inherited-readability-condition.util';-import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.util';+ buildRowAccessPolicy,+ type RowAccessPolicyEnvironment,+ type RowAccessPolicySubject,+} from 'src/engine/twenty-orm/utils/build-row-access-policy.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';import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';import { formatTwentyOrmEventToDatabaseBatchEvent } from 'src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util';@@ -49,8 +48,8 @@ import {getUpdateEventRecords,mergeRecordsWithUpdateValues,} from 'src/engine/twenty-orm/utils/merge-records-with-update-values.util';+import { isChildRecordBoundAtDeletion } from 'src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util';import { isOwningApplicationAuthContext } from 'src/engine/twenty-orm/utils/is-owning-application-auth-context.util';-import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';import { resolvePrincipalIdsFromAuthContext } from 'src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util';import { resolveInheritedReadabilityChildLinks } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-child-links.util';import { resolveInheritedReadabilityParents } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util';@@ -106,8 +105,6 @@ import {} from 'src/engine/twenty-orm/table-shape/types/workspace-table-shape.type';const ALWAYS_FALSE_CONDITION = '1=0';-const MAX_INHERITED_READABILITY_DEPTH = 3;-const MUTATION_EVENT_ACTIONS_BY_KIND: Record<MutationKind,DatabaseEventAction[]@@ -1533,6 +1530,11 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {: recordsBeforeInheritanceCheck,});+ const inheritedReadabilityChildRecordsByRecordId =+ kind === 'delete' || kind === 'soft-delete'+ ? await this.fetchInheritedReadabilityChildRecords(recordsBefore)+ : undefined;+const mutationResult = await this.morphAndExecute({selectQueryBuilder,kind,@@ -1568,11 +1570,88 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {): recordsAfterWrite;- this.emitMutationEvent({ kind, recordsBefore, recordsAfter });+ this.emitMutationEvent({+ kind,+ recordsBefore,+ recordsAfter,+ inheritedReadabilityChildRecordsByRecordId,+ });return mutationResult.generatedMaps;}+ private async fetchInheritedReadabilityChildRecords(+ records: ObjectRecord[],+ ): Promise<Map<string, InheritedReadabilityChildRecords> | undefined> {+ const { flatObjectMetadata } = this.options;++ if (+ records.length === 0 ||+ flatObjectMetadata.readability !== MetadataReadability.INHERITED ||+ !this.isRecordSharingEnabled()+ ) {+ return undefined;+ }++ const childrenParents = this.resolveInheritedReadabilityParents(+ flatObjectMetadata,+ ).filter(+ (parent): parent is InheritedReadabilityChildrenParent =>+ parent.kind === 'children',+ );++ if (childrenParents.length === 0) {+ return undefined;+ }++ const recordById = new Map(+ records.map((record) => [String(record.id), record]),+ );+ const recordIds = [...recordById.keys()];+ const childRecordsByRecordId = new Map(+ recordIds.map((recordId): [string, InheritedReadabilityChildRecords] => [+ recordId,+ Object.fromEntries(+ childrenParents.map((parent) => [+ parent.childFlatObjectMetadata.nameSingular,+ [],+ ]),+ ),+ ]),+ );++ for (const parent of childrenParents) {+ const childRepository = this.options.getRepositoryForObjectMetadataId(+ parent.childFlatObjectMetadata.id,+ );+ const childRecords = await childRepository+ .buildBypassingEventSelectQueryBuilder(+ parent.childFlatObjectMetadata.nameSingular,+ )+ .where({ [parent.childJoinColumnName]: In(recordIds) })+ .withDeleted()+ .getMany<ObjectRecord>();++ for (const childRecord of childRecords) {+ const recordId = String(childRecord[parent.childJoinColumnName]);+ const record = recordById.get(recordId);++ if (+ !isDefined(record) ||+ !isChildRecordBoundAtDeletion({ childRecord, record })+ ) {+ continue;+ }++ childRecordsByRecordId+ .get(recordId)+ ?.[parent.childFlatObjectMetadata.nameSingular].push(childRecord);+ }+ }++ return childRecordsByRecordId;+ }+private async morphAndExecute({selectQueryBuilder,kind,@@ -1657,10 +1736,15 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {kind,recordsBefore,recordsAfter,+ inheritedReadabilityChildRecordsByRecordId,}: {kind: MutationKind;recordsBefore: ObjectRecord[];recordsAfter?: ObjectRecord[];+ inheritedReadabilityChildRecordsByRecordId?: Map<+ string,+ InheritedReadabilityChildRecords+ >;}): void {if (this.options.shouldSkipEventEmission) {return;@@ -1683,6 +1767,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {recordsBefore: formattedBefore,recordsAfter: formattedAfter,authContext: this.options.authContext,+ inheritedReadabilityChildRecordsByRecordId,});if (isDefined(event)) {@@ -1782,230 +1867,107 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {return;}- this.applyRolePredicateForAlias({- queryBuilder,- alias,- flatObjectMetadata,- });- this.applyRecordShareGateForAlias({- queryBuilder,- alias,- flatObjectMetadata,- operationType,- });- }-- private applyRolePredicateForAlias({- queryBuilder,- alias,- flatObjectMetadata,- }: {- queryBuilder: WorkspaceSelectQueryBuilder;- alias: string;- flatObjectMetadata: FlatObjectMetadata;- }): void {- const recordFilter = resolveRowLevelPermissionRecordFilter({- internalContext: this.options.internalContext,- authContext: this.options.authContext,- objectMetadata: flatObjectMetadata,- });-- if (!isDefined(recordFilter)) {- return;+ if (+ alias === queryBuilder.alias &&+ !this.isObjectOperationPermitted({ flatObjectMetadata, operationType })+ ) {+ throw new PermissionsException(+ PermissionsExceptionMessage.PERMISSION_DENIED,+ PermissionsExceptionCode.PERMISSION_DENIED,+ );}- const renderedCondition = renderRowLevelPermissionFilterToSql({- recordFilter,+ const policy = buildRowAccessPolicy({+ subject: this.resolveRowAccessPolicySubject(),+ environment: this.resolveRowAccessPolicyEnvironment(),tableAlias: alias,- objectMetadata: flatObjectMetadata,- flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,- });-- if (!isDefined(renderedCondition)) {- return;- }-- this.addConditionForAlias({- queryBuilder,- alias,- sql: renderedCondition.sql,- parameters: renderedCondition.parameters,- });- }-- private applyRecordShareGateForAlias({- queryBuilder,- alias,- flatObjectMetadata,- operationType,- }: {- queryBuilder: WorkspaceSelectQueryBuilder;- alias: string;- flatObjectMetadata: FlatObjectMetadata;- operationType: OperationType;- }): void {- const isRecordSharingEnabled = this.isRecordSharingEnabled();- const isOwningApplication = isOwningApplicationAuthContext({- authContext: this.options.authContext,- owningApplicationId: flatObjectMetadata.applicationId,+ flatObjectMetadata,+ operationType,+ depth: 0,+ joinParentRelationShape: queryBuilder.getJoinParentRelationShape(alias),});- switch (flatObjectMetadata.readability) {- case MetadataReadability.OPEN:- return;- case MetadataReadability.INHERITED:- if (!isRecordSharingEnabled || isOwningApplication) {- return;- }-- this.applyInheritedReadabilityConditionForAlias({- queryBuilder,- alias,- flatObjectMetadata,- operationType,- });-+ switch (policy.kind) {+ case 'open':return;- case MetadataReadability.SYSTEM:- // recordShare rows are SYSTEM and hold the whole ACL, so they stay- // unreadable whether or not the workspace has enabled record sharing+ case 'denied':this.denyAccessForAlias({ queryBuilder, alias, flatObjectMetadata });return;- case MetadataReadability.APPLICATION:- if (isRecordSharingEnabled && !isOwningApplication) {- this.denyAccessForAlias({ queryBuilder, alias, flatObjectMetadata });- }-- return;- case MetadataReadability.PRIVATE:- // the owning application syncs and backfills every record of its- // object, so it reads them all instead of holding share rows- if (!isRecordSharingEnabled || isOwningApplication) {- return;- }-- this.applyRecordShareConditionForAlias({- queryBuilder,- alias,- flatObjectMetadata,- operationType,- });+ case 'gated':+ this.addConditionForAlias({ queryBuilder, alias, ...policy.condition });return;default:- assertUnreachable(flatObjectMetadata.readability);+ assertUnreachable(policy);}}- private applyRecordShareConditionForAlias({- queryBuilder,- alias,+ private isObjectOperationPermitted({flatObjectMetadata,operationType,}: {- queryBuilder: WorkspaceSelectQueryBuilder;- alias: string;flatObjectMetadata: FlatObjectMetadata;operationType: OperationType;- }): void {- const principalIds = resolvePrincipalIdsFromAuthContext({- authContext: this.options.authContext,- userWorkspaceRoleMap: this.options.internalContext.userWorkspaceRoleMap,- apiKeyRoleMap: this.options.internalContext.apiKeyRoleMap,- });-- if (!isDefined(principalIds)) {- return;- }-- const accessLevels = resolveRequiredRecordShareAccessLevels(operationType);-- if (accessLevels.length === 0) {- return;- }-- const condition = buildRecordShareCondition({- tableAlias: alias,- recordShareTableExpression: this.getRecordShareTableExpression(),- objectMetadataId: flatObjectMetadata.id,- principalIds,- accessLevels,+ }): boolean {+ return isObjectOperationPermitted({+ objectMetadata: flatObjectMetadata,+ operationType,+ objectsPermissions: this.options.objectRecordsPermissions,});-- this.addConditionForAlias({ queryBuilder, alias, ...condition });}- private applyInheritedReadabilityConditionForAlias({- queryBuilder,- alias,- flatObjectMetadata,+ buildRowAccessPolicy({+ subject,operationType,+ depth = 0,}: {- queryBuilder: WorkspaceSelectQueryBuilder;- alias: string;- flatObjectMetadata: FlatObjectMetadata;+ subject: RowAccessPolicySubject;operationType: OperationType;- }): void {- const principalIds = resolvePrincipalIdsFromAuthContext({- authContext: this.options.authContext,- userWorkspaceRoleMap: this.options.internalContext.userWorkspaceRoleMap,- apiKeyRoleMap: this.options.internalContext.apiKeyRoleMap,- });-- if (!isDefined(principalIds)) {- return;- }-- const accessLevels = resolveRequiredRecordShareAccessLevels(operationType);-- if (accessLevels.length === 0) {- return;- }-- const joinParentRelationShape =- queryBuilder.getJoinParentRelationShape(alias);- const parents = this.resolveInheritedReadabilityParents(flatObjectMetadata);-- // A join through a parent field is the canonical foreign key equality and its parent alias is already gated- if (- isDefined(joinParentRelationShape) &&- parents.some(- (parent) =>- parent.kind === 'column' &&- parent.fieldMetadataId ===- joinParentRelationShape.targetFieldMetadataId,- )- ) {- return;- }-- // An object whose parent cannot be inferred is gated like a PRIVATE one- if (parents.length === 0) {- this.applyRecordShareConditionForAlias({- queryBuilder,- alias,- flatObjectMetadata,- operationType,- });-- return;- }-- const condition = this.buildInheritedReadabilityConditionForAlias({- tableAlias: alias,- objectMetadataId: flatObjectMetadata.id,- parents,- principalIds,- accessLevels,- depth: 0,+ depth?: number;+ }): RowAccessPolicy {+ return buildRowAccessPolicy({+ subject,+ environment: this.resolveRowAccessPolicyEnvironment(),+ tableAlias: this.options.tableShape.nameSingular,+ flatObjectMetadata: this.options.flatObjectMetadata,+ operationType,+ depth,});+ }- if (!isDefined(condition)) {- return;- }+ private resolveRowAccessPolicySubject(): RowAccessPolicySubject {+ return {+ objectsPermissions: this.options.objectRecordsPermissions,+ principalIds: resolvePrincipalIdsFromAuthContext({+ authContext: this.options.authContext,+ userWorkspaceRoleMap: this.options.internalContext.userWorkspaceRoleMap,+ apiKeyRoleMap: this.options.internalContext.apiKeyRoleMap,+ }),+ isOwningApplication: (objectMetadata) =>+ isOwningApplicationAuthContext({+ authContext: this.options.authContext,+ owningApplicationId: objectMetadata.applicationId,+ }),+ resolveRowLevelPermissionRecordFilter: (objectMetadata) =>+ resolveRowLevelPermissionRecordFilter({+ internalContext: this.options.internalContext,+ authContext: this.options.authContext,+ objectMetadata,+ }),+ };+ }- this.addConditionForAlias({ queryBuilder, alias, ...condition });+ private resolveRowAccessPolicyEnvironment(): RowAccessPolicyEnvironment {+ return {+ isRecordSharingEnabled: this.isRecordSharingEnabled(),+ flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,+ flatObjectMetadataMaps:+ this.options.internalContext.flatObjectMetadataMaps,+ recordShareTableExpression: this.getRecordShareTableExpression(),+ resolveTableExpression: (objectMetadataId) =>+ this.getTableExpression(objectMetadataId),+ };}private resolveInheritedReadabilityParents(@@ -2019,244 +1981,13 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {});}- private buildInheritedReadabilityConditionForAlias({- tableAlias,- objectMetadataId,- parents,- principalIds,- accessLevels,- depth,- }: {- tableAlias: string;- objectMetadataId: string;- parents: InheritedReadabilityParent[];- principalIds: string[];- accessLevels: RecordShareAccessLevel[];- depth: number;- }): { sql: string; parameters: ObjectLiteral } | undefined {- return buildInheritedReadabilityCondition({- tableAlias,- objectMetadataId,- recordShareTableExpression: this.getRecordShareTableExpression(),- principalIds,- accessLevels,- parents: parents.map((parent) =>- parent.kind === 'column'- ? {- kind: 'column',- joinColumnName: parent.joinColumnName,- gate: this.resolveInheritedReadabilityParentGate({- tableAlias,- joinColumnName: parent.joinColumnName,- parentFlatObjectMetadata: parent.parentFlatObjectMetadata,- principalIds,- accessLevels,- depth,- }),- }- : this.buildInheritedReadabilityChildrenCondition({- tableAlias,- parent,- principalIds,- accessLevels,- depth,- }),- ),- });- }-- private buildInheritedReadabilityChildrenCondition({- tableAlias,- parent,- principalIds,- accessLevels,- depth,- }: {- tableAlias: string;- parent: InheritedReadabilityChildrenParent;- principalIds: string[];- accessLevels: RecordShareAccessLevel[];- depth: number;- }): InheritedReadabilityParentCondition {- const { childFlatObjectMetadata, childJoinColumnName } = parent;- const childTableAlias = `${tableAlias}_${childFlatObjectMetadata.nameSingular}`;- const childTableShape = this.options.tableShapeByObjectMetadataId(- childFlatObjectMetadata.id,- );-- return {- kind: 'children',- childTableAlias,- childTableExpression: `${escapeIdentifier(- childTableShape.schemaName,- )}.${escapeIdentifier(childTableShape.tableName)}`,- childJoinColumnName,- gate: this.resolveInheritedReadabilityChildGate({- childTableAlias,- childFlatObjectMetadata,- principalIds,- accessLevels,- depth,- }),- };- }-- // A child row grants access when the child object's own gate lets the caller- // read it: OPEN needs the row alone, PRIVATE a share row on it, INHERITED its- // own parents evaluated one level deeper, or a share row on it when it has- // no usable parent, as a root INHERITED record without one- private resolveInheritedReadabilityChildGate({- childTableAlias,- childFlatObjectMetadata,- principalIds,- accessLevels,- depth,- }: {- childTableAlias: string;- childFlatObjectMetadata: FlatObjectMetadata;- principalIds: string[];- accessLevels: RecordShareAccessLevel[];- depth: number;- }): InheritedReadabilityChildGate {- if (- isOwningApplicationAuthContext({- authContext: this.options.authContext,- owningApplicationId: childFlatObjectMetadata.applicationId,- })- ) {- return { kind: 'open' };- }-- const ownRecordShareGate: InheritedReadabilityChildGate = {- kind: 'gated',- condition: buildRecordShareCondition({- tableAlias: childTableAlias,- recordShareTableExpression: this.getRecordShareTableExpression(),- objectMetadataId: childFlatObjectMetadata.id,- principalIds,- accessLevels,- }),- };-- switch (childFlatObjectMetadata.readability) {- case MetadataReadability.OPEN:- return { kind: 'open' };- case MetadataReadability.SYSTEM:- case MetadataReadability.APPLICATION:- return { kind: 'denied' };- case MetadataReadability.PRIVATE:- return ownRecordShareGate;- case MetadataReadability.INHERITED: {- if (depth >= MAX_INHERITED_READABILITY_DEPTH) {- return { kind: 'denied' };- }-- const childParents = this.resolveInheritedReadabilityParents(- childFlatObjectMetadata,- );-- if (childParents.length === 0) {- return ownRecordShareGate;- }-- const condition = this.buildInheritedReadabilityConditionForAlias({- tableAlias: childTableAlias,- objectMetadataId: childFlatObjectMetadata.id,- parents: childParents,- principalIds,- accessLevels,- depth: depth + 1,- });-- return isDefined(condition)- ? { kind: 'gated', condition }- : { kind: 'open' };- }- default:- assertUnreachable(childFlatObjectMetadata.readability);- }- }-- private resolveInheritedReadabilityParentGate({- tableAlias,- joinColumnName,- parentFlatObjectMetadata,- principalIds,- accessLevels,- depth,- }: {- tableAlias: string;- joinColumnName: string;- parentFlatObjectMetadata: FlatObjectMetadata;- principalIds: string[];- accessLevels: RecordShareAccessLevel[];- depth: number;- }): InheritedReadabilityParentGate {- if (- isOwningApplicationAuthContext({- authContext: this.options.authContext,- owningApplicationId: parentFlatObjectMetadata.applicationId,- })- ) {- return { kind: 'open' };- }+ private getTableExpression(objectMetadataId: string): string {+ const tableShape =+ this.options.tableShapeByObjectMetadataId(objectMetadataId);- switch (parentFlatObjectMetadata.readability) {- case MetadataReadability.OPEN:- return { kind: 'open' };- case MetadataReadability.SYSTEM:- case MetadataReadability.APPLICATION:- return { kind: 'denied' };- case MetadataReadability.PRIVATE:- return {- kind: 'private',- objectMetadataId: parentFlatObjectMetadata.id,- };- case MetadataReadability.INHERITED: {- if (depth >= MAX_INHERITED_READABILITY_DEPTH) {- return { kind: 'denied' };- }-- const parentParents = this.resolveInheritedReadabilityParents(- parentFlatObjectMetadata,- );-- if (parentParents.length === 0) {- return { kind: 'denied' };- }-- const parentTableAlias = `${tableAlias}_${joinColumnName}`;- const parentCondition = this.buildInheritedReadabilityConditionForAlias(- {- tableAlias: parentTableAlias,- objectMetadataId: parentFlatObjectMetadata.id,- parents: parentParents,- principalIds,- accessLevels,- depth: depth + 1,- },- );-- if (!isDefined(parentCondition)) {- return { kind: 'open' };- }-- const parentTableShape = this.options.tableShapeByObjectMetadataId(- parentFlatObjectMetadata.id,- );-- return {- kind: 'inherited',- parentTableAlias,- parentTableExpression: `${escapeIdentifier(- parentTableShape.schemaName,- )}.${escapeIdentifier(parentTableShape.tableName)}`,- parentCondition,- };- }- default:- assertUnreachable(parentFlatObjectMetadata.readability);- }+ return `${escapeIdentifier(tableShape.schemaName)}.${escapeIdentifier(+ tableShape.tableName,+ )}`;}private getRecordShareTableExpression(): string {diff --git a/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-mutation-statement.util.ts b/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-mutation-statement.util.tsindex 77499e016e9..5638c59dca0 100644--- a/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-mutation-statement.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/sql/utils/build-mutation-statement.util.ts@@ -24,6 +24,7 @@ export type MutationStatementState = {kind: MutationKind;setClauses: SetClause[];whereClauses: WhereClause[];+ includeDeleted: boolean;returningColumns: string[];};@@ -55,10 +56,28 @@ const buildSetClause = (state: MutationStatementState): string =>).join(', ')}`;+const buildWhereExpression = (state: MutationStatementState): string => {+ const userExpression = renderUserWhereExpression(state.whereClauses);+ const shouldSkipTrashedRows =+ state.kind === 'soft-delete' &&+ !state.includeDeleted &&+ state.tableShape.hasDeletedAtColumn;++ if (!shouldSkipTrashedRows) {+ return userExpression;+ }++ const liveRowPredicate = `${quoteColumn(state.alias, 'deletedAt')} IS NULL`;++ return userExpression.length > 0+ ? `(${userExpression}) AND ${liveRowPredicate}`+ : liveRowPredicate;+};+export const buildMutationStatement = (state: MutationStatementState,): string => {- const whereExpression = renderUserWhereExpression(state.whereClauses);+ const whereExpression = buildWhereExpression(state);const returningClause = buildReturningClause(state);if (state.kind === 'delete') {diff --git a/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-child-records.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-child-records.type.tsnew file mode 100644index 00000000000..f025cec77f1--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-child-records.type.ts@@ -0,0 +1,8 @@+export type InheritedReadabilityChildRecords = Record<+ string,+ Record<string, unknown>[]+>;++export type InheritedReadabilityChildRecordsCarrier = {+ inheritedReadabilityChildRecords?: InheritedReadabilityChildRecords;+};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.tsnew file mode 100644index 00000000000..46ec61d3869--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts@@ -0,0 +1,8 @@+import { type ObjectLiteral } from 'typeorm';++export type SqlCondition = { sql: string; parameters: ObjectLiteral };++export type RowAccessPolicy =+ | { kind: 'open' }+ | { kind: 'denied' }+ | { kind: 'gated'; condition: SqlCondition };diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.tsindex 0f48af3dc59..bb0673fe6dc 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.ts@@ -7,7 +7,6 @@ import {const RECORD_SHARE_TABLE_EXPRESSION = '"workspace_abc"."recordShare"';const ATTACHMENT_OBJECT_METADATA_ID = 'attachment-object-metadata-id';-const NOTE_OBJECT_METADATA_ID = 'note-object-metadata-id';const PRINCIPAL_IDS = ['principal-1', 'principal-2'];const ACCESS_LEVELS = [RecordShareAccessLevel.READ];@@ -27,142 +26,103 @@ const build = (parents: InheritedReadabilityParentCondition[]) =>accessLevels: ACCESS_LEVELS,});-const findParameterValues = (- parameters: Record<string, unknown>,- prefix: string,-): unknown[] =>- Object.entries(parameters)- .filter(([name]) => name.startsWith(prefix))- .map(([, value]) => value);+const noteParent = (+ policy: InheritedReadabilityParentCondition['policy'],+): InheritedReadabilityParentCondition => ({+ kind: 'column',+ joinColumnName: 'targetNoteId',+ parentTableAlias: 'attachment_targetNoteId',+ parentTableExpression: '"workspace_abc"."note"',+ policy,+});++const personParent = (+ policy: InheritedReadabilityParentCondition['policy'],+): InheritedReadabilityParentCondition => ({+ kind: 'column',+ joinColumnName: 'targetPersonId',+ parentTableAlias: 'attachment_targetPersonId',+ parentTableExpression: '"workspace_abc"."person"',+ policy,+});describe('buildInheritedReadabilityCondition', () => {it('should accept a share row on the record itself or an OPEN parent present', () => {- const condition = build([- {- kind: 'column',- joinColumnName: 'targetPersonId',- gate: { kind: 'open' },- },+ const { sql, parameters } = build([+ personParent({ kind: 'open' }),{kind: 'column',joinColumnName: 'targetCompanyId',- gate: { kind: 'open' },+ parentTableAlias: 'attachment_targetCompanyId',+ parentTableExpression: '"workspace_abc"."company"',+ policy: { kind: 'open' },},]);- expect(condition).toBeDefined();-- const { sql, parameters } = condition!;-expect(sql.startsWith(OWN_RECORD_SHARE_EXISTS)).toBe(true);expect(sql).toContain(' OR "attachment"."targetPersonId" IS NOT NULL OR "attachment"."targetCompanyId" IS NOT NULL)',);expect(countOccurrences(sql, 'EXISTS')).toBe(1);expect(- findParameterValues(parameters, 'recordShareObjectMetadataId_'),+ Object.entries(parameters)+ .filter(([name]) => name.startsWith('recordShareObjectMetadataId_'))+ .map(([, value]) => value),).toEqual([ATTACHMENT_OBJECT_METADATA_ID]);});- it('should gate a PRIVATE parent on one record share EXISTS keyed by the parent column', () => {- const condition = build([- {- kind: 'column',- joinColumnName: 'targetPersonId',- gate: { kind: 'open' },- },- {- kind: 'column',- joinColumnName: 'targetNoteId',- gate: { kind: 'private', objectMetadataId: NOTE_OBJECT_METADATA_ID },- },+ it('should correlate a gated parent through the parent row under its policy', () => {+ const { sql, parameters } = build([+ personParent({ kind: 'open' }),+ noteParent({+ kind: 'gated',+ condition: {+ sql: '"attachment_targetNoteId"."companyId" IS NOT NULL',+ parameters: { nested: 'value' },+ },+ }),]);- expect(condition).toBeDefined();-- const { sql, parameters } = condition!;-expect(sql).toContain(- ' OR "attachment"."targetPersonId" IS NOT NULL OR ("attachment"."targetNoteId" IS NOT NULL AND EXISTS (SELECT 1 FROM "workspace_abc"."recordShare" AS "attachment_recordShare" WHERE "attachment_recordShare"."recordId" = "attachment"."targetNoteId"',+ ' OR "attachment"."targetPersonId" IS NOT NULL OR ("attachment"."targetNoteId" IS NOT NULL AND EXISTS (SELECT 1 FROM "workspace_abc"."note" AS "attachment_targetNoteId" WHERE "attachment_targetNoteId"."id" = "attachment"."targetNoteId" AND "attachment_targetNoteId"."companyId" IS NOT NULL)))',);expect(countOccurrences(sql, 'EXISTS')).toBe(2);expect(sql).not.toContain('"attachment"."targetPersonId" IS NOT NULL AND');- expect(- findParameterValues(parameters, 'recordShareObjectMetadataId_').sort(),- ).toEqual([ATTACHMENT_OBJECT_METADATA_ID, NOTE_OBJECT_METADATA_ID].sort());+ expect(parameters.nested).toBe('value');});it('should only keep rows shared directly when every parent is denied', () => {- const condition = build([- {- kind: 'column',- joinColumnName: 'targetNoteId',- gate: { kind: 'denied' },- },- ]);-- expect(condition).toBeDefined();-- const { sql } = condition!;+ const { sql } = build([noteParent({ kind: 'denied' })]);expect(sql.startsWith(OWN_RECORD_SHARE_EXISTS)).toBe(true);expect(sql).not.toContain('IS NOT NULL');expect(countOccurrences(sql, 'EXISTS')).toBe(1);});- it('should correlate an INHERITED parent through its own condition', () => {- const condition = build([- {- kind: 'column',- joinColumnName: 'targetNoteId',- gate: {- kind: 'inherited',- parentTableAlias: 'attachment_targetNoteId',- parentTableExpression: '"workspace_abc"."note"',- parentCondition: {- sql: '"attachment_targetNoteId"."companyId" IS NOT NULL',- parameters: { nested: 'value' },- },- },- },- ]);-- expect(condition).toBeDefined();-- const { sql, parameters } = condition!;-- expect(sql).toContain(- ' OR ("attachment"."targetNoteId" IS NOT NULL AND EXISTS (SELECT 1 FROM "workspace_abc"."note" AS "attachment_targetNoteId" WHERE "attachment_targetNoteId"."id" = "attachment"."targetNoteId" AND "attachment_targetNoteId"."companyId" IS NOT NULL)))',- );- expect(parameters.nested).toBe('value');- });-- it('should accept any live child row of an OPEN child object', () => {- const condition = build([+ it('should accept a live child row, or one trashed with the record, of an OPEN child object', () => {+ const { sql } = build([{kind: 'children',childTableAlias: 'attachment_noteTarget',childTableExpression: '"workspace_abc"."noteTarget"',childJoinColumnName: 'noteId',- gate: { kind: 'open' },+ policy: { kind: 'open' },},]);- expect(condition).toBeDefined();-- expect(condition!.sql).toContain(- ' OR EXISTS (SELECT 1 FROM "workspace_abc"."noteTarget" AS "attachment_noteTarget" WHERE "attachment_noteTarget"."noteId" = "attachment"."id" AND "attachment_noteTarget"."deletedAt" IS NULL))',+ expect(sql).toContain(+ ' OR EXISTS (SELECT 1 FROM "workspace_abc"."noteTarget" AS "attachment_noteTarget" WHERE "attachment_noteTarget"."noteId" = "attachment"."id" AND ("attachment_noteTarget"."deletedAt" IS NULL OR ("attachment"."deletedAt" IS NOT NULL AND "attachment_noteTarget"."deletedAt" >= "attachment"."deletedAt"))))',);});it('should require a readable child row of a gated child object and skip a denied one', () => {- const condition = build([+ const { sql, parameters } = build([{kind: 'children',childTableAlias: 'attachment_noteTarget',childTableExpression: '"workspace_abc"."noteTarget"',childJoinColumnName: 'noteId',- gate: {+ policy: {kind: 'gated',condition: {sql: '"attachment_noteTarget"."targetPersonId" IS NOT NULL',@@ -175,16 +135,12 @@ describe('buildInheritedReadabilityCondition', () => {childTableAlias: 'attachment_secret',childTableExpression: '"workspace_abc"."secret"',childJoinColumnName: 'attachmentId',- gate: { kind: 'denied' },+ policy: { kind: 'denied' },},]);- expect(condition).toBeDefined();-- const { sql, parameters } = condition!;-expect(sql).toContain(- ' OR EXISTS (SELECT 1 FROM "workspace_abc"."noteTarget" AS "attachment_noteTarget" WHERE "attachment_noteTarget"."noteId" = "attachment"."id" AND "attachment_noteTarget"."deletedAt" IS NULL AND "attachment_noteTarget"."targetPersonId" IS NOT NULL))',+ ' OR EXISTS (SELECT 1 FROM "workspace_abc"."noteTarget" AS "attachment_noteTarget" WHERE "attachment_noteTarget"."noteId" = "attachment"."id" AND ("attachment_noteTarget"."deletedAt" IS NULL OR ("attachment"."deletedAt" IS NOT NULL AND "attachment_noteTarget"."deletedAt" >= "attachment"."deletedAt")) AND "attachment_noteTarget"."targetPersonId" IS NOT NULL))',);expect(sql).not.toContain('secret');expect(parameters.nested).toBe('value');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.tsnew file mode 100644index 00000000000..d6ddaa2845f--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts@@ -0,0 +1,186 @@+import { MetadataReadability } from 'twenty-shared/types';++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 {+ buildRowAccessPolicy,+ type RowAccessPolicyEnvironment,+ type RowAccessPolicySubject,+} from 'src/engine/twenty-orm/utils/build-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/twenty-orm/utils/resolve-inherited-readability-parents.util';++jest.mock(+ 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util',+);+jest.mock(+ 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util',+);++const APPLICATION_ID = 'application-id';+const NOTE_FILTER = { title: { eq: 'restricted' } };++const buildObject = ({+ id,+ readability,+}: {+ id: string;+ readability: MetadataReadability;+}): FlatObjectMetadata =>+ getFlatObjectMetadataMock({+ id,+ nameSingular: id,+ namePlural: `${id}s`,+ universalIdentifier: `${id}-universal-identifier`,+ applicationId: APPLICATION_ID,+ isSystem: false,+ readability,+ readabilityParentFieldUniversalIdentifiers: null,+ } as Parameters<typeof getFlatObjectMetadataMock>[0]);++const attachment = buildObject({+ id: 'attachment',+ readability: MetadataReadability.INHERITED,+});+const note = buildObject({ id: 'note', readability: MetadataReadability.OPEN });+const person = buildObject({+ id: 'person',+ readability: MetadataReadability.PRIVATE,+});++const environment: RowAccessPolicyEnvironment = {+ isRecordSharingEnabled: true,+ flatFieldMetadataMaps: { byId: {} } as never,+ flatObjectMetadataMaps: { byId: {} } as never,+ recordShareTableExpression: '"workspace"."recordShare"',+ resolveTableExpression: (objectMetadataId) =>+ `"workspace"."${objectMetadataId}"`,+};++const readEverything: RowAccessPolicySubject = {+ objectsPermissions: undefined,+ principalIds: ['member-1'],+ isOwningApplication: () => false,+ resolveRowLevelPermissionRecordFilter: () => null,+};++const build = (+ subject: RowAccessPolicySubject,+ flatObjectMetadata: FlatObjectMetadata,+) =>+ buildRowAccessPolicy({+ subject,+ environment,+ tableAlias: flatObjectMetadata.nameSingular,+ flatObjectMetadata,+ operationType: 'select',+ depth: 0,+ });++const gatedSql = (+ subject: RowAccessPolicySubject,+ flatObjectMetadata: FlatObjectMetadata,+): string => {+ const policy = build(subject, flatObjectMetadata);++ expect(policy.kind).toBe('gated');++ return policy.kind === 'gated' ? policy.condition.sql : '';+};++describe('buildRowAccessPolicy', () => {+ beforeEach(() => {+ (resolveInheritedReadabilityParents as jest.Mock).mockReturnValue([+ {+ kind: 'column',+ fieldMetadataId: 'target-note-field-id',+ joinColumnName: 'targetNoteId',+ parentFlatObjectMetadata: note,+ },+ {+ kind: 'column',+ fieldMetadataId: 'target-person-field-id',+ joinColumnName: 'targetPersonId',+ parentFlatObjectMetadata: person,+ },+ ]);+ (renderRowLevelPermissionFilterToSql as jest.Mock).mockImplementation(+ ({ tableAlias }: { tableAlias: string }) => ({+ sql: `"${tableAlias}"."title" = :restricted`,+ parameters: { restricted: 'restricted' },+ }),+ );+ });++ it('opens an OPEN object to a subject without predicate', () => {+ expect(build(readEverything, note)).toEqual({ kind: 'open' });+ });++ it('denies an object the subject has no permission on', () => {+ expect(build({ ...readEverything, objectsPermissions: {} }, note)).toEqual({+ kind: 'denied',+ });+ });++ it('gates an OPEN object on the role predicate alone', () => {+ const sql = gatedSql(+ {+ ...readEverything,+ resolveRowLevelPermissionRecordFilter: () => NOTE_FILTER,+ },+ note,+ );++ expect(sql).toBe('("note"."title" = :restricted)');+ });++ it('gates a PRIVATE object on its share rows and leaves it open without principals', () => {+ expect(gatedSql(readEverything, person)).toContain(+ '"person_recordShare"."recordId" = "person"."id"',+ );+ expect(+ build({ ...readEverything, principalIds: undefined }, person),+ ).toEqual({ kind: 'open' });+ });++ it('follows an INHERITED object to its parents under the parents policies', () => {+ const sql = gatedSql(+ {+ ...readEverything,+ resolveRowLevelPermissionRecordFilter: (objectMetadata) =>+ objectMetadata.id === note.id ? NOTE_FILTER : null,+ },+ attachment,+ );++ expect(sql).toContain(+ '"attachment"."targetNoteId" IS NOT NULL AND EXISTS (SELECT 1 FROM "workspace"."note" AS "attachment_targetNoteId" WHERE "attachment_targetNoteId"."id" = "attachment"."targetNoteId" AND ("attachment_targetNoteId"."title" = :restricted))',+ );+ expect(sql).toContain(+ '"attachment"."targetPersonId" IS NOT NULL AND EXISTS (SELECT 1 FROM "workspace"."person" AS "attachment_targetPersonId" WHERE "attachment_targetPersonId"."id" = "attachment"."targetPersonId" AND (EXISTS (SELECT 1 FROM "workspace"."recordShare" AS "attachment_targetPersonId_recordShare"',+ );+ });++ it('drops a parent the subject may not read and keeps the others', () => {+ const sql = gatedSql(+ {+ ...readEverything,+ objectsPermissions: {+ [attachment.id]: { canReadObjectRecords: true },+ [note.id]: { canReadObjectRecords: true },+ [person.id]: { canReadObjectRecords: false },+ } as never,+ },+ attachment,+ );++ expect(sql).toContain('"attachment"."targetNoteId" IS NOT NULL');+ expect(sql).not.toContain('targetPersonId');+ });++ it('keeps an INHERITED object open for its owning application', () => {+ expect(+ build({ ...readEverything, isOwningApplication: () => true }, attachment),+ ).toEqual({ kind: 'open' });+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/format-twenty-orm-event-to-database-batch-event.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/format-twenty-orm-event-to-database-batch-event.util.spec.tsindex 8f75c608b68..2cc4bad1341 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/format-twenty-orm-event-to-database-batch-event.util.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/format-twenty-orm-event-to-database-batch-event.util.spec.ts@@ -1,4 +1,8 @@-import { type ObjectRecordUpdateEvent } from 'twenty-shared/database-events';+import {+ type ObjectRecordDeleteEvent,+ type ObjectRecordDestroyEvent,+ type ObjectRecordUpdateEvent,+} from 'twenty-shared/database-events';import { FieldMetadataType, RelationType } from 'twenty-shared/types';import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';@@ -10,6 +14,7 @@ import {TwentyOrmExceptionCode,} from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';import { formatTwentyOrmEventToDatabaseBatchEvent } from 'src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util';+import { type InheritedReadabilityChildRecordsCarrier } from 'src/engine/twenty-orm/types/inherited-readability-child-records.type';describe('formatTwentyOrmEventToDatabaseBatchEvent', () => {const workspaceId = 'workspace-id';@@ -242,4 +247,91 @@ describe('formatTwentyOrmEventToDatabaseBatchEvent', () => {},);});++ describe('DELETED and DESTROYED actions', () => {+ const deletedAtField = createMockField({+ id: 'deleted-at-id',+ type: FieldMetadataType.DATE_TIME,+ name: 'deletedAt',+ label: 'Deleted at',+ });+ const flatFieldMetadataMapsWithDeletedAt: FlatEntityMaps<FlatFieldMetadata> =+ {+ byUniversalIdentifier: {+ 'name-id': nameField,+ 'deleted-at-id': deletedAtField,+ },+ universalIdentifierById: {+ 'name-id': 'name-id',+ 'deleted-at-id': 'deleted-at-id',+ },+ universalIdentifiersByApplicationId: {},+ };+ const flatObjectMetadataWithDeletedAt = {+ ...flatObjectMetadata,+ fieldIds: ['name-id', 'deleted-at-id'],+ } as FlatObjectMetadata;+ const inheritedReadabilityChildRecordsByRecordId = new Map([+ [+ 'record-1',+ { noteTarget: [{ id: 'note-target-1', noteId: 'record-1' }] },+ ],+ ]);++ it('should carry the child records captured for a record on its deleted event only', () => {+ const result = formatTwentyOrmEventToDatabaseBatchEvent({+ action: DatabaseEventAction.DELETED,+ objectMetadataItem: flatObjectMetadataWithDeletedAt,+ flatFieldMetadataMaps: flatFieldMetadataMapsWithDeletedAt,+ workspaceId: mockWorkspaceId,+ authContext: mockAuthContext,+ recordsBefore: [+ { id: 'record-1', name: 'John', deletedAt: null },+ { id: 'record-2', name: 'Jane', deletedAt: null },+ ],+ recordsAfter: [+ { id: 'record-1', name: 'John', deletedAt: '2026-09-15T00:00:00Z' },+ { id: 'record-2', name: 'Jane', deletedAt: '2026-09-15T00:00:00Z' },+ ],+ inheritedReadabilityChildRecordsByRecordId,+ });+ const [deleteEvent1, deleteEvent2] =+ result?.events as ObjectRecordDeleteEvent[];++ expect(+ (deleteEvent1.properties as InheritedReadabilityChildRecordsCarrier)+ .inheritedReadabilityChildRecords,+ ).toEqual({+ noteTarget: [{ id: 'note-target-1', noteId: 'record-1' }],+ });+ expect(deleteEvent2.properties).not.toHaveProperty(+ 'inheritedReadabilityChildRecords',+ );+ });++ it('should carry the child records captured for a record on its destroyed event only', () => {+ const result = formatTwentyOrmEventToDatabaseBatchEvent({+ action: DatabaseEventAction.DESTROYED,+ objectMetadataItem: flatObjectMetadata,+ flatFieldMetadataMaps,+ workspaceId: mockWorkspaceId,+ authContext: mockAuthContext,+ recordsBefore: [+ { id: 'record-1', name: 'John' },+ { id: 'record-2', name: 'Jane' },+ ],+ inheritedReadabilityChildRecordsByRecordId,+ });+ const [destroyEvent1, destroyEvent2] =+ result?.events as ObjectRecordDestroyEvent[];++ expect(+ (destroyEvent1.properties as InheritedReadabilityChildRecordsCarrier)+ .inheritedReadabilityChildRecords,+ ).toEqual({ noteTarget: [{ id: 'note-target-1', noteId: 'record-1' }] });+ expect(destroyEvent2.properties).not.toHaveProperty(+ 'inheritedReadabilityChildRecords',+ );+ });+ });});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-child-record-bound-at-deletion.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-child-record-bound-at-deletion.util.spec.tsnew file mode 100644index 00000000000..591ad09f0be--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-child-record-bound-at-deletion.util.spec.ts@@ -0,0 +1,51 @@+import { isChildRecordBoundAtDeletion } from 'src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util';++describe('isChildRecordBoundAtDeletion', () => {+ it('should bind a live child record whatever the record state', () => {+ expect(+ isChildRecordBoundAtDeletion({+ childRecord: { deletedAt: null },+ record: { deletedAt: null },+ }),+ ).toBe(true);+ expect(+ isChildRecordBoundAtDeletion({+ childRecord: { deletedAt: null },+ record: { deletedAt: '2026-09-15T08:00:00.000Z' },+ }),+ ).toBe(true);+ });++ it('should not bind a child record detached before a live record is deleted', () => {+ expect(+ isChildRecordBoundAtDeletion({+ childRecord: { deletedAt: '2026-09-15T07:00:00.000Z' },+ record: { deletedAt: null },+ }),+ ).toBe(false);+ });++ it('should bind a child record deleted with or after a trashed record', () => {+ expect(+ isChildRecordBoundAtDeletion({+ childRecord: { deletedAt: new Date('2026-09-15T08:00:00.000Z') },+ record: { deletedAt: '2026-09-15T08:00:00.000Z' },+ }),+ ).toBe(true);+ expect(+ isChildRecordBoundAtDeletion({+ childRecord: { deletedAt: '2026-09-15T08:00:01.000Z' },+ record: { deletedAt: new Date('2026-09-15T08:00:00.000Z') },+ }),+ ).toBe(true);+ });++ it('should not bind a child record detached before a trashed record was deleted', () => {+ expect(+ isChildRecordBoundAtDeletion({+ childRecord: { deletedAt: '2026-09-15T07:59:59.000Z' },+ record: { deletedAt: '2026-09-15T08:00:00.000Z' },+ }),+ ).toBe(false);+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.tsindex 63dcf5b8376..8ea7f51a536 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.ts@@ -1,41 +1,38 @@import { type RecordShareAccessLevel } from 'twenty-shared/types';import { type ObjectLiteral } from 'typeorm';+import {+ type RowAccessPolicy,+ type SqlCondition,+} from 'src/engine/twenty-orm/types/row-access-policy.type';import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.util';import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';-type SqlCondition = { sql: string; parameters: ObjectLiteral };--export type InheritedReadabilityParentGate =- | { kind: 'open' }- | { kind: 'denied' }- | { kind: 'private'; objectMetadataId: string }- | {- kind: 'inherited';- parentTableAlias: string;- parentTableExpression: string;- parentCondition: SqlCondition;- };--export type InheritedReadabilityChildGate =- | { kind: 'open' }- | { kind: 'denied' }- | { kind: 'gated'; condition: SqlCondition };-export type InheritedReadabilityParentCondition =| {kind: 'column';joinColumnName: string;- gate: InheritedReadabilityParentGate;+ parentTableAlias: string;+ parentTableExpression: string;+ policy: RowAccessPolicy;}| {kind: 'children';childTableAlias: string;childTableExpression: string;childJoinColumnName: string;- gate: InheritedReadabilityChildGate;+ policy: RowAccessPolicy;};+const buildChildLinkBoundCondition = ({+ quotedTableAlias,+ quotedChildTableAlias,+}: {+ quotedTableAlias: string;+ quotedChildTableAlias: string;+}): string =>+ `(${quotedChildTableAlias}."deletedAt" IS NULL OR (${quotedTableAlias}."deletedAt" IS NOT NULL AND ${quotedChildTableAlias}."deletedAt" >= ${quotedTableAlias}."deletedAt"))`;+export const buildInheritedReadabilityCondition = ({tableAlias,objectMetadataId,@@ -50,11 +47,9 @@ export const buildInheritedReadabilityCondition = ({recordShareTableExpression: string;principalIds: string[];accessLevels: RecordShareAccessLevel[];-}): SqlCondition | undefined => {+}): SqlCondition => {const parameters: ObjectLiteral = {};const quotedTableAlias = escapeIdentifier(tableAlias);- const quoteColumn = (joinColumnName: string) =>- `${quotedTableAlias}.${escapeIdentifier(joinColumnName)}`;// The share rows on the record itself, its creator's among them, grant// access on their own, as they do on a PRIVATE record@@ -69,66 +64,44 @@ export const buildInheritedReadabilityCondition = ({Object.assign(parameters, ownRecordShareCondition.parameters);const parentConditions = parents.flatMap((parent) => {- if (parent.kind === 'children') {- const {- childTableAlias,- childTableExpression,- childJoinColumnName,- gate,- } = parent;-- if (gate.kind === 'denied') {- return [];- }+ if (parent.policy.kind === 'denied') {+ return [];+ }- const quotedChildTableAlias = escapeIdentifier(childTableAlias);+ if (parent.kind === 'children') {+ const quotedChildTableAlias = escapeIdentifier(parent.childTableAlias);const childRowConditions = [- `${quotedChildTableAlias}.${escapeIdentifier(childJoinColumnName)} = ${quotedTableAlias}."id"`,- `${quotedChildTableAlias}."deletedAt" IS NULL`,+ `${quotedChildTableAlias}.${escapeIdentifier(parent.childJoinColumnName)} = ${quotedTableAlias}."id"`,+ buildChildLinkBoundCondition({+ quotedTableAlias,+ quotedChildTableAlias,+ }),];- if (gate.kind === 'gated') {- Object.assign(parameters, gate.condition.parameters);- childRowConditions.push(gate.condition.sql);+ if (parent.policy.kind === 'gated') {+ Object.assign(parameters, parent.policy.condition.parameters);+ childRowConditions.push(parent.policy.condition.sql);}return [- `EXISTS (SELECT 1 FROM ${childTableExpression} AS ${quotedChildTableAlias} WHERE ${childRowConditions.join(' AND ')})`,+ `EXISTS (SELECT 1 FROM ${parent.childTableExpression} AS ${quotedChildTableAlias} WHERE ${childRowConditions.join(' AND ')})`,];}- const { joinColumnName, gate } = parent;- const notNullCondition = `${quoteColumn(joinColumnName)} IS NOT NULL`;-- switch (gate.kind) {- case 'open':- return [notNullCondition];- case 'denied':- return [];- case 'private': {- const recordShareCondition = buildRecordShareCondition({- tableAlias,- recordShareTableExpression,- objectMetadataId: gate.objectMetadataId,- principalIds,- accessLevels,- recordIdExpression: quoteColumn(joinColumnName),- });-- Object.assign(parameters, recordShareCondition.parameters);-- return [`(${notNullCondition} AND ${recordShareCondition.sql})`];- }- case 'inherited': {- const quotedParentTableAlias = escapeIdentifier(gate.parentTableAlias);-- Object.assign(parameters, gate.parentCondition.parameters);+ const quotedJoinColumn = `${quotedTableAlias}.${escapeIdentifier(parent.joinColumnName)}`;+ const notNullCondition = `${quotedJoinColumn} IS NOT NULL`;- return [- `(${notNullCondition} AND EXISTS (SELECT 1 FROM ${gate.parentTableExpression} AS ${quotedParentTableAlias} WHERE ${quotedParentTableAlias}."id" = ${quoteColumn(joinColumnName)} AND ${gate.parentCondition.sql}))`,- ];- }+ if (parent.policy.kind === 'open') {+ return [notNullCondition];}++ const quotedParentTableAlias = escapeIdentifier(parent.parentTableAlias);++ Object.assign(parameters, parent.policy.condition.parameters);++ return [+ `(${notNullCondition} AND EXISTS (SELECT 1 FROM ${parent.parentTableExpression} AS ${quotedParentTableAlias} WHERE ${quotedParentTableAlias}."id" = ${quotedJoinColumn} AND ${parent.policy.condition.sql}))`,+ ];});return {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.tsnew file mode 100644index 00000000000..9b51b290b80--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts@@ -0,0 +1,290 @@+import {+ MetadataReadability,+ type ObjectsPermissions,+ type RecordGqlOperationFilter,+ type RecordShareAccessLevel,+} from 'twenty-shared/types';+import { assertUnreachable, isDefined } from 'twenty-shared/utils';++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 { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/twenty-orm/constants/max-inherited-readability-depth.constant';+import { type OperationType } from 'src/engine/twenty-orm/repository/permissions.utils';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';+import { type WorkspaceRelationShape } from 'src/engine/twenty-orm/table-shape/types/workspace-table-shape.type';+import { type InheritedReadabilityParent } from 'src/engine/twenty-orm/types/inherited-readability-parent.type';+import {+ type RowAccessPolicy,+ 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 {+ buildInheritedReadabilityCondition,+ type InheritedReadabilityParentCondition,+} from 'src/engine/twenty-orm/utils/build-inherited-readability-condition.util';+import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.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';+import { resolveInheritedReadabilityParents } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util';++export type RowAccessPolicySubject = {+ objectsPermissions: ObjectsPermissions | undefined;+ principalIds: string[] | undefined;+ isOwningApplication: (objectMetadata: FlatObjectMetadata) => boolean;+ resolveRowLevelPermissionRecordFilter: (+ objectMetadata: FlatObjectMetadata,+ ) => RecordGqlOperationFilter | null;+};++export type RowAccessPolicyEnvironment = {+ isRecordSharingEnabled: boolean;+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+ recordShareTableExpression: string;+ resolveTableExpression: (objectMetadataId: string) => string;+};++type RowAccessPolicyContext = {+ subject: RowAccessPolicySubject;+ environment: RowAccessPolicyEnvironment;+};++type RowAccessPolicyTarget = {+ tableAlias: string;+ flatObjectMetadata: FlatObjectMetadata;+ operationType: OperationType;+ depth: number;+ joinParentRelationShape?: WorkspaceRelationShape;+};++export const buildRowAccessPolicy = ({+ subject,+ environment,+ ...target+}: RowAccessPolicyContext & RowAccessPolicyTarget): RowAccessPolicy => {+ const context = { subject, environment };++ if (+ isDefined(subject.objectsPermissions) &&+ !isObjectOperationPermitted({+ objectMetadata: target.flatObjectMetadata,+ operationType: target.operationType,+ objectsPermissions: subject.objectsPermissions,+ })+ ) {+ return { kind: 'denied' };+ }++ const recordShareGate = buildRecordShareGate(context, target);++ if (recordShareGate.kind === 'denied') {+ return { kind: 'denied' };+ }++ const conditions = [+ buildRolePredicate(context, target),+ recordShareGate.kind === 'gated' ? recordShareGate.condition : undefined,+ ].filter(isDefined);++ if (conditions.length === 0) {+ return { kind: 'open' };+ }++ return { kind: 'gated', condition: combineSqlConditions(conditions) };+};++const buildRolePredicate = (+ { subject, environment }: RowAccessPolicyContext,+ { tableAlias, flatObjectMetadata }: RowAccessPolicyTarget,+): SqlCondition | undefined => {+ const recordFilter =+ subject.resolveRowLevelPermissionRecordFilter(flatObjectMetadata);++ if (!isDefined(recordFilter)) {+ return undefined;+ }++ return (+ renderRowLevelPermissionFilterToSql({+ recordFilter,+ tableAlias,+ objectMetadata: flatObjectMetadata,+ flatFieldMetadataMaps: environment.flatFieldMetadataMaps,+ }) ?? undefined+ );+};++const buildRecordShareGate = (+ context: RowAccessPolicyContext,+ target: RowAccessPolicyTarget,+): RowAccessPolicy => {+ const { isRecordSharingEnabled } = context.environment;+ const isOwningApplication = context.subject.isOwningApplication(+ target.flatObjectMetadata,+ );++ switch (target.flatObjectMetadata.readability) {+ case MetadataReadability.OPEN:+ return { kind: 'open' };+ case MetadataReadability.INHERITED:+ if (!isRecordSharingEnabled || isOwningApplication) {+ return { kind: 'open' };+ }++ return buildInheritedReadabilityGate(context, target);+ case MetadataReadability.SYSTEM:+ return { kind: 'denied' };+ case MetadataReadability.APPLICATION:+ return isRecordSharingEnabled && !isOwningApplication+ ? { kind: 'denied' }+ : { kind: 'open' };+ case MetadataReadability.PRIVATE:+ if (!isRecordSharingEnabled || isOwningApplication) {+ return { kind: 'open' };+ }++ return buildOwnRecordShareGate(context, target);+ default:+ return assertUnreachable(target.flatObjectMetadata.readability);+ }+};++const resolveRecordSharePrincipals = (+ { subject }: RowAccessPolicyContext,+ { operationType }: RowAccessPolicyTarget,+):+ | { principalIds: string[]; accessLevels: RecordShareAccessLevel[] }+ | undefined => {+ if (!isDefined(subject.principalIds)) {+ return undefined;+ }++ const accessLevels = resolveRequiredRecordShareAccessLevels(operationType);++ if (accessLevels.length === 0) {+ return undefined;+ }++ return { principalIds: subject.principalIds, accessLevels };+};++const buildOwnRecordShareGate = (+ context: RowAccessPolicyContext,+ target: RowAccessPolicyTarget,+): RowAccessPolicy => {+ const principals = resolveRecordSharePrincipals(context, target);++ if (!isDefined(principals)) {+ return { kind: 'open' };+ }++ return {+ kind: 'gated',+ condition: buildRecordShareCondition({+ tableAlias: target.tableAlias,+ recordShareTableExpression:+ context.environment.recordShareTableExpression,+ objectMetadataId: target.flatObjectMetadata.id,+ ...principals,+ }),+ };+};++const buildInheritedReadabilityGate = (+ context: RowAccessPolicyContext,+ target: RowAccessPolicyTarget,+): RowAccessPolicy => {+ const { tableAlias, flatObjectMetadata, depth, joinParentRelationShape } =+ target;++ if (depth > MAX_INHERITED_READABILITY_DEPTH) {+ return { kind: 'denied' };+ }++ const parents = resolveInheritedReadabilityParents({+ flatObjectMetadata,+ flatFieldMetadataMaps: context.environment.flatFieldMetadataMaps,+ flatObjectMetadataMaps: context.environment.flatObjectMetadataMaps,+ });++ if (+ isDefined(joinParentRelationShape) &&+ parents.some(+ (parent) =>+ parent.kind === 'column' &&+ parent.fieldMetadataId ===+ joinParentRelationShape.targetFieldMetadataId,+ )+ ) {+ return { kind: 'open' };+ }++ if (parents.length === 0) {+ return buildOwnRecordShareGate(context, target);+ }++ const principals = resolveRecordSharePrincipals(context, target);++ if (!isDefined(principals)) {+ return { kind: 'open' };+ }++ return {+ kind: 'gated',+ condition: buildInheritedReadabilityCondition({+ tableAlias,+ objectMetadataId: flatObjectMetadata.id,+ parents: parents.map((parent) =>+ buildInheritedReadabilityParentCondition(context, target, parent),+ ),+ recordShareTableExpression:+ context.environment.recordShareTableExpression,+ ...principals,+ }),+ };+};++const buildInheritedReadabilityParentCondition = (+ context: RowAccessPolicyContext,+ { tableAlias, operationType, depth }: RowAccessPolicyTarget,+ parent: InheritedReadabilityParent,+): InheritedReadabilityParentCondition => {+ if (parent.kind === 'column') {+ const parentTableAlias = `${tableAlias}_${parent.joinColumnName}`;++ return {+ kind: 'column',+ joinColumnName: parent.joinColumnName,+ parentTableAlias,+ parentTableExpression: context.environment.resolveTableExpression(+ parent.parentFlatObjectMetadata.id,+ ),+ policy: buildRowAccessPolicy({+ ...context,+ tableAlias: parentTableAlias,+ flatObjectMetadata: parent.parentFlatObjectMetadata,+ operationType,+ depth: depth + 1,+ }),+ };+ }++ const childTableAlias = `${tableAlias}_${parent.childFlatObjectMetadata.nameSingular}`;++ return {+ kind: 'children',+ childTableAlias,+ childTableExpression: context.environment.resolveTableExpression(+ parent.childFlatObjectMetadata.id,+ ),+ childJoinColumnName: parent.childJoinColumnName,+ policy: buildRowAccessPolicy({+ ...context,+ tableAlias: childTableAlias,+ flatObjectMetadata: parent.childFlatObjectMetadata,+ operationType,+ depth: depth + 1,+ }),+ };+};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/combine-sql-conditions.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/combine-sql-conditions.util.tsnew file mode 100644index 00000000000..955dd6f8a35--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/combine-sql-conditions.util.ts@@ -0,0 +1,11 @@+import { type SqlCondition } from 'src/engine/twenty-orm/types/row-access-policy.type';++export const combineSqlConditions = (+ conditions: SqlCondition[],+): SqlCondition => ({+ sql: conditions.map((condition) => `(${condition.sql})`).join(' AND '),+ parameters: Object.assign(+ {},+ ...conditions.map((condition) => condition.parameters),+ ),+});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util.tsindex 408cc59f73e..408089fe484 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util.ts@@ -28,6 +28,7 @@ import {TwentyOrmException,TwentyOrmExceptionCode,} from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';+import { type InheritedReadabilityChildRecords } from 'src/engine/twenty-orm/types/inherited-readability-child-records.type';import { type DatabaseBatchEventInput } from 'src/engine/workspace-event-emitter/workspace-event-emitter';export const formatTwentyOrmEventToDatabaseBatchEvent = <@@ -40,6 +41,7 @@ export const formatTwentyOrmEventToDatabaseBatchEvent = <authContext,recordsAfter,recordsBefore,+ inheritedReadabilityChildRecordsByRecordId,}: {action: DatabaseEventAction;objectMetadataItem: FlatObjectMetadata;@@ -48,9 +50,22 @@ export const formatTwentyOrmEventToDatabaseBatchEvent = <authContext?: RawAuthContext;recordsAfter?: T[];recordsBefore?: T[];+ inheritedReadabilityChildRecordsByRecordId?: Map<+ string,+ InheritedReadabilityChildRecords+ >;}): DatabaseBatchEventInput<T, DatabaseEventAction> | undefined => {const objectMetadataNameSingular = objectMetadataItem.nameSingular;+ const buildInheritedReadabilityChildRecordsProperty = (recordId: string) => {+ const inheritedReadabilityChildRecords =+ inheritedReadabilityChildRecordsByRecordId?.get(recordId);++ return isDefined(inheritedReadabilityChildRecords)+ ? { inheritedReadabilityChildRecords }+ : {};+ };+let events: (| ObjectRecordDeleteEvent<T>| ObjectRecordRestoreEvent<T>@@ -151,6 +166,9 @@ export const formatTwentyOrmEventToDatabaseBatchEvent = <after: recordAfter,updatedFields,diff,+ ...(action === DatabaseEventAction.DELETED+ ? buildInheritedReadabilityChildRecordsProperty(recordAfter.id)+ : {}),},} satisfies| ObjectRecordUpdateEvent<T>@@ -196,7 +214,10 @@ export const formatTwentyOrmEventToDatabaseBatchEvent = <event.userWorkspaceId = authContext?.userWorkspaceId;event.workspaceMemberId = authContext?.workspaceMemberId;event.recordId = recordBefore.id;- event.properties = { before: recordBefore };+ event.properties = {+ before: recordBefore,+ ...buildInheritedReadabilityChildRecordsProperty(recordBefore.id),+ };return event;});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util.tsnew file mode 100644index 00000000000..8423e8630bc--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util.ts@@ -0,0 +1,24 @@+import { isDefined } from 'twenty-shared/utils';++const toTime = (value: unknown): number | undefined =>+ isDefined(value) && (typeof value === 'string' || value instanceof Date)+ ? new Date(value).getTime()+ : undefined;++export const isChildRecordBoundAtDeletion = ({+ childRecord,+ record,+}: {+ childRecord: Record<string, unknown>;+ record: Record<string, unknown>;+}): boolean => {+ const childDeletedAt = toTime(childRecord.deletedAt);++ if (!isDefined(childDeletedAt)) {+ return true;+ }++ const recordDeletedAt = toTime(record.deletedAt);++ return isDefined(recordDeletedAt) && childDeletedAt >= recordDeletedAt;+};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-exempt-from-object-permissions.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-exempt-from-object-permissions.util.tsnew file mode 100644index 00000000000..3c63c79e232--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-exempt-from-object-permissions.util.ts@@ -0,0 +1,11 @@+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';++import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';++// TODO: this should be improved, we may have more complex permission configuration for is system objects+export const isExemptFromObjectPermissions = (+ objectMetadata: FlatObjectMetadata,+): boolean =>+ objectMetadata.isSystem === true &&+ objectMetadata.universalIdentifier !==+ STANDARD_OBJECTS.workspaceMember.universalIdentifier;diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-object-operation-permitted.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-object-operation-permitted.util.tsnew file mode 100644index 00000000000..73cdcc5686d--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-object-operation-permitted.util.ts@@ -0,0 +1,37 @@+import { type ObjectsPermissions } from 'twenty-shared/types';+import { assertUnreachable } from 'twenty-shared/utils';++import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type OperationType } from 'src/engine/twenty-orm/repository/permissions.utils';+import { isExemptFromObjectPermissions } from 'src/engine/twenty-orm/utils/is-exempt-from-object-permissions.util';++export const isObjectOperationPermitted = ({+ objectMetadata,+ operationType,+ objectsPermissions,+}: {+ objectMetadata: FlatObjectMetadata;+ operationType: OperationType;+ objectsPermissions: ObjectsPermissions;+}): boolean => {+ if (isExemptFromObjectPermissions(objectMetadata)) {+ return true;+ }++ const objectPermissions = objectsPermissions[objectMetadata.id];++ switch (operationType) {+ case 'select':+ return objectPermissions?.canReadObjectRecords === true;+ case 'insert':+ case 'update':+ return objectPermissions?.canUpdateObjectRecords === true;+ case 'delete':+ return objectPermissions?.canDestroyObjectRecords === true;+ case 'restore':+ case 'soft-delete':+ return objectPermissions?.canSoftDeleteObjectRecords === true;+ default:+ return assertUnreachable(operationType);+ }+};diff --git a/packages/twenty-server/src/modules/note/query-hooks/note-post-query-hook.service.ts b/packages/twenty-server/src/modules/note/query-hooks/note-post-query-hook.service.tsindex 4fa44688638..98081fff5ab 100644--- a/packages/twenty-server/src/modules/note/query-hooks/note-post-query-hook.service.ts+++ b/packages/twenty-server/src/modules/note/query-hooks/note-post-query-hook.service.ts@@ -29,6 +29,7 @@ export class NotePostQueryHookService {const noteTargetRepository =this.workspaceOrmManager.getRepository<NoteTargetWorkspaceEntity>('noteTarget',+ { shouldBypassPermissionChecks: true },);await noteTargetRepository.softDelete({@@ -53,6 +54,7 @@ export class NotePostQueryHookService {const noteTargetRepository =this.workspaceOrmManager.getRepository<NoteTargetWorkspaceEntity>('noteTarget',+ { shouldBypassPermissionChecks: true },);await noteTargetRepository.restore({diff --git a/packages/twenty-server/src/modules/task/query-hooks/task-post-query-hook.service.ts b/packages/twenty-server/src/modules/task/query-hooks/task-post-query-hook.service.tsindex 611571add27..bc52384a759 100644--- a/packages/twenty-server/src/modules/task/query-hooks/task-post-query-hook.service.ts+++ b/packages/twenty-server/src/modules/task/query-hooks/task-post-query-hook.service.ts@@ -29,6 +29,7 @@ export class TaskPostQueryHookService {const taskTargetRepository =this.workspaceOrmManager.getRepository<TaskTargetWorkspaceEntity>('taskTarget',+ { shouldBypassPermissionChecks: true },);await taskTargetRepository.softDelete({@@ -53,6 +54,7 @@ export class TaskPostQueryHookService {const taskTargetRepository =this.workspaceOrmManager.getRepository<TaskTargetWorkspaceEntity>('taskTarget',+ { shouldBypassPermissionChecks: true },);await taskTargetRepository.restore({diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/__tests__/workflow-database-event-trigger.listener.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/__tests__/workflow-database-event-trigger.listener.spec.tsindex 620ed915b98..08f05572565 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/__tests__/workflow-database-event-trigger.listener.spec.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/__tests__/workflow-database-event-trigger.listener.spec.ts@@ -12,6 +12,7 @@ import {import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';@@ -119,6 +120,14 @@ describe('WorkflowDatabaseEventTriggerListener', () => {provide: RecordShareService,useValue: recordShareService,},+ {+ provide: RecordAccessPolicyService,+ useValue: {+ resolveRecordIdsReadableThroughParents: jest+ .fn()+ .mockResolvedValue(new Set()),+ },+ },{provide: 'MESSAGE_QUEUE_workflow-queue',useValue: messageQueueService,@@ -318,6 +327,45 @@ describe('WorkflowDatabaseEventTriggerListener', () => {);});+ it('should not hand the child records captured with a deletion to the workflow', async () => {+ const capturedEvent = {+ ...mockPayload.events[0],+ properties: {+ before: { field1: 'old', field2: 'old' },+ inheritedReadabilityChildRecords: {+ noteTarget: [{ id: 'note-target-1', noteId: 'record-1' }],+ },+ },+ };++ setTriggerMap([+ {+ type: AutomatedTriggerType.DATABASE_EVENT,+ workflowId,+ settings: {+ eventName: 'deleteEvent',+ },+ },+ ]);++ await listener.handleObjectRecordDeleteEvent({+ ...mockPayload,+ name: 'deleteEvent',+ events: [capturedEvent],+ });++ expect(messageQueueService.add).toHaveBeenCalledWith(+ WorkflowTriggerJob.name,+ expect.objectContaining({+ payload: {+ ...capturedEvent,+ properties: { before: { field1: 'old', field2: 'old' } },+ },+ }),+ { retryLimit: 3 },+ );+ });+it('should handle destroy events correctly', async () => {const destroyPayload: WorkspaceEventBatch<any> = {...mockPayload,diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.tsindex 7caaf116f28..6c6299d83c8 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts@@ -28,9 +28,13 @@ import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modulesimport { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { RecordShareService } from 'src/engine/record-share/services/record-share.service';import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';-import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';+import { omitInheritedReadabilityChildRecords } from 'src/engine/record-share/utils/omit-inherited-readability-child-records.util';+import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';+import { buildRoleRowAccessPolicySubject } from 'src/engine/record-share/utils/build-role-row-access-policy-subject.util';import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';@@ -77,6 +81,7 @@ export class WorkflowDatabaseEventTriggerListener {private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,private readonly workspaceCacheService: WorkspaceCacheService,private readonly recordShareService: RecordShareService,+ private readonly recordAccessPolicyService: RecordAccessPolicyService,) {}@OnDatabaseBatchEvent('*', DatabaseEventAction.CREATED)@@ -389,7 +394,7 @@ export class WorkflowDatabaseEventTriggerListener {coreWorkflowVersionId: eventListener.coreWorkflowVersionId,workspaceWorkflowVersionId:eventListener.workspaceWorkflowVersionId,- payload: eventPayload,+ payload: omitInheritedReadabilityChildRecords(eventPayload),},{ retryLimit: 3 },);@@ -417,12 +422,23 @@ export class WorkflowDatabaseEventTriggerListener {private async buildRecordShareGate(payload: WorkspaceEventBatch<ObjectRecordEvent>,): Promise<RecordShareGate | null> {- const { featureFlagsMap, flatApplicationMaps, flatRoleMaps } =- await this.workspaceCacheService.getOrRecompute(payload.workspaceId, [- 'featureFlagsMap',- 'flatApplicationMaps',- 'flatRoleMaps',- ]);+ const {+ featureFlagsMap,+ flatApplicationMaps,+ flatRoleMaps,+ rolesPermissions,+ flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps,+ } = await this.workspaceCacheService.getOrRecompute(payload.workspaceId, [+ 'featureFlagsMap',+ 'flatApplicationMaps',+ 'flatRoleMaps',+ 'rolesPermissions',+ 'flatRowLevelPermissionPredicateMaps',+ 'flatRowLevelPermissionPredicateGroupMaps',+ 'flatFieldMetadataMaps',+ ]);if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {return null;@@ -433,19 +449,19 @@ export class WorkflowDatabaseEventTriggerListener {TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,);+ const roleId =+ standardApplication?.defaultRoleId ??+ findFlatEntityByUniversalIdentifier({+ flatEntityMaps: flatRoleMaps,+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,+ })?.id;+return buildRecordShareGate({readability: payload.objectMetadata.readability,isOwningApplication:isDefined(standardApplication) &&payload.objectMetadata.applicationId === standardApplication.id,- principalIds: [- EVERYONE_PRINCIPAL_ID,- standardApplication?.defaultRoleId ??- findFlatEntityByUniversalIdentifier({- flatEntityMaps: flatRoleMaps,- universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,- })?.id,- ],+ principalIds: [EVERYONE_PRINCIPAL_ID, roleId],fetchRecordSharesByRecordId: async () =>indexRecordSharesByRecordId(await this.recordShareService.findByRecordIds({@@ -454,6 +470,20 @@ export class WorkflowDatabaseEventTriggerListener {recordIds: payload.events.map((event) => event.recordId),}),),+ resolveRecordIdsReadableThroughParents: () =>+ this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents({+ workspaceId: payload.workspaceId,+ objectMetadata: payload.objectMetadata,+ records: resolveEventRecordSnapshots(payload.events),+ subject: buildRoleRowAccessPolicySubject({+ roleId,+ owningApplicationId: standardApplication?.id,+ rolesPermissions,+ flatRowLevelPermissionPredicateMaps,+ flatRowLevelPermissionPredicateGroupMaps,+ flatFieldMetadataMaps,+ }),+ }),});}@@ -480,7 +510,7 @@ export class WorkflowDatabaseEventTriggerListener {return true;}- return isRecordSharedWithPrincipals({+ return isRecordAdmittedByRecordShareGate({recordShareGate,recordId: eventPayload.recordId,accessLevels: resolveRequiredRecordShareAccessLevels('select'),diff --git a/packages/twenty-server/test/integration/graphql/suites/hooks/note-target-hooks.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/hooks/note-target-hooks.integration-spec.tsindex da24da4100e..f09a17da2ac 100644--- a/packages/twenty-server/test/integration/graphql/suites/hooks/note-target-hooks.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/hooks/note-target-hooks.integration-spec.ts@@ -100,6 +100,81 @@ describe('noteTargets hooks on note actions', () => {).not.toBeNull();});+ it('deleteOne note should leave a noteTarget detached earlier at its own deletion time', async () => {+ const noteId = randomUUID();+ const detachedNoteTargetId = randomUUID();+ const attachedNoteTargetId = randomUUID();++ noteIds.push(noteId);+ noteTargetIds.push(detachedNoteTargetId, attachedNoteTargetId);++ await createOneOperation({+ objectMetadataSingularName: 'note',+ gqlFields: NOTE_GQL_FIELDS,+ input: { id: noteId, title: 'Test Note with a detached target' },+ });++ await Promise.all([+ createOneOperation({+ objectMetadataSingularName: 'noteTarget',+ gqlFields: NOTE_TARGET_GQL_FIELDS,+ input: { id: detachedNoteTargetId, noteId },+ }),+ createOneOperation({+ objectMetadataSingularName: 'noteTarget',+ gqlFields: NOTE_TARGET_GQL_FIELDS,+ input: { id: attachedNoteTargetId, noteId },+ }),+ ]);++ const detachResponse = await makeGraphqlAPIRequest(+ deleteOneOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ gqlFields: NOTE_TARGET_GQL_FIELDS,+ recordId: detachedNoteTargetId,+ }),+ );+ const detachedAt = detachResponse.body.data.deleteNoteTarget.deletedAt;++ expect(detachedAt).not.toBeNull();++ const deleteResponse = await makeGraphqlAPIRequest(+ deleteOneOperationFactory({+ objectMetadataSingularName: 'note',+ gqlFields: NOTE_GQL_FIELDS,+ recordId: noteId,+ }),+ );++ expect(deleteResponse.body.data.deleteNote.deletedAt).not.toBeNull();++ const noteTargetsResponse = await makeGraphqlAPIRequest(+ findManyOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ gqlFields: NOTE_TARGET_GQL_FIELDS,+ filter: {+ id: { in: [detachedNoteTargetId, attachedNoteTargetId] },+ not: { deletedAt: { is: 'NULL' } },+ },+ }),+ );+ const deletedAtByNoteTargetId = Object.fromEntries(+ noteTargetsResponse.body.data.noteTargets.edges.map(+ ({ node }: { node: { id: string; deletedAt: string } }) => [+ node.id,+ node.deletedAt,+ ],+ ),+ );++ expect(deletedAtByNoteTargetId[detachedNoteTargetId]).toBe(detachedAt);+ expect(deletedAtByNoteTargetId[attachedNoteTargetId]).not.toBeNull();+ expect(+ new Date(deletedAtByNoteTargetId[attachedNoteTargetId]).getTime(),+ ).toBeGreaterThan(new Date(detachedAt).getTime());+ });+it('deleteMany notes should soft delete related noteTargets', async () => {const noteId1 = randomUUID();const noteId2 = randomUUID();diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.tsindex b301ab8334a..3392aa09b8e 100644--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts@@ -1,5 +1,7 @@import { randomUUID } from 'node:crypto';+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';@@ -9,6 +11,7 @@ import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphimport { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';+import { upsertObjectPermissions } from 'test/integration/metadata/suites/object-permission/utils/upsert-object-permissions.util';import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';@@ -21,8 +24,11 @@ import {RecordShareRowCause,} from 'twenty-shared/types';+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';+import { type RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';import { type RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';@@ -444,6 +450,94 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {).toEqual(ATTACHMENT_IDS.sort());});+ it('should let the event gate see the same notes as the query gate', async () => {+ const memberRole = await findOneRoleByLabel({ label: 'Member' });+ const { rolesPermissions, flatObjectMetadataMaps } =+ await getAppProviderByClassName<WorkspaceCacheService>(+ 'WorkspaceCacheService',+ ).getOrRecompute(SEED_APPLE_WORKSPACE_ID, [+ 'rolesPermissions',+ 'flatObjectMetadataMaps',+ ]);+ const noteObjectMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityId: noteObjectMetadataId,+ flatEntityMaps: flatObjectMetadataMaps,+ });++ expect(noteObjectMetadata).toBeDefined();++ const recordIdsReadableThroughParents =+ await getAppProviderByClassName<RecordAccessPolicyService>(+ 'RecordAccessPolicyService',+ ).resolveRecordIdsReadableThroughParents({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ objectMetadata: noteObjectMetadata!,+ records: NOTE_IDS.map((id) => ({ id })),+ subject: {+ objectsPermissions: rolesPermissions[memberRole.id],+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ memberRole.id,+ ],+ isOwningApplication: () => false,+ resolveRowLevelPermissionRecordFilter: () => null,+ },+ });+ const notesResponse =+ await makeGraphqlAPIRequestWithMemberRole(findNotesOperation);++ expect([...recordIdsReadableThroughParents].sort()).toEqual(+ collectIds(notesResponse.body.data.notes.edges),+ );+ });++ it('should hide what is reached through the person from a role that cannot read people', async () => {+ const memberRole = await findOneRoleByLabel({ label: 'Member' });+ const setMemberCanReadPeople = (canReadObjectRecords: boolean) =>+ upsertObjectPermissions({+ expectToFail: false,+ input: {+ roleId: memberRole.id,+ objectPermissions: [+ {+ objectMetadataId: personObjectMetadataId,+ canReadObjectRecords,+ canUpdateObjectRecords: canReadObjectRecords,+ canSoftDeleteObjectRecords: canReadObjectRecords,+ canDestroyObjectRecords: canReadObjectRecords,+ },+ ],+ },+ });++ await setMemberCanReadPeople(false);++ const notesResponse =+ await makeGraphqlAPIRequestWithMemberRole(findNotesOperation);+ const noteTargetsResponse = await makeGraphqlAPIRequestWithMemberRole(+ findNoteTargetsOperation,+ );+ const attachmentsResponse = await makeGraphqlAPIRequestWithMemberRole(+ findAttachmentsOperation,+ );++ await setMemberCanReadPeople(true);++ expect(notesResponse.body.errors).toBeUndefined();+ expect(collectIds(notesResponse.body.data.notes.edges)).toEqual(+ [NOTE_ON_COMPANY_ID, NOTE_ON_BOTH_ID].sort(),+ );+ expect(noteTargetsResponse.body.errors).toBeUndefined();+ expect(+ collectIds(noteTargetsResponse.body.data.noteTargets.edges),+ ).toEqual([COMPANY_NOTE_TARGET_ID, BOTH_COMPANY_NOTE_TARGET_ID].sort());+ expect(attachmentsResponse.body.errors).toBeUndefined();+ expect(+ collectIds(attachmentsResponse.body.data.attachments.edges),+ ).toEqual([COMPANY_NOTE_ATTACHMENT_ID]);+ });+it('should still refuse to rename the note on the private person or attach it elsewhere', async () => {const renameResponse = await makeGraphqlAPIRequestWithMemberRole(renameNoteOperation(NOTE_ON_PERSON_ID, 'Renamed with READ'),@@ -520,5 +614,159 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {].sort(),);});++ it('should keep a deleted note readable through the links captured with its deletion', async () => {+ const memberRole = await findOneRoleByLabel({ label: 'Member' });+ const { rolesPermissions, flatObjectMetadataMaps } =+ await getAppProviderByClassName<WorkspaceCacheService>(+ 'WorkspaceCacheService',+ ).getOrRecompute(SEED_APPLE_WORKSPACE_ID, [+ 'rolesPermissions',+ 'flatObjectMetadataMaps',+ ]);+ const noteObjectMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityId: noteObjectMetadataId,+ flatEntityMaps: flatObjectMetadataMaps,+ });+ const resolveReadableNoteIds = (+ records: Parameters<+ RecordAccessPolicyService['resolveRecordIdsReadableThroughParents']+ >[0]['records'],+ ) =>+ getAppProviderByClassName<RecordAccessPolicyService>(+ 'RecordAccessPolicyService',+ ).resolveRecordIdsReadableThroughParents({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ objectMetadata: noteObjectMetadata!,+ records,+ subject: {+ objectsPermissions: rolesPermissions[memberRole.id],+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ memberRole.id,+ ],+ isOwningApplication: () => false,+ resolveRowLevelPermissionRecordFilter: () => null,+ },+ });+ const noteOnPersonFilter = { id: { eq: NOTE_ON_PERSON_ID } };++ const deleteResponse = await makeGraphqlAPIRequest(+ deleteManyOperationFactory({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ gqlFields: 'id',+ filter: noteOnPersonFilter,+ }),+ );+ const readableThroughLiveLinks = await resolveReadableNoteIds([+ { id: NOTE_ON_PERSON_ID },+ ]);+ const readableThroughCapturedLinks = await resolveReadableNoteIds([+ {+ id: NOTE_ON_PERSON_ID,+ inheritedReadabilityChildRecords: {+ noteTarget: [+ {+ id: PERSON_NOTE_TARGET_ID,+ noteId: NOTE_ON_PERSON_ID,+ targetPersonId: PERSON_ID,+ },+ ],+ },+ },+ ]);+ const restoreResponse = await makeGraphqlAPIRequest(+ restoreManyOperationFactory({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ gqlFields: 'id',+ filter: noteOnPersonFilter,+ }),+ );++ expect(deleteResponse.body.errors).toBeUndefined();+ expect(deleteResponse.body.data.deleteNotes).toEqual([+ { id: NOTE_ON_PERSON_ID },+ ]);+ expect(restoreResponse.body.errors).toBeUndefined();+ expect(restoreResponse.body.data.restoreNotes).toEqual([+ { id: NOTE_ON_PERSON_ID },+ ]);+ expect([...readableThroughLiveLinks]).toEqual([]);+ expect([...readableThroughCapturedLinks]).toEqual([NOTE_ON_PERSON_ID]);+ });++ it('should not show a deleted note in the trash through a target detached before its deletion', async () => {+ const noteOnCompanyFilter = { id: { eq: NOTE_ON_COMPANY_ID } };+ const companyNoteTargetFilter = { id: { eq: COMPANY_NOTE_TARGET_ID } };++ const detachResponse = await makeGraphqlAPIRequest(+ deleteManyOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ gqlFields: 'id',+ filter: companyNoteTargetFilter,+ }),+ );++ await setRecordSharingEnabled(false);++ const deleteResponse = await makeGraphqlAPIRequest(+ deleteManyOperationFactory({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ gqlFields: 'id',+ filter: noteOnCompanyFilter,+ }),+ );++ await setRecordSharingEnabled(true);++ const trashedNotesResponse = await makeGraphqlAPIRequestWithMemberRole(+ findManyOperationFactory({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ gqlFields: 'id',+ filter: {+ ...noteOnCompanyFilter,+ not: { deletedAt: { is: 'NULL' } },+ },+ }),+ );++ await setRecordSharingEnabled(false);++ const restoreNoteResponse = await makeGraphqlAPIRequest(+ restoreManyOperationFactory({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ gqlFields: 'id',+ filter: noteOnCompanyFilter,+ }),+ );+ const restoreTargetResponse = await makeGraphqlAPIRequest(+ restoreManyOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ gqlFields: 'id',+ filter: companyNoteTargetFilter,+ }),+ );++ await setRecordSharingEnabled(true);++ expect(detachResponse.body.data.deleteNoteTargets).toEqual([+ { id: COMPANY_NOTE_TARGET_ID },+ ]);+ expect(deleteResponse.body.data.deleteNotes).toEqual([+ { id: NOTE_ON_COMPANY_ID },+ ]);+ expect(trashedNotesResponse.body.errors).toBeUndefined();+ expect(trashedNotesResponse.body.data.notes.edges).toEqual([]);+ expect(restoreNoteResponse.body.errors).toBeUndefined();+ expect(restoreTargetResponse.body.errors).toBeUndefined();+ });});});diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.tsindex 97600c3fa1e..efa55a441c7 100644--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts@@ -29,7 +29,7 @@ import { capitalize } from 'twenty-shared/utils';import { type RecordShareService } from 'src/engine/record-share/services/record-share.service';import { type RecordShare } from 'src/engine/record-share/types/record-share.type';import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';-import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';@@ -90,10 +90,11 @@ describe('recordShareTwinObjectRecordsPermissions', () => {operationType: 'select' | 'update';}) =>ALL_RECORD_IDS.filter((recordId) =>- isRecordSharedWithPrincipals({+ isRecordAdmittedByRecordShareGate({recordShareGate: {recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),principalIds,+ recordIdsReadableThroughParents: new Set(),},recordId,accessLevels: resolveRequiredRecordShareAccessLevels(operationType),