The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsnew file mode 100644index 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.tsindex 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.tsindex 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 outconst 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.tsindex 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/typimport { 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.tssimilarity index 84%rename from packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.tsrename to packages/twenty-server/src/engine/record-share/types/event-record-access-gate.type.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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/woimport { 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.tsnew file mode 100644index 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.tsindex 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-mimport { 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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/decoratoimport { 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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([]);+ },+ );+});