Skip to content

The open alternative to Salesforce, designed for AI.

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.mdx
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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/typ
import { 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.ts
index 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.ts
index 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/typ
import { 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.ts
index 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-share
export 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.typ
export 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.ts
index 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.ts
similarity index 93%
rename from packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.ts
rename to packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-admitted-by-record-share-gate.util.spec.ts
index 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.ts
index 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.ts
index 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.typ
import { 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 ask
export 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.ts
new file mode 100644
index 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.ts
similarity index 82%
rename from packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.ts
rename to packages/twenty-server/src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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-field
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
import { type 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.ts
index 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-object
import { 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/re
import { 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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-modules
import { 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.ts
index 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.ts
index 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-graph
import { 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.ts
index 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),