Skip to content

The open alternative to Salesforce, designed for AI.

[1/5] Enforce SYSTEM record visibility for event delivery (#26244)

Félix Malfait367c62f1f20a
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/__tests__/record-access-policy.service.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/__tests__/record-access-policy.service.spec.ts
new file mode 100644
index 00000000000..a3d6a79846a
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/__tests__/record-access-policy.service.spec.ts
@@ -0,0 +1,63 @@
+import { Test } from '@nestjs/testing';
+import { MetadataReadability } from 'twenty-shared/types';
+
+import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
+import { RecordShareService } from 'src/engine/core-modules/record-share/services/record-share.service';
+import { RecordSharingFeatureService } from 'src/engine/core-modules/record-share/services/record-sharing-feature.service';
+import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+describe('mandatory event visibility', () => {
+ it.each([
+ [false, false],
+ [false, true],
+ [true, false],
+ [true, true],
+ ])(
+ 'denies SYSTEM records with sharing=%s and owning application=%s',
+ async (sharingEnabled, owningApplication) => {
+ const module = await Test.createTestingModule({
+ providers: [
+ RecordAccessPolicyService,
+ { provide: WorkspaceOrmManager, useValue: {} },
+ { provide: WorkspaceCacheService, useValue: {} },
+ { provide: RecordShareService, useValue: {} },
+ {
+ provide: RecordSharingFeatureService,
+ useValue: {
+ isRecordSharingEnabled: jest
+ .fn()
+ .mockResolvedValue(sharingEnabled),
+ },
+ },
+ ],
+ }).compile();
+ const service = module.get(RecordAccessPolicyService);
+ const gate = service.buildEventRecordAccessGate({
+ name: 'company.created',
+ workspaceId: COMPANY_FLAT_OBJECT_MOCK.workspaceId,
+ objectMetadata: {
+ ...COMPANY_FLAT_OBJECT_MOCK,
+ readability: MetadataReadability.SYSTEM,
+ },
+ events: [
+ {
+ recordId: 'private-record',
+ properties: { after: { id: 'private-record' } },
+ },
+ ],
+ });
+
+ expect(
+ await gate.resolveAdmittedRecordIds({
+ objectsPermissions: undefined,
+ principalIds: ['everyone'],
+ isOwningApplication: () => owningApplication,
+ resolveRowLevelPermissionRecordFilter: () => null,
+ }),
+ ).toEqual(new Set());
+ await module.close();
+ },
+ );
+});
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts
index 4e150964bbc..c009d4d1b69 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts
@@ -46,6 +46,7 @@ type SnapshotEvaluation = {
subject: RowAccessPolicySubject;
depth: number;
maps?: ReadabilityMaps;
+ isRecordSharingEnabled?: boolean;
};
type SnapshotEvaluationInContext = SnapshotEvaluation & {
@@ -98,12 +99,15 @@ export class RecordAccessPolicyService {
return new Set();
}
- if (!(await fetchIsRecordSharingEnabled())) {
- return new Set(snapshots.map((snapshot) => snapshot.id));
- }
-
return this.resolveSnapshotIdsAdmittedByRecordShareGate(
- { workspaceId, objectMetadata, snapshots, subject, depth: 0 },
+ {
+ workspaceId,
+ objectMetadata,
+ snapshots,
+ subject,
+ depth: 0,
+ isRecordSharingEnabled: await fetchIsRecordSharingEnabled(),
+ },
fetchRecordShares,
);
},
@@ -166,8 +170,14 @@ export class RecordAccessPolicyService {
fetchRecordShares: FetchRecordShares,
): Promise<Set<string>> {
const { objectMetadata, snapshots, subject } = evaluation;
+ const resolvedIsRecordSharingEnabled =
+ evaluation.isRecordSharingEnabled ??
+ (await this.recordSharingFeatureService.isRecordSharingEnabled(
+ evaluation.workspaceId,
+ ));
const gateKind = resolveRecordShareGateKind({
readability: objectMetadata.readability,
+ isRecordSharingEnabled: resolvedIsRecordSharingEnabled,
isOwningApplication: subject.isOwningApplication(objectMetadata),
});
@@ -187,7 +197,10 @@ export class RecordAccessPolicyService {
evaluation,
fetchRecordShares,
)),
- ...(await this.resolveSnapshotIdsReadableThroughParents(evaluation)),
+ ...(await this.resolveSnapshotIdsReadableThroughParents({
+ ...evaluation,
+ isRecordSharingEnabled: resolvedIsRecordSharingEnabled,
+ })),
]);
default:
return assertUnreachable(gateKind);
@@ -301,6 +314,7 @@ export class RecordAccessPolicyService {
depth,
maps,
parent,
+ isRecordSharingEnabled,
}: SnapshotEvaluationInContext & {
parent: InheritedReadabilityChildrenParent;
}): Promise<Set<string>> {
@@ -360,6 +374,7 @@ export class RecordAccessPolicyService {
workspaceId,
objectMetadata: parent.childFlatObjectMetadata,
snapshots: [...capturedChildSnapshotsBySnapshotId.values()].flat(),
+ isRecordSharingEnabled,
subject,
depth: depth + 1,
maps,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts
index f6fb0a6e267..1aeb62cbf78 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-share-gate-kind.util.spec.ts
@@ -5,6 +5,20 @@ import { MetadataReadability } from 'twenty-shared/types';
import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';
describe('resolveRecordShareGateKind', () => {
+ it.each(Object.values(MetadataReadability))(
+ 'enforces %s without the sharing entitlement',
+ (readability) => {
+ for (const isOwningApplication of [true, false]) {
+ expect(
+ resolveRecordShareGateKind({
+ readability,
+ isOwningApplication,
+ isRecordSharingEnabled: false,
+ }),
+ ).toBe(readability === MetadataReadability.SYSTEM ? 'deny' : 'open');
+ }
+ },
+ );
it.each([
{
readability: MetadataReadability.OPEN,
@@ -60,7 +74,11 @@ describe('resolveRecordShareGateKind', () => {
'should resolve $expected for $readability readability when isOwningApplication is $isOwningApplication',
({ readability, isOwningApplication, expected }) => {
expect(
- resolveRecordShareGateKind({ readability, isOwningApplication }),
+ resolveRecordShareGateKind({
+ readability,
+ isOwningApplication,
+ isRecordSharingEnabled: true,
+ }),
).toBe(expected);
},
);
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
index 029e1f2e9bd..00e636a550b 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
@@ -1,9 +1,7 @@
/* @license Enterprise */
-import {
- MetadataReadability,
- type RecordShareAccessLevel,
-} from 'twenty-shared/types';
+import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';
+import { type RecordShareAccessLevel } from 'twenty-shared/types';
import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/core-modules/record-share/constants/max-inherited-readability-depth.constant';
@@ -39,33 +37,26 @@ export const buildRecordShareGate = ({
target.flatObjectMetadata,
);
- switch (target.flatObjectMetadata.readability) {
- case MetadataReadability.OPEN:
+ const gateKind = resolveRecordShareGateKind({
+ readability: target.flatObjectMetadata.readability,
+ isOwningApplication,
+ isRecordSharingEnabled,
+ });
+ switch (gateKind) {
+ case 'open':
return { kind: 'open' };
- case MetadataReadability.INHERITED:
- if (!isRecordSharingEnabled || isOwningApplication) {
- return { kind: 'open' };
- }
-
+ case 'deny':
+ return { kind: 'denied' };
+ case 'inherited':
return buildInheritedReadabilityGate({
context,
target,
buildParentPolicy,
});
- case MetadataReadability.SYSTEM:
- return { kind: 'denied' };
- case MetadataReadability.APPLICATION:
- return isRecordSharingEnabled && !isOwningApplication
- ? { kind: 'denied' }
- : { kind: 'open' };
- case MetadataReadability.PRIVATE:
- if (!isRecordSharingEnabled || isOwningApplication) {
- return { kind: 'open' };
- }
-
+ case 'private':
return buildOwnRecordShareGate(context, target);
default:
- return assertUnreachable(target.flatObjectMetadata.readability);
+ return assertUnreachable(gateKind);
}
};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util.ts
index 3d29186a9c1..f47dc2fd87f 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util.ts
@@ -8,9 +8,11 @@ export type RecordShareGateKind = 'open' | 'deny' | 'private' | 'inherited';
export const resolveRecordShareGateKind = ({
readability,
isOwningApplication,
+ isRecordSharingEnabled,
}: {
readability: MetadataReadability;
isOwningApplication: boolean;
+ isRecordSharingEnabled: boolean;
}): RecordShareGateKind => {
switch (readability) {
case MetadataReadability.OPEN:
@@ -18,11 +20,15 @@ export const resolveRecordShareGateKind = ({
case MetadataReadability.SYSTEM:
return 'deny';
case MetadataReadability.APPLICATION:
- return isOwningApplication ? 'open' : 'deny';
+ return !isRecordSharingEnabled || isOwningApplication ? 'open' : 'deny';
case MetadataReadability.PRIVATE:
- return isOwningApplication ? 'open' : 'private';
+ return !isRecordSharingEnabled || isOwningApplication
+ ? 'open'
+ : 'private';
case MetadataReadability.INHERITED:
- return isOwningApplication ? 'open' : 'inherited';
+ return !isRecordSharingEnabled || isOwningApplication
+ ? 'open'
+ : 'inherited';
default:
assertUnreachable(readability);
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts
new file mode 100644
index 00000000000..856d78658f8
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts
@@ -0,0 +1,93 @@
+import { Test } from '@nestjs/testing';
+import { MetadataReadability } from 'twenty-shared/types';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';
+import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
+import { RecordShareService } from 'src/engine/core-modules/record-share/services/record-share.service';
+import { RecordSharingFeatureService } from 'src/engine/core-modules/record-share/services/record-sharing-feature.service';
+import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
+import { CallWebhookJobsJob } from 'src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job';
+import { WebhookRateLimitService } from 'src/engine/metadata-modules/webhook/jobs/webhook-rate-limit.service';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+describe('webhook mandatory visibility', () => {
+ it.each([false, true])(
+ 'drops missing metadata and SYSTEM batches with sharing=%s',
+ async (sharingEnabled) => {
+ const add = jest.fn();
+ const objectMetadata = {
+ ...COMPANY_FLAT_OBJECT_MOCK,
+ readability: MetadataReadability.SYSTEM,
+ };
+ const maps = {
+ byUniversalIdentifier: {},
+ universalIdentifierById: {},
+ universalIdentifiersByApplicationId: {},
+ };
+ const getOrRecompute = jest.fn();
+ const module = await Test.createTestingModule({
+ providers: [
+ CallWebhookJobsJob,
+ RecordAccessPolicyService,
+ {
+ provide: getQueueToken(MessageQueue.webhookQueue),
+ useValue: { add },
+ },
+ { provide: WorkspaceCacheService, useValue: { getOrRecompute } },
+ { provide: WorkspaceOrmManager, useValue: {} },
+ { provide: RecordShareService, useValue: {} },
+ {
+ provide: RecordSharingFeatureService,
+ useValue: { isRecordSharingEnabled: async () => sharingEnabled },
+ },
+ {
+ provide: WebhookRateLimitService,
+ useValue: {
+ admitWebhookEventsWithinRateLimit: async ({
+ webhookEvents,
+ }: {
+ webhookEvents: unknown[];
+ }) => webhookEvents,
+ },
+ },
+ ],
+ }).compile();
+ for (const flatObjectMetadataMaps of [
+ maps,
+ {
+ ...maps,
+ byUniversalIdentifier: {
+ [objectMetadata.universalIdentifier]: objectMetadata,
+ },
+ universalIdentifierById: {
+ [objectMetadata.id]: objectMetadata.universalIdentifier,
+ },
+ },
+ ]) {
+ getOrRecompute.mockResolvedValue({
+ flatObjectMetadataMaps,
+ flatWebhookMaps: {
+ ...maps,
+ byUniversalIdentifier: {
+ webhook: { id: 'webhook', operations: ['company.created'] },
+ },
+ },
+ });
+ await module.get(CallWebhookJobsJob).handle({
+ name: 'company.created',
+ workspaceId: objectMetadata.workspaceId,
+ objectMetadata,
+ events: [
+ {
+ recordId: 'private-record',
+ properties: { after: { id: 'private-record' } },
+ },
+ ],
+ });
+ expect(add).not.toHaveBeenCalled();
+ }
+ await module.close();
+ },
+ );
+});
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 274a62e6792..fe8d7682376 100644
--- a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/call-webhook-jobs.job.ts
@@ -19,7 +19,6 @@ import { findWebhooksMatchingEventName } from 'src/engine/metadata-modules/webho
import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';
import { EVERYONE_ROW_ACCESS_POLICY_SUBJECT } from 'src/engine/core-modules/record-share/constants/everyone-row-access-policy-subject.constant';
import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
-import { RecordSharingFeatureService } from 'src/engine/core-modules/record-share/services/record-sharing-feature.service';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
const WEBHOOK_JOBS_CHUNK_SIZE = 20;
@@ -32,7 +31,6 @@ export class CallWebhookJobsJob {
private readonly messageQueueService: MessageQueueService,
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly recordAccessPolicyService: RecordAccessPolicyService,
- private readonly recordSharingFeatureService: RecordSharingFeatureService,
private readonly webhookRateLimitService: WebhookRateLimitService,
) {}
@@ -65,13 +63,8 @@ export class CallWebhookJobsJob {
flatEntityMaps: flatObjectMetadataMaps,
});
- const isRecordSharingEnabled =
- await this.recordSharingFeatureService.isRecordSharingEnabled(
- workspaceEventBatch.workspaceId,
- );
-
// Without the readability the batch cannot be gated, so nothing may leave
- if (isRecordSharingEnabled && !isDefined(flatObjectMetadata)) {
+ if (!isDefined(flatObjectMetadata)) {
this.logger.warn(
`Object metadata ${workspaceEventBatch.objectMetadata.id} not found for workspace ${workspaceEventBatch.workspaceId}, dropping the webhook batch`,
);
@@ -80,14 +73,12 @@ export class CallWebhookJobsJob {
}
// A webhook carries no identity, so only a row granted to everyone lets an event out
- const admittedRecordIds = isDefined(flatObjectMetadata)
- ? await this.recordAccessPolicyService
- .buildEventRecordAccessGate({
- ...workspaceEventBatch,
- objectMetadata: flatObjectMetadata,
- })
- .resolveAdmittedRecordIds(EVERYONE_ROW_ACCESS_POLICY_SUBJECT)
- : undefined;
+ const admittedRecordIds = await this.recordAccessPolicyService
+ .buildEventRecordAccessGate({
+ ...workspaceEventBatch,
+ objectMetadata: flatObjectMetadata,
+ })
+ .resolveAdmittedRecordIds(EVERYONE_ROW_ACCESS_POLICY_SUBJECT);
const webhookEvents = transformEventBatchToWebhookEvents({
workspaceEventBatch,
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 ad9706de3b5..6790ff0756e 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
@@ -69,6 +69,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
description: 'Test object for testing',
targetTableName: 'test_objects',
isSystem: false,
+ readability: MetadataReadability.OPEN,
isActive: true,
isRemote: false,
isAuditLogged: true,
@@ -504,55 +505,61 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
);
});
- 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,
- }),
- };
-
- recordSharingFeatureService.isRecordSharingEnabled.mockResolvedValue(
- true,
- );
-
- workspaceCacheService.getOrRecompute.mockImplementation(((
- _workspaceId: string,
- keys: string[],
- ) =>
- Promise.resolve(
- !keys.includes('workflowAutomatedTriggerMaps')
- ? {
- featureFlagsMap: {},
- flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
- flatRoleMaps: { byUniversalIdentifier: {} },
- rolesPermissions: {},
- flatRowLevelPermissionPredicateMaps:
- createEmptyFlatEntityMaps(),
- flatRowLevelPermissionPredicateGroupMaps:
- createEmptyFlatEntityMaps(),
- flatFieldMetadataMaps: createEmptyFlatEntityMaps(),
- }
- : {
- workflowAutomatedTriggerMaps: {
- byWorkflowId: {
- [workflowId]: {
- type: AutomatedTriggerType.DATABASE_EVENT,
- coreWorkflowVersionId: `core-version-${workflowId}`,
- workspaceWorkflowVersionId: `workspace-version-${workflowId}`,
- workflowId,
- settings: { eventName: databaseEventName },
+ it.each([true, false])(
+ 'should not trigger workflow for a system object with sharing=%s and no resolved role',
+ async (sharingEnabled) => {
+ const systemPayload: WorkspaceEventBatch<ObjectRecordUpdateEvent> = {
+ ...mockPayload,
+ objectMetadata: createMockFlatObjectMetadata({
+ readability: MetadataReadability.SYSTEM,
+ }),
+ };
+
+ recordSharingFeatureService.isRecordSharingEnabled.mockResolvedValue(
+ sharingEnabled,
+ );
+
+ workspaceCacheService.getOrRecompute.mockImplementation(((
+ _workspaceId: string,
+ keys: string[],
+ ) =>
+ Promise.resolve(
+ !keys.includes('workflowAutomatedTriggerMaps')
+ ? {
+ featureFlagsMap: {},
+ flatApplicationMaps: {
+ byId: {},
+ idByUniversalIdentifier: {},
+ },
+ flatRoleMaps: { byUniversalIdentifier: {} },
+ rolesPermissions: {},
+ flatRowLevelPermissionPredicateMaps:
+ createEmptyFlatEntityMaps(),
+ flatRowLevelPermissionPredicateGroupMaps:
+ createEmptyFlatEntityMaps(),
+ flatFieldMetadataMaps: createEmptyFlatEntityMaps(),
+ }
+ : {
+ workflowAutomatedTriggerMaps: {
+ byWorkflowId: {
+ [workflowId]: {
+ type: AutomatedTriggerType.DATABASE_EVENT,
+ coreWorkflowVersionId: `core-version-${workflowId}`,
+ workspaceWorkflowVersionId: `workspace-version-${workflowId}`,
+ workflowId,
+ settings: { eventName: databaseEventName },
+ },
},
},
},
- },
- )) as never);
+ )) as never);
- await listener.handleObjectRecordUpdateEvent(systemPayload);
+ await listener.handleObjectRecordUpdateEvent(systemPayload);
- expect(recordShareService.findByRecordIds).not.toHaveBeenCalled();
- expect(messageQueueService.add).not.toHaveBeenCalled();
- });
+ expect(recordShareService.findByRecordIds).not.toHaveBeenCalled();
+ expect(messageQueueService.add).not.toHaveBeenCalled();
+ },
+ );
it('should handle multiple events in a batch', async () => {
const batchPayload: WorkspaceEventBatch<any> = {