Skip to content

The open alternative to Salesforce, designed for AI.

Record sharing: gate events through one access policy entry point (#25964)

martmulla482b18565f0
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 811223df092..bb16b7a666b 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,12 +1,9 @@
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';
@@ -22,14 +19,7 @@ import {
LogicFunctionTriggerJobData,
} from 'src/engine/core-modules/logic-function/logic-function-trigger/jobs/logic-function-trigger.job';
import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';
-import { 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 { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';
-import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';
import { buildRoleRowAccessPolicySubject } from 'src/engine/record-share/utils/build-role-row-access-policy-subject.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';
@@ -42,7 +32,6 @@ export class CallDatabaseEventTriggerJobsJob {
private readonly messageQueueService: MessageQueueService,
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly applicationJobEnqueueThrottlerService: ApplicationJobEnqueueThrottlerService,
- private readonly recordShareService: RecordShareService,
private readonly recordAccessPolicyService: RecordAccessPolicyService,
) {}
@@ -51,7 +40,6 @@ export class CallDatabaseEventTriggerJobsJob {
const {
flatLogicFunctionMaps,
flatApplicationMaps,
- featureFlagsMap,
rolesPermissions,
flatRowLevelPermissionPredicateMaps,
flatRowLevelPermissionPredicateGroupMaps,
@@ -61,7 +49,6 @@ export class CallDatabaseEventTriggerJobsJob {
[
'flatLogicFunctionMaps',
'flatApplicationMaps',
- 'featureFlagsMap',
'rolesPermissions',
'flatRowLevelPermissionPredicateMaps',
'flatRowLevelPermissionPredicateGroupMaps',
@@ -109,20 +96,10 @@ export class CallDatabaseEventTriggerJobsJob {
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));
+ const eventRecordShareGate =
+ this.recordAccessPolicyService.buildEventRecordShareGate(
+ workspaceEventBatch,
+ );
for (const [
applicationId,
@@ -138,32 +115,25 @@ export class CallDatabaseEventTriggerJobsJob {
continue;
}
+ const admittedRecordIds =
+ await eventRecordShareGate.resolveAdmittedRecordIds(
+ buildRoleRowAccessPolicySubject({
+ roleId: application.defaultRoleId ?? undefined,
+ owningApplicationId: application.id,
+ rolesPermissions,
+ flatRowLevelPermissionPredicateMaps,
+ flatRowLevelPermissionPredicateGroupMaps,
+ flatFieldMetadataMaps,
+ }),
+ );
const logicFunctionPayloads = transformEventBatchToEventPayloads({
logicFunctions,
- workspaceEventBatch: await this.filterEventsSharedWithApplication({
- workspaceEventBatch,
- application,
- isRecordShareGated,
- fetchRecordSharesByRecordId,
- resolveRecordIdsReadableThroughParents: () =>
- this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents(
- {
- workspaceId: workspaceEventBatch.workspaceId,
- objectMetadata: workspaceEventBatch.objectMetadata,
- records: resolveEventRecordSnapshots(
- workspaceEventBatch.events,
- ),
- subject: buildRoleRowAccessPolicySubject({
- roleId: application.defaultRoleId ?? undefined,
- owningApplicationId: application.id,
- rolesPermissions,
- flatRowLevelPermissionPredicateMaps,
- flatRowLevelPermissionPredicateGroupMaps,
- flatFieldMetadataMaps,
- }),
- },
- ),
- }),
+ workspaceEventBatch: {
+ ...workspaceEventBatch,
+ events: workspaceEventBatch.events.filter((event) =>
+ admittedRecordIds.has(event.recordId),
+ ),
+ },
});
if (logicFunctionPayloads.length === 0) {
@@ -201,46 +171,6 @@ export class CallDatabaseEventTriggerJobsJob {
}
}
- private async filterEventsSharedWithApplication({
- workspaceEventBatch,
- application,
- isRecordShareGated,
- fetchRecordSharesByRecordId,
- resolveRecordIdsReadableThroughParents,
- }: {
- workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;
- application: FlatApplication;
- isRecordShareGated: boolean;
- fetchRecordSharesByRecordId: () => Promise<Map<string, RecordShare[]>>;
- resolveRecordIdsReadableThroughParents: () => Promise<Set<string>>;
- }): 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,
- resolveRecordIdsReadableThroughParents,
- })
- : null;
-
- if (!isDefined(recordShareGate)) {
- return workspaceEventBatch;
- }
-
- return {
- ...workspaceEventBatch,
- events: workspaceEventBatch.events.filter((event) =>
- isRecordAdmittedByRecordShareGate({
- 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 1a3fd96eb07..9ace025b482 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,7 +1,6 @@
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';
@@ -21,10 +20,6 @@ import { computeWebhookOperationsToMatch } from 'src/engine/metadata-modules/web
import { transformEventBatchToWebhookEvents } from 'src/engine/metadata-modules/webhook/utils/transform-event-batch-to-webhook-events';
import { EVERYONE_ROW_ACCESS_POLICY_SUBJECT } from 'src/engine/record-share/constants/everyone-row-access-policy-subject.constant';
import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';
-import { RecordShareService } from 'src/engine/record-share/services/record-share.service';
-import { 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 { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
const WEBHOOK_JOBS_CHUNK_SIZE = 20;
@@ -36,7 +31,6 @@ export class CallWebhookJobsJob {
@InjectMessageQueue(MessageQueue.webhookQueue)
private readonly messageQueueService: MessageQueueService,
private readonly workspaceCacheService: WorkspaceCacheService,
- private readonly recordShareService: RecordShareService,
private readonly recordAccessPolicyService: RecordAccessPolicyService,
private readonly webhookRateLimitService: WebhookRateLimitService,
) {}
@@ -93,40 +87,19 @@ export class CallWebhookJobsJob {
}
// 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,
- ),
- }),
- ),
- resolveRecordIdsReadableThroughParents: () =>
- this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents(
- {
- workspaceId: workspaceEventBatch.workspaceId,
- objectMetadata: flatObjectMetadata,
- records: resolveEventRecordSnapshots(
- workspaceEventBatch.events,
- ),
- subject: EVERYONE_ROW_ACCESS_POLICY_SUBJECT,
- },
- ),
+ const admittedRecordIds = isDefined(flatObjectMetadata)
+ ? await this.recordAccessPolicyService
+ .buildEventRecordShareGate({
+ ...workspaceEventBatch,
+ objectMetadata: flatObjectMetadata,
})
- : null;
+ .resolveAdmittedRecordIds(EVERYONE_ROW_ACCESS_POLICY_SUBJECT)
+ : undefined;
const webhookEvents = transformEventBatchToWebhookEvents({
workspaceEventBatch,
webhooks,
- recordShareGate,
+ admittedRecordIds,
});
const admittedWebhookEvents =
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 642012378ef..706d86ca31b 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,19 +1,11 @@
-import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
-import {
- MetadataReadability,
- RecordShareAccessLevel,
- RecordSharePrincipalType,
- RecordShareRowCause,
-} from 'twenty-shared/types';
+import { MetadataReadability } 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',
@@ -256,7 +248,7 @@ describe('transformEventBatchToWebhookEvents', () => {
expect(resultWithoutEventDate).toEqual(expectedResultWithoutEventDate);
});
- it('should only keep events of a private object for records shared with everyone', () => {
+ it('should only keep the events of the admitted records', () => {
const workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent> = {
workspaceId: 'workspaceId',
objectMetadata: {
@@ -288,37 +280,10 @@ describe('transformEventBatchToWebhookEvents', () => {
},
] 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],
- recordIdsReadableThroughParents: new Set(),
- },
+ admittedRecordIds: new Set(['recordId-1']),
});
expect(result).toHaveLength(1);
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 1912174a135..058be7b281e 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
@@ -6,28 +6,21 @@ import { type WebhookEntity } from 'src/engine/metadata-modules/webhook/entities
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 RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';
-import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';
-import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';
export const transformEventBatchToWebhookEvents = ({
workspaceEventBatch,
webhooks,
- recordShareGate,
+ admittedRecordIds,
}: {
workspaceEventBatch: WorkspaceEventBatchForWebhook<ObjectRecordEvent>;
webhooks: Pick<WebhookEntity, 'id' | 'targetUrl' | 'secret'>[];
- recordShareGate?: RecordShareGate | null;
+ admittedRecordIds?: Set<string>;
}): CallWebhookJobData[] => {
const result: CallWebhookJobData[] = [];
- const events = isDefined(recordShareGate)
+ const events = isDefined(admittedRecordIds)
? workspaceEventBatch.events.filter((event) =>
- isRecordAdmittedByRecordShareGate({
- recordShareGate,
- recordId: event.recordId,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
- }),
+ admittedRecordIds.has(event.recordId),
)
: workspaceEventBatch.events;
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
deleted file mode 100644
index b7103cc82a0..00000000000
--- a/packages/twenty-server/src/engine/record-share/constants/deny-all-record-share-gate.constant.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-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: [],
- recordIdsReadableThroughParents: new Set(),
-};
diff --git a/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.ts b/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.ts
index 1c2f8e98031..12cbca9b3b9 100644
--- a/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.ts
+++ b/packages/twenty-server/src/engine/record-share/services/record-access-policy.service.ts
@@ -1,6 +1,7 @@
import { Injectable } from '@nestjs/common';
-import { type ObjectRecord } from 'twenty-shared/types';
+import { type ObjectRecordEvent } from 'twenty-shared/database-events';
+import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';
import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import { isNonEmptyString } from '@sniptt/guards';
import { In } from 'typeorm';
@@ -9,9 +10,13 @@ import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/typ
import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { RecordShareService } from 'src/engine/record-share/services/record-share.service';
-import { indexRecordSharesByRecordId } from 'src/engine/record-share/utils/index-record-shares-by-record-id.util';
-import { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';
-import { type EventRecordSnapshot } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';
+import { type EventRecordShareGate } from 'src/engine/record-share/types/event-record-share-gate.type';
+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';
+import {
+ type EventRecordSnapshot,
+ resolveEventRecordSnapshots,
+} from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';
+import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/record-share/utils/resolve-record-ids-shared-with-principals.util';
import { resolveRecordShareGateKind } from 'src/engine/record-share/utils/resolve-record-share-gate-kind.util';
import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/twenty-orm/constants/max-inherited-readability-depth.constant';
import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';
@@ -24,6 +29,7 @@ import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twent
import { resolveInheritedReadabilityParents } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util';
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';
type ReadabilityMaps = {
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
@@ -36,9 +42,15 @@ type SnapshotEvaluation = {
snapshots: EventRecordSnapshot[];
subject: RowAccessPolicySubject;
depth: number;
+ maps?: ReadabilityMaps;
+};
+
+type SnapshotEvaluationInContext = SnapshotEvaluation & {
maps: ReadabilityMaps;
};
+type FetchRecordShares = () => Promise<RecordShare[]>;
+
@Injectable()
export class RecordAccessPolicyService {
constructor(
@@ -47,47 +59,118 @@ export class RecordAccessPolicyService {
private readonly recordShareService: RecordShareService,
) {}
- async resolveRecordIdsReadableThroughParents({
+ buildEventRecordShareGate({
workspaceId,
objectMetadata,
- records,
- subject,
- }: {
- workspaceId: string;
- objectMetadata: FlatObjectMetadata;
- records: EventRecordSnapshot[];
- subject: RowAccessPolicySubject;
- }): Promise<Set<string>> {
- if (records.length === 0) {
- return new Set();
+ events,
+ }: WorkspaceEventBatch<ObjectRecordEvent>): EventRecordShareGate {
+ let recordSharesPromise: Promise<RecordShare[]> | undefined;
+ const fetchRecordShares: FetchRecordShares = () =>
+ (recordSharesPromise ??= this.recordShareService.findByRecordIds({
+ workspaceId,
+ objectMetadataId: objectMetadata.id,
+ recordIds: events.map((event) => event.recordId),
+ }));
+
+ return {
+ resolveAdmittedRecordIds: async (subject) => {
+ const { featureFlagsMap } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'featureFlagsMap',
+ ]);
+ const snapshots = resolveEventRecordSnapshots(events);
+
+ if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {
+ return new Set(snapshots.map((snapshot) => snapshot.id));
+ }
+
+ return this.resolveSnapshotIdsAdmittedByRecordShareGate(
+ { workspaceId, objectMetadata, snapshots, subject, depth: 0 },
+ fetchRecordShares,
+ );
+ },
+ };
+ }
+
+ private async resolveSnapshotIdsAdmittedByRecordShareGate(
+ evaluation: SnapshotEvaluation,
+ fetchRecordShares: FetchRecordShares,
+ ): Promise<Set<string>> {
+ const { objectMetadata, snapshots, subject } = evaluation;
+ const gateKind = resolveRecordShareGateKind({
+ readability: objectMetadata.readability,
+ isOwningApplication: subject.isOwningApplication(objectMetadata),
+ });
+
+ switch (gateKind) {
+ case 'open':
+ return new Set(snapshots.map((snapshot) => snapshot.id));
+ case 'deny':
+ return new Set();
+ case 'private':
+ return this.resolveSnapshotIdsSharedWithSubject(
+ evaluation,
+ fetchRecordShares,
+ );
+ case 'inherited':
+ return new Set([
+ ...(await this.resolveSnapshotIdsSharedWithSubject(
+ evaluation,
+ fetchRecordShares,
+ )),
+ ...(await this.resolveSnapshotIdsReadableThroughParents(evaluation)),
+ ]);
+ default:
+ return assertUnreachable(gateKind);
+ }
+ }
+
+ private async resolveSnapshotIdsSharedWithSubject(
+ { snapshots, subject }: SnapshotEvaluation,
+ fetchRecordShares: FetchRecordShares,
+ ): Promise<Set<string>> {
+ const snapshotIds = snapshots.map((snapshot) => snapshot.id);
+
+ if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {
+ return new Set(snapshotIds);
}
- const maps = await this.workspaceCacheService.getOrRecompute(workspaceId, [
- 'flatObjectMetadataMaps',
- 'flatFieldMetadataMapsOrm',
- ]);
+ const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({
+ recordShares: await fetchRecordShares(),
+ principalIds: subject.principalIds,
+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),
+ });
- return this.workspaceOrmManager.executeInWorkspaceContext(
- () =>
- this.resolveSnapshotIdsReadableThroughParents({
- workspaceId,
- objectMetadata,
- snapshots: records,
- subject,
- depth: 0,
- maps,
- }),
- buildSystemAuthContext(workspaceId),
+ return new Set(
+ snapshotIds.filter((snapshotId) => sharedRecordIds.has(snapshotId)),
);
}
private async resolveSnapshotIdsReadableThroughParents(
evaluation: SnapshotEvaluation,
): Promise<Set<string>> {
+ const { workspaceId, objectMetadata, maps } = evaluation;
+
+ if (!isDefined(maps)) {
+ const loadedMaps = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['flatObjectMetadataMaps', 'flatFieldMetadataMapsOrm'],
+ );
+
+ return this.workspaceOrmManager.executeInWorkspaceContext(
+ () =>
+ this.resolveSnapshotIdsReadableThroughParents({
+ ...evaluation,
+ maps: loadedMaps,
+ }),
+ buildSystemAuthContext(workspaceId),
+ );
+ }
+
const parents = resolveInheritedReadabilityParents({
- flatObjectMetadata: evaluation.objectMetadata,
- flatFieldMetadataMaps: evaluation.maps.flatFieldMetadataMapsOrm,
- flatObjectMetadataMaps: evaluation.maps.flatObjectMetadataMaps,
+ flatObjectMetadata: objectMetadata,
+ flatFieldMetadataMaps: maps.flatFieldMetadataMapsOrm,
+ flatObjectMetadataMaps: maps.flatObjectMetadataMaps,
});
const readableSnapshotIds = new Set<string>();
@@ -96,10 +179,12 @@ export class RecordAccessPolicyService {
parent.kind === 'column'
? await this.resolveSnapshotIdsReadableThroughColumnParent({
...evaluation,
+ maps,
parent,
})
: await this.resolveSnapshotIdsReadableThroughChildren({
...evaluation,
+ maps,
parent,
});
@@ -116,7 +201,7 @@ export class RecordAccessPolicyService {
subject,
depth,
parent,
- }: SnapshotEvaluation & {
+ }: SnapshotEvaluationInContext & {
parent: InheritedReadabilityColumnParent;
}): Promise<Set<string>> {
const parentIdBySnapshotId = new Map(
@@ -147,7 +232,7 @@ export class RecordAccessPolicyService {
depth,
maps,
parent,
- }: SnapshotEvaluation & {
+ }: SnapshotEvaluationInContext & {
parent: InheritedReadabilityChildrenParent;
}): Promise<Set<string>> {
const childNameSingular = parent.childFlatObjectMetadata.nameSingular;
@@ -228,9 +313,10 @@ export class RecordAccessPolicyService {
}
private async resolveReadableSnapshotIds(
- evaluation: SnapshotEvaluation,
+ evaluation: SnapshotEvaluationInContext,
): Promise<Set<string>> {
- const { objectMetadata, snapshots, subject, depth, maps } = evaluation;
+ const { workspaceId, objectMetadata, snapshots, subject, depth, maps } =
+ evaluation;
if (snapshots.length === 0 || depth > MAX_INHERITED_READABILITY_DEPTH) {
return new Set();
@@ -262,69 +348,15 @@ export class RecordAccessPolicyService {
}),
)
: snapshots;
- const gateKind = resolveRecordShareGateKind({
- readability: objectMetadata.readability,
- isOwningApplication: subject.isOwningApplication(objectMetadata),
- });
- switch (gateKind) {
- case 'open':
- return new Set(candidateSnapshots.map((snapshot) => snapshot.id));
- case 'deny':
- return new Set();
- case 'private':
- return this.resolveSnapshotIdsSharedWithSubject({
- ...evaluation,
- snapshots: candidateSnapshots,
- });
- case 'inherited':
- return new Set([
- ...(await this.resolveSnapshotIdsSharedWithSubject({
- ...evaluation,
- snapshots: candidateSnapshots,
- })),
- ...(await this.resolveSnapshotIdsReadableThroughParents({
- ...evaluation,
- snapshots: candidateSnapshots,
- })),
- ]);
- default:
- return assertUnreachable(gateKind);
- }
- }
-
- private async resolveSnapshotIdsSharedWithSubject({
- workspaceId,
- objectMetadata,
- snapshots,
- subject,
- }: SnapshotEvaluation): Promise<Set<string>> {
- const snapshotIds = snapshots.map((snapshot) => snapshot.id);
-
- if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {
- return new Set(snapshotIds);
- }
-
- const recordShareGate = {
- recordSharesByRecordId: indexRecordSharesByRecordId(
- await this.recordShareService.findByRecordIds({
+ return this.resolveSnapshotIdsAdmittedByRecordShareGate(
+ { ...evaluation, snapshots: candidateSnapshots },
+ () =>
+ this.recordShareService.findByRecordIds({
workspaceId,
objectMetadataId: objectMetadata.id,
- recordIds: snapshotIds,
- }),
- ),
- principalIds: subject.principalIds,
- recordIdsReadableThroughParents: new Set<string>(),
- };
-
- return new Set(
- snapshotIds.filter((recordId) =>
- isRecordAdmittedByRecordShareGate({
- recordShareGate,
- recordId,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
+ recordIds: candidateSnapshots.map((snapshot) => snapshot.id),
}),
- ),
);
}
@@ -332,12 +364,12 @@ export class RecordAccessPolicyService {
objectMetadata,
recordIds,
subject,
- depth = 0,
+ depth,
}: {
objectMetadata: FlatObjectMetadata;
recordIds: string[];
subject: RowAccessPolicySubject;
- depth?: number;
+ depth: number;
}): Promise<Set<string>> {
if (recordIds.length === 0) {
return new Set();
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 96ff35e9e68..b5612756d45 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
@@ -74,20 +74,6 @@ export class RecordShareService {
);
}
- async findByRecord({
- workspaceId,
- objectMetadataId,
- recordId,
- }: {
- workspaceId: string;
- objectMetadataId: string;
- recordId: string;
- }): Promise<RecordShare[]> {
- return this.withRepository({ workspaceId }, (repository) =>
- repository.find({ where: { objectMetadataId, recordId } }),
- );
- }
-
async findByRecordIds({
workspaceId,
objectMetadataId,
diff --git a/packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.ts b/packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.ts
new file mode 100644
index 00000000000..6620b4581cc
--- /dev/null
+++ b/packages/twenty-server/src/engine/record-share/types/event-record-share-gate.type.ts
@@ -0,0 +1,7 @@
+import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';
+
+export type EventRecordShareGate = {
+ resolveAdmittedRecordIds: (
+ subject: RowAccessPolicySubject,
+ ) => Promise<Set<string>>;
+};
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
deleted file mode 100644
index f219ca46a54..00000000000
--- a/packages/twenty-server/src/engine/record-share/types/record-share-gate.type.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { type RecordShare } from 'src/engine/record-share/types/record-share.type';
-
-export type RecordShareGate = {
- recordSharesByRecordId: Map<string, RecordShare[]>;
- principalIds: string[];
- recordIdsReadableThroughParents: Set<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
deleted file mode 100644
index ba947d0bc7c..00000000000
--- a/packages/twenty-server/src/engine/record-share/utils/__tests__/build-record-share-gate.util.spec.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-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,
- resolveRecordIdsReadableThroughParents: async () => new Set(),
- });
-
- 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,
- resolveRecordIdsReadableThroughParents: async () => new Set(),
- });
-
- 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(),
- resolveRecordIdsReadableThroughParents: async () => new Set(),
- });
-
- expect(gate).toBeNull();
- });
-
- it('fetches the rows of a PRIVATE object and keeps each principal once', async () => {
- const resolveRecordIdsReadableThroughParents = jest.fn(
- async () => new Set<string>(),
- );
- const gate = await buildRecordShareGate({
- readability: MetadataReadability.PRIVATE,
- isOwningApplication: false,
- principalIds: [
- EVERYONE_PRINCIPAL_ID,
- undefined,
- 'role-1',
- 'role-1',
- null,
- ],
- fetchRecordSharesByRecordId: async () =>
- indexRecordSharesByRecordId([RECORD_SHARE]),
- resolveRecordIdsReadableThroughParents,
- });
-
- expect(gate).toEqual({
- recordSharesByRecordId: indexRecordSharesByRecordId([RECORD_SHARE]),
- principalIds: [EVERYONE_PRINCIPAL_ID, 'role-1'],
- recordIdsReadableThroughParents: new Set(),
- });
- expect(resolveRecordIdsReadableThroughParents).not.toHaveBeenCalled();
- });
-
- it('asks the parents of an INHERITED object on top of its own rows', async () => {
- const resolveRecordIdsReadableThroughParents = jest.fn(
- async () => new Set(['record-2']),
- );
-
- const gate = await buildRecordShareGate({
- readability: MetadataReadability.INHERITED,
- isOwningApplication: false,
- principalIds: [EVERYONE_PRINCIPAL_ID, 'member-1'],
- fetchRecordSharesByRecordId: async () =>
- indexRecordSharesByRecordId([RECORD_SHARE]),
- resolveRecordIdsReadableThroughParents,
- });
-
- expect(gate).toEqual({
- recordSharesByRecordId: indexRecordSharesByRecordId([RECORD_SHARE]),
- principalIds: [EVERYONE_PRINCIPAL_ID, 'member-1'],
- recordIdsReadableThroughParents: new Set(['record-2']),
- });
- });
-
- it('lets the owning application through an INHERITED object without asking', async () => {
- const resolveRecordIdsReadableThroughParents = jest.fn(
- async () => new Set(['record-2']),
- );
-
- const gate = await buildRecordShareGate({
- readability: MetadataReadability.INHERITED,
- isOwningApplication: true,
- principalIds: [],
- fetchRecordSharesByRecordId: async () => new Map(),
- resolveRecordIdsReadableThroughParents,
- });
-
- expect(gate).toBeNull();
- expect(resolveRecordIdsReadableThroughParents).not.toHaveBeenCalled();
- });
-});
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
deleted file mode 100644
index bd4d42ccef0..00000000000
--- a/packages/twenty-server/src/engine/record-share/utils/__tests__/index-record-shares-by-record-id.util.spec.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-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-admitted-by-record-share-gate.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-admitted-by-record-share-gate.util.spec.ts
deleted file mode 100644
index e456c796b8d..00000000000
--- a/packages/twenty-server/src/engine/record-share/utils/__tests__/is-record-admitted-by-record-share-gate.util.spec.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-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 { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.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) =>
- isRecordAdmittedByRecordShareGate({
- recordShareGate: {
- recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),
- principalIds,
- recordIdsReadableThroughParents: new Set(),
- },
- recordId,
- accessLevels,
- }),
- );
-
-describe('isRecordAdmittedByRecordShareGate', () => {
- 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(
- isRecordAdmittedByRecordShareGate({
- recordShareGate: {
- recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),
- principalIds: [WORKSPACE_MEMBER_ID],
- recordIdsReadableThroughParents: new Set(),
- },
- recordId: RECORD_IDS.UNSHARED,
- accessLevels: [RecordShareAccessLevel.READ],
- }),
- ).toBe(false);
- });
-});
diff --git a/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-ids-shared-with-principals.util.spec.ts b/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-ids-shared-with-principals.util.spec.ts
new file mode 100644
index 00000000000..84dd1417aa8
--- /dev/null
+++ b/packages/twenty-server/src/engine/record-share/utils/__tests__/resolve-record-ids-shared-with-principals.util.spec.ts
@@ -0,0 +1,64 @@
+import {
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';
+import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/record-share/utils/resolve-record-ids-shared-with-principals.util';
+
+const buildRecordShare = (
+ recordId: string,
+ principalId: string,
+ accessLevel: RecordShareAccessLevel,
+): RecordShare => ({
+ id: `${recordId}-${principalId}`,
+ recordId,
+ objectMetadataId: 'object-metadata-id',
+ principalId,
+ principalType: RecordSharePrincipalType.ROLE,
+ accessLevel,
+ rowCause: RecordShareRowCause.MANUAL,
+ sourceId: 'source-id',
+});
+
+describe('resolveRecordIdsSharedWithPrincipals', () => {
+ const recordShares = [
+ buildRecordShare('record-1', 'role-1', RecordShareAccessLevel.READ),
+ buildRecordShare('record-2', 'role-2', RecordShareAccessLevel.FULL),
+ buildRecordShare('record-3', 'role-1', RecordShareAccessLevel.FULL),
+ ];
+
+ it('should keep the records a listed principal holds at a listed access level', () => {
+ expect(
+ resolveRecordIdsSharedWithPrincipals({
+ recordShares,
+ principalIds: ['role-1'],
+ accessLevels: [
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.FULL,
+ ],
+ }),
+ ).toEqual(new Set(['record-1', 'record-3']));
+ });
+
+ it('should drop the records whose share rows only grant a lower access level', () => {
+ expect(
+ resolveRecordIdsSharedWithPrincipals({
+ recordShares,
+ principalIds: ['role-1', 'role-2'],
+ accessLevels: [RecordShareAccessLevel.FULL],
+ }),
+ ).toEqual(new Set(['record-2', 'record-3']));
+ });
+
+ it('should admit nothing to a principal without a share row', () => {
+ expect(
+ resolveRecordIdsSharedWithPrincipals({
+ recordShares,
+ principalIds: ['role-3'],
+ accessLevels: [RecordShareAccessLevel.READ],
+ }),
+ ).toEqual(new Set());
+ });
+});
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
deleted file mode 100644
index ebc229366b1..00000000000
--- a/packages/twenty-server/src/engine/record-share/utils/build-record-share-gate.util.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-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';
-
-export const buildRecordShareGate = async ({
- readability,
- isOwningApplication,
- principalIds,
- fetchRecordSharesByRecordId,
- resolveRecordIdsReadableThroughParents,
-}: {
- readability: MetadataReadability;
- isOwningApplication: boolean;
- principalIds: (string | null | undefined)[];
- fetchRecordSharesByRecordId: () => Promise<Map<string, RecordShare[]>>;
- resolveRecordIdsReadableThroughParents: () => Promise<Set<string>>;
-}): Promise<RecordShareGate | null> => {
- const gateKind = resolveRecordShareGateKind({
- readability,
- isOwningApplication,
- });
-
- switch (gateKind) {
- case 'open':
- return null;
- case 'deny':
- return DENY_ALL_RECORD_SHARE_GATE;
- case 'private':
- case 'inherited':
- return {
- recordSharesByRecordId: await fetchRecordSharesByRecordId(),
- principalIds: [
- ...new Set(
- principalIds.filter(
- (principalId): principalId is string =>
- typeof principalId === 'string',
- ),
- ),
- ],
- recordIdsReadableThroughParents:
- gateKind === 'inherited'
- ? await resolveRecordIdsReadableThroughParents()
- : new Set(),
- };
- 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
deleted file mode 100644
index 02f404e2507..00000000000
--- a/packages/twenty-server/src/engine/record-share/utils/index-record-shares-by-record-id.util.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-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-admitted-by-record-share-gate.util.ts b/packages/twenty-server/src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util.ts
deleted file mode 100644
index 9a1c2ab2d7b..00000000000
--- a/packages/twenty-server/src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { type RecordShareAccessLevel } from 'twenty-shared/types';
-
-import { type RecordShareGate } from 'src/engine/record-share/types/record-share-gate.type';
-
-export const isRecordAdmittedByRecordShareGate = ({
- recordShareGate,
- recordId,
- accessLevels,
-}: {
- recordShareGate: RecordShareGate;
- recordId: string;
- accessLevels: RecordShareAccessLevel[];
-}): boolean =>
- recordShareGate.recordIdsReadableThroughParents.has(recordId) ||
- (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-ids-shared-with-principals.util.ts b/packages/twenty-server/src/engine/record-share/utils/resolve-record-ids-shared-with-principals.util.ts
new file mode 100644
index 00000000000..5d6b6d11930
--- /dev/null
+++ b/packages/twenty-server/src/engine/record-share/utils/resolve-record-ids-shared-with-principals.util.ts
@@ -0,0 +1,22 @@
+import { type RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/record-share/types/record-share.type';
+
+export const resolveRecordIdsSharedWithPrincipals = ({
+ recordShares,
+ principalIds,
+ accessLevels,
+}: {
+ recordShares: RecordShare[];
+ principalIds: string[];
+ accessLevels: RecordShareAccessLevel[];
+}): Set<string> =>
+ new Set(
+ recordShares
+ .filter(
+ (recordShare) =>
+ principalIds.includes(recordShare.principalId) &&
+ accessLevels.includes(recordShare.accessLevel),
+ )
+ .map((recordShare) => recordShare.recordId),
+ );
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 35e9e409cb9..bea8120e7dc 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
@@ -26,6 +26,7 @@ import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-objec
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';
import { RecordShareService } from 'src/engine/record-share/services/record-share.service';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { 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';
@@ -112,8 +113,9 @@ describe('ObjectRecordEventPublisher', () => {
const userWorkspaceId = 'test-user-workspace-id';
const roleId = 'test-role-id';
- let mockRecordAccessPolicyService: {
- resolveRecordIdsReadableThroughParents: jest.Mock;
+ let mockWorkspaceOrmManager: {
+ executeInWorkspaceContext: jest.Mock;
+ getRepository: jest.Mock;
};
const companyObjectMetadata: FlatObjectMetadata = COMPANY_FLAT_OBJECT_MOCK;
@@ -276,10 +278,9 @@ describe('ObjectRecordEventPublisher', () => {
findByRecordIds: jest.fn().mockResolvedValue([]),
};
- mockRecordAccessPolicyService = {
- resolveRecordIdsReadableThroughParents: jest
- .fn()
- .mockResolvedValue(new Set()),
+ mockWorkspaceOrmManager = {
+ executeInWorkspaceContext: jest.fn(),
+ getRepository: jest.fn(),
};
mockWorkspaceManyOrAllFlatEntityMapsCacheService = {
@@ -331,9 +332,10 @@ describe('ObjectRecordEventPublisher', () => {
provide: RecordShareService,
useValue: mockRecordShareService,
},
+ RecordAccessPolicyService,
{
- provide: RecordAccessPolicyService,
- useValue: mockRecordAccessPolicyService,
+ provide: WorkspaceOrmManager,
+ useValue: mockWorkspaceOrmManager,
},
],
}).compile();
@@ -459,7 +461,7 @@ describe('ObjectRecordEventPublisher', () => {
).not.toHaveBeenCalled();
});
- it('should not resolve the records readable through parents for a stream whose queries target another object', async () => {
+ it('should not evaluate the record share gate for a stream whose queries target another object', async () => {
const inheritedObjectMetadata: FlatObjectMetadata = {
...companyObjectMetadata,
readability: MetadataReadability.INHERITED,
@@ -491,9 +493,7 @@ describe('ObjectRecordEventPublisher', () => {
events: [createMockEvent()],
} as WorkspaceEventBatch<never>);
- expect(
- mockRecordAccessPolicyService.resolveRecordIdsReadableThroughParents,
- ).not.toHaveBeenCalled();
+ expect(mockRecordShareService.findByRecordIds).not.toHaveBeenCalled();
expect(
mockSubscriptionService.publishToEventStream,
).not.toHaveBeenCalled();
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 0531c91f384..6ee60e09574 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
@@ -6,7 +6,6 @@ import {
} from 'twenty-shared/constants';
import { type ObjectRecordEvent } from 'twenty-shared/database-events';
import {
- FeatureFlagKey,
Nullable,
ObjectRecord,
type ObjectsPermissions,
@@ -40,15 +39,8 @@ import { UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/ty
import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';
import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';
import { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';
-import { 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 { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';
+import { type EventRecordShareGate } from 'src/engine/record-share/types/event-record-share-gate.type';
import { omitInheritedReadabilityChildRecords } from 'src/engine/record-share/utils/omit-inherited-readability-child-records.util';
-import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.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 {
@@ -57,7 +49,6 @@ 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';
@@ -75,7 +66,6 @@ type StreamPermissionsContext = {
userWorkspaceRoleMap: UserWorkspaceRoleMap;
rolesPermissions: ObjectsPermissionsByRoleId;
flatApplicationMaps: FlatApplicationCacheMaps;
- featureFlagsMap: Record<FeatureFlagKey, boolean>;
};
@Injectable()
@@ -89,7 +79,6 @@ export class ObjectRecordEventPublisher {
private readonly processNestedRelationsHelper: ProcessNestedRelationsHelper,
private readonly workspaceManyOrAllFlatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
private readonly commonSelectFieldsHelper: CommonSelectFieldsHelper,
- private readonly recordShareService: RecordShareService,
private readonly recordAccessPolicyService: RecordAccessPolicyService,
) {}
@@ -117,10 +106,8 @@ export class ObjectRecordEventPublisher {
flatWorkspaceMemberMaps,
);
- const recordSharesByRecordId = await this.fetchRecordSharesByRecordId({
- workspaceEventBatch: eventBatch,
- featureFlagsMap: permissionsContext.featureFlagsMap,
- });
+ const eventRecordShareGate =
+ this.recordAccessPolicyService.buildEventRecordShareGate(eventBatch);
const streamIdsToRemove: string[] = [];
@@ -141,7 +128,7 @@ export class ObjectRecordEventPublisher {
permissionsContext,
flatWorkspaceMemberMaps,
workspaceMemberIdByUserId,
- recordSharesByRecordId,
+ eventRecordShareGate,
});
}
@@ -161,34 +148,6 @@ 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] ||
- !['private', 'inherited'].includes(
- resolveRecordShareGateKind({
- readability: workspaceEventBatch.objectMetadata.readability,
- isOwningApplication: false,
- }),
- )
- ) {
- 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,
@@ -196,7 +155,7 @@ export class ObjectRecordEventPublisher {
permissionsContext,
flatWorkspaceMemberMaps,
workspaceMemberIdByUserId,
- recordSharesByRecordId,
+ eventRecordShareGate,
}: {
streamChannelId: string;
streamData: EventStreamData;
@@ -204,7 +163,7 @@ export class ObjectRecordEventPublisher {
permissionsContext: StreamPermissionsContext;
flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps;
workspaceMemberIdByUserId: Map<string, string>;
- recordSharesByRecordId: Map<string, RecordShare[]>;
+ eventRecordShareGate: EventRecordShareGate;
}): Promise<void> {
const roleIds = this.resolveStreamRoleIds(
streamData.authContext,
@@ -264,17 +223,16 @@ export class ObjectRecordEventPublisher {
flatWorkspaceMemberMaps,
);
- const subscriberRecordShareGate = await this.buildSubscriberRecordShareGate(
- {
- workspaceEventBatch,
- subscriberAuthContext,
- roleIds,
- objectsPermissions,
- permissionsContext,
- flatWorkspaceMemberMaps,
- recordSharesByRecordId,
- },
- );
+ const admittedRecordIds =
+ await eventRecordShareGate.resolveAdmittedRecordIds(
+ this.buildSubscriberRowAccessPolicySubject({
+ subscriberAuthContext,
+ roleIds,
+ objectsPermissions,
+ permissionsContext,
+ flatWorkspaceMemberMaps,
+ }),
+ );
const restrictedFields = objectPermissions.restrictedFields;
@@ -304,14 +262,7 @@ export class ObjectRecordEventPublisher {
continue;
}
- if (
- isDefined(subscriberRecordShareGate) &&
- !isRecordAdmittedByRecordShareGate({
- recordShareGate: subscriberRecordShareGate,
- recordId: filteredEvent.recordId,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
- })
- ) {
+ if (!admittedRecordIds.has(filteredEvent.recordId)) {
continue;
}
@@ -575,55 +526,6 @@ export class ObjectRecordEventPublisher {
return workspaceMemberIdByUserId.get(subscriberAuthContext.userId);
}
- private async buildSubscriberRecordShareGate({
- workspaceEventBatch,
- subscriberAuthContext,
- roleIds,
- objectsPermissions,
- permissionsContext,
- flatWorkspaceMemberMaps,
- recordSharesByRecordId,
- }: {
- workspaceEventBatch: WorkspaceEventBatch<ObjectRecordEvent>;
- subscriberAuthContext: SerializableAuthContext;
- roleIds: string[];
- objectsPermissions: ObjectsPermissions;
- permissionsContext: StreamPermissionsContext;
- flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps;
- recordSharesByRecordId: Map<string, RecordShare[]>;
- }): Promise<RecordShareGate | null> {
- if (
- !permissionsContext.featureFlagsMap[
- FeatureFlagKey.IS_RECORD_SHARING_ENABLED
- ]
- ) {
- return null;
- }
-
- const { objectMetadata } = workspaceEventBatch;
- const subject = this.buildSubscriberRowAccessPolicySubject({
- subscriberAuthContext,
- roleIds,
- objectsPermissions,
- permissionsContext,
- flatWorkspaceMemberMaps,
- });
-
- return buildRecordShareGate({
- readability: objectMetadata.readability,
- isOwningApplication: subject.isOwningApplication(objectMetadata),
- principalIds: subject.principalIds ?? [],
- fetchRecordSharesByRecordId: async () => recordSharesByRecordId,
- resolveRecordIdsReadableThroughParents: () =>
- this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents({
- workspaceId: workspaceEventBatch.workspaceId,
- objectMetadata,
- records: resolveEventRecordSnapshots(workspaceEventBatch.events),
- subject,
- }),
- });
- }
-
private buildSubscriberRowAccessPolicySubject({
subscriberAuthContext,
roleIds,
@@ -843,7 +745,6 @@ export class ObjectRecordEventPublisher {
userWorkspaceRoleMap,
rolesPermissions,
flatApplicationMaps,
- featureFlagsMap,
} = await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatRowLevelPermissionPredicateMaps',
'flatRowLevelPermissionPredicateGroupMaps',
@@ -851,7 +752,6 @@ export class ObjectRecordEventPublisher {
'userWorkspaceRoleMap',
'rolesPermissions',
'flatApplicationMaps',
- 'featureFlagsMap',
]);
return {
@@ -861,7 +761,6 @@ export class ObjectRecordEventPublisher {
userWorkspaceRoleMap,
rolesPermissions,
flatApplicationMaps,
- featureFlagsMap,
};
}
}
diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
index 5ae60f1254d..ac4689549d9 100644
--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
@@ -32,6 +32,7 @@ import {
import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';
import { type InheritedReadabilityChildRecords } from 'src/engine/twenty-orm/types/inherited-readability-child-records.type';
import { type InheritedReadabilityChildrenParent } from 'src/engine/twenty-orm/types/inherited-readability-children-parent.type';
+import { type InheritedReadabilityColumnParent } from 'src/engine/twenty-orm/types/inherited-readability-column-parent.type';
import { type InheritedReadabilityParent } from 'src/engine/twenty-orm/types/inherited-readability-parent.type';
import { type InheritedReadabilityParentLink } from 'src/engine/twenty-orm/types/inherited-readability-parent-link.type';
import { type RowAccessPolicy } from 'src/engine/twenty-orm/types/row-access-policy.type';
@@ -187,12 +188,6 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
);
}
- private createPermissionBypassingQueryBuilder(): WorkspaceSelectQueryBuilder {
- return this.buildBypassingEventSelectQueryBuilder(
- this.options.tableShape.nameSingular,
- );
- }
-
formatResult<T>(records: unknown): T {
return formatResult<T>(
records,
@@ -844,7 +839,9 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
);
const existingRecords = await applyFindOptionsToQueryBuilder(
- repository.createPermissionBypassingQueryBuilder(),
+ repository.buildBypassingEventSelectQueryBuilder(
+ repository.options.tableShape.nameSingular,
+ ),
{ where: conflictWhere, withDeleted: true },
).getMany<ObjectRecord>();
@@ -1369,16 +1366,9 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return [];
}
- return this.resolveInheritedReadabilityParents(flatObjectMetadata).flatMap(
- (parent) =>
- parent.kind === 'column'
- ? [
- {
- joinColumnName: parent.joinColumnName,
- parentFlatObjectMetadata: parent.parentFlatObjectMetadata,
- },
- ]
- : [],
+ return this.resolveInheritedReadabilityParents(flatObjectMetadata).filter(
+ (parent): parent is InheritedReadabilityColumnParent =>
+ parent.kind === 'column',
);
}
@@ -1964,7 +1954,9 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,
flatObjectMetadataMaps:
this.options.internalContext.flatObjectMetadataMaps,
- recordShareTableExpression: this.getRecordShareTableExpression(),
+ recordShareTableExpression: this.getTableExpression(
+ this.options.internalContext.objectIdByNameSingular.recordShare,
+ ),
resolveTableExpression: (objectMetadataId) =>
this.getTableExpression(objectMetadataId),
};
@@ -1990,16 +1982,6 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
)}`;
}
- private getRecordShareTableExpression(): string {
- const recordShareTableShape = this.options.tableShapeByObjectMetadataId(
- this.options.internalContext.objectIdByNameSingular.recordShare,
- );
-
- return `${escapeIdentifier(
- recordShareTableShape.schemaName,
- )}.${escapeIdentifier(recordShareTableShape.tableName)}`;
- }
-
private denyAccessForAlias({
queryBuilder,
alias,
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts
index f32c988ba6b..9d69567463b 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts
@@ -69,21 +69,6 @@ describe('buildRecordShareCondition', () => {
).toEqual([]);
});
- it('should correlate on the given record id expression', () => {
- const { sql } = buildRecordShareCondition({
- tableAlias: 'attachment',
- recordShareTableExpression: '"workspace_abc"."recordShare"',
- objectMetadataId: OBJECT_METADATA_ID,
- principalIds: PRINCIPAL_IDS,
- accessLevels: ACCESS_LEVELS,
- recordIdExpression: '"attachment"."targetNoteId"',
- });
-
- expect(sql).toContain(
- '"attachment_recordShare"."recordId" = "attachment"."targetNoteId"',
- );
- });
-
it('should escape the alias it derives', () => {
const { sql } = buildRecordShareCondition({
tableAlias: 'per"son',
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts
index ffe924793e7..cd8882f6324 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts
@@ -11,14 +11,12 @@ export const buildRecordShareCondition = ({
objectMetadataId,
principalIds,
accessLevels,
- recordIdExpression,
}: {
tableAlias: string;
recordShareTableExpression: string;
objectMetadataId: string;
principalIds: string[];
accessLevels: RecordShareAccessLevel[];
- recordIdExpression?: string;
}): { sql: string; parameters: ObjectLiteral } => {
const parameterSuffix = randomBytes(5).toString('hex');
const objectMetadataIdParameterName = `recordShareObjectMetadataId_${parameterSuffix}`;
@@ -26,11 +24,9 @@ export const buildRecordShareCondition = ({
const accessLevelsParameterName = `recordShareAccessLevels_${parameterSuffix}`;
const recordShareAlias = escapeIdentifier(`${tableAlias}_recordShare`);
- const recordIdSql =
- recordIdExpression ?? `${escapeIdentifier(tableAlias)}."id"`;
const conditions = [
- `${recordShareAlias}."recordId" = ${recordIdSql}`,
+ `${recordShareAlias}."recordId" = ${escapeIdentifier(tableAlias)}."id"`,
`${recordShareAlias}."objectMetadataId" = :${objectMetadataIdParameterName}`,
`${recordShareAlias}."principalId" = ANY(:${principalIdsParameterName})`,
`${recordShareAlias}."accessLevel" IN (:...${accessLevelsParameterName})`,
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 08f05572565..0459db50b5c 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
@@ -34,6 +34,8 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
) => {
workspaceCacheService.getOrRecompute.mockResolvedValue({
featureFlagsMap: {},
+ flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
+ flatRoleMaps: { byUniversalIdentifier: {} },
workflowAutomatedTriggerMaps: {
byWorkflowId: Object.fromEntries(
listeners.map((listener) => [
@@ -93,6 +95,8 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
workspaceCacheService = {
getOrRecompute: jest.fn().mockResolvedValue({
featureFlagsMap: {},
+ flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
+ flatRoleMaps: { byUniversalIdentifier: {} },
workflowAutomatedTriggerMaps: { byWorkflowId: {} },
} as never),
} as any;
@@ -120,14 +124,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
provide: RecordShareService,
useValue: recordShareService,
},
- {
- provide: RecordAccessPolicyService,
- useValue: {
- resolveRecordIdsReadableThroughParents: jest
- .fn()
- .mockResolvedValue(new Set()),
- },
- },
+ RecordAccessPolicyService,
{
provide: 'MESSAGE_QUEUE_workflow-queue',
useValue: messageQueueService,
@@ -425,7 +422,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
keys: string[],
) =>
Promise.resolve(
- keys.includes('featureFlagsMap')
+ !keys.includes('workflowAutomatedTriggerMaps')
? {
featureFlagsMap: {
[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true,
@@ -443,6 +440,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
},
},
flatRoleMaps: { byUniversalIdentifier: {} },
+ rolesPermissions: {},
}
: {
workflowAutomatedTriggerMaps: {
@@ -500,13 +498,14 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
keys: string[],
) =>
Promise.resolve(
- keys.includes('featureFlagsMap')
+ !keys.includes('workflowAutomatedTriggerMaps')
? {
featureFlagsMap: {
[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: true,
},
flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
flatRoleMaps: { byUniversalIdentifier: {} },
+ rolesPermissions: {},
}
: {
workflowAutomatedTriggerMaps: {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts b/packages/twenty-server/src/modules/workflow/workflow-trigger/automated-trigger/listeners/workflow-database-event-trigger.listener.ts
index 6c6299d83c8..7e528c93db6 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,7 +1,6 @@
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,
@@ -10,7 +9,7 @@ import {
type ObjectRecordUpdateEvent,
type ObjectRecordUpsertEvent,
} from 'twenty-shared/database-events';
-import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';
+import { 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';
@@ -29,15 +28,8 @@ import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-m
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 { RecordAccessPolicyService } from 'src/engine/record-share/services/record-access-policy.service';
-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 { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';
import { omitInheritedReadabilityChildRecords } from 'src/engine/record-share/utils/omit-inherited-readability-child-records.util';
-import { resolveEventRecordSnapshots } from 'src/engine/record-share/utils/resolve-event-record-snapshots.util';
import { buildRoleRowAccessPolicySubject } from 'src/engine/record-share/utils/build-role-row-access-policy-subject.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';
@@ -80,7 +72,6 @@ export class WorkflowDatabaseEventTriggerListener {
private readonly messageQueueService: MessageQueueService,
private readonly workflowCommonWorkspaceService: WorkflowCommonWorkspaceService,
private readonly workspaceCacheService: WorkspaceCacheService,
- private readonly recordShareService: RecordShareService,
private readonly recordAccessPolicyService: RecordAccessPolicyService,
) {}
@@ -374,7 +365,7 @@ export class WorkflowDatabaseEventTriggerListener {
return;
}
- const recordShareGate = await this.buildRecordShareGate(payload);
+ const admittedRecordIds = await this.resolveAdmittedRecordIds(payload);
for (const eventListener of eventListeners) {
for (const eventPayload of payload.events) {
@@ -382,7 +373,7 @@ export class WorkflowDatabaseEventTriggerListener {
eventPayload,
eventListener,
action,
- recordShareGate,
+ admittedRecordIds,
});
if (shouldTriggerJob) {
@@ -419,11 +410,10 @@ export class WorkflowDatabaseEventTriggerListener {
);
}
- private async buildRecordShareGate(
+ private async resolveAdmittedRecordIds(
payload: WorkspaceEventBatch<ObjectRecordEvent>,
- ): Promise<RecordShareGate | null> {
+ ): Promise<Set<string>> {
const {
- featureFlagsMap,
flatApplicationMaps,
flatRoleMaps,
rolesPermissions,
@@ -431,7 +421,6 @@ export class WorkflowDatabaseEventTriggerListener {
flatRowLevelPermissionPredicateGroupMaps,
flatFieldMetadataMaps,
} = await this.workspaceCacheService.getOrRecompute(payload.workspaceId, [
- 'featureFlagsMap',
'flatApplicationMaps',
'flatRoleMaps',
'rolesPermissions',
@@ -440,83 +429,43 @@ export class WorkflowDatabaseEventTriggerListener {
'flatFieldMetadataMaps',
]);
- if (!featureFlagsMap[FeatureFlagKey.IS_RECORD_SHARING_ENABLED]) {
- return null;
- }
-
const standardApplication = findActiveFlatApplicationByUniversalIdentifier(
flatApplicationMaps,
TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,
);
- const roleId =
- standardApplication?.defaultRoleId ??
- findFlatEntityByUniversalIdentifier({
- flatEntityMaps: flatRoleMaps,
- universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
- })?.id;
-
- return buildRecordShareGate({
- readability: payload.objectMetadata.readability,
- isOwningApplication:
- isDefined(standardApplication) &&
- payload.objectMetadata.applicationId === standardApplication.id,
- principalIds: [EVERYONE_PRINCIPAL_ID, roleId],
- fetchRecordSharesByRecordId: async () =>
- indexRecordSharesByRecordId(
- await this.recordShareService.findByRecordIds({
- workspaceId: payload.workspaceId,
- objectMetadataId: payload.objectMetadata.id,
- recordIds: payload.events.map((event) => event.recordId),
- }),
- ),
- resolveRecordIdsReadableThroughParents: () =>
- this.recordAccessPolicyService.resolveRecordIdsReadableThroughParents({
- workspaceId: payload.workspaceId,
- objectMetadata: payload.objectMetadata,
- records: resolveEventRecordSnapshots(payload.events),
- subject: buildRoleRowAccessPolicySubject({
- roleId,
- owningApplicationId: standardApplication?.id,
- rolesPermissions,
- flatRowLevelPermissionPredicateMaps,
- flatRowLevelPermissionPredicateGroupMaps,
- flatFieldMetadataMaps,
- }),
+ return this.recordAccessPolicyService
+ .buildEventRecordShareGate(payload)
+ .resolveAdmittedRecordIds(
+ buildRoleRowAccessPolicySubject({
+ roleId:
+ standardApplication?.defaultRoleId ??
+ findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: flatRoleMaps,
+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
+ })?.id,
+ owningApplicationId: standardApplication?.id,
+ rolesPermissions,
+ flatRowLevelPermissionPredicateMaps,
+ flatRowLevelPermissionPredicateGroupMaps,
+ flatFieldMetadataMaps,
}),
- });
+ );
}
private shouldTriggerJob({
eventPayload,
eventListener,
action,
- recordShareGate,
- }: TriggerEvaluationArgs & { recordShareGate: RecordShareGate | null }) {
+ admittedRecordIds,
+ }: TriggerEvaluationArgs & { admittedRecordIds: Set<string> }) {
return (
this.eventMatchesWatchedFields({ eventPayload, eventListener, action }) &&
this.eventMatchesRecordFilter({ eventPayload, eventListener }) &&
- this.eventMatchesRecordShare({ eventPayload, recordShareGate })
+ admittedRecordIds.has(eventPayload.recordId)
);
}
- private eventMatchesRecordShare({
- eventPayload,
- recordShareGate,
- }: Pick<TriggerEvaluationArgs, 'eventPayload'> & {
- recordShareGate: RecordShareGate | null;
- }) {
- if (!isDefined(recordShareGate)) {
- return true;
- }
-
- return isRecordAdmittedByRecordShareGate({
- recordShareGate,
- recordId: eventPayload.recordId,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
- });
- }
-
private eventMatchesWatchedFields({
eventPayload,
eventListener,
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts
index 97a568a9065..c22f141dca3 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/create-share-with-object-records-permissions.integration-spec.ts
@@ -157,10 +157,10 @@ describe('createShareWithObjectRecordsPermissions', () => {
const createdPersonIds: string[] = [];
const findRecordShares = (recordId: string) =>
- recordShareService.findByRecord({
+ recordShareService.findByRecordIds({
workspaceId: SEED_APPLE_WORKSPACE_ID,
objectMetadataId,
- recordId,
+ recordIds: [recordId],
});
const trackRecordId = (): string => {
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts
index 3392aa09b8e..d0faf445662 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts
@@ -1,6 +1,10 @@
import { randomUUID } from 'node:crypto';
import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import {
+ type ObjectRecordDeleteEvent,
+ type ObjectRecordEvent,
+} from 'twenty-shared/database-events';
import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';
@@ -466,14 +470,20 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
expect(noteObjectMetadata).toBeDefined();
- const recordIdsReadableThroughParents =
+ const recordIdsAdmittedByEventGate =
await getAppProviderByClassName<RecordAccessPolicyService>(
'RecordAccessPolicyService',
- ).resolveRecordIdsReadableThroughParents({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- objectMetadata: noteObjectMetadata!,
- records: NOTE_IDS.map((id) => ({ id })),
- subject: {
+ )
+ .buildEventRecordShareGate({
+ name: 'note.created',
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ objectMetadata: noteObjectMetadata!,
+ events: NOTE_IDS.map((id) => ({
+ recordId: id,
+ properties: { after: { id } },
+ })),
+ })
+ .resolveAdmittedRecordIds({
objectsPermissions: rolesPermissions[memberRole.id],
principalIds: [
EVERYONE_PRINCIPAL_ID,
@@ -482,12 +492,11 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
],
isOwningApplication: () => false,
resolveRowLevelPermissionRecordFilter: () => null,
- },
- });
+ });
const notesResponse =
await makeGraphqlAPIRequestWithMemberRole(findNotesOperation);
- expect([...recordIdsReadableThroughParents].sort()).toEqual(
+ expect([...recordIdsAdmittedByEventGate].sort()).toEqual(
collectIds(notesResponse.body.data.notes.edges),
);
});
@@ -628,18 +637,17 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
flatEntityId: noteObjectMetadataId,
flatEntityMaps: flatObjectMetadataMaps,
});
- const resolveReadableNoteIds = (
- records: Parameters<
- RecordAccessPolicyService['resolveRecordIdsReadableThroughParents']
- >[0]['records'],
- ) =>
+ const resolveReadableNoteIds = (events: ObjectRecordEvent[]) =>
getAppProviderByClassName<RecordAccessPolicyService>(
'RecordAccessPolicyService',
- ).resolveRecordIdsReadableThroughParents({
- workspaceId: SEED_APPLE_WORKSPACE_ID,
- objectMetadata: noteObjectMetadata!,
- records,
- subject: {
+ )
+ .buildEventRecordShareGate({
+ name: 'note.deleted',
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ objectMetadata: noteObjectMetadata!,
+ events,
+ })
+ .resolveAdmittedRecordIds({
objectsPermissions: rolesPermissions[memberRole.id],
principalIds: [
EVERYONE_PRINCIPAL_ID,
@@ -648,8 +656,7 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
],
isOwningApplication: () => false,
resolveRowLevelPermissionRecordFilter: () => null,
- },
- });
+ });
const noteOnPersonFilter = { id: { eq: NOTE_ON_PERSON_ID } };
const deleteResponse = await makeGraphqlAPIRequest(
@@ -660,21 +667,30 @@ describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {
filter: noteOnPersonFilter,
}),
);
+ const deletedNoteEventProperties = {
+ before: { id: NOTE_ON_PERSON_ID },
+ after: { id: NOTE_ON_PERSON_ID },
+ updatedFields: ['deletedAt'],
+ diff: {},
+ };
const readableThroughLiveLinks = await resolveReadableNoteIds([
- { id: NOTE_ON_PERSON_ID },
+ { recordId: NOTE_ON_PERSON_ID, properties: deletedNoteEventProperties },
]);
const readableThroughCapturedLinks = await resolveReadableNoteIds([
{
- id: NOTE_ON_PERSON_ID,
- inheritedReadabilityChildRecords: {
- noteTarget: [
- {
- id: PERSON_NOTE_TARGET_ID,
- noteId: NOTE_ON_PERSON_ID,
- targetPersonId: PERSON_ID,
- },
- ],
- },
+ recordId: NOTE_ON_PERSON_ID,
+ properties: {
+ ...deletedNoteEventProperties,
+ inheritedReadabilityChildRecords: {
+ noteTarget: [
+ {
+ id: PERSON_NOTE_TARGET_ID,
+ noteId: NOTE_ON_PERSON_ID,
+ targetPersonId: PERSON_ID,
+ },
+ ],
+ },
+ } as ObjectRecordDeleteEvent['properties'],
},
]);
const restoreResponse = await makeGraphqlAPIRequest(
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts
index daa5316a54e..ec051738a20 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts
@@ -105,10 +105,10 @@ describe('recordShare object', () => {
recordShares: [recordShareInput],
});
- const insertedRecordShares = await recordShareService.findByRecord({
+ const insertedRecordShares = await recordShareService.findByRecordIds({
workspaceId: SEED_APPLE_WORKSPACE_ID,
objectMetadataId: personObjectMetadataId,
- recordId: PERSON_DATA_SEED_IDS.ID_1,
+ recordIds: [PERSON_DATA_SEED_IDS.ID_1],
});
expect(insertedRecordShares).toHaveLength(1);
@@ -122,10 +122,10 @@ describe('recordShare object', () => {
});
const recordSharesAfterDuplicateInsert =
- await recordShareService.findByRecord({
+ await recordShareService.findByRecordIds({
workspaceId: SEED_APPLE_WORKSPACE_ID,
objectMetadataId: personObjectMetadataId,
- recordId: PERSON_DATA_SEED_IDS.ID_1,
+ recordIds: [PERSON_DATA_SEED_IDS.ID_1],
});
expect(recordSharesAfterDuplicateInsert).toHaveLength(1);
@@ -138,10 +138,10 @@ describe('recordShare object', () => {
sourceId,
});
- const recordSharesAfterDelete = await recordShareService.findByRecord({
+ const recordSharesAfterDelete = await recordShareService.findByRecordIds({
workspaceId: SEED_APPLE_WORKSPACE_ID,
objectMetadataId: personObjectMetadataId,
- recordId: PERSON_DATA_SEED_IDS.ID_1,
+ recordIds: [PERSON_DATA_SEED_IDS.ID_1],
});
expect(recordSharesAfterDelete).toHaveLength(0);
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
index efa55a441c7..7f3f469542c 100644
--- 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
@@ -28,8 +28,7 @@ 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 { isRecordAdmittedByRecordShareGate } from 'src/engine/record-share/utils/is-record-admitted-by-record-share-gate.util';
+import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/record-share/utils/resolve-record-ids-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';
@@ -88,18 +87,17 @@ describe('recordShareTwinObjectRecordsPermissions', () => {
}: {
principalIds: string[];
operationType: 'select' | 'update';
- }) =>
- ALL_RECORD_IDS.filter((recordId) =>
- isRecordAdmittedByRecordShareGate({
- recordShareGate: {
- recordSharesByRecordId: indexRecordSharesByRecordId(recordShares),
- principalIds,
- recordIdsReadableThroughParents: new Set(),
- },
- recordId,
- accessLevels: resolveRequiredRecordShareAccessLevels(operationType),
- }),
+ }) => {
+ const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({
+ recordShares,
+ principalIds,
+ accessLevels: resolveRequiredRecordShareAccessLevels(operationType),
+ });
+
+ return ALL_RECORD_IDS.filter((recordId) =>
+ sharedRecordIds.has(recordId),
).sort();
+ };
beforeAll(async () => {
recordShareService =