Skip to content

The open alternative to Salesforce, designed for AI.

Record sharing: fail closed on unresolved row predicates, gate application events on the role, run dashboard duplication under the caller (#26021)

martmull85d8434d23b9
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts
new file mode 100644
index 00000000000..4aabf57f8d8
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts
@@ -0,0 +1,375 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+
+import { type ObjectRecordUpdateEvent } from 'twenty-shared/database-events';
+import {
+ FeatureFlagKey,
+ FieldMetadataType,
+ MetadataReadability,
+ type ObjectsPermissionsByRoleId,
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { LogicFunctionTriggerJob } from 'src/engine/core-modules/logic-function/logic-function-trigger/jobs/logic-function-trigger.job';
+import { CallDatabaseEventTriggerJobsJob } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/call-database-event-trigger-jobs.job';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { ApplicationJobEnqueueThrottlerService } from 'src/engine/core-modules/message-queue/services/application-job-enqueue-throttler.service';
+import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
+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';
+import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
+
+const WORKSPACE_ID = 'workspace-id';
+const OBJECT_METADATA_ID = 'company-object-id';
+const NAME_FIELD_ID = 'name-field-id';
+const SALARY_FIELD_ID = 'salary-field-id';
+const CITY_FIELD_ID = 'city-field-id';
+const APPLICATION_ID = 'application-id';
+const APPLICATION_ROLE_ID = 'application-role-id';
+const LOGIC_FUNCTION_ID = 'logic-function-id';
+
+const buildMaps = (
+ entities: ({ id: string; universalIdentifier: string } & Record<
+ string,
+ unknown
+ >)[],
+) =>
+ entities.reduce(
+ (maps, entity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: entity as never,
+ flatEntityMaps: maps,
+ }),
+ createEmptyFlatEntityMaps(),
+ );
+
+const flatFieldMetadataMaps = buildMaps([
+ getFlatFieldMetadataMock({
+ id: NAME_FIELD_ID,
+ universalIdentifier: NAME_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.TEXT,
+ name: 'name',
+ }),
+ getFlatFieldMetadataMock({
+ id: SALARY_FIELD_ID,
+ universalIdentifier: SALARY_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.NUMBER,
+ name: 'salary',
+ }),
+ getFlatFieldMetadataMock({
+ id: CITY_FIELD_ID,
+ universalIdentifier: CITY_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.TEXT,
+ name: 'city',
+ }),
+]);
+
+const buildObjectMetadata = (readability: MetadataReadability) =>
+ getFlatObjectMetadataMock({
+ id: OBJECT_METADATA_ID,
+ universalIdentifier: OBJECT_METADATA_ID,
+ nameSingular: 'company',
+ namePlural: 'companies',
+ applicationId: 'other-application-id',
+ readability,
+ fieldIds: [NAME_FIELD_ID, SALARY_FIELD_ID, CITY_FIELD_ID],
+ fieldUniversalIdentifiers: [NAME_FIELD_ID, SALARY_FIELD_ID, CITY_FIELD_ID],
+ });
+
+const buildEvent = (
+ recordId: string,
+ record: Record<string, unknown>,
+ updatedFields = ['name', 'salary'],
+): ObjectRecordUpdateEvent =>
+ ({
+ recordId,
+ userId: 'user-id',
+ userWorkspaceId: 'user-workspace-id',
+ properties: {
+ updatedFields,
+ before: { id: recordId, ...record, name: 'Old' },
+ after: { id: recordId, ...record },
+ diff: {
+ name: { before: 'Old', after: record.name },
+ salary: { before: 0, after: record.salary },
+ },
+ },
+ }) as unknown as ObjectRecordUpdateEvent;
+
+const buildRolesPermissions = ({
+ canReadObjectRecords = true,
+ restrictedFields = {},
+}: {
+ canReadObjectRecords?: boolean;
+ restrictedFields?: Record<string, { canRead: boolean; canUpdate: boolean }>;
+} = {}): ObjectsPermissionsByRoleId => ({
+ [APPLICATION_ROLE_ID]: {
+ [OBJECT_METADATA_ID]: {
+ canReadObjectRecords,
+ canUpdateObjectRecords: false,
+ canSoftDeleteObjectRecords: false,
+ canDestroyObjectRecords: false,
+ restrictedFields,
+ rowLevelPermissionPredicates: [],
+ rowLevelPermissionPredicateGroups: [],
+ },
+ },
+});
+
+describe('CallDatabaseEventTriggerJobsJob', () => {
+ let job: CallDatabaseEventTriggerJobsJob;
+ let messageQueueService: { bulkAdd: jest.Mock };
+ let recordShareService: { findByRecordIds: jest.Mock };
+ let cacheData: Record<string, unknown>;
+
+ const buildBatch = (
+ events: ObjectRecordUpdateEvent[],
+ readability = MetadataReadability.OPEN,
+ ): WorkspaceEventBatch<ObjectRecordUpdateEvent> => ({
+ name: 'company.updated',
+ workspaceId: WORKSPACE_ID,
+ objectMetadata: buildObjectMetadata(readability),
+ events,
+ });
+
+ const enqueuedPayloads = () =>
+ messageQueueService.bulkAdd.mock.calls.flatMap(([, jobs]) =>
+ (jobs as { data: { payload: ObjectRecordUpdateEvent } }[]).map(
+ (enqueuedJob) => enqueuedJob.data.payload,
+ ),
+ );
+
+ beforeEach(async () => {
+ cacheData = {
+ featureFlagsMap: {},
+ flatLogicFunctionMaps: buildMaps([
+ {
+ id: LOGIC_FUNCTION_ID,
+ universalIdentifier: LOGIC_FUNCTION_ID,
+ workspaceId: WORKSPACE_ID,
+ applicationId: APPLICATION_ID,
+ databaseEventTriggerSettings: { eventName: 'company.updated' },
+ deletedAt: null,
+ },
+ ]),
+ flatApplicationMaps: {
+ byId: {
+ [APPLICATION_ID]: {
+ id: APPLICATION_ID,
+ applicationRegistrationId: 'application-registration-id',
+ defaultRoleId: APPLICATION_ROLE_ID,
+ deletedAt: null,
+ },
+ },
+ idByUniversalIdentifier: {},
+ },
+ rolesPermissions: buildRolesPermissions(),
+ flatRowLevelPermissionPredicateMaps: createEmptyFlatEntityMaps(),
+ flatRowLevelPermissionPredicateGroupMaps: createEmptyFlatEntityMaps(),
+ flatFieldMetadataMaps,
+ flatFieldMetadataMapsOrm: flatFieldMetadataMaps,
+ };
+
+ messageQueueService = { bulkAdd: jest.fn().mockResolvedValue(undefined) };
+ recordShareService = { findByRecordIds: jest.fn().mockResolvedValue([]) };
+
+ const module: TestingModule = await Test.createTestingModule({
+ providers: [
+ CallDatabaseEventTriggerJobsJob,
+ RecordAccessPolicyService,
+ {
+ provide: getQueueToken(MessageQueue.logicFunctionQueue),
+ useValue: messageQueueService,
+ },
+ {
+ provide: WorkspaceCacheService,
+ useValue: {
+ getOrRecompute: jest.fn().mockImplementation(async () => cacheData),
+ },
+ },
+ {
+ provide: ApplicationJobEnqueueThrottlerService,
+ useValue: { throttleOrThrow: jest.fn().mockResolvedValue(undefined) },
+ },
+ { provide: RecordShareService, useValue: recordShareService },
+ {
+ provide: WorkspaceOrmManager,
+ useValue: {
+ getRepository: jest.fn(),
+ executeInWorkspaceContext: jest
+ .fn()
+ .mockImplementation((fn: () => unknown) => fn()),
+ },
+ },
+ ],
+ }).compile();
+
+ job = module.get(CallDatabaseEventTriggerJobsJob);
+ });
+
+ it('should enqueue the events of an object the application role reads', async () => {
+ const event = buildEvent('record-1', { name: 'New', salary: 10 });
+
+ await job.handle(buildBatch([event]));
+
+ expect(messageQueueService.bulkAdd).toHaveBeenCalledWith(
+ LogicFunctionTriggerJob.name,
+ [
+ {
+ data: expect.objectContaining({
+ logicFunctionId: LOGIC_FUNCTION_ID,
+ workspaceId: WORKSPACE_ID,
+ userId: 'user-id',
+ userWorkspaceId: 'user-workspace-id',
+ payload: expect.objectContaining(event),
+ }),
+ },
+ ],
+ expect.anything(),
+ );
+ });
+
+ it('should not enqueue events of an object the application role cannot read', async () => {
+ cacheData.rolesPermissions = buildRolesPermissions({
+ canReadObjectRecords: false,
+ });
+
+ await job.handle(
+ buildBatch([buildEvent('record-1', { name: 'New', salary: 10 })]),
+ );
+
+ expect(messageQueueService.bulkAdd).not.toHaveBeenCalled();
+ });
+
+ it('should not enqueue events for an application without a role', async () => {
+ (
+ cacheData.flatApplicationMaps as {
+ byId: Record<string, { defaultRoleId: string | null }>;
+ }
+ ).byId[APPLICATION_ID].defaultRoleId = null;
+
+ await job.handle(
+ buildBatch([buildEvent('record-1', { name: 'New', salary: 10 })]),
+ );
+
+ expect(messageQueueService.bulkAdd).not.toHaveBeenCalled();
+ });
+
+ it('should not enqueue events for an application whose role permissions are unknown', async () => {
+ cacheData.rolesPermissions = {};
+
+ await job.handle(
+ buildBatch([buildEvent('record-1', { name: 'New', salary: 10 })]),
+ );
+
+ expect(messageQueueService.bulkAdd).not.toHaveBeenCalled();
+ });
+
+ it('should only enqueue the events passing the role row-level filter', async () => {
+ cacheData.flatRowLevelPermissionPredicateMaps = buildMaps([
+ {
+ id: 'predicate-city',
+ universalIdentifier: 'predicate-city',
+ roleId: APPLICATION_ROLE_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ fieldMetadataId: CITY_FIELD_ID,
+ operand: 'CONTAINS',
+ value: 'Paris',
+ subFieldName: null,
+ workspaceMemberFieldMetadataId: null,
+ workspaceMemberSubFieldName: null,
+ rowLevelPermissionPredicateGroupId: null,
+ positionInRowLevelPermissionPredicateGroup: null,
+ deletedAt: null,
+ },
+ ]);
+
+ await job.handle(
+ buildBatch([
+ buildEvent('record-paris', { name: 'A', salary: 1, city: 'Paris' }),
+ buildEvent('record-berlin', { name: 'B', salary: 2, city: 'Berlin' }),
+ ]),
+ );
+
+ expect(enqueuedPayloads().map((payload) => payload.recordId)).toEqual([
+ 'record-paris',
+ ]);
+ });
+
+ it('should omit the fields the application role cannot read', async () => {
+ cacheData.rolesPermissions = buildRolesPermissions({
+ restrictedFields: {
+ [SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ });
+
+ await job.handle(
+ buildBatch([buildEvent('record-1', { name: 'New', salary: 10 })]),
+ );
+
+ expect(enqueuedPayloads()[0].properties).toEqual({
+ updatedFields: ['name'],
+ before: { id: 'record-1', name: 'Old' },
+ after: { id: 'record-1', name: 'New' },
+ diff: { name: { before: 'Old', after: 'New' } },
+ });
+ });
+
+ it('should not enqueue an update touching only fields the application role cannot read', async () => {
+ cacheData.rolesPermissions = buildRolesPermissions({
+ restrictedFields: {
+ [SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ });
+
+ await job.handle(
+ buildBatch([
+ buildEvent('record-1', { name: 'Same', salary: 10 }, ['salary']),
+ ]),
+ );
+
+ expect(messageQueueService.bulkAdd).not.toHaveBeenCalled();
+ });
+
+ it('should only enqueue the events of a private object shared with the application role', async () => {
+ cacheData.featureFlagsMap = {
+ [FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true,
+ };
+ recordShareService.findByRecordIds.mockResolvedValue([
+ {
+ id: 'record-share-1',
+ recordId: 'record-shared',
+ objectMetadataId: OBJECT_METADATA_ID,
+ principalId: APPLICATION_ROLE_ID,
+ principalType: RecordSharePrincipalType.ROLE,
+ accessLevel: RecordShareAccessLevel.READ,
+ rowCause: RecordShareRowCause.MANUAL,
+ sourceId: 'source-1',
+ },
+ ]);
+
+ await job.handle(
+ buildBatch(
+ [
+ buildEvent('record-private', { name: 'A', salary: 1 }),
+ buildEvent('record-shared', { name: 'B', salary: 2 }),
+ ],
+ MetadataReadability.PRIVATE,
+ ),
+ );
+
+ expect(enqueuedPayloads().map((payload) => payload.recordId)).toEqual([
+ 'record-shared',
+ ]);
+ });
+});
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 bb16b7a666b..226dadb6e7f 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
@@ -20,9 +20,17 @@ import {
} 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 { buildRoleRowAccessPolicySubject } from 'src/engine/record-share/utils/build-role-row-access-policy-subject.util';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/record-share/utils/omit-restricted-fields-from-event.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';
+// An update left with no visible field would only reveal that a hidden one changed
+const isUpdateOfHiddenFieldsOnly = (event: ObjectRecordEvent): boolean => {
+ const { updatedFields } = event.properties as { updatedFields?: string[] };
+
+ return isDefined(updatedFields) && updatedFields.length === 0;
+};
+
@Processor(MessageQueue.triggerQueue)
export class CallDatabaseEventTriggerJobsJob {
private readonly logger = new Logger(CallDatabaseEventTriggerJobsJob.name);
@@ -96,8 +104,8 @@ export class CallDatabaseEventTriggerJobsJob {
return;
}
- const eventRecordShareGate =
- this.recordAccessPolicyService.buildEventRecordShareGate(
+ const eventRecordAccessGate =
+ this.recordAccessPolicyService.buildEventRecordAccessGate(
workspaceEventBatch,
);
@@ -115,10 +123,24 @@ export class CallDatabaseEventTriggerJobsJob {
continue;
}
+ const applicationRoleId = application.defaultRoleId;
+ const applicationObjectsPermissions = isDefined(applicationRoleId)
+ ? rolesPermissions[applicationRoleId]
+ : undefined;
+
+ // An application receives what its role lets it read, as through the
+ // API: without a role it reads nothing.
+ if (
+ !isDefined(applicationRoleId) ||
+ !isDefined(applicationObjectsPermissions)
+ ) {
+ continue;
+ }
+
const admittedRecordIds =
- await eventRecordShareGate.resolveAdmittedRecordIds(
+ await eventRecordAccessGate.resolveAdmittedRecordIds(
buildRoleRowAccessPolicySubject({
- roleId: application.defaultRoleId ?? undefined,
+ roleId: applicationRoleId,
owningApplicationId: application.id,
rolesPermissions,
flatRowLevelPermissionPredicateMaps,
@@ -126,13 +148,24 @@ export class CallDatabaseEventTriggerJobsJob {
flatFieldMetadataMaps,
}),
);
+ const restrictedFields =
+ applicationObjectsPermissions[workspaceEventBatch.objectMetadata.id]
+ ?.restrictedFields;
+ const admittedEvents = workspaceEventBatch.events
+ .filter((event) => admittedRecordIds.has(event.recordId))
+ .map((event) =>
+ omitRestrictedFieldsFromEvent({
+ event,
+ restrictedFields,
+ flatFieldMetadataMaps,
+ }),
+ )
+ .filter((event) => !isUpdateOfHiddenFieldsOnly(event));
const logicFunctionPayloads = transformEventBatchToEventPayloads({
logicFunctions,
workspaceEventBatch: {
...workspaceEventBatch,
- events: workspaceEventBatch.events.filter((event) =>
- admittedRecordIds.has(event.recordId),
- ),
+ events: admittedEvents,
},
});
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 9ace025b482..93fce80c69e 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
@@ -89,7 +89,7 @@ export class CallWebhookJobsJob {
// A webhook carries no identity, so only a row granted to everyone lets an event out
const admittedRecordIds = isDefined(flatObjectMetadata)
? await this.recordAccessPolicyService
- .buildEventRecordShareGate({
+ .buildEventRecordAccessGate({
...workspaceEventBatch,
objectMetadata: flatObjectMetadata,
})
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
index 12cbca9b3b9..c6ea656012a 100644
--- 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
@@ -10,7 +10,7 @@ import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/typ
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 { type EventRecordShareGate } from 'src/engine/record-share/types/event-record-share-gate.type';
+import { type EventRecordAccessGate } from 'src/engine/record-share/types/event-record-access-gate.type';
import { type RecordShare } from 'src/engine/record-share/types/record-share.type';
import {
type EventRecordSnapshot,
@@ -59,11 +59,14 @@ export class RecordAccessPolicyService {
private readonly recordShareService: RecordShareService,
) {}
- buildEventRecordShareGate({
+ // A subject receives the records a query would return it: its role must read
+ // the object and the row-level filter must hold on the event snapshot before
+ // the share gate of the object is consulted.
+ buildEventRecordAccessGate({
workspaceId,
objectMetadata,
events,
- }: WorkspaceEventBatch<ObjectRecordEvent>): EventRecordShareGate {
+ }: WorkspaceEventBatch<ObjectRecordEvent>): EventRecordAccessGate {
let recordSharesPromise: Promise<RecordShare[]> | undefined;
const fetchRecordShares: FetchRecordShares = () =>
(recordSharesPromise ??= this.recordShareService.findByRecordIds({
@@ -74,11 +77,22 @@ export class RecordAccessPolicyService {
return {
resolveAdmittedRecordIds: async (subject) => {
+ const snapshots = await this.resolveSnapshotsReadableByRole({
+ workspaceId,
+ objectMetadata,
+ snapshots: resolveEventRecordSnapshots(events),
+ subject,
+ depth: 0,
+ });
+
+ if (snapshots.length === 0) {
+ return new Set();
+ }
+
const { featureFlagsMap } =
await this.workspaceCacheService.getOrRecompute(workspaceId, [
'featureFlagsMap',
]);
- const snapshots = resolveEventRecordSnapshots(events);
if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {
return new Set(snapshots.map((snapshot) => snapshot.id));
@@ -92,6 +106,57 @@ export class RecordAccessPolicyService {
};
}
+ private async resolveSnapshotsReadableByRole({
+ workspaceId,
+ objectMetadata,
+ snapshots,
+ subject,
+ maps,
+ }: SnapshotEvaluation): Promise<EventRecordSnapshot[]> {
+ if (snapshots.length === 0) {
+ return [];
+ }
+
+ if (
+ isDefined(subject.objectsPermissions) &&
+ !isObjectOperationPermitted({
+ objectMetadata,
+ operationType: 'select',
+ objectsPermissions: subject.objectsPermissions,
+ })
+ ) {
+ return [];
+ }
+
+ const rowLevelPermissionRecordFilter =
+ subject.resolveRowLevelPermissionRecordFilter(objectMetadata);
+
+ if (
+ !isDefined(rowLevelPermissionRecordFilter) ||
+ Object.keys(rowLevelPermissionRecordFilter).length === 0
+ ) {
+ return snapshots;
+ }
+
+ const flatFieldMetadataMaps =
+ maps?.flatFieldMetadataMapsOrm ??
+ (
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMapsOrm',
+ ])
+ ).flatFieldMetadataMapsOrm;
+
+ return snapshots.filter((snapshot) =>
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: snapshot,
+ filter: rowLevelPermissionRecordFilter,
+ flatObjectMetadata: objectMetadata,
+ flatFieldMetadataMaps,
+ shouldIgnoreSoftDeleteDefaultFilter: true,
+ }),
+ );
+ }
+
private async resolveSnapshotIdsAdmittedByRecordShareGate(
evaluation: SnapshotEvaluation,
fetchRecordShares: FetchRecordShares,
@@ -315,40 +380,19 @@ export class RecordAccessPolicyService {
private async resolveReadableSnapshotIds(
evaluation: SnapshotEvaluationInContext,
): Promise<Set<string>> {
- const { workspaceId, objectMetadata, snapshots, subject, depth, maps } =
- evaluation;
+ const { workspaceId, objectMetadata, depth } = evaluation;
- if (snapshots.length === 0 || depth > MAX_INHERITED_READABILITY_DEPTH) {
+ if (depth > MAX_INHERITED_READABILITY_DEPTH) {
return new Set();
}
- if (
- isDefined(subject.objectsPermissions) &&
- !isObjectOperationPermitted({
- objectMetadata,
- operationType: 'select',
- objectsPermissions: subject.objectsPermissions,
- })
- ) {
+ const candidateSnapshots =
+ await this.resolveSnapshotsReadableByRole(evaluation);
+
+ if (candidateSnapshots.length === 0) {
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;
-
return this.resolveSnapshotIdsAdmittedByRecordShareGate(
{ ...evaluation, snapshots: candidateSnapshots },
() =>
diff --git a/packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.ts b/packages/twenty-server/src/engine/record-share/types/event-record-access-gate.type.ts
similarity index 84%
rename from packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.ts
rename to packages/twenty-server/src/engine/record-share/types/event-record-access-gate.type.ts
index 6620b4581cc..61e18f90f14 100644
--- a/packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.ts
+++ b/packages/twenty-server/src/engine/record-share/types/event-record-access-gate.type.ts
@@ -1,6 +1,6 @@
import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';
-export type EventRecordShareGate = {
+export type EventRecordAccessGate = {
resolveAdmittedRecordIds: (
subject: RowAccessPolicySubject,
) => Promise<Set<string>>;
diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
new file mode 100644
index 00000000000..648a7014444
--- /dev/null
+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/omit-restricted-fields-from-event.util.spec.ts
@@ -0,0 +1,212 @@
+import { type ObjectRecordUpdateEvent } from 'twenty-shared/database-events';
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/record-share/utils/omit-restricted-fields-from-event.util';
+
+const OBJECT_METADATA_ID = 'company-object-id';
+const SALARY_FIELD_ID = 'salary-field-id';
+const NAME_FIELD_ID = 'name-field-id';
+const COMPANY_FIELD_ID = 'company-field-id';
+const OWNER_FIELD_ID = 'owner-field-id';
+
+const flatFieldMetadataMaps = [
+ getFlatFieldMetadataMock({
+ id: NAME_FIELD_ID,
+ universalIdentifier: NAME_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.TEXT,
+ name: 'name',
+ }),
+ getFlatFieldMetadataMock({
+ id: SALARY_FIELD_ID,
+ universalIdentifier: SALARY_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.NUMBER,
+ name: 'salary',
+ }),
+ getFlatFieldMetadataMock({
+ id: COMPANY_FIELD_ID,
+ universalIdentifier: COMPANY_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.RELATION,
+ name: 'company',
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'companyId',
+ },
+ }),
+ getFlatFieldMetadataMock({
+ id: OWNER_FIELD_ID,
+ universalIdentifier: OWNER_FIELD_ID,
+ objectMetadataId: OBJECT_METADATA_ID,
+ type: FieldMetadataType.RELATION,
+ name: 'owner',
+ settings: {
+ relationType: RelationType.MANY_TO_ONE,
+ joinColumnName: 'ownerWorkspaceMemberId',
+ },
+ }),
+].reduce(
+ (maps, flatEntity) =>
+ addFlatEntityToFlatEntityMapsOrThrow({ flatEntity, flatEntityMaps: maps }),
+ createEmptyFlatEntityMaps(),
+);
+
+const updateEvent = {
+ recordId: 'record-1',
+ userId: 'user-1',
+ properties: {
+ updatedFields: ['name', 'salary'],
+ before: { id: 'record-1', name: 'Old', salary: 100 },
+ after: { id: 'record-1', name: 'New', salary: 200 },
+ diff: {
+ name: { before: 'Old', after: 'New' },
+ salary: { before: 100, after: 200 },
+ },
+ },
+} as unknown as ObjectRecordUpdateEvent;
+
+describe('omitRestrictedFieldsFromEvent', () => {
+ it('should return the event untouched when no field is restricted', () => {
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: updateEvent,
+ restrictedFields: {
+ [SALARY_FIELD_ID]: { canRead: true, canUpdate: false },
+ },
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(updateEvent);
+ });
+
+ it('should return the event untouched without restricted fields', () => {
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: updateEvent,
+ restrictedFields: undefined,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(updateEvent);
+ });
+
+ it('should drop an unreadable field from every part of the event', () => {
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: updateEvent,
+ restrictedFields: {
+ [SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual({
+ recordId: 'record-1',
+ userId: 'user-1',
+ properties: {
+ updatedFields: ['name'],
+ before: { id: 'record-1', name: 'Old' },
+ after: { id: 'record-1', name: 'New' },
+ diff: { name: { before: 'Old', after: 'New' } },
+ },
+ });
+ });
+
+ it('should leave no updated field when only unreadable fields changed', () => {
+ const salaryOnlyUpdateEvent = {
+ ...updateEvent,
+ properties: {
+ updatedFields: ['salary'],
+ before: { id: 'record-1', salary: 100 },
+ after: { id: 'record-1', salary: 200 },
+ },
+ } as unknown as ObjectRecordUpdateEvent;
+
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: salaryOnlyUpdateEvent,
+ restrictedFields: {
+ [SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ flatFieldMetadataMaps,
+ }).properties,
+ ).toEqual({
+ updatedFields: [],
+ before: { id: 'record-1' },
+ after: { id: 'record-1' },
+ });
+ });
+
+ it('should keep a deleted record whose snapshot only sits in before', () => {
+ const deleteEvent = {
+ recordId: 'record-1',
+ properties: { before: { id: 'record-1', name: 'Old', salary: 100 } },
+ } as unknown as ObjectRecordUpdateEvent;
+
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: deleteEvent,
+ restrictedFields: {
+ [SALARY_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ flatFieldMetadataMaps,
+ }).properties,
+ ).toEqual({ before: { id: 'record-1', name: 'Old' } });
+ });
+
+ it('should drop the join column of an unreadable relation alongside its name', () => {
+ const companyUpdateEvent = {
+ recordId: 'record-1',
+ properties: {
+ updatedFields: ['name', 'company', 'companyId'],
+ before: { id: 'record-1', name: 'Old', companyId: 'company-1' },
+ after: { id: 'record-1', name: 'New', companyId: 'company-2' },
+ diff: {
+ name: { before: 'Old', after: 'New' },
+ company: { before: { id: 'company-1' }, after: { id: 'company-2' } },
+ },
+ },
+ } as unknown as ObjectRecordUpdateEvent;
+
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: companyUpdateEvent,
+ restrictedFields: {
+ [COMPANY_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ flatFieldMetadataMaps,
+ }).properties,
+ ).toEqual({
+ updatedFields: ['name'],
+ before: { id: 'record-1', name: 'Old' },
+ after: { id: 'record-1', name: 'New' },
+ diff: { name: { before: 'Old', after: 'New' } },
+ });
+ });
+
+ it('should drop both join column spellings when settings rename it', () => {
+ const ownerUpdateEvent = {
+ recordId: 'record-1',
+ properties: {
+ updatedFields: ['owner', 'ownerId'],
+ before: { id: 'record-1', ownerWorkspaceMemberId: 'member-1' },
+ after: { id: 'record-1', ownerWorkspaceMemberId: 'member-2' },
+ },
+ } as unknown as ObjectRecordUpdateEvent;
+
+ expect(
+ omitRestrictedFieldsFromEvent({
+ event: ownerUpdateEvent,
+ restrictedFields: {
+ [OWNER_FIELD_ID]: { canRead: false, canUpdate: false },
+ },
+ flatFieldMetadataMaps,
+ }).properties,
+ ).toEqual({
+ updatedFields: [],
+ before: { id: 'record-1' },
+ after: { id: 'record-1' },
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/record-share/utils/omit-restricted-fields-from-event.util.ts b/packages/twenty-server/src/engine/record-share/utils/omit-restricted-fields-from-event.util.ts
new file mode 100644
index 00000000000..89a42e6b0fa
--- /dev/null
+++ b/packages/twenty-server/src/engine/record-share/utils/omit-restricted-fields-from-event.util.ts
@@ -0,0 +1,124 @@
+import { type ObjectRecordEvent } from 'twenty-shared/database-events';
+import {
+ RelationType,
+ type RestrictedFieldsPermissions,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';
+import { getJoinColumnNameForRelationField } from 'src/engine/metadata-modules/field-metadata/utils/get-join-column-name-for-relation-field.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
+
+type EventProperties = {
+ before?: object;
+ after?: object;
+ diff?: object;
+ updatedFields?: string[];
+};
+
+const buildRestrictedFieldNames = ({
+ restrictedFields,
+ flatFieldMetadataMaps,
+}: {
+ restrictedFields: RestrictedFieldsPermissions;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): Set<string> => {
+ const restrictedFieldNames = new Set<string>();
+
+ for (const [fieldMetadataId, permissions] of Object.entries(
+ restrictedFields,
+ )) {
+ if (permissions.canRead !== false) {
+ continue;
+ }
+
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(flatFieldMetadata)) {
+ continue;
+ }
+
+ restrictedFieldNames.add(flatFieldMetadata.name);
+
+ if (
+ !isMorphOrRelationFlatFieldMetadata(flatFieldMetadata) ||
+ flatFieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE
+ ) {
+ continue;
+ }
+
+ // The owning side of a relation also travels as its join column: the record
+ // snapshots carry the ORM spelling, which settings can rename, while
+ // computeUpdatedFieldsFromDiff always appends <name>Id.
+ restrictedFieldNames.add(
+ getJoinColumnNameForRelationField(flatFieldMetadata),
+ );
+ restrictedFieldNames.add(
+ computeMorphOrRelationFieldJoinColumnName({
+ name: flatFieldMetadata.name,
+ }),
+ );
+ }
+
+ return restrictedFieldNames;
+};
+
+export const omitRestrictedFieldsFromEvent = <
+ TEvent extends ObjectRecordEvent,
+>({
+ event,
+ restrictedFields,
+ flatFieldMetadataMaps,
+}: {
+ event: TEvent;
+ restrictedFields: RestrictedFieldsPermissions | undefined;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): TEvent => {
+ if (!isDefined(restrictedFields)) {
+ return event;
+ }
+
+ const restrictedFieldNames = buildRestrictedFieldNames({
+ restrictedFields,
+ flatFieldMetadataMaps,
+ });
+
+ if (restrictedFieldNames.size === 0) {
+ return event;
+ }
+
+ const omitRestrictedFields = (record: object | undefined) =>
+ isDefined(record)
+ ? Object.fromEntries(
+ Object.entries(record).filter(
+ ([fieldName]) => !restrictedFieldNames.has(fieldName),
+ ),
+ )
+ : undefined;
+
+ const properties = event.properties as EventProperties;
+ const before = omitRestrictedFields(properties.before);
+ const after = omitRestrictedFields(properties.after);
+ const diff = omitRestrictedFields(properties.diff);
+
+ return {
+ ...event,
+ properties: {
+ ...properties,
+ ...(isDefined(before) && { before }),
+ ...(isDefined(after) && { after }),
+ ...(isDefined(diff) && { diff }),
+ ...(isDefined(properties.updatedFields) && {
+ updatedFields: properties.updatedFields.filter(
+ (fieldName) => !restrictedFieldNames.has(fieldName),
+ ),
+ }),
+ },
+ };
+};
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 6ee60e09574..036472c846a 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
@@ -12,7 +12,6 @@ import {
type ObjectsPermissionsByRoleId,
type RecordGqlOperationFilter,
type RecordGqlOperationSignature,
- type RestrictedFieldsPermissions,
} from 'twenty-shared/types';
import {
isDefined,
@@ -32,15 +31,15 @@ import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/wo
import { type FlatWorkspaceMemberMaps } from 'src/engine/core-modules/user/types/flat-workspace-member-maps.type';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
-import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
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 { type EventRecordShareGate } from 'src/engine/record-share/types/event-record-share-gate.type';
+import { type EventRecordAccessGate } from 'src/engine/record-share/types/event-record-access-gate.type';
import { omitInheritedReadabilityChildRecords } from 'src/engine/record-share/utils/omit-inherited-readability-child-records.util';
+import { omitRestrictedFieldsFromEvent } from 'src/engine/record-share/utils/omit-restricted-fields-from-event.util';
import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';
import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';
import {
@@ -106,8 +105,8 @@ export class ObjectRecordEventPublisher {
flatWorkspaceMemberMaps,
);
- const eventRecordShareGate =
- this.recordAccessPolicyService.buildEventRecordShareGate(eventBatch);
+ const eventRecordAccessGate =
+ this.recordAccessPolicyService.buildEventRecordAccessGate(eventBatch);
const streamIdsToRemove: string[] = [];
@@ -128,7 +127,7 @@ export class ObjectRecordEventPublisher {
permissionsContext,
flatWorkspaceMemberMaps,
workspaceMemberIdByUserId,
- eventRecordShareGate,
+ eventRecordAccessGate,
});
}
@@ -155,7 +154,7 @@ export class ObjectRecordEventPublisher {
permissionsContext,
flatWorkspaceMemberMaps,
workspaceMemberIdByUserId,
- eventRecordShareGate,
+ eventRecordAccessGate,
}: {
streamChannelId: string;
streamData: EventStreamData;
@@ -163,7 +162,7 @@ export class ObjectRecordEventPublisher {
permissionsContext: StreamPermissionsContext;
flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps;
workspaceMemberIdByUserId: Map<string, string>;
- eventRecordShareGate: EventRecordShareGate;
+ eventRecordAccessGate: EventRecordAccessGate;
}): Promise<void> {
const roleIds = this.resolveStreamRoleIds(
streamData.authContext,
@@ -224,7 +223,7 @@ export class ObjectRecordEventPublisher {
);
const admittedRecordIds =
- await eventRecordShareGate.resolveAdmittedRecordIds(
+ await eventRecordAccessGate.resolveAdmittedRecordIds(
this.buildSubscriberRowAccessPolicySubject({
subscriberAuthContext,
roleIds,
@@ -245,11 +244,11 @@ export class ObjectRecordEventPublisher {
...omitInheritedReadabilityChildRecords(event),
};
- const filteredEvent = this.filterRestrictedFieldsFromEvent(
- eventWithObjectName,
+ const filteredEvent = omitRestrictedFieldsFromEvent({
+ event: eventWithObjectName,
restrictedFields,
- permissionsContext.flatFieldMetadataMaps,
- );
+ flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,
+ });
const filteredProperties = filteredEvent.properties as {
updatedFields?: string[];
@@ -565,72 +564,6 @@ export class ObjectRecordEventPublisher {
};
}
- private filterRestrictedFieldsFromEvent(
- event: ObjectRecordSubscriptionEvent,
- restrictedFields: RestrictedFieldsPermissions | undefined,
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>,
- ): ObjectRecordSubscriptionEvent {
- if (!restrictedFields || Object.keys(restrictedFields).length === 0) {
- return event;
- }
-
- const restrictedFieldNames = new Set(
- Object.entries(restrictedFields)
- .filter(([, permissions]) => permissions.canRead === false)
- .map(([fieldMetadataId]) => {
- const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: fieldMetadataId,
- flatEntityMaps: flatFieldMetadataMaps,
- });
-
- return fieldMetadata?.name;
- })
- .filter(isDefined),
- );
-
- if (restrictedFieldNames.size === 0) {
- return event;
- }
-
- const filterRecord = (record: object | undefined): object | undefined => {
- if (!record) {
- return record;
- }
-
- return Object.fromEntries(
- Object.entries(record).filter(
- ([key]) => !restrictedFieldNames.has(key),
- ),
- );
- };
-
- const properties = event.properties as {
- before?: object;
- after?: object;
- updatedFields?: string[];
- diff?: object;
- };
-
- const filteredBefore = filterRecord(properties.before);
- const filteredAfter = filterRecord(properties.after);
- const filteredDiff = filterRecord(properties.diff);
-
- const filteredProperties = {
- ...properties,
- ...(filteredBefore !== undefined && { before: filteredBefore }),
- ...(filteredAfter !== undefined && { after: filteredAfter }),
- ...(filteredDiff !== undefined && { diff: filteredDiff }),
- updatedFields: properties.updatedFields?.filter(
- (field) => !restrictedFieldNames.has(field),
- ),
- };
-
- return {
- ...event,
- properties: filteredProperties,
- } as ObjectRecordSubscriptionEvent;
- }
-
private getMatchingObjectRecordQueryIds({
queries,
event,
diff --git a/packages/twenty-server/src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant.ts b/packages/twenty-server/src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant.ts
new file mode 100644
index 00000000000..2ac8e2c4848
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant.ts
@@ -0,0 +1,7 @@
+import { type RecordGqlOperationFilter } from 'twenty-shared/types';
+
+// A filter no record satisfies: both the SQL renderer and the in-memory
+// matcher read an empty conjunction as true, so its negation is always false.
+export const UNSATISFIABLE_RECORD_FILTER: RecordGqlOperationFilter = {
+ not: { and: [] },
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-level-permission-record-filter.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-level-permission-record-filter.util.spec.ts
index d0aa5f2b552..e2113d00553 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-level-permission-record-filter.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-level-permission-record-filter.util.spec.ts
@@ -1,5 +1,9 @@
-import { FieldMetadataType } from 'twenty-shared/types';
+import {
+ FieldMetadataType,
+ RowLevelPermissionPredicateGroupLogicalOperator,
+} from 'twenty-shared/types';
+import { type UserWorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
@@ -7,13 +11,24 @@ import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-m
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
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 { UNSATISFIABLE_RECORD_FILTER } from 'src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant';
import { buildRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util';
const OBJECT_ID = 'object-1';
+const WORKSPACE_MEMBER_OBJECT_ID = 'workspace-member-object';
const FIELD_ID = 'field-1';
+const STATUS_FIELD_ID = 'status-field';
+const WORKSPACE_MEMBER_LOCALE_FIELD_ID = 'workspace-member-locale-field';
+const WORKSPACE_MEMBER_TEAM_FIELD_ID = 'workspace-member-team-field';
const USER_ROLE_ID = 'user-role-1';
const APPLICATION_ROLE_ID = 'application-role-1';
const UNRESTRICTED_ROLE_ID = 'unrestricted-role-1';
+const LOCALE_BOUND_ROLE_ID = 'locale-bound-role-1';
+const TEAM_BOUND_ROLE_ID = 'team-bound-role-1';
+const OR_GROUP_ROLE_ID = 'or-group-role-1';
+const AND_GROUP_ROLE_ID = 'and-group-role-1';
+const NESTED_GROUP_ROLE_ID = 'nested-group-role-1';
+const OR_GROUP_ONLY_MEMBER_ROLE_ID = 'or-group-only-member-role-1';
const buildMaps = (
entities: ({ id: string; universalIdentifier: string } & Record<
@@ -34,8 +49,8 @@ const flatObjectMetadata = {
id: OBJECT_ID,
nameSingular: 'thing',
namePlural: 'things',
- fieldIds: [FIELD_ID],
- fieldUniversalIdentifiers: [FIELD_ID],
+ fieldIds: [FIELD_ID, STATUS_FIELD_ID],
+ fieldUniversalIdentifiers: [FIELD_ID, STATUS_FIELD_ID],
} as unknown as FlatObjectMetadata;
const flatFieldMetadataMaps = buildMaps([
@@ -46,43 +61,169 @@ const flatFieldMetadataMaps = buildMaps([
type: FieldMetadataType.TEXT,
objectMetadataId: OBJECT_ID,
},
+ {
+ id: STATUS_FIELD_ID,
+ universalIdentifier: STATUS_FIELD_ID,
+ name: 'status',
+ type: FieldMetadataType.SELECT,
+ objectMetadataId: OBJECT_ID,
+ options: [
+ { value: 'OPEN', label: 'Open' },
+ { value: 'CLOSED', label: 'Closed' },
+ ],
+ },
+ {
+ id: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ universalIdentifier: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ name: 'locale',
+ type: FieldMetadataType.TEXT,
+ objectMetadataId: WORKSPACE_MEMBER_OBJECT_ID,
+ },
+ {
+ id: WORKSPACE_MEMBER_TEAM_FIELD_ID,
+ universalIdentifier: WORKSPACE_MEMBER_TEAM_FIELD_ID,
+ name: 'team',
+ type: FieldMetadataType.SELECT,
+ objectMetadataId: WORKSPACE_MEMBER_OBJECT_ID,
+ options: [
+ { value: 'OPEN', label: 'Open' },
+ { value: 'SALES', label: 'Sales' },
+ ],
+ },
]) as unknown as FlatEntityMaps<FlatFieldMetadata>;
-const buildPredicate = (id: string, roleId: string, value: string) => ({
+const buildPredicate = (
+ id: string,
+ roleId: string,
+ predicate: Record<string, unknown>,
+) => ({
id,
universalIdentifier: id,
roleId,
objectMetadataId: OBJECT_ID,
fieldMetadataId: FIELD_ID,
operand: 'CONTAINS',
- value,
+ value: null,
subFieldName: null,
workspaceMemberFieldMetadataId: null,
workspaceMemberSubFieldName: null,
rowLevelPermissionPredicateGroupId: null,
positionInRowLevelPermissionPredicateGroup: null,
deletedAt: null,
+ ...predicate,
});
const flatRowLevelPermissionPredicateMaps = buildMaps([
- buildPredicate('predicate-user', USER_ROLE_ID, 'visible-to-user'),
- buildPredicate(
- 'predicate-application',
- APPLICATION_ROLE_ID,
- 'visible-to-application',
- ),
+ buildPredicate('predicate-user', USER_ROLE_ID, { value: 'visible-to-user' }),
+ buildPredicate('predicate-application', APPLICATION_ROLE_ID, {
+ value: 'visible-to-application',
+ }),
+ buildPredicate('predicate-locale', LOCALE_BOUND_ROLE_ID, {
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ }),
+ buildPredicate('predicate-team', TEAM_BOUND_ROLE_ID, {
+ fieldMetadataId: STATUS_FIELD_ID,
+ operand: 'IS',
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_TEAM_FIELD_ID,
+ }),
+ buildPredicate('predicate-or-static', OR_GROUP_ROLE_ID, {
+ value: 'shared-with-everyone',
+ rowLevelPermissionPredicateGroupId: 'or-group',
+ }),
+ buildPredicate('predicate-or-member', OR_GROUP_ROLE_ID, {
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ rowLevelPermissionPredicateGroupId: 'or-group',
+ }),
+ buildPredicate('predicate-and-static', AND_GROUP_ROLE_ID, {
+ value: 'shared-with-everyone',
+ rowLevelPermissionPredicateGroupId: 'and-group',
+ }),
+ buildPredicate('predicate-and-member', AND_GROUP_ROLE_ID, {
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ rowLevelPermissionPredicateGroupId: 'and-group',
+ }),
+ buildPredicate('predicate-nested-static', NESTED_GROUP_ROLE_ID, {
+ value: 'kept-branch',
+ rowLevelPermissionPredicateGroupId: 'nested-or-group',
+ }),
+ buildPredicate('predicate-nested-and-static', NESTED_GROUP_ROLE_ID, {
+ value: 'denied-branch',
+ rowLevelPermissionPredicateGroupId: 'nested-and-group',
+ }),
+ buildPredicate('predicate-nested-and-member', NESTED_GROUP_ROLE_ID, {
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ rowLevelPermissionPredicateGroupId: 'nested-and-group',
+ }),
+ buildPredicate('predicate-only-member-first', OR_GROUP_ONLY_MEMBER_ROLE_ID, {
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ rowLevelPermissionPredicateGroupId: 'or-group-only-member',
+ }),
+ buildPredicate('predicate-only-member-second', OR_GROUP_ONLY_MEMBER_ROLE_ID, {
+ workspaceMemberFieldMetadataId: WORKSPACE_MEMBER_LOCALE_FIELD_ID,
+ rowLevelPermissionPredicateGroupId: 'or-group-only-member',
+ }),
]) as unknown as FlatRowLevelPermissionPredicateMaps;
-const flatRowLevelPermissionPredicateGroupMaps =
- createEmptyFlatEntityMaps() as unknown as FlatRowLevelPermissionPredicateGroupMaps;
+const buildPredicateGroup = (
+ id: string,
+ roleId: string,
+ logicalOperator: RowLevelPermissionPredicateGroupLogicalOperator,
+ parentRowLevelPermissionPredicateGroupId: string | null = null,
+) => ({
+ id,
+ universalIdentifier: id,
+ roleId,
+ logicalOperator,
+ parentRowLevelPermissionPredicateGroupId,
+ deletedAt: null,
+});
+
+const flatRowLevelPermissionPredicateGroupMaps = buildMaps([
+ buildPredicateGroup(
+ 'or-group',
+ OR_GROUP_ROLE_ID,
+ RowLevelPermissionPredicateGroupLogicalOperator.OR,
+ ),
+ buildPredicateGroup(
+ 'and-group',
+ AND_GROUP_ROLE_ID,
+ RowLevelPermissionPredicateGroupLogicalOperator.AND,
+ ),
+ buildPredicateGroup(
+ 'nested-or-group',
+ NESTED_GROUP_ROLE_ID,
+ RowLevelPermissionPredicateGroupLogicalOperator.OR,
+ ),
+ buildPredicateGroup(
+ 'nested-and-group',
+ NESTED_GROUP_ROLE_ID,
+ RowLevelPermissionPredicateGroupLogicalOperator.AND,
+ 'nested-or-group',
+ ),
+ buildPredicateGroup(
+ 'or-group-only-member',
+ OR_GROUP_ONLY_MEMBER_ROLE_ID,
+ RowLevelPermissionPredicateGroupLogicalOperator.OR,
+ ),
+]) as unknown as FlatRowLevelPermissionPredicateGroupMaps;
+
+const buildWorkspaceMember = (workspaceMember: Record<string, unknown>) =>
+ ({
+ id: 'workspace-member-1',
+ ...workspaceMember,
+ }) as unknown as UserWorkspaceAuthContext['workspaceMember'];
-const build = (roleIds: string[]) =>
+const build = (
+ roleIds: string[],
+ workspaceMember?: UserWorkspaceAuthContext['workspaceMember'],
+) =>
buildRowLevelPermissionRecordFilter({
flatRowLevelPermissionPredicateMaps,
flatRowLevelPermissionPredicateGroupMaps,
flatFieldMetadataMaps,
objectMetadata: flatObjectMetadata,
roleIds,
+ workspaceMember,
});
describe('buildRowLevelPermissionRecordFilter', () => {
@@ -114,4 +255,87 @@ describe('buildRowLevelPermissionRecordFilter', () => {
],
});
});
+
+ describe('predicate bound to a workspace member field', () => {
+ it('should filter on the value carried by the workspace member', () => {
+ expect(
+ build(
+ [LOCALE_BOUND_ROLE_ID],
+ buildWorkspaceMember({ locale: 'fr-FR' }),
+ ),
+ ).toEqual({ name: { ilike: '%fr-FR%' } });
+ });
+
+ it('should match nothing when no workspace member acts, as for an api key', () => {
+ expect(build([LOCALE_BOUND_ROLE_ID])).toEqual(
+ UNSATISFIABLE_RECORD_FILTER,
+ );
+ });
+
+ it('should match nothing when the workspace member does not carry the value', () => {
+ expect(
+ build([LOCALE_BOUND_ROLE_ID], buildWorkspaceMember({ locale: null })),
+ ).toEqual(UNSATISFIABLE_RECORD_FILTER);
+ });
+
+ it('should match nothing when the workspace member value does not fit the target field', () => {
+ expect(
+ build([TEAM_BOUND_ROLE_ID], buildWorkspaceMember({ team: 'SALES' })),
+ ).toEqual(UNSATISFIABLE_RECORD_FILTER);
+ });
+
+ it('should filter on a workspace member value that fits the target field', () => {
+ expect(
+ build([TEAM_BOUND_ROLE_ID], buildWorkspaceMember({ team: 'OPEN' })),
+ ).toEqual({ status: { in: ['OPEN'] } });
+ });
+
+ it('should keep matching nothing when the other role is unrestricted', () => {
+ expect(build([LOCALE_BOUND_ROLE_ID, UNRESTRICTED_ROLE_ID])).toEqual(
+ UNSATISFIABLE_RECORD_FILTER,
+ );
+ });
+
+ it('should keep the other branches of an OR group it cannot satisfy', () => {
+ expect(build([OR_GROUP_ROLE_ID])).toEqual({
+ or: [{ name: { ilike: '%shared-with-everyone%' } }],
+ });
+ });
+
+ it('should keep both branches of an OR group once the member carries the value', () => {
+ expect(
+ build([OR_GROUP_ROLE_ID], buildWorkspaceMember({ locale: 'fr-FR' })),
+ ).toEqual({
+ or: [
+ { name: { ilike: '%shared-with-everyone%' } },
+ { name: { ilike: '%fr-FR%' } },
+ ],
+ });
+ });
+
+ it('should match nothing when an AND group holds a branch it cannot satisfy', () => {
+ expect(build([AND_GROUP_ROLE_ID])).toEqual(UNSATISFIABLE_RECORD_FILTER);
+ });
+
+ it('should drop a nested AND branch it cannot satisfy and keep its sibling', () => {
+ expect(build([NESTED_GROUP_ROLE_ID])).toEqual({
+ or: [{ name: { ilike: '%kept-branch%' } }],
+ });
+ });
+
+ it('should match nothing when no branch of an OR group can be satisfied', () => {
+ expect(build([OR_GROUP_ONLY_MEMBER_ROLE_ID])).toEqual(
+ UNSATISFIABLE_RECORD_FILTER,
+ );
+ });
+
+ it('should keep matching nothing when the other role restricts', () => {
+ expect(build([LOCALE_BOUND_ROLE_ID, USER_ROLE_ID])).toEqual({
+ and: [
+ UNSATISFIABLE_RECORD_FILTER,
+ { name: { ilike: '%visible-to-user%' } },
+ ],
+ });
+ });
+ });
});
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts
index c51458d931b..acbd53b31ca 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts
@@ -9,6 +9,7 @@ import {
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 FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { UNSATISFIABLE_RECORD_FILTER } from 'src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant';
import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';
describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {
@@ -170,6 +171,17 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {
expect(result).toBe(true);
});
+ it('never matches the unsatisfiable filter', () => {
+ const result = isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: UNSATISFIABLE_RECORD_FILTER,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ });
+
+ expect(result).toBe(false);
+ });
+
it('returns false for deleted records without deletedAt filter', () => {
const result = isRecordMatchingRLSRowLevelPermissionPredicate({
record: { ...baseRecord, deletedAt: new Date().toISOString() },
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/render-row-level-permission-filter-to-sql.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/render-row-level-permission-filter-to-sql.util.spec.ts
index 3d37dd9cf48..edfee2b60c3 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/render-row-level-permission-filter-to-sql.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/render-row-level-permission-filter-to-sql.util.spec.ts
@@ -8,6 +8,7 @@ import { type ObjectLiteral } from 'typeorm';
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 FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { UNSATISFIABLE_RECORD_FILTER } from 'src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant';
import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';
const createFlatFieldMetadata = (
@@ -102,6 +103,15 @@ describe('renderRowLevelPermissionFilterToSql', () => {
).toBeNull();
});
+ it('renders the unsatisfiable filter as a condition no row meets', () => {
+ expect(
+ renderRowLevelPermissionFilterToSql({
+ ...baseArgs,
+ recordFilter: UNSATISFIABLE_RECORD_FILTER,
+ }),
+ ).toEqual({ sql: 'NOT (1=1)', parameters: {} });
+ });
+
it('renders a single field condition referencing the join alias', () => {
const result = renderRowLevelPermissionFilterToSql({
...baseArgs,
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util.ts
index 53fd12cb8b8..6caa70b899d 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util.ts
@@ -27,6 +27,9 @@ import {
} from 'src/engine/metadata-modules/permissions/permissions.exception';
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 { type FlatRowLevelPermissionPredicate } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate.type';
+import { UNSATISFIABLE_RECORD_FILTER } from 'src/engine/twenty-orm/constants/unsatisfiable-record-filter.constant';
+import { resolveUnsatisfiableRecordFilterGroupIds } from 'src/engine/twenty-orm/utils/resolve-unsatisfiable-record-filter-group-ids.util';
import { resolveWorkspaceMemberPredicateValue } from 'src/engine/twenty-orm/utils/resolve-workspace-member-predicate-value.util';
import { validatePredicateValueCompatibility } from 'src/engine/twenty-orm/utils/validate-predicate-value-compatibility.util';
@@ -39,6 +42,54 @@ type BuildRecordFilterForRoleArgs = {
workspaceMember?: UserWorkspaceAuthContext['workspaceMember'];
};
+const resolveWorkspaceMemberBoundPredicateValue = ({
+ predicate,
+ workspaceMemberFieldMetadataId,
+ targetFieldMetadata,
+ flatFieldMetadataMaps,
+ workspaceMember,
+}: {
+ predicate: FlatRowLevelPermissionPredicate;
+ workspaceMemberFieldMetadataId: string;
+ targetFieldMetadata: OrmFlatFieldMetadata;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+ workspaceMember: UserWorkspaceAuthContext['workspaceMember'] | undefined;
+}): RowLevelPermissionPredicateValue | null => {
+ const workspaceMemberFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: workspaceMemberFieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(workspaceMemberFieldMetadata)) {
+ throw new PermissionsException(
+ `Workspace member field metadata not found for row level predicate ${predicate.id}`,
+ PermissionsExceptionCode.FIELD_METADATA_NOT_FOUND,
+ );
+ }
+
+ if (!isDefined(workspaceMember)) {
+ return null;
+ }
+
+ const resolvedWorkspaceMemberValue = resolveWorkspaceMemberPredicateValue({
+ workspaceMember,
+ workspaceMemberFieldMetadata,
+ workspaceMemberSubFieldName: predicate.workspaceMemberSubFieldName,
+ });
+
+ if (!isDefined(resolvedWorkspaceMemberValue)) {
+ return null;
+ }
+
+ const isPredicateValueCompatible = validatePredicateValueCompatibility({
+ workspaceMemberFieldMetadata,
+ targetFieldMetadata,
+ predicateValue: resolvedWorkspaceMemberValue,
+ });
+
+ return isPredicateValueCompatible ? resolvedWorkspaceMemberValue : null;
+};
+
const buildRecordFilterForRole = ({
flatRowLevelPermissionPredicateMaps,
flatRowLevelPermissionPredicateGroupMaps,
@@ -62,84 +113,61 @@ const buildRecordFilterForRole = ({
return null;
}
- const recordFilters = predicates
- .map((predicate) => {
- const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
- flatEntityId: predicate.fieldMetadataId,
- flatEntityMaps: flatFieldMetadataMaps,
- });
-
- if (!isDefined(fieldMetadata)) {
- throw new PermissionsException(
- `Field metadata not found for row level predicate ${predicate.id}`,
- PermissionsExceptionCode.FIELD_METADATA_NOT_FOUND,
- );
- }
+ const recordFilters: RecordFilter[] = [];
+ const unsatisfiableRecordFilterIds = new Set<string>();
- const workspaceMemberFieldMetadataId =
- predicate.workspaceMemberFieldMetadataId;
- let predicateValue: RowLevelPermissionPredicateValue = predicate.value;
-
- if (isDefined(workspaceMemberFieldMetadataId)) {
- const workspaceMemberFieldMetadata = findFlatEntityByIdInFlatEntityMaps(
- {
- flatEntityId: workspaceMemberFieldMetadataId,
- flatEntityMaps: flatFieldMetadataMaps,
- },
- );
-
- if (!isDefined(workspaceMemberFieldMetadata)) {
- throw new PermissionsException(
- `Workspace member field metadata not found for row level predicate ${predicate.id}`,
- PermissionsExceptionCode.FIELD_METADATA_NOT_FOUND,
- );
- }
-
- if (!isDefined(workspaceMember)) {
- return null;
- }
-
- const resolvedWorkspaceMemberValue =
- resolveWorkspaceMemberPredicateValue({
- workspaceMember,
- workspaceMemberFieldMetadata,
- workspaceMemberSubFieldName: predicate.workspaceMemberSubFieldName,
- });
-
- if (!isDefined(resolvedWorkspaceMemberValue)) {
- return null;
- }
-
- const isPredicateValueCompatible = validatePredicateValueCompatibility({
- workspaceMemberFieldMetadata,
+ for (const predicate of predicates) {
+ const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: predicate.fieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(fieldMetadata)) {
+ throw new PermissionsException(
+ `Field metadata not found for row level predicate ${predicate.id}`,
+ PermissionsExceptionCode.FIELD_METADATA_NOT_FOUND,
+ );
+ }
+
+ const workspaceMemberFieldMetadataId =
+ predicate.workspaceMemberFieldMetadataId;
+ let predicateValue: RowLevelPermissionPredicateValue = predicate.value;
+
+ if (isDefined(workspaceMemberFieldMetadataId)) {
+ const workspaceMemberBoundValue =
+ resolveWorkspaceMemberBoundPredicateValue({
+ predicate,
+ workspaceMemberFieldMetadataId,
targetFieldMetadata: fieldMetadata,
- predicateValue: resolvedWorkspaceMemberValue,
+ flatFieldMetadataMaps,
+ workspaceMember,
});
- if (!isPredicateValueCompatible) {
- return null;
- }
-
- predicateValue = resolvedWorkspaceMemberValue;
+ // A predicate bound to a workspace member value the acting principal does
+ // not carry (no member, unset field, incompatible value) cannot be
+ // satisfied. Dropping it would lift the restriction instead of applying
+ // it, so it is kept as a branch that never matches.
+ if (!isDefined(workspaceMemberBoundValue)) {
+ unsatisfiableRecordFilterIds.add(predicate.id);
}
- const effectiveSubFieldName = predicate.subFieldName as
- | CompositeFieldSubFieldName
- | undefined;
+ predicateValue = workspaceMemberBoundValue ?? predicate.value;
+ }
- let filterValue = convertViewFilterValueToString(predicateValue);
+ const effectiveSubFieldName = predicate.subFieldName as
+ | CompositeFieldSubFieldName
+ | undefined;
- return {
- id: predicate.id,
- fieldMetadataId: predicate.fieldMetadataId,
- value: filterValue,
- type: getFilterTypeFromFieldType(fieldMetadata.type),
- operand: predicate.operand as unknown as RecordFilter['operand'],
- recordFilterGroupId: predicate.rowLevelPermissionPredicateGroupId,
- subFieldName: effectiveSubFieldName,
- } satisfies RecordFilter;
- })
- .filter(isDefined);
+ recordFilters.push({
+ id: predicate.id,
+ fieldMetadataId: predicate.fieldMetadataId,
+ value: convertViewFilterValueToString(predicateValue),
+ type: getFilterTypeFromFieldType(fieldMetadata.type),
+ operand: predicate.operand as unknown as RecordFilter['operand'],
+ recordFilterGroupId: predicate.rowLevelPermissionPredicateGroupId,
+ subFieldName: effectiveSubFieldName,
+ });
+ }
const relevantGroupIds = new Set<string>();
@@ -186,9 +214,79 @@ const buildRecordFilterForRole = ({
predicateGroup.parentRowLevelPermissionPredicateGroupId,
}));
+ if (unsatisfiableRecordFilterIds.size === 0) {
+ return computeRecordGqlOperationFilter({
+ recordFilters,
+ recordFilterGroups,
+ fieldMetadataItems: Object.values(
+ flatFieldMetadataMaps.byUniversalIdentifier,
+ ).filter(isDefined),
+ filterValueDependencies: {
+ currentWorkspaceMemberId: workspaceMember?.id,
+ },
+ });
+ }
+
+ const unsatisfiableRecordFilterGroupIds =
+ resolveUnsatisfiableRecordFilterGroupIds({
+ recordFilters,
+ recordFilterGroups,
+ unsatisfiableRecordFilterIds,
+ });
+
+ const recordFilterGroupById = new Map(
+ recordFilterGroups.map((recordFilterGroup) => [
+ recordFilterGroup.id,
+ recordFilterGroup,
+ ]),
+ );
+
+ const isInUnsatisfiableGroup = (
+ recordFilterGroupId: string | null | undefined,
+ ): boolean => {
+ const visitedGroupIds = new Set<string>();
+ let currentGroupId = recordFilterGroupId;
+
+ while (isDefined(currentGroupId) && !visitedGroupIds.has(currentGroupId)) {
+ if (unsatisfiableRecordFilterGroupIds.has(currentGroupId)) {
+ return true;
+ }
+
+ visitedGroupIds.add(currentGroupId);
+ currentGroupId =
+ recordFilterGroupById.get(currentGroupId)?.parentRecordFilterGroupId;
+ }
+
+ return false;
+ };
+
+ // The role filter ANDs the branches that sit outside any group, so one of
+ // them being unsatisfiable leaves the role with nothing to match.
+ const isRoleFilterUnsatisfiable =
+ recordFilters.some(
+ (recordFilter) =>
+ !isDefined(recordFilter.recordFilterGroupId) &&
+ unsatisfiableRecordFilterIds.has(recordFilter.id),
+ ) ||
+ recordFilterGroups.some(
+ (recordFilterGroup) =>
+ !isDefined(recordFilterGroup.parentRecordFilterGroupId) &&
+ unsatisfiableRecordFilterGroupIds.has(recordFilterGroup.id),
+ );
+
+ if (isRoleFilterUnsatisfiable) {
+ return UNSATISFIABLE_RECORD_FILTER;
+ }
+
return computeRecordGqlOperationFilter({
- recordFilters,
- recordFilterGroups,
+ recordFilters: recordFilters.filter(
+ (recordFilter) =>
+ !unsatisfiableRecordFilterIds.has(recordFilter.id) &&
+ !isInUnsatisfiableGroup(recordFilter.recordFilterGroupId),
+ ),
+ recordFilterGroups: recordFilterGroups.filter(
+ (recordFilterGroup) => !isInUnsatisfiableGroup(recordFilterGroup.id),
+ ),
fieldMetadataItems: Object.values(
flatFieldMetadataMaps.byUniversalIdentifier,
).filter(isDefined),
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/resolve-unsatisfiable-record-filter-group-ids.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-unsatisfiable-record-filter-group-ids.util.ts
new file mode 100644
index 00000000000..fae19903291
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-unsatisfiable-record-filter-group-ids.util.ts
@@ -0,0 +1,90 @@
+import { RecordFilterGroupLogicalOperator } from 'twenty-shared/types';
+import {
+ isDefined,
+ type RecordFilter,
+ type RecordFilterGroup,
+} from 'twenty-shared/utils';
+
+// A group cannot be satisfied when every branch of an OR fails, or when any
+// branch of an AND does. Propagating branch by branch keeps a denied branch
+// from denying the disjunction it sits in.
+export const resolveUnsatisfiableRecordFilterGroupIds = ({
+ recordFilters,
+ recordFilterGroups,
+ unsatisfiableRecordFilterIds,
+}: {
+ recordFilters: RecordFilter[];
+ recordFilterGroups: RecordFilterGroup[];
+ unsatisfiableRecordFilterIds: Set<string>;
+}): Set<string> => {
+ const recordFilterGroupById = new Map(
+ recordFilterGroups.map((recordFilterGroup) => [
+ recordFilterGroup.id,
+ recordFilterGroup,
+ ]),
+ );
+ const childGroupIdsByParentGroupId = new Map<string, string[]>();
+ const recordFilterIdsByGroupId = new Map<string, string[]>();
+
+ for (const recordFilterGroup of recordFilterGroups) {
+ const parentGroupId = recordFilterGroup.parentRecordFilterGroupId;
+
+ if (isDefined(parentGroupId)) {
+ childGroupIdsByParentGroupId.set(parentGroupId, [
+ ...(childGroupIdsByParentGroupId.get(parentGroupId) ?? []),
+ recordFilterGroup.id,
+ ]);
+ }
+ }
+
+ for (const recordFilter of recordFilters) {
+ const groupId = recordFilter.recordFilterGroupId;
+
+ if (isDefined(groupId)) {
+ recordFilterIdsByGroupId.set(groupId, [
+ ...(recordFilterIdsByGroupId.get(groupId) ?? []),
+ recordFilter.id,
+ ]);
+ }
+ }
+
+ const unsatisfiableGroupIds = new Set<string>();
+ const visitedGroupIds = new Set<string>();
+
+ const isGroupUnsatisfiable = (groupId: string): boolean => {
+ const recordFilterGroup = recordFilterGroupById.get(groupId);
+
+ if (!isDefined(recordFilterGroup) || visitedGroupIds.has(groupId)) {
+ return unsatisfiableGroupIds.has(groupId);
+ }
+
+ visitedGroupIds.add(groupId);
+
+ const branches = [
+ ...(recordFilterIdsByGroupId.get(groupId) ?? []).map((recordFilterId) =>
+ unsatisfiableRecordFilterIds.has(recordFilterId),
+ ),
+ ...(childGroupIdsByParentGroupId.get(groupId) ?? []).map(
+ isGroupUnsatisfiable,
+ ),
+ ];
+
+ const isUnsatisfiable =
+ branches.length > 0 &&
+ (recordFilterGroup.logicalOperator === RecordFilterGroupLogicalOperator.OR
+ ? branches.every(Boolean)
+ : branches.some(Boolean));
+
+ if (isUnsatisfiable) {
+ unsatisfiableGroupIds.add(groupId);
+ }
+
+ return isUnsatisfiable;
+ };
+
+ for (const recordFilterGroup of recordFilterGroups) {
+ isGroupUnsatisfiable(recordFilterGroup.id);
+ }
+
+ return unsatisfiableGroupIds;
+};
diff --git a/packages/twenty-server/src/modules/dashboard/controllers/dashboard.controller.ts b/packages/twenty-server/src/modules/dashboard/controllers/dashboard.controller.ts
index cb7dd79ba23..7be4a9716de 100644
--- a/packages/twenty-server/src/modules/dashboard/controllers/dashboard.controller.ts
+++ b/packages/twenty-server/src/modules/dashboard/controllers/dashboard.controller.ts
@@ -4,15 +4,16 @@ import { ApiPath } from 'twenty-shared/types';
import { getWorkspaceAuthContext } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';
import { JwtAuthGuard } from 'src/engine/guards/jwt-auth.guard';
-import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
+import { CustomPermissionGuard } from 'src/engine/guards/custom-permission.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { PermissionsRestApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-rest-api-exception.filter';
import { DuplicatedDashboardDTO } from 'src/modules/dashboard/dtos/duplicated-dashboard.dto';
import { DashboardRestApiExceptionFilter } from 'src/modules/dashboard/filters/dashboard-rest-api-exception.filter';
import { DashboardDuplicationService } from 'src/modules/dashboard/services/dashboard-duplication.service';
@Controller(`${ApiPath.Rest}/dashboards`)
-@UseGuards(JwtAuthGuard, WorkspaceAuthGuard, NoPermissionGuard)
-@UseFilters(DashboardRestApiExceptionFilter)
+@UseGuards(JwtAuthGuard, WorkspaceAuthGuard, CustomPermissionGuard)
+@UseFilters(DashboardRestApiExceptionFilter, PermissionsRestApiExceptionFilter)
export class DashboardController {
constructor(
private readonly dashboardDuplicationService: DashboardDuplicationService,
diff --git a/packages/twenty-server/src/modules/dashboard/resolvers/dashboard.resolver.ts b/packages/twenty-server/src/modules/dashboard/resolvers/dashboard.resolver.ts
index 0f1793862ae..9b4710e8695 100644
--- a/packages/twenty-server/src/modules/dashboard/resolvers/dashboard.resolver.ts
+++ b/packages/twenty-server/src/modules/dashboard/resolvers/dashboard.resolver.ts
@@ -5,9 +5,10 @@ import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorato
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { getWorkspaceAuthContext } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';
import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
-import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
+import { CustomPermissionGuard } from 'src/engine/guards/custom-permission.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { PageLayoutGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/page-layout/utils/page-layout-graphql-api-exception.filter';
+import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
import { DuplicatedDashboardDTO } from 'src/modules/dashboard/dtos/duplicated-dashboard.dto';
import { DashboardDuplicationService } from 'src/modules/dashboard/services/dashboard-duplication.service';
import { DashboardGraphqlApiExceptionFilter } from 'src/modules/dashboard/utils/dashboard-graphql-api-exception.filter';
@@ -16,6 +17,7 @@ import { DashboardGraphqlApiExceptionFilter } from 'src/modules/dashboard/utils/
@UseFilters(
DashboardGraphqlApiExceptionFilter,
PageLayoutGraphqlApiExceptionFilter,
+ PermissionsGraphqlApiExceptionFilter,
)
@UseGuards(WorkspaceAuthGuard)
@UsePipes(ResolverValidationPipe)
@@ -25,7 +27,7 @@ export class DashboardResolver {
) {}
@Mutation(() => DuplicatedDashboardDTO)
- @UseGuards(NoPermissionGuard)
+ @UseGuards(CustomPermissionGuard)
async duplicateDashboard(
@Args('id', { type: () => UUIDScalarType }) id: string,
): Promise<DuplicatedDashboardDTO> {
diff --git a/packages/twenty-server/src/modules/dashboard/services/__tests__/dashboard-duplication.service.spec.ts b/packages/twenty-server/src/modules/dashboard/services/__tests__/dashboard-duplication.service.spec.ts
new file mode 100644
index 00000000000..6f7d68c085d
--- /dev/null
+++ b/packages/twenty-server/src/modules/dashboard/services/__tests__/dashboard-duplication.service.spec.ts
@@ -0,0 +1,267 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+
+import { ActorFromAuthContextService } from 'src/engine/core-modules/actor/services/actor-from-auth-context.service';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
+import { PageLayoutDuplicationService } from 'src/engine/metadata-modules/page-layout/services/page-layout-duplication.service';
+import { PageLayoutService } from 'src/engine/metadata-modules/page-layout/services/page-layout.service';
+import {
+ PermissionsException,
+ PermissionsExceptionCode,
+} from 'src/engine/metadata-modules/permissions/permissions.exception';
+import {
+ type ORMWorkspaceContext,
+ withWorkspaceContext,
+} from 'src/engine/twenty-orm/storage/orm-workspace-context.storage';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import {
+ DashboardException,
+ DashboardExceptionCode,
+} from 'src/modules/dashboard/exceptions/dashboard.exception';
+import { DashboardDuplicationService } from 'src/modules/dashboard/services/dashboard-duplication.service';
+
+const WORKSPACE_ID = 'workspace-id';
+const USER_WORKSPACE_ID = 'user-workspace-id';
+const ROLE_ID = 'role-id';
+const DASHBOARD_OBJECT_METADATA_ID = 'dashboard-object-id';
+const DASHBOARD_ID = 'dashboard-id';
+const PAGE_LAYOUT_ID = 'page-layout-id';
+
+const authContext = {
+ type: 'user',
+ workspace: { id: WORKSPACE_ID },
+ userWorkspaceId: USER_WORKSPACE_ID,
+ user: { id: 'user-id' },
+ workspaceMember: { id: 'workspace-member-id' },
+} as unknown as WorkspaceAuthContext;
+
+const originalDashboard = {
+ id: DASHBOARD_ID,
+ title: 'Sales',
+ pageLayoutId: PAGE_LAYOUT_ID,
+ position: 1,
+ createdAt: '2024-01-01T00:00:00.000Z',
+ updatedAt: '2024-01-01T00:00:00.000Z',
+};
+
+const buildWorkspaceContext = ({
+ canUpdateObjectRecords = true,
+ userWorkspaceRoleMap = { [USER_WORKSPACE_ID]: ROLE_ID },
+}: {
+ canUpdateObjectRecords?: boolean;
+ userWorkspaceRoleMap?: Record<string, string>;
+} = {}): ORMWorkspaceContext =>
+ ({
+ authContext,
+ userWorkspaceRoleMap,
+ apiKeyRoleMap: {},
+ objectIdByNameSingular: { dashboard: DASHBOARD_OBJECT_METADATA_ID },
+ flatObjectMetadataMaps: addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: getFlatObjectMetadataMock({
+ id: DASHBOARD_OBJECT_METADATA_ID,
+ universalIdentifier: DASHBOARD_OBJECT_METADATA_ID,
+ nameSingular: 'dashboard',
+ namePlural: 'dashboards',
+ isSystem: false,
+ }),
+ flatEntityMaps: createEmptyFlatEntityMaps(),
+ }),
+ permissionsPerRoleId: {
+ [ROLE_ID]: {
+ [DASHBOARD_OBJECT_METADATA_ID]: {
+ canReadObjectRecords: true,
+ canUpdateObjectRecords,
+ canSoftDeleteObjectRecords: false,
+ canDestroyObjectRecords: false,
+ restrictedFields: {},
+ rowLevelPermissionPredicates: [],
+ rowLevelPermissionPredicateGroups: [],
+ },
+ },
+ },
+ }) as unknown as ORMWorkspaceContext;
+
+describe('DashboardDuplicationService', () => {
+ let service: DashboardDuplicationService;
+ let workspaceContext: ORMWorkspaceContext;
+ let dashboardRepository: { findOne: jest.Mock; insert: jest.Mock };
+ let workspaceOrmManager: {
+ getRepository: jest.Mock;
+ executeInWorkspaceContext: jest.Mock;
+ };
+ let pageLayoutDuplicationService: { duplicate: jest.Mock };
+ let pageLayoutService: { destroy: jest.Mock };
+
+ beforeEach(async () => {
+ workspaceContext = buildWorkspaceContext();
+ dashboardRepository = {
+ findOne: jest
+ .fn()
+ .mockImplementation(async ({ where }: { where: { id: string } }) =>
+ where.id === DASHBOARD_ID
+ ? originalDashboard
+ : { ...originalDashboard, id: where.id, title: 'Sales (Copy)' },
+ ),
+ insert: jest
+ .fn()
+ .mockResolvedValue({ identifiers: [{ id: 'new-dashboard-id' }] }),
+ };
+ workspaceOrmManager = {
+ getRepository: jest.fn().mockReturnValue(dashboardRepository),
+ executeInWorkspaceContext: jest
+ .fn()
+ .mockImplementation((fn: () => unknown) =>
+ withWorkspaceContext(workspaceContext, fn),
+ ),
+ };
+ pageLayoutDuplicationService = {
+ duplicate: jest.fn().mockResolvedValue({ id: 'new-page-layout-id' }),
+ };
+ pageLayoutService = { destroy: jest.fn().mockResolvedValue(true) };
+
+ const module: TestingModule = await Test.createTestingModule({
+ providers: [
+ DashboardDuplicationService,
+ {
+ provide: PageLayoutDuplicationService,
+ useValue: pageLayoutDuplicationService,
+ },
+ { provide: PageLayoutService, useValue: pageLayoutService },
+ { provide: WorkspaceOrmManager, useValue: workspaceOrmManager },
+ {
+ provide: ActorFromAuthContextService,
+ useValue: {
+ injectActorFieldsOnCreate: jest
+ .fn()
+ .mockImplementation(
+ async ({ records }: { records: object[] }) => records,
+ ),
+ },
+ },
+ ],
+ }).compile();
+
+ service = module.get(DashboardDuplicationService);
+ });
+
+ it('should read the source and create the copy under the caller role', async () => {
+ const duplicatedDashboard = await service.duplicateDashboard(
+ DASHBOARD_ID,
+ authContext,
+ );
+
+ expect(workspaceOrmManager.getRepository).toHaveBeenCalledWith(
+ 'dashboard',
+ { intersectionOf: [ROLE_ID] },
+ );
+ expect(pageLayoutDuplicationService.duplicate).toHaveBeenCalledWith({
+ pageLayoutId: PAGE_LAYOUT_ID,
+ workspaceId: WORKSPACE_ID,
+ });
+ expect(dashboardRepository.insert).toHaveBeenCalledWith({
+ title: 'Sales (Copy)',
+ pageLayoutId: 'new-page-layout-id',
+ position: 1,
+ });
+ expect(duplicatedDashboard).toMatchObject({
+ id: 'new-dashboard-id',
+ title: 'Sales (Copy)',
+ });
+ });
+
+ it('should only read the columns the duplication copies', async () => {
+ await service.duplicateDashboard(DASHBOARD_ID, authContext);
+
+ expect(dashboardRepository.findOne).toHaveBeenNthCalledWith(1, {
+ where: { id: DASHBOARD_ID },
+ select: ['id', 'title', 'pageLayoutId', 'position'],
+ });
+ expect(dashboardRepository.findOne).toHaveBeenNthCalledWith(2, {
+ where: { id: 'new-dashboard-id' },
+ select: [
+ 'id',
+ 'title',
+ 'pageLayoutId',
+ 'position',
+ 'createdAt',
+ 'updatedAt',
+ ],
+ });
+ });
+
+ it('should refuse the caller before copying the layout when the role cannot create dashboards', async () => {
+ workspaceContext = buildWorkspaceContext({
+ canUpdateObjectRecords: false,
+ });
+
+ await expect(
+ service.duplicateDashboard(DASHBOARD_ID, authContext),
+ ).rejects.toMatchObject({
+ constructor: PermissionsException,
+ code: PermissionsExceptionCode.PERMISSION_DENIED,
+ });
+ expect(pageLayoutDuplicationService.duplicate).not.toHaveBeenCalled();
+ expect(dashboardRepository.insert).not.toHaveBeenCalled();
+ });
+
+ it('should refuse a caller without a role before reading the source', async () => {
+ workspaceContext = buildWorkspaceContext({ userWorkspaceRoleMap: {} });
+
+ await expect(
+ service.duplicateDashboard(DASHBOARD_ID, authContext),
+ ).rejects.toMatchObject({
+ constructor: PermissionsException,
+ code: PermissionsExceptionCode.PERMISSION_DENIED,
+ });
+ expect(dashboardRepository.findOne).not.toHaveBeenCalled();
+ expect(pageLayoutDuplicationService.duplicate).not.toHaveBeenCalled();
+ });
+
+ it('should destroy the duplicated layout when the dashboard insert is refused', async () => {
+ const permissionDenied = new PermissionsException(
+ 'Entity performing the request does not have permission',
+ PermissionsExceptionCode.PERMISSION_DENIED,
+ );
+
+ dashboardRepository.insert.mockRejectedValue(permissionDenied);
+
+ await expect(
+ service.duplicateDashboard(DASHBOARD_ID, authContext),
+ ).rejects.toBe(permissionDenied);
+ expect(pageLayoutService.destroy).toHaveBeenCalledWith({
+ id: 'new-page-layout-id',
+ workspaceId: WORKSPACE_ID,
+ });
+ });
+
+ it('should surface the insert failure even when the layout cannot be destroyed', async () => {
+ const insertError = new Error('insert failed');
+
+ dashboardRepository.insert.mockRejectedValue(insertError);
+ pageLayoutService.destroy.mockRejectedValue(new Error('destroy failed'));
+
+ await expect(
+ service.duplicateDashboard(DASHBOARD_ID, authContext),
+ ).rejects.toBe(insertError);
+ });
+
+ it('should keep the duplicated layout when the dashboard is created', async () => {
+ await service.duplicateDashboard(DASHBOARD_ID, authContext);
+
+ expect(pageLayoutService.destroy).not.toHaveBeenCalled();
+ });
+
+ it('should report a missing dashboard when the source is out of the caller reach', async () => {
+ dashboardRepository.findOne.mockResolvedValue(null);
+
+ await expect(
+ service.duplicateDashboard(DASHBOARD_ID, authContext),
+ ).rejects.toMatchObject({
+ constructor: DashboardException,
+ code: DashboardExceptionCode.DASHBOARD_NOT_FOUND,
+ });
+ expect(pageLayoutDuplicationService.duplicate).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-server/src/modules/dashboard/services/dashboard-duplication.service.ts b/packages/twenty-server/src/modules/dashboard/services/dashboard-duplication.service.ts
index df7601b48fa..a590e98be03 100644
--- a/packages/twenty-server/src/modules/dashboard/services/dashboard-duplication.service.ts
+++ b/packages/twenty-server/src/modules/dashboard/services/dashboard-duplication.service.ts
@@ -4,9 +4,24 @@ import { appendCopySuffix, isDefined } from 'twenty-shared/utils';
import { ActorFromAuthContextService } from 'src/engine/core-modules/actor/services/actor-from-auth-context.service';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
import { PageLayoutDuplicationService } from 'src/engine/metadata-modules/page-layout/services/page-layout-duplication.service';
+import { PageLayoutService } from 'src/engine/metadata-modules/page-layout/services/page-layout.service';
+import {
+ PermissionsException,
+ PermissionsExceptionCode,
+ PermissionsExceptionMessage,
+} from 'src/engine/metadata-modules/permissions/permissions.exception';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
+import {
+ getWorkspaceContext,
+ type ORMWorkspaceContext,
+} from 'src/engine/twenty-orm/storage/orm-workspace-context.storage';
+import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';
+import { resolveObjectRecordsPermissions } from 'src/engine/twenty-orm/utils/resolve-object-records-permissions.util';
+import { resolveRolePermissionConfig } from 'src/engine/twenty-orm/utils/resolve-role-permission-config.util';
import { DuplicatedDashboardDTO } from 'src/modules/dashboard/dtos/duplicated-dashboard.dto';
import {
DashboardException,
@@ -16,12 +31,28 @@ import {
} from 'src/modules/dashboard/exceptions/dashboard.exception';
import { DashboardWorkspaceEntity } from 'src/modules/dashboard/standard-objects/dashboard.workspace-entity';
+// A role-scoped read validates every column it selects, so reading the whole
+// row would refuse a duplication over a dashboard field it never copies
+const DUPLICATION_SOURCE_COLUMNS: (keyof DashboardWorkspaceEntity)[] = [
+ 'id',
+ 'title',
+ 'pageLayoutId',
+ 'position',
+];
+
+const DUPLICATED_DASHBOARD_COLUMNS: (keyof DashboardWorkspaceEntity)[] = [
+ ...DUPLICATION_SOURCE_COLUMNS,
+ 'createdAt',
+ 'updatedAt',
+];
+
@Injectable()
export class DashboardDuplicationService {
private readonly logger = new Logger(DashboardDuplicationService.name);
constructor(
private readonly pageLayoutDuplicationService: PageLayoutDuplicationService,
+ private readonly pageLayoutService: PageLayoutService,
private readonly workspaceOrmManager: WorkspaceOrmManager,
private readonly actorFromAuthContextService: ActorFromAuthContextService,
) {}
@@ -34,14 +65,29 @@ export class DashboardDuplicationService {
const workspaceId = workspace.id;
return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const workspaceContext = getWorkspaceContext();
+ const rolePermissionConfig = resolveRolePermissionConfig({
+ authContext: workspaceContext.authContext,
+ userWorkspaceRoleMap: workspaceContext.userWorkspaceRoleMap,
+ apiKeyRoleMap: workspaceContext.apiKeyRoleMap,
+ });
+
+ if (!isDefined(rolePermissionConfig)) {
+ throw new PermissionsException(
+ PermissionsExceptionMessage.PERMISSION_DENIED,
+ PermissionsExceptionCode.PERMISSION_DENIED,
+ );
+ }
+
const dashboardRepository =
this.workspaceOrmManager.getRepository<DashboardWorkspaceEntity>(
'dashboard',
- { shouldBypassPermissionChecks: true },
+ rolePermissionConfig,
);
const originalDashboard = await dashboardRepository.findOne({
where: { id: dashboardId },
+ select: DUPLICATION_SOURCE_COLUMNS,
});
if (!isDefined(originalDashboard)) {
@@ -64,6 +110,13 @@ export class DashboardDuplicationService {
);
}
+ // The layout copy lives in the core schema, outside the dashboard
+ // insert, so a caller who may not create dashboards is refused before it
+ this.assertCanCreateDashboardOrThrow({
+ workspaceContext,
+ rolePermissionConfig,
+ });
+
try {
const newPageLayout = await this.pageLayoutDuplicationService.duplicate(
{
@@ -72,12 +125,13 @@ export class DashboardDuplicationService {
},
);
- const newDashboard = await this.createDuplicatedDashboard(
+ const newDashboard = await this.createDuplicatedDashboardOrRollback({
originalDashboard,
- newPageLayout.id,
+ newPageLayoutId: newPageLayout.id,
dashboardRepository,
authContext,
- );
+ workspaceId,
+ });
return {
id: newDashboard.id,
@@ -98,6 +152,82 @@ export class DashboardDuplicationService {
}, authContext);
}
+ private assertCanCreateDashboardOrThrow({
+ workspaceContext,
+ rolePermissionConfig,
+ }: {
+ workspaceContext: ORMWorkspaceContext;
+ rolePermissionConfig: RolePermissionConfig;
+ }): void {
+ const { objectRecordsPermissions, shouldBypassPermissionChecks } =
+ resolveObjectRecordsPermissions({
+ rolePermissionConfig,
+ objectPermissionsByRoleId: workspaceContext.permissionsPerRoleId,
+ });
+
+ if (shouldBypassPermissionChecks) {
+ return;
+ }
+
+ const dashboardObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: workspaceContext.objectIdByNameSingular.dashboard,
+ flatEntityMaps: workspaceContext.flatObjectMetadataMaps,
+ });
+
+ if (
+ !isDefined(dashboardObjectMetadata) ||
+ !isObjectOperationPermitted({
+ objectMetadata: dashboardObjectMetadata,
+ operationType: 'insert',
+ objectsPermissions: objectRecordsPermissions,
+ })
+ ) {
+ throw new PermissionsException(
+ PermissionsExceptionMessage.PERMISSION_DENIED,
+ PermissionsExceptionCode.PERMISSION_DENIED,
+ );
+ }
+ }
+
+ // The layout lives in the core schema, outside the dashboard insert, so a
+ // refused or failed insert has to take the layout it was created for with it
+ private async createDuplicatedDashboardOrRollback({
+ originalDashboard,
+ newPageLayoutId,
+ dashboardRepository,
+ authContext,
+ workspaceId,
+ }: {
+ originalDashboard: DashboardWorkspaceEntity;
+ newPageLayoutId: string;
+ dashboardRepository: WorkspaceRepository<DashboardWorkspaceEntity>;
+ authContext: WorkspaceAuthContext;
+ workspaceId: string;
+ }): Promise<DashboardWorkspaceEntity> {
+ try {
+ return await this.createDuplicatedDashboard(
+ originalDashboard,
+ newPageLayoutId,
+ dashboardRepository,
+ authContext,
+ );
+ } catch (error) {
+ try {
+ await this.pageLayoutService.destroy({
+ id: newPageLayoutId,
+ workspaceId,
+ });
+ } catch (rollbackError) {
+ this.logger.error(
+ `Failed to destroy page layout ${newPageLayoutId} left by a failed dashboard duplication: ${rollbackError.message}`,
+ rollbackError.stack,
+ );
+ }
+
+ throw error;
+ }
+ }
+
private async createDuplicatedDashboard(
originalDashboard: DashboardWorkspaceEntity,
newPageLayoutId: string,
@@ -125,6 +255,7 @@ export class DashboardDuplicationService {
const newDashboard = await dashboardRepository.findOne({
where: { id: newDashboardId },
+ select: DUPLICATED_DASHBOARD_COLUMNS,
});
if (!isDefined(newDashboard)) {
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 0459db50b5c..39ae7f7591a 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 { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.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 { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
@@ -441,6 +442,11 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
},
flatRoleMaps: { byUniversalIdentifier: {} },
rolesPermissions: {},
+ flatRowLevelPermissionPredicateMaps:
+ createEmptyFlatEntityMaps(),
+ flatRowLevelPermissionPredicateGroupMaps:
+ createEmptyFlatEntityMaps(),
+ flatFieldMetadataMaps: createEmptyFlatEntityMaps(),
}
: {
workflowAutomatedTriggerMaps: {
@@ -506,6 +512,11 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
flatRoleMaps: { byUniversalIdentifier: {} },
rolesPermissions: {},
+ flatRowLevelPermissionPredicateMaps:
+ createEmptyFlatEntityMaps(),
+ flatRowLevelPermissionPredicateGroupMaps:
+ createEmptyFlatEntityMaps(),
+ flatFieldMetadataMaps: createEmptyFlatEntityMaps(),
}
: {
workflowAutomatedTriggerMaps: {
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 7e528c93db6..2b5300a10df 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
@@ -435,7 +435,7 @@ export class WorkflowDatabaseEventTriggerListener {
);
return this.recordAccessPolicyService
- .buildEventRecordShareGate(payload)
+ .buildEventRecordAccessGate(payload)
.resolveAdmittedRecordIds(
buildRoleRowAccessPolicySubject({
roleId:
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 d0faf445662..09ae585c284 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
@@ -474,7 +474,7 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
await getAppProviderByClassName<RecordAccessPolicyService>(
'RecordAccessPolicyService',
)
- .buildEventRecordShareGate({
+ .buildEventRecordAccessGate({
name: 'note.created',
workspaceId: SEED_APPLE_WORKSPACE_ID,
objectMetadata: noteObjectMetadata!,
@@ -641,7 +641,7 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
getAppProviderByClassName<RecordAccessPolicyService>(
'RecordAccessPolicyService',
)
- .buildEventRecordShareGate({
+ .buildEventRecordAccessGate({
name: 'note.deleted',
workspaceId: SEED_APPLE_WORKSPACE_ID,
objectMetadata: noteObjectMetadata!,
diff --git a/packages/twenty-server/test/integration/metadata/suites/dashboard/failing-dashboard-duplication.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/dashboard/failing-dashboard-duplication.integration-spec.ts
index d823d4efc68..90ae6cd8c03 100644
--- a/packages/twenty-server/test/integration/metadata/suites/dashboard/failing-dashboard-duplication.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/dashboard/failing-dashboard-duplication.integration-spec.ts
@@ -1,10 +1,18 @@
import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
import {
createTestDashboardWithGraphQL,
destroyDashboardWithGraphQL,
} from 'test/integration/metadata/suites/dashboard/utils/dashboard-graphql.util';
+import { duplicateOneDashboardQueryFactory } from 'test/integration/metadata/suites/dashboard/utils/duplicate-one-dashboard-query-factory.util';
import { duplicateOneDashboard } from 'test/integration/metadata/suites/dashboard/utils/duplicate-one-dashboard.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { upsertObjectPermissions } from 'test/integration/metadata/suites/object-permission/utils/upsert-object-permissions.util';
import { destroyOnePageLayout } from 'test/integration/metadata/suites/page-layout/utils/destroy-one-page-layout.util';
+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { makeMetadataAPIRequestWithMemberRole } from 'test/integration/metadata/suites/utils/make-metadata-api-request-with-member-role.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
import {
type EachTestingContext,
eachTestingContextFilter,
@@ -81,3 +89,103 @@ describe('Dashboard duplication should fail', () => {
},
);
});
+
+describe('Dashboard duplication should follow the caller role', () => {
+ const DASHBOARD_ID = '3d1f2a52-6c5e-4b9a-8f1e-2c4d6e8f0a1b';
+ const DASHBOARD_TITLE = 'Dashboard Out Of Reach';
+ let dashboardObjectMetadataId: string;
+ let memberRoleId: string;
+
+ const setMemberDashboardPermissions = ({
+ canReadObjectRecords,
+ canUpdateObjectRecords,
+ }: {
+ canReadObjectRecords: boolean;
+ canUpdateObjectRecords: boolean;
+ }) =>
+ upsertObjectPermissions({
+ expectToFail: false,
+ input: {
+ roleId: memberRoleId,
+ objectPermissions: [
+ {
+ objectMetadataId: dashboardObjectMetadataId,
+ canReadObjectRecords,
+ canUpdateObjectRecords,
+ canSoftDeleteObjectRecords: canUpdateObjectRecords,
+ canDestroyObjectRecords: canUpdateObjectRecords,
+ },
+ ],
+ },
+ });
+
+ beforeAll(async () => {
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 100 } },
+ gqlFields: 'id nameSingular',
+ });
+ const dashboardObject = objects.find(
+ (object) => object.nameSingular === 'dashboard',
+ );
+
+ jestExpectToBeDefined(dashboardObject);
+
+ dashboardObjectMetadataId = dashboardObject.id;
+ memberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
+
+ await createTestDashboardWithGraphQL({
+ id: DASHBOARD_ID,
+ title: DASHBOARD_TITLE,
+ });
+ });
+
+ afterAll(async () => {
+ await setMemberDashboardPermissions({
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: true,
+ });
+ await destroyDashboardWithGraphQL(DASHBOARD_ID);
+ });
+
+ it.each([
+ {
+ title: 'read dashboards',
+ permissions: {
+ canReadObjectRecords: false,
+ canUpdateObjectRecords: false,
+ },
+ },
+ {
+ title: 'create dashboards',
+ permissions: {
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: false,
+ },
+ },
+ ])(
+ 'should refuse a member whose role cannot $title',
+ async ({ permissions }) => {
+ await setMemberDashboardPermissions(permissions);
+
+ const response = await makeMetadataAPIRequestWithMemberRole(
+ duplicateOneDashboardQueryFactory({ input: { id: DASHBOARD_ID } }),
+ );
+
+ expect(response.body.data?.duplicateDashboard ?? null).toBeNull();
+ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
+
+ const copies = await makeGraphqlAPIRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'dashboard',
+ objectMetadataPluralName: 'dashboards',
+ gqlFields: 'id',
+ filter: { title: { eq: `${DASHBOARD_TITLE} (Copy)` } },
+ }),
+ );
+
+ expect(copies.body.errors).toBeUndefined();
+ expect(copies.body.data.dashboards.edges).toEqual([]);
+ },
+ );
+});