The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Revert "Revert "Record sharing 5/14: evaluate record shares in memory for events"" (#25650)
martmulleca522c2c4f9
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/logic-function-trigger.module.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/logic-function-trigger.module.tsindex d9ce5ef75c7..225bf2129a9 100644--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/logic-function-trigger.module.ts+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/logic-function-trigger.module.ts@@ -12,6 +12,7 @@ import { LogicFunctionTriggerService } from 'src/engine/core-modules/logic-functimport { RouteTriggerService } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/route/route-trigger.service';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';+import { RecordShareModule } from 'src/engine/record-share/record-share.module';import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';@Module({@@ -21,6 +22,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cacheWorkspaceDomainsModule,WorkspaceCacheModule,CronModule,+ RecordShareModule,],providers: [LogicFunctionTriggerJob,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 5964d069986..dbb61207e30 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@@ -1,9 +1,12 @@import { Logger } from '@nestjs/common';+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import { FeatureFlagKey } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import type { ObjectRecordEvent } from 'twenty-shared/database-events';+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';import { findActiveFlatApplicationById } from 'src/engine/core-modules/application/utils/find-active-flat-application-by-id.util';import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';@@ -18,6 +21,12 @@ import {LogicFunctionTriggerJob,LogicFunctionTriggerJobData,} from 'src/engine/core-modules/logic-function/logic-function-trigger/jobs/logic-function-trigger.job';+import { RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';@@ -30,14 +39,15 @@ export class CallDatabaseEventTriggerJobsJob {private readonly messageQueueService: MessageQueueService,private readonly workspaceCacheService: WorkspaceCacheService,private readonly applicationJobEnqueueThrottlerService: ApplicationJobEnqueueThrottlerService,+ private readonly recordShareService: RecordShareService,) {}@Process(CallDatabaseEventTriggerJobsJob.name)async handle(workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>) {- const { flatLogicFunctionMaps, flatApplicationMaps } =+ const { flatLogicFunctionMaps, flatApplicationMaps, featureFlagsMap } =await this.workspaceCacheService.getOrRecompute(workspaceEventBatch.workspaceId,- ['flatLogicFunctionMaps', 'flatApplicationMaps'],+ ['flatLogicFunctionMaps', 'flatApplicationMaps', 'featureFlagsMap'],);const logicFunctionsWithDatabaseEventTrigger = Object.values(@@ -76,6 +86,25 @@ export class CallDatabaseEventTriggerJobsJob {);}+ if (logicFunctionsByApplicationId.size === 0) {+ return;+ }++ const isRecordShareGated =+ featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED];++ let recordSharesByRecordIdPromise:+ | Promise<Map<string, RecordShare[]>>+ | undefined;+ const fetchRecordSharesByRecordId = () =>+ (recordSharesByRecordIdPromise ??= this.recordShareService+ .findByRecordIds({+ workspaceId: workspaceEventBatch.workspaceId,+ objectMetadataId: workspaceEventBatch.objectMetadata.id,+ recordIds: workspaceEventBatch.events.map((event) => event.recordId),+ })+ .then(indexRecordSharesByRecordId));+for (const [applicationId,logicFunctions,@@ -86,13 +115,18 @@ export class CallDatabaseEventTriggerJobsJob {);const applicationRegistrationId = application?.applicationRegistrationId;- if (!isDefined(applicationRegistrationId)) {+ if (!isDefined(application) || !isDefined(applicationRegistrationId)) {continue;}const logicFunctionPayloads = transformEventBatchToEventPayloads({logicFunctions,- workspaceEventBatch,+ workspaceEventBatch: await this.filterEventsSharedWithApplication({+ workspaceEventBatch,+ application,+ isRecordShareGated,+ fetchRecordSharesByRecordId,+ }),});if (logicFunctionPayloads.length === 0) {@@ -130,6 +164,43 @@ export class CallDatabaseEventTriggerJobsJob {}}+ private async filterEventsSharedWithApplication({+ workspaceEventBatch,+ application,+ isRecordShareGated,+ fetchRecordSharesByRecordId,+ }: {+ workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;+ application: FlatApplication;+ isRecordShareGated: boolean;+ fetchRecordSharesByRecordId: () => Promise<Map<string, RecordShare[]>>;+ }): Promise<WorkspaceEventBatch<ObjectRecordEvent>> {+ const recordShareGate = isRecordShareGated+ ? await buildRecordShareGate({+ readability: workspaceEventBatch.objectMetadata.readability,+ isOwningApplication:+ workspaceEventBatch.objectMetadata.applicationId === application.id,+ principalIds: [EVERYONE_PRINCIPAL_ID, application.defaultRoleId],+ fetchRecordSharesByRecordId,+ })+ : null;++ if (!isDefined(recordShareGate)) {+ return workspaceEventBatch;+ }++ return {+ ...workspaceEventBatch,+ events: workspaceEventBatch.events.filter((event) =>+ isRecordSharedWithPrincipals({+ recordShareGate,+ recordId: event.recordId,+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),+ }),+ ),+ };+ }+private shouldTriggerJob({workspaceEventBatch,eventName,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 999ed864d09..46d8d08ccdf 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@@ -1,6 +1,8 @@import { Logger } from '@nestjs/common';import chunk from 'lodash.chunk';+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import { FeatureFlagKey } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import type { ObjectRecordEvent } from 'twenty-shared/database-events';@@ -10,13 +12,17 @@ import { Process } from 'src/engine/core-modules/message-queue/decorators/procesimport { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';import { CallWebhookJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';import { WebhookRateLimitService } from 'src/engine/metadata-modules/webhook/jobs/webhook-rate-limit.service';import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';+import { type WorkspaceEventBatchForWebhook } from 'src/engine/metadata-modules/webhook/types/workspace-event-batch-for-webhook.type';import { computeWebhookOperationsToMatch } from 'src/engine/metadata-modules/webhook/utils/compute-webhook-operations-to-match.util';import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';+import { RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';-import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';const WEBHOOK_JOBS_CHUNK_SIZE = 20;@@ -27,12 +33,13 @@ export class CallWebhookJobsJob {@InjectMessageQueue(MessageQueue.webhookQueue)private readonly messageQueueService: MessageQueueService,private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly recordShareService: RecordShareService,private readonly webhookRateLimitService: WebhookRateLimitService,) {}@Process(CallWebhookJobsJob.name)async handle(- workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>,+ workspaceEventBatch: WorkspaceEventBatchForWebhook<ObjectRecordEvent>,): Promise<void> {// If you change that function, double check it does not break Zapier// trigger in packages/twenty-zapier/src/triggers/trigger_record.ts@@ -46,10 +53,11 @@ export class CallWebhookJobsJob {operation,});- const { flatWebhookMaps } = await this.workspaceCacheService.getOrRecompute(- workspaceEventBatch.workspaceId,- ['flatWebhookMaps'],- );+ const { flatWebhookMaps, flatObjectMetadataMaps, featureFlagsMap } =+ await this.workspaceCacheService.getOrRecompute(+ workspaceEventBatch.workspaceId,+ ['flatWebhookMaps', 'flatObjectMetadataMaps', 'featureFlagsMap'],+ );const webhooks = Object.values(flatWebhookMaps.byUniversalIdentifier).filter(isDefined)@@ -59,9 +67,51 @@ export class CallWebhookJobsJob {),);+ if (webhooks.length === 0) {+ return;+ }++ const flatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityId: workspaceEventBatch.objectMetadata.id,+ flatEntityMaps: flatObjectMetadataMaps,+ });++ const isRecordSharingEnabled =+ featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED] ?? false;++ // Without the readability the batch cannot be gated, so nothing may leave+ if (isRecordSharingEnabled && !isDefined(flatObjectMetadata)) {+ this.logger.warn(+ `Object metadata ${workspaceEventBatch.objectMetadata.id} not found for workspace ${workspaceEventBatch.workspaceId}, dropping the webhook batch`,+ );++ return;+ }++ // A webhook carries no identity, so only a row granted to everyone lets an event out+ const recordShareGate =+ isRecordSharingEnabled && isDefined(flatObjectMetadata)+ ? await buildRecordShareGate({+ readability: flatObjectMetadata.readability,+ isOwningApplication: false,+ principalIds: [EVERYONE_PRINCIPAL_ID],+ fetchRecordSharesByRecordId: async () =>+ indexRecordSharesByRecordId(+ await this.recordShareService.findByRecordIds({+ workspaceId: workspaceEventBatch.workspaceId,+ objectMetadataId: workspaceEventBatch.objectMetadata.id,+ recordIds: workspaceEventBatch.events.map(+ (event) => event.recordId,+ ),+ }),+ ),+ })+ : null;+const webhookEvents = transformEventBatchToWebhookEvents({workspaceEventBatch,webhooks,+ recordShareGate,});const admittedWebhookEvents =diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/webhook-job.module.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/webhook-job.module.tsindex 56a67685fde..e9092e7e917 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/webhook-job.module.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/webhook-job.module.ts@@ -10,6 +10,7 @@ import { CallWebhookJobsForMetadataJob } from 'src/engine/metadata-modules/webhoimport { CallWebhookJobsJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job';import { CallWebhookJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook.job';import { WebhookRateLimitService } from 'src/engine/metadata-modules/webhook/jobs/webhook-rate-limit.service';+import { RecordShareModule } from 'src/engine/record-share/record-share.module';import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';@Module({@@ -18,6 +19,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cacheFeatureFlagModule,FlatWebhookModule,MetricsModule,+ RecordShareModule,SecureHttpClientModule,UsageLimitModule,WorkspaceCacheModule,diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.tsindex 2fa8dd5389c..69afdd71292 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/__tests__/transform-event-batch-to-webhook-events.spec.ts@@ -1,9 +1,19 @@+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import {+ MetadataReadability,+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';+import type { ObjectRecordEvent } from 'twenty-shared/database-events';import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';import type { WebhookEntity } from 'src/engine/metadata-modules/webhook/entities/webhook.entity';import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';const mockObjectMetadata: FlatObjectMetadata = {id: 'id',@@ -246,6 +256,77 @@ describe('transformEventBatchToWebhookEvents', () => {expect(resultWithoutEventDate).toEqual(expectedResultWithoutEventDate);});+ it('should only keep events of a private object for records shared with everyone', () => {+ const workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent> = {+ workspaceId: 'workspaceId',+ objectMetadata: {+ ...mockObjectMetadata,+ readability: MetadataReadability.PRIVATE,+ },+ name: 'objectNameSingular.created',+ events: [+ {+ recordId: 'recordId-1',+ properties: {+ after: { id: 'recordId-1', nameSingular: 'nameSingular-1' },+ },+ },+ {+ recordId: 'recordId-2',+ properties: {+ after: { id: 'recordId-2', nameSingular: 'nameSingular-2' },+ },+ },+ ],+ };++ const webhooks = [+ {+ id: 'webhook-id',+ targetUrl: 'targetUrl',+ secret: 'secret',+ },+ ] as WebhookEntity[];++ const recordShares = [+ {+ id: 'record-share-1',+ recordId: 'recordId-1',+ objectMetadataId: mockObjectMetadata.id,+ principalId: EVERYONE_PRINCIPAL_ID,+ principalType: RecordSharePrincipalType.EVERYONE,+ accessLevel: RecordShareAccessLevel.READ,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'source-1',+ },+ {+ id: 'record-share-2',+ recordId: 'recordId-2',+ objectMetadataId: mockObjectMetadata.id,+ principalId: 'workspace-member-id',+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,+ accessLevel: RecordShareAccessLevel.FULL,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'source-1',+ },+ ] as RecordShare[];++ const result = transformEventBatchToWebhookEvents({+ workspaceEventBatch,+ webhooks,+ recordShareGate: {+ recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),+ principalIds: [EVERYONE_PRINCIPAL_ID],+ },+ });++ expect(result).toHaveLength(1);+ expect(result[0].record).toEqual({+ id: 'recordId-1',+ nameSingular: 'nameSingular-1',+ });+ });+it('should include position-only update events', () => {const workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent> = {workspaceId: 'workspaceId',diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.tsindex dfe8c666ca4..a6d2dad2109 100644--- a/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events.ts@@ -1,19 +1,36 @@+import { isDefined } from 'twenty-shared/utils';+import type { ObjectRecordEvent } from 'twenty-shared/database-events';import { type WebhookEntity } from 'src/engine/metadata-modules/webhook/entities/webhook.entity';import { type CallWebhookJobData } from 'src/engine/metadata-modules/webhook/types/webhook-job-data.type';+import { type WorkspaceEventBatchForWebhook } from 'src/engine/metadata-modules/webhook/types/workspace-event-batch-for-webhook.type';import { transformEventToWebhookEvent } from 'src/engine/metadata-modules/webhook/utils/transform-event-to-webhook-event';-import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';+import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';+import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';export const transformEventBatchToWebhookEvents = ({workspaceEventBatch,webhooks,+ recordShareGate,}: {- workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;+ workspaceEventBatch: WorkspaceEventBatchForWebhook<ObjectRecordEvent>;webhooks: Pick<WebhookEntity, 'id' | 'targetUrl' | 'secret'>[];+ recordShareGate?: RecordShareGate | null;}): CallWebhookJobData[] => {const result: CallWebhookJobData[] = [];+ const events = isDefined(recordShareGate)+ ? workspaceEventBatch.events.filter((event) =>+ isRecordSharedWithPrincipals({+ recordShareGate,+ recordId: event.recordId,+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),+ }),+ )+ : workspaceEventBatch.events;+for (const webhook of webhooks) {const targetUrl = webhook.targetUrl;const eventName = workspaceEventBatch.name;@@ -26,7 +43,7 @@ export const transformEventBatchToWebhookEvents = ({const eventDate = new Date();const secret = webhook.secret;- for (const eventData of workspaceEventBatch.events) {+ for (const eventData of events) {const { record, updatedFields } = transformEventToWebhookEvent({eventName: workspaceEventBatch.name,event: eventData,diff --git a/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.ts b/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.tsnew file mode 100644index 00000000000..59a1819b5b3--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.ts@@ -0,0 +1,6 @@+import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';++export const DENY_ALL_RECORD_SHARE_GATE: RecordShareGate = {+ recordSharesByRecordId: new Map(),+ principalIds: [],+};diff --git a/packages/twenty-server/src/engine/record-share/services/record-share.service.ts b/packages/twenty-server/src/engine/record-share/services/record-share.service.tsindex 8bd09a73215..96ff35e9e68 100644--- a/packages/twenty-server/src/engine/record-share/services/record-share.service.ts+++ b/packages/twenty-server/src/engine/record-share/services/record-share.service.ts@@ -88,6 +88,26 @@ export class RecordShareService {);}+ async findByRecordIds({+ workspaceId,+ objectMetadataId,+ recordIds,+ }: {+ workspaceId: string;+ objectMetadataId: string;+ recordIds: string[];+ }): Promise<RecordShare[]> {+ if (recordIds.length === 0) {+ return [];+ }++ return this.withRepository({ workspaceId }, (repository) =>+ repository.find({+ where: { objectMetadataId, recordId: In(recordIds) },+ }),+ );+ }+private async withRepository<TResult>({workspaceId,diff --git a/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.ts b/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.tsnew file mode 100644index 00000000000..5faa761f8f5--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.ts@@ -0,0 +1,6 @@+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';++export type RecordShareGate = {+ recordSharesByRecordId: Map<string, RecordShare[]>;+ principalIds: string[];+};diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.tsnew file mode 100644index 00000000000..840a2317d2c--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.ts@@ -0,0 +1,89 @@+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import {+ MetadataReadability,+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';++import { DENY_ALL_RECORD_SHARE_GATE } from 'src/engine/record-share/constants/deny-all-record-share-gate.constant';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';++const RECORD_SHARE: RecordShare = {+ id: 'record-share-1',+ recordId: 'record-1',+ objectMetadataId: 'object-1',+ principalId: 'member-1',+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,+ accessLevel: RecordShareAccessLevel.READ,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'member-2',+} as RecordShare;++describe('buildRecordShareGate', () => {+ it('does not gate an OPEN object and does not fetch the rows', async () => {+ const fetchRecordSharesByRecordId = jest.fn(async () =>+ indexRecordSharesByRecordId([RECORD_SHARE]),+ );++ const gate = await buildRecordShareGate({+ readability: MetadataReadability.OPEN,+ isOwningApplication: false,+ principalIds: ['member-1'],+ fetchRecordSharesByRecordId,+ });++ expect(gate).toBeNull();+ expect(fetchRecordSharesByRecordId).not.toHaveBeenCalled();+ });++ it('denies everyone on a SYSTEM object without fetching the rows', async () => {+ const fetchRecordSharesByRecordId = jest.fn(async () =>+ indexRecordSharesByRecordId([RECORD_SHARE]),+ );++ const gate = await buildRecordShareGate({+ readability: MetadataReadability.SYSTEM,+ isOwningApplication: false,+ principalIds: ['member-1'],+ fetchRecordSharesByRecordId,+ });++ expect(gate).toBe(DENY_ALL_RECORD_SHARE_GATE);+ expect(fetchRecordSharesByRecordId).not.toHaveBeenCalled();+ });++ it('lets the owning application through an APPLICATION object', async () => {+ const gate = await buildRecordShareGate({+ readability: MetadataReadability.APPLICATION,+ isOwningApplication: true,+ principalIds: [],+ fetchRecordSharesByRecordId: async () => new Map(),+ });++ expect(gate).toBeNull();+ });++ it('fetches the rows of a PRIVATE object and keeps each principal once', async () => {+ const gate = await buildRecordShareGate({+ readability: MetadataReadability.PRIVATE,+ isOwningApplication: false,+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ undefined,+ 'role-1',+ 'role-1',+ null,+ ],+ fetchRecordSharesByRecordId: async () =>+ indexRecordSharesByRecordId([RECORD_SHARE]),+ });++ expect(gate).toEqual({+ recordSharesByRecordId: indexRecordSharesByRecordId([RECORD_SHARE]),+ principalIds: [EVERYONE_PRINCIPAL_ID, 'role-1'],+ });+ });+});diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/index-record-shares-by-record-id.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/index-record-shares-by-record-id.util.spec.tsnew file mode 100644index 00000000000..bd4d42ccef0--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/index-record-shares-by-record-id.util.spec.ts@@ -0,0 +1,47 @@+import {+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';++import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';++const buildRecordShare = (+ recordId: string,+ principalId: string,+): RecordShare => ({+ id: `${recordId}-${principalId}`,+ recordId,+ objectMetadataId: 'object-1',+ principalId,+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,+ accessLevel: RecordShareAccessLevel.READ,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'source-1',+});++describe('indexRecordSharesByRecordId', () => {+ it('should group every row under its record and keep records apart', () => {+ const firstShareOfRecordOne = buildRecordShare('record-1', 'member-1');+ const secondShareOfRecordOne = buildRecordShare('record-1', 'member-2');+ const shareOfRecordTwo = buildRecordShare('record-2', 'member-1');++ expect(+ indexRecordSharesByRecordId([+ firstShareOfRecordOne,+ shareOfRecordTwo,+ secondShareOfRecordOne,+ ]),+ ).toEqual(+ new Map([+ ['record-1', [firstShareOfRecordOne, secondShareOfRecordOne]],+ ['record-2', [shareOfRecordTwo]],+ ]),+ );+ });++ it('should return an empty index for no rows', () => {+ expect(indexRecordSharesByRecordId([])).toEqual(new Map());+ });+});diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.tsnew file mode 100644index 00000000000..ae4b2d6c316--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-shared-with-principals.util.spec.ts@@ -0,0 +1,171 @@+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import {+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';++import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';++const OBJECT_METADATA_ID = 'object-metadata-1';+const WORKSPACE_MEMBER_ID = 'workspace-member-1';+const MEMBER_ROLE_ID = 'member-role-1';+const ADMIN_ROLE_ID = 'admin-role-1';++const RECORD_IDS = {+ SHARED_READ_WITH_MEMBER: 'record-shared-read-with-member',+ SHARED_READ_WRITE_WITH_MEMBER_ROLE:+ 'record-shared-read-write-with-member-role',+ SHARED_FULL_WITH_EVERYONE: 'record-shared-full-with-everyone',+ SHARED_FULL_WITH_ADMIN_ROLE: 'record-shared-full-with-admin-role',+ UNSHARED: 'record-unshared',+};++const buildRecordShare = ({+ recordId,+ principalId,+ principalType,+ accessLevel,+}: Pick<+ RecordShare,+ 'recordId' | 'principalId' | 'principalType' | 'accessLevel'+>): RecordShare => ({+ id: `${recordId}-${principalId}`,+ recordId,+ objectMetadataId: OBJECT_METADATA_ID,+ principalId,+ principalType,+ accessLevel,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'source-1',+});++const recordShares: RecordShare[] = [+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_READ_WITH_MEMBER,+ principalId: WORKSPACE_MEMBER_ID,+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,+ accessLevel: RecordShareAccessLevel.READ,+ }),+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,+ principalId: MEMBER_ROLE_ID,+ principalType: RecordSharePrincipalType.ROLE,+ accessLevel: RecordShareAccessLevel.READ_WRITE,+ }),+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ principalId: EVERYONE_PRINCIPAL_ID,+ principalType: RecordSharePrincipalType.EVERYONE,+ accessLevel: RecordShareAccessLevel.FULL,+ }),+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,+ principalId: ADMIN_ROLE_ID,+ principalType: RecordSharePrincipalType.ROLE,+ accessLevel: RecordShareAccessLevel.FULL,+ }),+];++const MEMBER_PRINCIPAL_IDS = [+ EVERYONE_PRINCIPAL_ID,+ WORKSPACE_MEMBER_ID,+ MEMBER_ROLE_ID,+];+const ADMIN_PRINCIPAL_IDS = [EVERYONE_PRINCIPAL_ID, ADMIN_ROLE_ID];+const EVERYONE_PRINCIPAL_IDS = [EVERYONE_PRINCIPAL_ID];++const sharedRecordIds = ({+ principalIds,+ accessLevels,+}: {+ principalIds: string[];+ accessLevels: RecordShareAccessLevel[];+}) =>+ Object.values(RECORD_IDS).filter((recordId) =>+ isRecordSharedWithPrincipals({+ recordShareGate: {+ recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),+ principalIds,+ },+ recordId,+ accessLevels,+ }),+ );++describe('isRecordSharedWithPrincipals', () => {+ it.each([+ {+ principals: 'the member, their role and everyone',+ principalIds: MEMBER_PRINCIPAL_IDS,+ operationType: 'select' as const,+ expectedRecordIds: [+ RECORD_IDS.SHARED_READ_WITH_MEMBER,+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ ],+ },+ {+ principals: 'the member, their role and everyone',+ principalIds: MEMBER_PRINCIPAL_IDS,+ operationType: 'update' as const,+ expectedRecordIds: [+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ ],+ },+ {+ principals: 'the member, their role and everyone',+ principalIds: MEMBER_PRINCIPAL_IDS,+ operationType: 'delete' as const,+ expectedRecordIds: [RECORD_IDS.SHARED_FULL_WITH_EVERYONE],+ },+ {+ principals: 'the admin role and everyone',+ principalIds: ADMIN_PRINCIPAL_IDS,+ operationType: 'select' as const,+ expectedRecordIds: [+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,+ ],+ },+ {+ principals: 'everyone alone',+ principalIds: EVERYONE_PRINCIPAL_IDS,+ operationType: 'select' as const,+ expectedRecordIds: [RECORD_IDS.SHARED_FULL_WITH_EVERYONE],+ },+ {+ principals: 'everyone alone',+ principalIds: EVERYONE_PRINCIPAL_IDS,+ operationType: 'insert' as const,+ expectedRecordIds: [],+ },+ ])(+ 'should share with $principals on $operationType exactly $expectedRecordIds',+ ({ principalIds, operationType, expectedRecordIds }) => {+ expect(+ sharedRecordIds({+ principalIds,+ accessLevels: resolveRequiredRecordShareAccessLevels(operationType),+ }),+ ).toEqual(expectedRecordIds);+ },+ );++ it('should ignore rows of another record with the same principal', () => {+ expect(+ isRecordSharedWithPrincipals({+ recordShareGate: {+ recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),+ principalIds: [WORKSPACE_MEMBER_ID],+ },+ recordId: RECORD_IDS.UNSHARED,+ accessLevels: [RecordShareAccessLevel.READ],+ }),+ ).toBe(false);+ });+});diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.tsnew file mode 100644index 00000000000..6c3b714ab9d--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts@@ -0,0 +1,60 @@+import { MetadataReadability } from 'twenty-shared/types';++import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';++describe('resolveRecordShareGateKind', () => {+ it.each([+ {+ readability: MetadataReadability.OPEN,+ isOwningApplication: false,+ expected: 'open',+ },+ {+ readability: MetadataReadability.OPEN,+ isOwningApplication: true,+ expected: 'open',+ },+ {+ readability: MetadataReadability.INHERITED,+ isOwningApplication: false,+ expected: 'open',+ },+ {+ readability: MetadataReadability.SYSTEM,+ isOwningApplication: false,+ expected: 'deny',+ },+ {+ readability: MetadataReadability.SYSTEM,+ isOwningApplication: true,+ expected: 'deny',+ },+ {+ readability: MetadataReadability.APPLICATION,+ isOwningApplication: false,+ expected: 'deny',+ },+ {+ readability: MetadataReadability.APPLICATION,+ isOwningApplication: true,+ expected: 'open',+ },+ {+ readability: MetadataReadability.PRIVATE,+ isOwningApplication: false,+ expected: 'private',+ },+ {+ readability: MetadataReadability.PRIVATE,+ isOwningApplication: true,+ expected: 'open',+ },+ ])(+ 'should resolve $expected for $readability readability when isOwningApplication is $isOwningApplication',+ ({ readability, isOwningApplication, expected }) => {+ expect(+ resolveRecordShareGateKind({ readability, isOwningApplication }),+ ).toBe(expected);+ },+ );+});diff --git a/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.ts b/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.tsnew file mode 100644index 00000000000..954f6d1f4a9--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.ts@@ -0,0 +1,47 @@+import { type MetadataReadability } from 'twenty-shared/types';+import { assertUnreachable } from 'twenty-shared/utils';++import { DENY_ALL_RECORD_SHARE_GATE } from 'src/engine/record-share/constants/deny-all-record-share-gate.constant';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';+import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';++// The share rows are only worth fetching and indexing for a PRIVATE object, so+// the caller hands over how to get them and the gate kind decides whether to ask+export const buildRecordShareGate = async ({+ readability,+ isOwningApplication,+ principalIds,+ fetchRecordSharesByRecordId,+}: {+ readability: MetadataReadability;+ isOwningApplication: boolean;+ principalIds: (string | null | undefined)[];+ fetchRecordSharesByRecordId: () => Promise<Map<string, RecordShare[]>>;+}): Promise<RecordShareGate | null> => {+ const gateKind = resolveRecordShareGateKind({+ readability,+ isOwningApplication,+ });++ switch (gateKind) {+ case 'open':+ return null;+ case 'deny':+ return DENY_ALL_RECORD_SHARE_GATE;+ case 'private':+ return {+ recordSharesByRecordId: await fetchRecordSharesByRecordId(),+ principalIds: [+ ...new Set(+ principalIds.filter(+ (principalId): principalId is string =>+ typeof principalId === 'string',+ ),+ ),+ ],+ };+ default:+ return assertUnreachable(gateKind);+ }+};diff --git a/packages/twenty-server/src/engine/record-share/utils/index-record-shares-by-record-id.util.ts b/packages/twenty-server/src/engine/record-share/utils/index-record-shares-by-record-id.util.tsnew file mode 100644index 00000000000..02f404e2507--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/index-record-shares-by-record-id.util.ts@@ -0,0 +1,24 @@+import { isDefined } from 'twenty-shared/utils';++import { type RecordShare } from 'src/engine/record-share/types/record-share.type';++export const indexRecordSharesByRecordId = (+ recordShares: RecordShare[],+): Map<string, RecordShare[]> => {+ const recordSharesByRecordId = new Map<string, RecordShare[]>();++ for (const recordShare of recordShares) {+ const recordSharesOfRecord = recordSharesByRecordId.get(+ recordShare.recordId,+ );++ if (isDefined(recordSharesOfRecord)) {+ recordSharesOfRecord.push(recordShare);+ continue;+ }++ recordSharesByRecordId.set(recordShare.recordId, [recordShare]);+ }++ return recordSharesByRecordId;+};diff --git a/packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.ts b/packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.tsnew file mode 100644index 00000000000..3084965a296--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/is-record-shared-with-principals.util.ts@@ -0,0 +1,18 @@+import { type RecordShareAccessLevel } from 'twenty-shared/types';++import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';++export const isRecordSharedWithPrincipals = ({+ recordShareGate,+ recordId,+ accessLevels,+}: {+ recordShareGate: RecordShareGate;+ recordId: string;+ accessLevels: RecordShareAccessLevel[];+}): boolean =>+ (recordShareGate.recordSharesByRecordId.get(recordId) ?? []).some(+ (recordShare) =>+ recordShareGate.principalIds.includes(recordShare.principalId) &&+ accessLevels.includes(recordShare.accessLevel),+ );diff --git a/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.ts b/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.tsnew file mode 100644index 00000000000..5a9bb02550a--- /dev/null+++ b/packages/twenty-server/src/engine/record-share/utils/resolve-record-share-gate-kind.util.ts@@ -0,0 +1,26 @@+import { MetadataReadability } from 'twenty-shared/types';+import { assertUnreachable } from 'twenty-shared/utils';++export type RecordShareGateKind = 'open' | 'deny' | 'private';++export const resolveRecordShareGateKind = ({+ readability,+ isOwningApplication,+}: {+ readability: MetadataReadability;+ isOwningApplication: boolean;+}): RecordShareGateKind => {+ switch (readability) {+ case MetadataReadability.OPEN:+ case MetadataReadability.INHERITED:+ return 'open';+ case MetadataReadability.SYSTEM:+ return 'deny';+ case MetadataReadability.APPLICATION:+ return isOwningApplication ? 'open' : 'deny';+ case MetadataReadability.PRIVATE:+ return isOwningApplication ? 'open' : 'private';+ default:+ assertUnreachable(readability);+ }+};diff --git a/packages/twenty-server/src/engine/subscriptions/event-stream.resolver.ts b/packages/twenty-server/src/engine/subscriptions/event-stream.resolver.tsindex ee1782f2bb2..ad07a35c750 100644--- a/packages/twenty-server/src/engine/subscriptions/event-stream.resolver.ts+++ b/packages/twenty-server/src/engine/subscriptions/event-stream.resolver.ts@@ -17,6 +17,7 @@ import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entimport { AuthApiKey } from 'src/engine/decorators/auth/auth-api-key.decorator';import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';+import { AuthWorkspaceMemberId } from 'src/engine/decorators/auth/auth-workspace-member-id.decorator';import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';import { RequestLocale } from 'src/engine/decorators/locale/request-locale.decorator';@@ -73,6 +74,7 @@ export class EventStreamResolver {@AuthUser({ allowUndefined: true }) user: AuthContextUser | undefined,@AuthUserWorkspaceId({ allowUndefined: true })userWorkspaceId: string | undefined,+ @AuthWorkspaceMemberId() workspaceMemberId: string | undefined,@AuthApiKey() apiKey: ApiKeyEntity | undefined,@AuthApplication({ allowUndefined: true })application: FlatApplication | undefined,@@ -113,6 +115,7 @@ export class EventStreamResolver {authContext: {userId: user?.id,userWorkspaceId,+ workspaceMemberId,apiKeyId: apiKey?.id,applicationId: application?.id,},diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.tsindex 0b31f97e170..7be339b1c72 100644--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts@@ -1,10 +1,16 @@import { Test, type TestingModule } from '@nestjs/testing';+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';import {+ FeatureFlagKey,FieldMetadataType,+ MetadataReadability,type ObjectsPermissions,type ObjectsPermissionsByRoleId,type RecordGqlOperationFilter,+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,} from 'twenty-shared/types';import { ProcessNestedRelationsHelper } from 'src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper';@@ -18,6 +24,8 @@ import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-fieldimport { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';import { type EventStreamData } from 'src/engine/subscriptions/types/event-stream-data.type';@@ -93,6 +101,9 @@ describe('ObjectRecordEventPublisher', () => {'getOrRecomputeManyOrAllFlatEntityMaps'>>;+ let mockRecordShareService: jest.Mocked<+ Pick<RecordShareService, 'findByRecordIds'>+ >;const workspaceId = COMPANY_FLAT_OBJECT_MOCK.workspaceId;const streamChannelId = 'test-stream-channel-id';@@ -165,6 +176,7 @@ describe('ObjectRecordEventPublisher', () => {userWorkspaceRoleMap?: Record<string, string>;rolesPermissions?: ObjectsPermissionsByRoleId;flatApplicationMaps?: FlatApplicationCacheMaps;+ featureFlagsMap?: Partial<Record<FeatureFlagKey, boolean>>;};const mockFlatWorkspaceMemberMaps = {@@ -203,6 +215,7 @@ describe('ObjectRecordEventPublisher', () => {byId: {},idByUniversalIdentifier: {},},+ featureFlagsMap: overrides.featureFlagsMap ?? {},});const createCacheMock = (@@ -253,6 +266,10 @@ describe('ObjectRecordEventPublisher', () => {processNestedRelations: jest.fn(),};+ mockRecordShareService = {+ findByRecordIds: jest.fn().mockResolvedValue([]),+ };+mockWorkspaceManyOrAllFlatEntityMapsCacheService = {getOrRecomputeManyOrAllFlatEntityMaps: jest.fn().mockResolvedValue({flatFieldMetadataMaps: mockFlatFieldMetadataMaps,@@ -298,6 +315,10 @@ describe('ObjectRecordEventPublisher', () => {provide: CommonSelectFieldsHelper,useValue: new CommonSelectFieldsHelper(),},+ {+ provide: RecordShareService,+ useValue: mockRecordShareService,+ },],}).compile();@@ -422,6 +443,64 @@ describe('ObjectRecordEventPublisher', () => {).not.toHaveBeenCalled();});+ it('should only publish events of a private object for records shared with the subscriber', async () => {+ const privateObjectMetadata: FlatObjectMetadata = {+ ...companyObjectMetadata,+ readability: MetadataReadability.PRIVATE,+ };++ mockWorkspaceCacheService.getOrRecompute.mockImplementation(+ createCacheMock({+ featureFlagsMap: { [FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true },+ }),+ );++ mockRecordShareService.findByRecordIds.mockResolvedValue([+ {+ id: 'record-share-1',+ recordId: 'record-1',+ objectMetadataId: privateObjectMetadata.id,+ principalId: EVERYONE_PRINCIPAL_ID,+ principalType: RecordSharePrincipalType.EVERYONE,+ accessLevel: RecordShareAccessLevel.READ,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'source-1',+ },+ ] as RecordShare[]);++ const eventBatch: WorkspaceEventBatch<MockObjectRecordEvent> = {+ name: 'company.created',+ workspaceId,+ objectMetadata: privateObjectMetadata,+ events: [+ createMockEvent(),+ createMockEvent({+ recordId: 'record-2',+ properties: { after: { id: 'record-2', name: 'Hidden Company' } },+ }),+ ],+ };++ await service.publish(eventBatch as WorkspaceEventBatch<never>);++ expect(mockRecordShareService.findByRecordIds).toHaveBeenCalledWith({+ workspaceId,+ objectMetadataId: privateObjectMetadata.id,+ recordIds: ['record-1', 'record-2'],+ });++ const publishCall = (+ mockSubscriptionService.publishToEventStream as jest.Mock+ ).mock.calls[0][0];++ expect(+ publishCall.payload.objectRecordEventsWithQueryIds.map(+ (matchedEvent: { objectRecordEvent: { recordId: string } }) =>+ matchedEvent.objectRecordEvent.recordId,+ ),+ ).toEqual(['record-1']);+ });+it('should not publish events when record does not match RLS filter', async () => {(isRecordMatchingRLSRowLevelPermissionPredicate as jest.Mockdiff --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 e5148e96dc4..8f5a1bc4811 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@@ -1,8 +1,12 @@import { Injectable, Logger } from '@nestjs/common';-import { QUERY_MAX_RECORDS_FROM_RELATION } from 'twenty-shared/constants';+import {+ EVERYONE_PRINCIPAL_ID,+ QUERY_MAX_RECORDS_FROM_RELATION,+} from 'twenty-shared/constants';import { type ObjectRecordEvent } from 'twenty-shared/database-events';import {+ FeatureFlagKey,Nullable,ObjectRecord,type ObjectsPermissions,@@ -35,6 +39,13 @@ import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-objectimport { UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map';import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';+import { RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';import { SubscriptionService } from 'src/engine/subscriptions/subscription.service';import {@@ -43,6 +54,7 @@ import {} from 'src/engine/subscriptions/types/event-stream-data.type';import { type EventStreamPayload } from 'src/engine/subscriptions/types/event-stream-payload.type';import { ObjectRecordSubscriptionEvent } from 'src/engine/subscriptions/types/object-record-subscription-event.type';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';import { buildRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/build-row-level-permission-record-filter.util';import { computePermissionIntersection } from 'src/engine/twenty-orm/utils/compute-permission-intersection.util';@@ -59,6 +71,7 @@ type StreamPermissionsContext = {userWorkspaceRoleMap: UserWorkspaceRoleMap;rolesPermissions: ObjectsPermissionsByRoleId;flatApplicationMaps: FlatApplicationCacheMaps;+ featureFlagsMap: Record<FeatureFlagKey, boolean>;};@Injectable()@@ -72,6 +85,7 @@ export class ObjectRecordEventPublisher {private readonly processNestedRelationsHelper: ProcessNestedRelationsHelper,private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,private readonly commonSelectFieldsHelper: CommonSelectFieldsHelper,+ private readonly recordShareService: RecordShareService,) {}async publish(@@ -94,6 +108,15 @@ export class ObjectRecordEventPublisher {const { permissionsContext, flatWorkspaceMemberMaps } =await this.fetchObjectRecordStreamContext(workspaceId);+ const workspaceMemberIdByUserId = this.buildWorkspaceMemberIdByUserId(+ flatWorkspaceMemberMaps,+ );++ const recordSharesByRecordId = await this.fetchRecordSharesByRecordId({+ workspaceEventBatch: eventBatch,+ featureFlagsMap: permissionsContext.featureFlagsMap,+ });+const streamIdsToRemove: string[] = [];for (const [streamChannelId, streamData] of streamsData) {@@ -112,6 +135,8 @@ export class ObjectRecordEventPublisher {workspaceEventBatch: eventBatch,permissionsContext,flatWorkspaceMemberMaps,+ workspaceMemberIdByUserId,+ recordSharesByRecordId,});}@@ -131,18 +156,48 @@ export class ObjectRecordEventPublisher {return { permissionsContext, flatWorkspaceMemberMaps };}+ private async fetchRecordSharesByRecordId({+ workspaceEventBatch,+ featureFlagsMap,+ }: {+ workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;+ featureFlagsMap: Record<FeatureFlagKey, boolean>;+ }): Promise<Map<string, RecordShare[]>> {+ if (+ !featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED] ||+ resolveRecordShareGateKind({+ readability: workspaceEventBatch.objectMetadata.readability,+ isOwningApplication: false,+ }) !== 'private'+ ) {+ return new Map();+ }++ return indexRecordSharesByRecordId(+ await this.recordShareService.findByRecordIds({+ workspaceId: workspaceEventBatch.workspaceId,+ objectMetadataId: workspaceEventBatch.objectMetadata.id,+ recordIds: workspaceEventBatch.events.map((event) => event.recordId),+ }),+ );+ }+private async processObjectRecordStreamEvents({streamChannelId,streamData,workspaceEventBatch,permissionsContext,flatWorkspaceMemberMaps,+ workspaceMemberIdByUserId,+ recordSharesByRecordId,}: {streamChannelId: string;streamData: EventStreamData;workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;permissionsContext: StreamPermissionsContext;flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps;+ workspaceMemberIdByUserId: Map<string, string>;+ recordSharesByRecordId: Map<string, RecordShare[]>;}): Promise<void> {const roleIds = this.resolveStreamRoleIds(streamData.authContext,@@ -176,14 +231,32 @@ export class ObjectRecordEventPublisher {const objectNameSingular = workspaceEventBatch.objectMetadata.nameSingular;+ const subscriberAuthContext: SerializableAuthContext = {+ ...streamData.authContext,+ workspaceMemberId: this.resolveSubscriberWorkspaceMemberId({+ subscriberAuthContext: streamData.authContext,+ workspaceMemberIdByUserId,+ }),+ };+const subscriberRLSFilter = this.buildSubscriberRLSFilter(- streamData.authContext,+ subscriberAuthContext,roleIds,workspaceEventBatch.objectMetadata,permissionsContext,flatWorkspaceMemberMaps,);+ const subscriberRecordShareGate = await this.buildSubscriberRecordShareGate(+ {+ subscriberAuthContext,+ roleIds,+ objectMetadata: workspaceEventBatch.objectMetadata,+ featureFlagsMap: permissionsContext.featureFlagsMap,+ recordSharesByRecordId,+ },+ );+const restrictedFields = objectPermissions.restrictedFields;for (const event of workspaceEventBatch.events) {@@ -212,13 +285,24 @@ export class ObjectRecordEventPublisher {continue;}- const matchedQueryIds = this.getMatchingObjectRecordQueryIds(- streamData.queries,- filteredEvent,+ if (+ isDefined(subscriberRecordShareGate) &&+ !isRecordSharedWithPrincipals({+ recordShareGate: subscriberRecordShareGate,+ recordId: filteredEvent.recordId,+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),+ })+ ) {+ continue;+ }++ const matchedQueryIds = this.getMatchingObjectRecordQueryIds({+ queries: streamData.queries,+ event: filteredEvent,subscriberRLSFilter,- workspaceEventBatch.objectMetadata,- permissionsContext.flatFieldMetadataMaps,- );+ objectMetadata: workspaceEventBatch.objectMetadata,+ flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,+ });if (matchedQueryIds.length === 0) {continue;@@ -428,6 +512,81 @@ export class ObjectRecordEventPublisher {});}+ private buildWorkspaceMemberIdByUserId(+ flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps,+ ): Map<string, string> {+ const workspaceMemberIdByUserId = new Map<string, string>();++ for (const flatWorkspaceMember of Object.values(+ flatWorkspaceMemberMaps.byId,+ )) {+ if (+ !isDefined(flatWorkspaceMember) ||+ isDefined(flatWorkspaceMember.deletedAt) ||+ !isDefined(flatWorkspaceMember.userId)+ ) {+ continue;+ }++ workspaceMemberIdByUserId.set(+ flatWorkspaceMember.userId,+ flatWorkspaceMember.id,+ );+ }++ return workspaceMemberIdByUserId;+ }++ // A stream created before the member id was stored only carries the user id+ private resolveSubscriberWorkspaceMemberId({+ subscriberAuthContext,+ workspaceMemberIdByUserId,+ }: {+ subscriberAuthContext: SerializableAuthContext;+ workspaceMemberIdByUserId: Map<string, string>;+ }): string | undefined {+ if (isDefined(subscriberAuthContext.workspaceMemberId)) {+ return subscriberAuthContext.workspaceMemberId;+ }++ if (!isDefined(subscriberAuthContext.userId)) {+ return undefined;+ }++ return workspaceMemberIdByUserId.get(subscriberAuthContext.userId);+ }++ private async buildSubscriberRecordShareGate({+ subscriberAuthContext,+ roleIds,+ objectMetadata,+ featureFlagsMap,+ recordSharesByRecordId,+ }: {+ subscriberAuthContext: SerializableAuthContext;+ roleIds: string[];+ objectMetadata: FlatObjectMetadata;+ featureFlagsMap: Record<FeatureFlagKey, boolean>;+ recordSharesByRecordId: Map<string, RecordShare[]>;+ }): Promise<RecordShareGate | null> {+ if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {+ return null;+ }++ return buildRecordShareGate({+ readability: objectMetadata.readability,+ isOwningApplication:+ isDefined(objectMetadata.applicationId) &&+ subscriberAuthContext.applicationId === objectMetadata.applicationId,+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ subscriberAuthContext.workspaceMemberId,+ ...roleIds,+ ],+ fetchRecordSharesByRecordId: async () => recordSharesByRecordId,+ });+ }+private filterRestrictedFieldsFromEvent(event: ObjectRecordSubscriptionEvent,restrictedFields: RestrictedFieldsPermissions | undefined,@@ -494,13 +653,19 @@ export class ObjectRecordEventPublisher {} as ObjectRecordSubscriptionEvent;}- private getMatchingObjectRecordQueryIds(- queries: Record<string, RecordOrMetadataGqlOperationSignature>,- event: ObjectRecordSubscriptionEvent,- subscriberRLSFilter: RecordGqlOperationFilter | null,- objectMetadata: FlatObjectMetadata,- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>,- ): string[] {+ private getMatchingObjectRecordQueryIds({+ queries,+ event,+ subscriberRLSFilter,+ objectMetadata,+ flatFieldMetadataMaps,+ }: {+ queries: Record<string, RecordOrMetadataGqlOperationSignature>;+ event: ObjectRecordSubscriptionEvent;+ subscriberRLSFilter: RecordGqlOperationFilter | null;+ objectMetadata: FlatObjectMetadata;+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;+ }): string[] {const matchedQueryIds: string[] = [];for (const [queryId, operationSignature] of Object.entries(queries)) {@@ -509,13 +674,13 @@ export class ObjectRecordEventPublisher {}if (- this.isQueryMatchingObjectRecordEvent(+ this.isQueryMatchingObjectRecordEvent({operationSignature,event,subscriberRLSFilter,objectMetadata,flatFieldMetadataMaps,- )+ })) {matchedQueryIds.push(queryId);}@@ -524,13 +689,19 @@ export class ObjectRecordEventPublisher {return matchedQueryIds;}- private isQueryMatchingObjectRecordEvent(- operationSignature: RecordGqlOperationSignature,- event: ObjectRecordSubscriptionEvent,- subscriberRLSFilter: RecordGqlOperationFilter | null,- objectMetadata: FlatObjectMetadata,- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>,- ): boolean {+ private isQueryMatchingObjectRecordEvent({+ operationSignature,+ event,+ subscriberRLSFilter,+ objectMetadata,+ flatFieldMetadataMaps,+ }: {+ operationSignature: RecordGqlOperationSignature;+ event: ObjectRecordSubscriptionEvent;+ subscriberRLSFilter: RecordGqlOperationFilter | null;+ objectMetadata: FlatObjectMetadata;+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;+ }): boolean {if (operationSignature.objectNameSingular !== event.objectNameSingular) {return false;}@@ -596,6 +767,7 @@ export class ObjectRecordEventPublisher {userWorkspaceRoleMap,rolesPermissions,flatApplicationMaps,+ featureFlagsMap,} = await this.workspaceCacheService.getOrRecompute(workspaceId, ['flatRowLevelPermissionPredicateMaps','flatRowLevelPermissionPredicateGroupMaps',@@ -603,6 +775,7 @@ export class ObjectRecordEventPublisher {'userWorkspaceRoleMap','rolesPermissions','flatApplicationMaps',+ 'featureFlagsMap',]);return {@@ -612,6 +785,7 @@ export class ObjectRecordEventPublisher {userWorkspaceRoleMap,rolesPermissions,flatApplicationMaps,+ featureFlagsMap,};}}diff --git a/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts b/packages/twenty-server/src/engine/subscriptions/subscriptions.module.tsindex 48827647186..ee48293461f 100644--- a/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts+++ b/packages/twenty-server/src/engine/subscriptions/subscriptions.module.ts@@ -12,6 +12,7 @@ import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entimport { ApplicationTranslationCatalogModule } from 'src/engine/metadata-modules/application-translation-catalog/application-translation-catalog.module';import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';import { NavigationMenuItemModule } from 'src/engine/metadata-modules/navigation-menu-item/navigation-menu-item.module';+import { RecordShareModule } from 'src/engine/record-share/record-share.module';import { EventStreamResolver } from 'src/engine/subscriptions/event-stream.resolver';import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';import { MetadataEventEmitter } from 'src/engine/subscriptions/metadata-event/metadata-event-emitter';@@ -37,6 +38,7 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cacheNavigationMenuItemModule,I18nModule,ApplicationTranslationCatalogModule,+ RecordShareModule,],providers: [SubscriptionService,diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.tsindex aa154db8c0b..ef58fa10810 100644--- a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/automated-trigger.module.ts@@ -5,6 +5,7 @@ import { CacheStorageModule } from 'src/engine/core-modules/cache-storage/cache-import { CronModule } from 'src/engine/core-modules/cron/cron.module';import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';+import { RecordShareModule } from 'src/engine/record-share/record-share.module';import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';import { WorkflowCommonModule } from 'src/modules/workflow/common/workflow-common.module';@@ -19,6 +20,7 @@ import { WorkflowDatabaseEventTriggerListener } from 'src/modules/workflow/workfCacheStorageModule,CronModule,FeatureFlagModule,+ RecordShareModule,WorkflowCommonModule,WorkspaceCacheModule,WorkspaceDataSourceModule,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 6e5df706c3a..620ed915b98 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@@ -1,7 +1,18 @@import { Test, type TestingModule } from '@nestjs/testing';+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';+import type { ObjectRecordUpdateEvent } from 'twenty-shared/database-events';+import {+ FeatureFlagKey,+ MetadataReadability,+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';+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 { 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';@@ -15,11 +26,13 @@ describe('WorkflowDatabaseEventTriggerListener', () => {let workspaceOrmManager: jest.Mocked<WorkspaceOrmManager>;let messageQueueService: jest.Mocked<MessageQueueService>;let workspaceCacheService: jest.Mocked<WorkspaceCacheService>;+ let recordShareService: jest.Mocked<RecordShareService>;const setTriggerMap = (listeners: Array<{ workflowId: string; settings: object; type?: unknown }>,) => {workspaceCacheService.getOrRecompute.mockResolvedValue({+ featureFlagsMap: {},workflowAutomatedTriggerMaps: {byWorkflowId: Object.fromEntries(listeners.map((listener) => [@@ -78,10 +91,15 @@ describe('WorkflowDatabaseEventTriggerListener', () => {workspaceCacheService = {getOrRecompute: jest.fn().mockResolvedValue({+ featureFlagsMap: {},workflowAutomatedTriggerMaps: { byWorkflowId: {} },} as never),} as any;+ recordShareService = {+ findByRecordIds: jest.fn().mockResolvedValue([]),+ } as unknown as jest.Mocked<RecordShareService>;+const module: TestingModule = await Test.createTestingModule({providers: [WorkflowDatabaseEventTriggerListener,@@ -97,6 +115,10 @@ describe('WorkflowDatabaseEventTriggerListener', () => {provide: WorkspaceCacheService,useValue: workspaceCacheService,},+ {+ provide: RecordShareService,+ useValue: recordShareService,+ },{provide: 'MESSAGE_QUEUE_workflow-queue',useValue: messageQueueService,@@ -335,6 +357,130 @@ describe('WorkflowDatabaseEventTriggerListener', () => {);});+ it('should only trigger workflow for records of a private object shared with the workflow role', async () => {+ const applicationRoleId = 'application-role-id';+ const applicationId = 'twenty-standard-application-id';++ const privatePayload: WorkspaceEventBatch<ObjectRecordUpdateEvent> = {+ ...mockPayload,+ objectMetadata: createMockFlatObjectMetadata({+ readability: MetadataReadability.PRIVATE,+ }),+ events: [+ mockPayload.events[0],+ { ...mockPayload.events[0], recordId: 'test-record-2' },+ ],+ };++ workspaceCacheService.getOrRecompute.mockImplementation(((+ _workspaceId: string,+ keys: string[],+ ) =>+ Promise.resolve(+ keys.includes('featureFlagsMap')+ ? {+ featureFlagsMap: {+ [FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true,+ },+ flatApplicationMaps: {+ byId: {+ [applicationId]: {+ id: applicationId,+ defaultRoleId: applicationRoleId,+ },+ },+ idByUniversalIdentifier: {+ [TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER]:+ applicationId,+ },+ },+ flatRoleMaps: { byUniversalIdentifier: {} },+ }+ : {+ workflowAutomatedTriggerMaps: {+ byWorkflowId: {+ [workflowId]: {+ type: AutomatedTriggerType.DATABASE_EVENT,+ coreWorkflowVersionId: `core-version-${workflowId}`,+ workspaceWorkflowVersionId: `workspace-version-${workflowId}`,+ workflowId,+ settings: { eventName: databaseEventName },+ },+ },+ },+ },+ )) as never);++ recordShareService.findByRecordIds.mockResolvedValue([+ {+ id: 'record-share-1',+ recordId: 'test-record-2',+ objectMetadataId: privatePayload.objectMetadata.id,+ principalId: applicationRoleId,+ principalType: RecordSharePrincipalType.ROLE,+ accessLevel: RecordShareAccessLevel.READ,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId: 'source-1',+ },+ ]);++ await listener.handleObjectRecordUpdateEvent(privatePayload);++ expect(recordShareService.findByRecordIds).toHaveBeenCalledWith({+ workspaceId,+ objectMetadataId: privatePayload.objectMetadata.id,+ recordIds: ['test-record', 'test-record-2'],+ });+ expect(messageQueueService.add).toHaveBeenCalledTimes(1);+ expect(messageQueueService.add).toHaveBeenCalledWith(+ WorkflowTriggerJob.name,+ expect.objectContaining({ payload: privatePayload.events[1] }),+ { retryLimit: 3 },+ );+ });++ it('should not trigger workflow for records of a system object even when no role can be resolved', async () => {+ const systemPayload: WorkspaceEventBatch<ObjectRecordUpdateEvent> = {+ ...mockPayload,+ objectMetadata: createMockFlatObjectMetadata({+ readability: MetadataReadability.SYSTEM,+ }),+ };++ workspaceCacheService.getOrRecompute.mockImplementation(((+ _workspaceId: string,+ keys: string[],+ ) =>+ Promise.resolve(+ keys.includes('featureFlagsMap')+ ? {+ featureFlagsMap: {+ [FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true,+ },+ flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },+ flatRoleMaps: { byUniversalIdentifier: {} },+ }+ : {+ workflowAutomatedTriggerMaps: {+ byWorkflowId: {+ [workflowId]: {+ type: AutomatedTriggerType.DATABASE_EVENT,+ coreWorkflowVersionId: `core-version-${workflowId}`,+ workspaceWorkflowVersionId: `workspace-version-${workflowId}`,+ workflowId,+ settings: { eventName: databaseEventName },+ },+ },+ },+ },+ )) as never);++ await listener.handleObjectRecordUpdateEvent(systemPayload);++ expect(recordShareService.findByRecordIds).not.toHaveBeenCalled();+ expect(messageQueueService.add).not.toHaveBeenCalled();+ });+it('should handle multiple events in a batch', async () => {const batchPayload: WorkspaceEventBatch<any> = {...mockPayload,diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.tsindex 2ccd5dea26e..7caaf116f28 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@@ -1,5 +1,7 @@import { Injectable, Logger } from '@nestjs/common';+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';import {ObjectRecordEvent,type ObjectRecordCreateEvent,@@ -8,24 +10,33 @@ import {type ObjectRecordUpdateEvent,type ObjectRecordUpsertEvent,} from 'twenty-shared/database-events';-import { type ObjectRecord } from 'twenty-shared/types';+import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';import { TRIGGER_STEP_ID } from 'twenty-shared/workflow';import { In } from 'typeorm';import { OnDatabaseBatchEvent } from 'src/engine/api/graphql/graphql-query-runner/decorators/on-database-batch-event.decorator';import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';+import { findActiveFlatApplicationByUniversalIdentifier } from 'src/engine/core-modules/application/utils/find-active-flat-application-by-universal-identifier.util';import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.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 { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';+import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { buildRecordShareGate } from 'src/engine/record-share/utils/build-record-share-gate.util';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';+import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';import { isCachedDatabaseEventTrigger } from 'src/engine/core-modules/workflow/utils/cached-workflow-automated-trigger.util';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';@@ -65,6 +76,7 @@ export class WorkflowDatabaseEventTriggerListener {private readonly messageQueueService: MessageQueueService,private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly recordShareService: RecordShareService,) {}@OnDatabaseBatchEvent('*', DatabaseEventAction.CREATED)@@ -353,12 +365,19 @@ export class WorkflowDatabaseEventTriggerListener {databaseEventName,);+ if (eventListeners.length === 0) {+ return;+ }++ const recordShareGate = await this.buildRecordShareGate(payload);+for (const eventListener of eventListeners) {for (const eventPayload of payload.events) {const shouldTriggerJob = this.shouldTriggerJob({eventPayload,eventListener,action,+ recordShareGate,});if (shouldTriggerJob) {@@ -395,17 +414,79 @@ export class WorkflowDatabaseEventTriggerListener {);}+ private async buildRecordShareGate(+ payload: WorkspaceEventBatch<ObjectRecordEvent>,+ ): Promise<RecordShareGate | null> {+ const { featureFlagsMap, flatApplicationMaps, flatRoleMaps } =+ await this.workspaceCacheService.getOrRecompute(payload.workspaceId, [+ 'featureFlagsMap',+ 'flatApplicationMaps',+ 'flatRoleMaps',+ ]);++ if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {+ return null;+ }++ const standardApplication = findActiveFlatApplicationByUniversalIdentifier(+ flatApplicationMaps,+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,+ );++ return buildRecordShareGate({+ readability: payload.objectMetadata.readability,+ isOwningApplication:+ isDefined(standardApplication) &&+ payload.objectMetadata.applicationId === standardApplication.id,+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ standardApplication?.defaultRoleId ??+ findFlatEntityByUniversalIdentifier({+ flatEntityMaps: flatRoleMaps,+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,+ })?.id,+ ],+ fetchRecordSharesByRecordId: async () =>+ indexRecordSharesByRecordId(+ await this.recordShareService.findByRecordIds({+ workspaceId: payload.workspaceId,+ objectMetadataId: payload.objectMetadata.id,+ recordIds: payload.events.map((event) => event.recordId),+ }),+ ),+ });+ }+private shouldTriggerJob({eventPayload,eventListener,action,- }: TriggerEvaluationArgs) {+ recordShareGate,+ }: TriggerEvaluationArgs & { recordShareGate: RecordShareGate | null }) {return (this.eventMatchesWatchedFields({ eventPayload, eventListener, action }) &&- this.eventMatchesRecordFilter({ eventPayload, eventListener })+ this.eventMatchesRecordFilter({ eventPayload, eventListener }) &&+ this.eventMatchesRecordShare({ eventPayload, recordShareGate }));}+ private eventMatchesRecordShare({+ eventPayload,+ recordShareGate,+ }: Pick<TriggerEvaluationArgs, 'eventPayload'> & {+ recordShareGate: RecordShareGate | null;+ }) {+ if (!isDefined(recordShareGate)) {+ return true;+ }++ return isRecordSharedWithPrincipals({+ recordShareGate,+ recordId: eventPayload.recordId,+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),+ });+ }+private eventMatchesWatchedFields({eventPayload,eventListener,diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.tsnew file mode 100644index 00000000000..97600c3fa1e--- /dev/null+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-twin-object-records-permissions.integration-spec.ts@@ -0,0 +1,330 @@+import { randomUUID } from 'node:crypto';++import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';+import { makeGraphqlAPIRequestWithApiKey } from 'test/integration/graphql/utils/make-graphql-api-request-with-api-key.util';+import { makeGraphqlAPIRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';+import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';+import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';+import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';+import {+ FeatureFlagKey,+ FieldMetadataType,+ MetadataReadability,+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';+import { capitalize } from 'twenty-shared/utils';++import { type RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';+import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';+import { isRecordSharedWithPrincipals } from 'src/engine/record-share/utils/is-record-shared-with-principals.util';+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';++const OBJECT_SINGULAR = 'recordShareTwinObject';+const OBJECT_PLURAL = 'recordShareTwinObjects';+const UPDATE_RESPONSE_KEY = `update${capitalize(OBJECT_PLURAL)}`;+const RECORD_GQL_FIELDS = `+ id+ name+`;++const RECORD_IDS = {+ SHARED_READ_WITH_JONY: randomUUID(),+ SHARED_READ_WRITE_WITH_MEMBER_ROLE: randomUUID(),+ SHARED_FULL_WITH_EVERYONE: randomUUID(),+ SHARED_FULL_WITH_ADMIN_ROLE: randomUUID(),+ UNSHARED: randomUUID(),+};++const ALL_RECORD_IDS = Object.values(RECORD_IDS);+const ALL_RECORDS_FILTER = { id: { in: ALL_RECORD_IDS } };++const collectIds = (edges: { node: { id: string } }[]): string[] =>+ edges.map((edge) => edge.node.id).sort();++const collectRecordIds = (records: { id: string }[]): string[] =>+ records.map((record) => record.id).sort();++const findManyOperation = findManyOperationFactory({+ objectMetadataSingularName: OBJECT_SINGULAR,+ objectMetadataPluralName: OBJECT_PLURAL,+ gqlFields: RECORD_GQL_FIELDS,+ filter: ALL_RECORDS_FILTER,+});++const setRecordSharingEnabled = (value: boolean) =>+ updateFeatureFlag({+ featureFlag: FeatureFlagKey.IS_RECORD_SHARING_ENABLED,+ value,+ expectToFail: false,+ });++describe('recordShareTwinObjectRecordsPermissions', () => {+ let recordShareService: RecordShareService;+ let objectMetadataId: string;+ let recordShares: RecordShare[];+ let memberRoleId: string;+ let adminRoleId: string;++ const sourceId = randomUUID();++ const recordIdsSharedInMemory = ({+ principalIds,+ operationType,+ }: {+ principalIds: string[];+ operationType: 'select' | 'update';+ }) =>+ ALL_RECORD_IDS.filter((recordId) =>+ isRecordSharedWithPrincipals({+ recordShareGate: {+ recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),+ principalIds,+ },+ recordId,+ accessLevels: resolveRequiredRecordShareAccessLevels(operationType),+ }),+ ).sort();++ beforeAll(async () => {+ recordShareService =+ getAppProviderByClassName<RecordShareService>('RecordShareService');++ const { data } = await createOneObjectMetadata({+ input: {+ nameSingular: OBJECT_SINGULAR,+ namePlural: OBJECT_PLURAL,+ labelSingular: 'Record Share Twin Object',+ labelPlural: 'Record Share Twin Objects',+ icon: 'IconLock',+ isLabelSyncedWithName: false,+ },+ });++ objectMetadataId = data.createOneObject.id;++ await createOneFieldMetadata({+ input: {+ name: 'name',+ label: 'Name',+ type: FieldMetadataType.TEXT,+ objectMetadataId,+ isLabelSyncedWithName: false,+ },+ });++ for (const [name, id] of Object.entries(RECORD_IDS)) {+ const response = await makeGraphqlAPIRequest(+ createOneOperationFactory({+ objectMetadataSingularName: OBJECT_SINGULAR,+ gqlFields: RECORD_GQL_FIELDS,+ data: { id, name },+ }),+ );++ expect(response.body.errors).toBeUndefined();+ }++ memberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;+ adminRoleId = (await findOneRoleByLabel({ label: 'Admin' })).id;++ const buildRecordShare = ({+ recordId,+ principalId,+ principalType,+ accessLevel,+ }: {+ recordId: string;+ principalId: string;+ principalType: RecordSharePrincipalType;+ accessLevel: RecordShareAccessLevel;+ }) => ({+ recordId,+ objectMetadataId,+ principalId,+ principalType,+ accessLevel,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId,+ });++ await recordShareService.insertMany({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ recordShares: [+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_READ_WITH_JONY,+ principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,+ accessLevel: RecordShareAccessLevel.READ,+ }),+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,+ principalId: memberRoleId,+ principalType: RecordSharePrincipalType.ROLE,+ accessLevel: RecordShareAccessLevel.READ_WRITE,+ }),+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ principalId: EVERYONE_PRINCIPAL_ID,+ principalType: RecordSharePrincipalType.EVERYONE,+ accessLevel: RecordShareAccessLevel.FULL,+ }),+ buildRecordShare({+ recordId: RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,+ principalId: adminRoleId,+ principalType: RecordSharePrincipalType.ROLE,+ accessLevel: RecordShareAccessLevel.FULL,+ }),+ ],+ });++ recordShares = await recordShareService.findByRecordIds({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ objectMetadataId,+ recordIds: ALL_RECORD_IDS,+ });++ await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);+ await setRecordSharingEnabled(true);+ });++ afterAll(async () => {+ await setRecordSharingEnabled(false);+ await recordShareService.deleteBySourceId({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ sourceId,+ });+ await setObjectReadability(objectMetadataId, MetadataReadability.OPEN);+ await makeGraphqlAPIRequest(+ destroyManyOperationFactory({+ objectMetadataSingularName: OBJECT_SINGULAR,+ objectMetadataPluralName: OBJECT_PLURAL,+ gqlFields: 'id',+ filter: ALL_RECORDS_FILTER,+ }),+ );+ await updateOneObjectMetadata({+ expectToFail: false,+ input: {+ idToUpdate: objectMetadataId,+ updatePayload: { isActive: false },+ },+ });+ await deleteOneObjectMetadata({+ input: { idToDelete: objectMetadataId },+ });+ });++ it('should fetch one row per share of the batch', () => {+ expect(recordShares).toHaveLength(4);+ expect(+ recordShares.every(+ (recordShare) => recordShare.objectMetadataId === objectMetadataId,+ ),+ ).toBe(true);+ });++ it('should read the same records in memory as the SQL gate for the admin', async () => {+ const response = await makeGraphqlAPIRequest(findManyOperation);++ expect(response.body.errors).toBeUndefined();+ expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(+ recordIdsSharedInMemory({+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,+ adminRoleId,+ ],+ operationType: 'select',+ }),+ );+ });++ it('should read the same records in memory as the SQL gate for the member', async () => {+ const response =+ await makeGraphqlAPIRequestWithMemberRole(findManyOperation);++ expect(response.body.errors).toBeUndefined();++ const readRecordIds = collectIds(response.body.data[OBJECT_PLURAL].edges);++ expect(readRecordIds).toEqual(+ [+ RECORD_IDS.SHARED_READ_WITH_JONY,+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ ].sort(),+ );+ expect(readRecordIds).toEqual(+ recordIdsSharedInMemory({+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ memberRoleId,+ ],+ operationType: 'select',+ }),+ );+ });++ it('should read the same records in memory as the SQL gate for the api key', async () => {+ const response = await makeGraphqlAPIRequestWithApiKey(findManyOperation);++ expect(response.body.errors).toBeUndefined();+ expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(+ recordIdsSharedInMemory({+ principalIds: [EVERYONE_PRINCIPAL_ID, adminRoleId],+ operationType: 'select',+ }),+ );+ });++ it('should update the same records in memory as the SQL gate for the member', async () => {+ const response = await makeGraphqlAPIRequestWithMemberRole(+ updateManyOperationFactory({+ objectMetadataSingularName: OBJECT_SINGULAR,+ objectMetadataPluralName: OBJECT_PLURAL,+ gqlFields: RECORD_GQL_FIELDS,+ data: { name: 'updated by member' },+ filter: ALL_RECORDS_FILTER,+ }),+ );++ expect(response.body.errors).toBeUndefined();++ const updatedRecordIds = collectRecordIds(+ response.body.data[UPDATE_RESPONSE_KEY],+ );++ expect(updatedRecordIds).toEqual(+ [+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,+ ].sort(),+ );+ expect(updatedRecordIds).toEqual(+ recordIdsSharedInMemory({+ principalIds: [+ EVERYONE_PRINCIPAL_ID,+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ memberRoleId,+ ],+ operationType: 'update',+ }),+ );+ });+});