Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
index 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-funct
import { 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-cache
WorkspaceDomainsModule,
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.ts
index 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.ts
index 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/proces
import { 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.ts
index 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/webho
import { 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-cache
FeatureFlagModule,
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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ent
import { 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.ts
index 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-field
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { 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.Mock
diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
index 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-object
import { UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map';
import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';
import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';
+import { 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.ts
index 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.ent
import { 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-cache
NavigationMenuItemModule,
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.ts
index 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/workf
CacheStorageModule,
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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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',
+ }),
+ );
+ });
+});