Skip to content

The open alternative to Salesforce, designed for AI.

fix(sharing): enforce upgraded metadata before sharing rollout (#26520)

Félix Malfait545a4a666738
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
index b538df880e3..d6955bdac4a 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
@@ -384,7 +384,6 @@ export abstract class CommonBaseQueryRunnerService<
rolePermissionConfig,
repository,
featureFlagsMap: context.featureFlagsMap,
- isRecordSharingEnabled: context.isRecordSharingEnabled,
};
}
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts
index 2c30fcd917f..ba003ad8f52 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts
@@ -86,7 +86,8 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
if (isPrivateObject || isNonEmptyArray(args.shareWith)) {
await this.shareWithService.validateShareWithOrThrow({
authContext: queryRunnerContext.authContext,
- isRecordSharingEnabled: this.isRecordSharingEnabled(queryRunnerContext),
+ isRecordSharingEnforced:
+ this.isRecordSharingEnforced(queryRunnerContext),
shareWith: args.shareWith,
});
}
@@ -620,7 +621,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
objectMetadataId: flatObjectMetadata.id,
recordIds: insertResult.generatedMaps.map((record) => record.id),
apiKeyRoleMap: repository.internalContext.apiKeyRoleMap,
- isRecordSharingEnabled: this.isRecordSharingEnabled(queryRunnerContext),
+ isRecordSharingEnforced: this.isRecordSharingEnforced(queryRunnerContext),
shareWith,
transactionScope,
});
@@ -632,20 +633,20 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
switch (queryRunnerContext.flatObjectMetadata.readability) {
case MetadataReadability.PRIVATE:
return true;
- // An inherited record gets its creator's share row like a PRIVATE one,
- // but one created while the flag is off must keep following its parent
- // once the flag turns on instead of becoming readable by everyone
+ // Legacy inherited records must keep following their parent after
+ // activation instead of receiving an EVERYONE compatibility grant.
case MetadataReadability.INHERITED:
- return this.isRecordSharingEnabled(queryRunnerContext);
+ return this.isRecordSharingEnforced(queryRunnerContext);
default:
return false;
}
}
- private isRecordSharingEnabled(
+ private isRecordSharingEnforced(
queryRunnerContext: CommonExtendedQueryRunnerContext,
): boolean {
- return queryRunnerContext.isRecordSharingEnabled;
+ return !queryRunnerContext.repository.internalContext
+ .isLegacyRecordAccessOpen;
}
private resolveNestedRelationsForCreate({
diff --git a/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts b/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts
index dfe1abb46dd..bf11e437dde 100644
--- a/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts
+++ b/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts
@@ -15,5 +15,4 @@ export type CommonExtendedQueryRunnerContext = Omit<
repository: WorkspaceRepository<ObjectRecord>;
commonQueryParser: GraphqlQueryParser;
featureFlagsMap: Record<FeatureFlagKey, boolean>;
- isRecordSharingEnabled: boolean;
};
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts
index e5b3012423b..48a59c61833 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-trigger/triggers/database-event/__tests__/call-database-event-trigger-jobs.job.spec.ts
@@ -130,7 +130,10 @@ describe('CallDatabaseEventTriggerJobsJob', () => {
let job: CallDatabaseEventTriggerJobsJob;
let messageQueueService: { bulkAdd: jest.Mock };
let recordShareService: { findByRecordIds: jest.Mock };
- let recordSharingFeatureService: { isRecordSharingEnabled: jest.Mock };
+ let recordSharingFeatureService: {
+ isRecordSharingEnabled: jest.Mock;
+ isLegacyRecordAccessOpen: jest.Mock;
+ };
let cacheData: Record<string, unknown>;
const buildBatch = (
@@ -182,8 +185,11 @@ describe('CallDatabaseEventTriggerJobsJob', () => {
};
messageQueueService = { bulkAdd: jest.fn().mockResolvedValue(undefined) };
- recordShareService = { findByRecordIds: jest.fn().mockResolvedValue([]) };
+ recordShareService = {
+ findByRecordIds: jest.fn().mockResolvedValue([]),
+ };
recordSharingFeatureService = {
+ isLegacyRecordAccessOpen: jest.fn().mockResolvedValue(false),
isRecordSharingEnabled: jest.fn().mockResolvedValue(false),
};
@@ -198,14 +204,20 @@ describe('CallDatabaseEventTriggerJobsJob', () => {
{
provide: WorkspaceCacheService,
useValue: {
- getOrRecompute: jest.fn().mockImplementation(async () => cacheData),
+ getOrRecompute: jest.fn().mockImplementation(async () => ({
+ flatObjectMetadataMaps: { byUniversalIdentifier: {} },
+ ...cacheData,
+ })),
},
},
{
provide: ApplicationJobEnqueueThrottlerService,
useValue: { throttleOrThrow: jest.fn().mockResolvedValue(undefined) },
},
- { provide: RecordShareService, useValue: recordShareService },
+ {
+ provide: RecordShareService,
+ useValue: recordShareService,
+ },
{
provide: RecordSharingFeatureService,
useValue: recordSharingFeatureService,
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
index a3d6a79846a..19c418716f0 100644
--- 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
@@ -1,63 +1,127 @@
import { Test } from '@nestjs/testing';
-import { MetadataReadability } from 'twenty-shared/types';
-
+import {
+ MetadataReadability,
+ RecordShareRowCause,
+ RecordShareAccessLevel,
+} 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 { RecordShareService } from 'src/engine/core-modules/record-share/services/record-share.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,
+const setup = async ({
+ rowCause,
+ legacyOpen = false,
+}: { rowCause?: RecordShareRowCause; legacyOpen?: boolean } = {}) => {
+ const module = await Test.createTestingModule({
+ providers: [
+ RecordAccessPolicyService,
+ { provide: WorkspaceOrmManager, useValue: {} },
+ { provide: WorkspaceCacheService, useValue: {} },
+ {
+ provide: RecordSharingFeatureService,
+ useValue: {
+ isLegacyRecordAccessOpen: jest.fn().mockResolvedValue(legacyOpen),
+ },
+ },
+ {
+ provide: RecordShareService,
+ useValue: {
+ findByRecordIds: jest.fn().mockResolvedValue(
+ rowCause
+ ? [
+ {
+ recordId: 'record',
+ principalId: 'member',
+ rowCause,
+ accessLevel: RecordShareAccessLevel.FULL,
+ },
+ ]
+ : [],
+ ),
},
- events: [
- {
- recordId: 'private-record',
- properties: { after: { id: 'private-record' } },
- },
- ],
- });
+ },
+ ],
+ }).compile();
+ const gate = (readability: MetadataReadability) =>
+ module.get(RecordAccessPolicyService).buildEventRecordAccessGate({
+ name: 'company.created',
+ workspaceId: COMPANY_FLAT_OBJECT_MOCK.workspaceId,
+ objectMetadata: { ...COMPANY_FLAT_OBJECT_MOCK, readability },
+ events: [{ recordId: 'record', properties: { after: { id: 'record' } } }],
+ });
+ return { module, gate };
+};
+
+const subject = {
+ objectsPermissions: undefined,
+ principalIds: ['member'],
+ isOwningApplication: () => false,
+ resolveRowLevelPermissionRecordFilter: () => null,
+};
+
+describe('mandatory event visibility', () => {
+ it('resolves rollout access once per batch across concurrent subscribers', async () => {
+ const { module, gate } = await setup({
+ rowCause: RecordShareRowCause.OWNER,
+ });
+ const eventGate = gate(MetadataReadability.PRIVATE);
+ const admitted = await Promise.all([
+ eventGate.resolveAdmittedRecordIds(subject),
+ eventGate.resolveAdmittedRecordIds({
+ ...subject,
+ principalIds: ['other-member'],
+ }),
+ ]);
+ expect(admitted).toEqual([new Set(['record']), new Set()]);
+ expect(
+ module.get(RecordSharingFeatureService).isLegacyRecordAccessOpen,
+ ).toHaveBeenCalledTimes(1);
+ await gate(MetadataReadability.PRIVATE).resolveAdmittedRecordIds(subject);
+ expect(
+ module.get(RecordSharingFeatureService).isLegacyRecordAccessOpen,
+ ).toHaveBeenCalledTimes(2);
+ await module.close();
+ });
+ it.each([true, false])(
+ 'denies SYSTEM records with owning application=%s',
+ async (isOwningApplication) => {
+ const { module, gate } = await setup();
expect(
- await gate.resolveAdmittedRecordIds({
- objectsPermissions: undefined,
- principalIds: ['everyone'],
- isOwningApplication: () => owningApplication,
- resolveRowLevelPermissionRecordFilter: () => null,
+ await gate(MetadataReadability.SYSTEM).resolveAdmittedRecordIds({
+ ...subject,
+ isOwningApplication: () => isOwningApplication,
}),
).toEqual(new Set());
await module.close();
},
);
+
+ it.each([
+ RecordShareRowCause.OWNER,
+ RecordShareRowCause.APPLICATION,
+ RecordShareRowCause.MANUAL,
+ ])('honors %s grants after metadata activation', async (rowCause) => {
+ const { module, gate } = await setup({ rowCause });
+ expect(
+ await gate(MetadataReadability.PRIVATE).resolveAdmittedRecordIds(subject),
+ ).toEqual(new Set(['record']));
+ await module.close();
+ });
+
+ it.each([true, false])(
+ 'uses the resolved legacy-access decision (%s) for unshared events',
+ async (legacyOpen) => {
+ const { module, gate } = await setup({ legacyOpen });
+ expect(
+ await gate(MetadataReadability.PRIVATE).resolveAdmittedRecordIds(
+ subject,
+ ),
+ ).toEqual(new Set(legacyOpen ? ['record'] : []));
+ await module.close();
+ },
+ );
});
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/__tests__/record-sharing-feature.service.legacy-access.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/__tests__/record-sharing-feature.service.legacy-access.spec.ts
new file mode 100644
index 00000000000..071414386a1
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/__tests__/record-sharing-feature.service.legacy-access.spec.ts
@@ -0,0 +1,88 @@
+import { Test } from '@nestjs/testing';
+import { DiscoveryService } from '@nestjs/core';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { MetadataReadability } from 'twenty-shared/types';
+import { RecordSharingEntitlementProvider } from 'src/engine/core-modules/record-share/interfaces/record-sharing-entitlement-provider.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';
+
+class TestEntitlementProvider extends RecordSharingEntitlementProvider {
+ hasRecordSharingEntitlement = jest.fn<Promise<boolean>, [string]>();
+}
+
+const setup = async ({
+ readability = MetadataReadability.SYSTEM,
+ flag = true,
+ entitled = false,
+}: {
+ readability?: MetadataReadability;
+ flag?: boolean;
+ entitled?: boolean;
+} = {}) => {
+ const provider = new TestEntitlementProvider();
+ provider.hasRecordSharingEntitlement.mockResolvedValue(entitled);
+ const module = await Test.createTestingModule({
+ providers: [
+ RecordSharingFeatureService,
+ {
+ provide: DiscoveryService,
+ useValue: { getProviders: () => [{ instance: provider }] },
+ },
+ {
+ provide: WorkspaceCacheService,
+ useValue: {
+ getOrRecompute: jest.fn().mockResolvedValue({
+ flatObjectMetadataMaps: {
+ byUniversalIdentifier: {
+ [STANDARD_OBJECTS.agentChatThread.universalIdentifier]: {
+ readability,
+ },
+ },
+ },
+ featureFlagsMap: { IS_RECORD_SHARING_ENABLED: flag },
+ billingEntitlements: {},
+ }),
+ },
+ },
+ ],
+ }).compile();
+ await module.init();
+ return { module, provider, service: module.get(RecordSharingFeatureService) };
+};
+
+describe('record-sharing rollout entitlement compatibility', () => {
+ it('honors an effective self-hosted entitlement even with an empty billing cache', async () => {
+ const { module, provider, service } = await setup({ entitled: true });
+ expect(await service.isLegacyRecordAccessOpen('workspace')).toBe(false);
+ expect(provider.hasRecordSharingEntitlement).toHaveBeenCalledWith(
+ 'workspace',
+ );
+ await module.close();
+ });
+
+ it('preserves legacy access when sharing was not entitled', async () => {
+ const { module, service } = await setup();
+ expect(await service.isLegacyRecordAccessOpen('workspace')).toBe(true);
+ await module.close();
+ });
+
+ it('does not consult entitlement once metadata has been activated', async () => {
+ const { module, provider, service } = await setup({
+ readability: MetadataReadability.PRIVATE,
+ flag: false,
+ });
+ expect(await service.isLegacyRecordAccessOpen('workspace')).toBe(false);
+ expect(provider.hasRecordSharingEntitlement).not.toHaveBeenCalled();
+ await module.close();
+ });
+
+ it('keeps the legacy-open policy when the feature flag is off', async () => {
+ const { module, provider, service } = await setup({
+ flag: false,
+ entitled: true,
+ });
+ expect(await service.isLegacyRecordAccessOpen('workspace')).toBe(true);
+ expect(provider.hasRecordSharingEntitlement).not.toHaveBeenCalled();
+ 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 c009d4d1b69..4406eec8e2e 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
@@ -3,7 +3,7 @@
import { Injectable } from '@nestjs/common';
import { type ObjectRecordEvent } from 'twenty-shared/database-events';
-import { type ObjectRecord } from 'twenty-shared/types';
+import { MetadataReadability, type ObjectRecord } from 'twenty-shared/types';
import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import { isNonEmptyString } from '@sniptt/guards';
import { In } from 'typeorm';
@@ -11,8 +11,8 @@ import { In } from 'typeorm';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
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/core-modules/record-share/services/record-share.service';
import { RecordSharingFeatureService } from 'src/engine/core-modules/record-share/services/record-sharing-feature.service';
+import { RecordShareService } from 'src/engine/core-modules/record-share/services/record-share.service';
import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';
import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
import {
@@ -46,7 +46,7 @@ type SnapshotEvaluation = {
subject: RowAccessPolicySubject;
depth: number;
maps?: ReadabilityMaps;
- isRecordSharingEnabled?: boolean;
+ isLegacyRecordAccessOpen?: boolean;
};
type SnapshotEvaluationInContext = SnapshotEvaluation & {
@@ -80,10 +80,10 @@ export class RecordAccessPolicyService {
recordIds: events.map((event) => event.recordId),
}));
- let isRecordSharingEnabledPromise: Promise<boolean> | undefined;
- const fetchIsRecordSharingEnabled = () =>
- (isRecordSharingEnabledPromise ??=
- this.recordSharingFeatureService.isRecordSharingEnabled(workspaceId));
+ let legacyRecordAccessOpenPromise: Promise<boolean> | undefined;
+ const fetchLegacyRecordAccessOpen = () =>
+ (legacyRecordAccessOpenPromise ??=
+ this.recordSharingFeatureService.isLegacyRecordAccessOpen(workspaceId));
return {
resolveAdmittedRecordIds: async (subject) => {
@@ -106,7 +106,10 @@ export class RecordAccessPolicyService {
snapshots,
subject,
depth: 0,
- isRecordSharingEnabled: await fetchIsRecordSharingEnabled(),
+ isLegacyRecordAccessOpen:
+ objectMetadata.readability !== MetadataReadability.SYSTEM &&
+ objectMetadata.readability !== MetadataReadability.OPEN &&
+ (await fetchLegacyRecordAccessOpen()),
},
fetchRecordShares,
);
@@ -170,14 +173,14 @@ export class RecordAccessPolicyService {
fetchRecordShares: FetchRecordShares,
): Promise<Set<string>> {
const { objectMetadata, snapshots, subject } = evaluation;
- const resolvedIsRecordSharingEnabled =
- evaluation.isRecordSharingEnabled ??
- (await this.recordSharingFeatureService.isRecordSharingEnabled(
+ const legacyOpen =
+ evaluation.isLegacyRecordAccessOpen ??
+ (await this.recordSharingFeatureService.isLegacyRecordAccessOpen(
evaluation.workspaceId,
));
const gateKind = resolveRecordShareGateKind({
+ isRecordSharingEnabled: !legacyOpen,
readability: objectMetadata.readability,
- isRecordSharingEnabled: resolvedIsRecordSharingEnabled,
isOwningApplication: subject.isOwningApplication(objectMetadata),
});
@@ -199,7 +202,7 @@ export class RecordAccessPolicyService {
)),
...(await this.resolveSnapshotIdsReadableThroughParents({
...evaluation,
- isRecordSharingEnabled: resolvedIsRecordSharingEnabled,
+ isLegacyRecordAccessOpen: legacyOpen,
})),
]);
default:
@@ -313,8 +316,8 @@ export class RecordAccessPolicyService {
subject,
depth,
maps,
+ isLegacyRecordAccessOpen,
parent,
- isRecordSharingEnabled,
}: SnapshotEvaluationInContext & {
parent: InheritedReadabilityChildrenParent;
}): Promise<Set<string>> {
@@ -374,10 +377,10 @@ export class RecordAccessPolicyService {
workspaceId,
objectMetadata: parent.childFlatObjectMetadata,
snapshots: [...capturedChildSnapshotsBySnapshotId.values()].flat(),
- isRecordSharingEnabled,
subject,
depth: depth + 1,
maps,
+ isLegacyRecordAccessOpen,
});
for (const [
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing-feature.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing-feature.service.ts
index b83207a5054..41435ef944f 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing-feature.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing-feature.service.ts
@@ -9,6 +9,7 @@ import { isDefined } from 'twenty-shared/utils';
import { type RecordSharingEntitlementProvider } from 'src/engine/core-modules/record-share/interfaces/record-sharing-entitlement-provider.service';
import { NoRecordSharingEntitlementProvider } from 'src/engine/core-modules/record-share/services/no-record-sharing-entitlement-provider.service';
import { findRecordSharingEntitlementProvider } from 'src/engine/core-modules/record-share/utils/find-record-sharing-entitlement-provider.util';
+import { isLegacyRecordAccessOpen } from 'src/engine/core-modules/record-share/utils/is-legacy-record-access-open.util';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
@Injectable()
@@ -49,4 +50,21 @@ export class RecordSharingFeatureService implements OnModuleInit {
return this.entitlementProvider.hasRecordSharingEntitlement(workspaceId);
}
+
+ async isLegacyRecordAccessOpen(workspaceId: string): Promise<boolean> {
+ const { flatObjectMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ ]);
+ if (
+ !isLegacyRecordAccessOpen({
+ flatObjectMetadataMaps,
+ wasRecordSharingEnabled: false,
+ })
+ ) {
+ return false;
+ }
+
+ return !(await this.isRecordSharingEnabled(workspaceId));
+ }
}
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/share-with.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/share-with.service.ts
index 5d0d1e62df5..773abee76ec 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/share-with.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/share-with.service.ts
@@ -22,16 +22,16 @@ export class ShareWithService {
async validateShareWithOrThrow({
authContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith,
}: {
authContext: WorkspaceAuthContext;
- isRecordSharingEnabled: boolean;
+ isRecordSharingEnforced: boolean;
shareWith?: ShareWithInput[] | null;
}): Promise<void> {
validateShareWithArgOrThrow({
authContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith,
});
@@ -57,7 +57,7 @@ export class ShareWithService {
objectMetadataId,
recordIds,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith,
transactionScope,
}: {
@@ -65,7 +65,7 @@ export class ShareWithService {
objectMetadataId: string;
recordIds: string[];
apiKeyRoleMap: Record<string, string>;
- isRecordSharingEnabled: boolean;
+ isRecordSharingEnforced: boolean;
shareWith?: ShareWithInput[] | null;
transactionScope?: WorkspaceTransactionScope;
}): Promise<void> {
@@ -86,7 +86,7 @@ export class ShareWithService {
objectMetadataId,
authContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith,
}),
transactionScope,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts
index 5dafc867b09..cccea5325d0 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-inputs-for-created-records.util.spec.ts
@@ -56,7 +56,7 @@ const everyoneFullRowFor = (recordId: string) => ({
describe('buildRecordShareInputsForCreatedRecords', () => {
describe('with record sharing enabled', () => {
- const isRecordSharingEnabled = true;
+ const isRecordSharingEnforced = true;
it('should give a user a FULL owner row per record', () => {
expect(
@@ -65,7 +65,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: userAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
}),
).toEqual([
{
@@ -96,7 +96,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: userAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ roleId: ROLE_ID, accessLevel: RecordShareAccessLevel.READ },
{
@@ -135,7 +135,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: apiKeyAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
@@ -169,7 +169,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: apiKeyAuthContext,
apiKeyRoleMap: {},
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
@@ -189,7 +189,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: applicationAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ roleId: ROLE_ID, accessLevel: RecordShareAccessLevel.FULL },
],
@@ -223,7 +223,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: applicationAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{
roleId: APPLICATION_ROLE_ID,
@@ -254,7 +254,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
application: { id: APPLICATION_ID, defaultRoleId: null },
} as unknown as WorkspaceAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ roleId: ROLE_ID, accessLevel: RecordShareAccessLevel.FULL },
],
@@ -269,7 +269,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: systemAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
@@ -289,7 +289,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
});
describe('with record sharing disabled', () => {
- const isRecordSharingEnabled = false;
+ const isRecordSharingEnforced = false;
it('should give a user the FULL owner row and an EVERYONE FULL row, so the record stays open once the flag turns on', () => {
expect(
@@ -298,7 +298,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: userAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: null,
}),
).toEqual([
@@ -317,7 +317,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: apiKeyAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
}),
).toEqual([
everyoneFullRowFor('record-1'),
@@ -332,7 +332,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: systemAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [],
}),
).toEqual([everyoneFullRowFor('record-1')]);
@@ -345,7 +345,7 @@ describe('buildRecordShareInputsForCreatedRecords', () => {
objectMetadataId: OBJECT_METADATA_ID,
authContext: apiKeyAuthContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{
workspaceMemberId: OTHER_WORKSPACE_MEMBER_ID,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/is-legacy-record-access-open.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/is-legacy-record-access-open.util.spec.ts
new file mode 100644
index 00000000000..49e91bf7193
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/is-legacy-record-access-open.util.spec.ts
@@ -0,0 +1,41 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { MetadataReadability } from 'twenty-shared/types';
+import { isLegacyRecordAccessOpen } from 'src/engine/core-modules/record-share/utils/is-legacy-record-access-open.util';
+import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';
+
+it.each([
+ [MetadataReadability.SYSTEM, false, false, true],
+ [MetadataReadability.SYSTEM, true, false, true],
+ [MetadataReadability.SYSTEM, true, true, false],
+ [MetadataReadability.PRIVATE, false, false, false],
+ [MetadataReadability.PRIVATE, true, false, false],
+])(
+ 'preserves pre-upgrade policy only until metadata activation: %s/%s/%s',
+ (readability, flag, entitlement, expected) => {
+ const legacyOpen = isLegacyRecordAccessOpen({
+ flatObjectMetadataMaps: {
+ byUniversalIdentifier: {
+ [STANDARD_OBJECTS.agentChatThread.universalIdentifier]: {
+ readability,
+ },
+ },
+ },
+ wasRecordSharingEnabled: flag && entitlement,
+ });
+ expect(legacyOpen).toBe(expected);
+ expect(
+ resolveRecordShareGateKind({
+ readability: MetadataReadability.PRIVATE,
+ isOwningApplication: false,
+ isRecordSharingEnabled: !legacyOpen,
+ }),
+ ).toBe(expected ? 'open' : 'private');
+ expect(
+ resolveRecordShareGateKind({
+ readability: MetadataReadability.SYSTEM,
+ isOwningApplication: false,
+ isRecordSharingEnabled: !legacyOpen,
+ }),
+ ).toBe('deny');
+ },
+);
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/validate-share-with-arg-or-throw.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/validate-share-with-arg-or-throw.util.spec.ts
index 381b443a41c..4fc113126cf 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/validate-share-with-arg-or-throw.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/validate-share-with-arg-or-throw.util.spec.ts
@@ -29,13 +29,13 @@ const SHARE_WITH_REQUIRED_MESSAGE =
describe('validateShareWithArgOrThrow', () => {
describe('with record sharing enabled', () => {
- const isRecordSharingEnabled = true;
+ const isRecordSharingEnforced = true;
it('should accept a user without shareWith', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: userAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
}),
).not.toThrow();
});
@@ -44,7 +44,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: apiKeyAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
}),
).toThrow(SHARE_WITH_REQUIRED_MESSAGE);
});
@@ -53,7 +53,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: apiKeyAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [],
}),
).toThrow(SHARE_WITH_REQUIRED_MESSAGE);
@@ -63,7 +63,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: systemAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
}),
).toThrow(SHARE_WITH_REQUIRED_MESSAGE);
});
@@ -72,7 +72,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: apiKeyAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ everyone: true, accessLevel: RecordShareAccessLevel.READ },
],
@@ -82,13 +82,13 @@ describe('validateShareWithArgOrThrow', () => {
});
describe('with record sharing disabled', () => {
- const isRecordSharingEnabled = false;
+ const isRecordSharingEnforced = false;
it('should accept an api key without shareWith', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: apiKeyAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
}),
).not.toThrow();
});
@@ -97,7 +97,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: systemAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [],
}),
).not.toThrow();
@@ -107,7 +107,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: apiKeyAuthContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith: [
{ everyone: false, accessLevel: RecordShareAccessLevel.READ },
],
@@ -122,7 +122,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: userAuthContext,
- isRecordSharingEnabled: true,
+ isRecordSharingEnforced: true,
shareWith: null,
}),
).not.toThrow();
@@ -132,7 +132,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: userAuthContext,
- isRecordSharingEnabled: true,
+ isRecordSharingEnforced: true,
shareWith: [
{
workspaceMemberId: OTHER_WORKSPACE_MEMBER_ID,
@@ -151,7 +151,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: userAuthContext,
- isRecordSharingEnabled: true,
+ isRecordSharingEnforced: true,
shareWith: [
{ everyone: false, accessLevel: RecordShareAccessLevel.READ },
],
@@ -165,7 +165,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: userAuthContext,
- isRecordSharingEnabled: true,
+ isRecordSharingEnforced: true,
shareWith: [
{
workspaceMemberId: 'not-a-uuid',
@@ -180,7 +180,7 @@ describe('validateShareWithArgOrThrow', () => {
expect(() =>
validateShareWithArgOrThrow({
authContext: userAuthContext,
- isRecordSharingEnabled: true,
+ isRecordSharingEnforced: true,
shareWith: [
{
workspaceMemberId: OTHER_WORKSPACE_MEMBER_ID,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-inputs-for-created-records.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-inputs-for-created-records.util.ts
index 1067ea2bad6..fc8eb92138a 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-inputs-for-created-records.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-inputs-for-created-records.util.ts
@@ -112,21 +112,21 @@ export const buildRecordShareInputsForCreatedRecords = ({
objectMetadataId,
authContext,
apiKeyRoleMap,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith,
}: {
recordIds: string[];
objectMetadataId: string;
authContext: WorkspaceAuthContext;
apiKeyRoleMap: Record<string, string>;
- isRecordSharingEnabled: boolean;
+ isRecordSharingEnforced: boolean;
shareWith?: ShareWithInput[] | null;
}): RecordShareInput[] => {
const shareWithEntries = shareWith ?? [];
- // A record created while the flag is off is readable by everyone today and
- // must stay so once the flag turns on, whoever created it
+ // Records created under legacy open access must remain accessible after
+ // enforcement is activated, whoever created them.
const everyoneFullRows =
- !isRecordSharingEnabled && !isNonEmptyArray(shareWithEntries)
+ !isRecordSharingEnforced && !isNonEmptyArray(shareWithEntries)
? recordIds.map((recordId) => ({
recordId,
objectMetadataId,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/is-legacy-record-access-open.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/is-legacy-record-access-open.util.ts
new file mode 100644
index 00000000000..7062520fcfe
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/is-legacy-record-access-open.util.ts
@@ -0,0 +1,25 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { MetadataReadability } from 'twenty-shared/types';
+
+export const isLegacyRecordAccessOpen = ({
+ flatObjectMetadataMaps,
+ wasRecordSharingEnabled,
+}: {
+ flatObjectMetadataMaps: {
+ byUniversalIdentifier: Record<
+ string,
+ { readability: MetadataReadability } | undefined
+ >;
+ };
+ wasRecordSharingEnabled: boolean;
+}): boolean => {
+ const thread =
+ flatObjectMetadataMaps.byUniversalIdentifier[
+ STANDARD_OBJECTS.agentChatThread.universalIdentifier
+ ];
+ // SYSTEM stays in place until compatibility grants have committed.
+ return (
+ thread?.readability === MetadataReadability.SYSTEM &&
+ !wasRecordSharingEnabled
+ );
+};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/validate-share-with-arg-or-throw.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/validate-share-with-arg-or-throw.util.ts
index 8c12aa3fb83..0c2d2caf468 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/validate-share-with-arg-or-throw.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/validate-share-with-arg-or-throw.util.ts
@@ -14,15 +14,15 @@ import { resolveShareWithPrincipalOrThrow } from 'src/engine/core-modules/record
export const validateShareWithArgOrThrow = ({
authContext,
- isRecordSharingEnabled,
+ isRecordSharingEnforced,
shareWith,
}: {
authContext: WorkspaceAuthContext;
- isRecordSharingEnabled: boolean;
+ isRecordSharingEnforced: boolean;
shareWith?: ShareWithInput[] | null;
}): void => {
if (
- isRecordSharingEnabled &&
+ isRecordSharingEnforced &&
!isUserAuthContext(authContext) &&
!isNonEmptyArray(shareWith)
) {
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
index 856d78658f8..d16553bfbeb 100644
--- 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
@@ -39,7 +39,10 @@ describe('webhook mandatory visibility', () => {
{ provide: RecordShareService, useValue: {} },
{
provide: RecordSharingFeatureService,
- useValue: { isRecordSharingEnabled: async () => sharingEnabled },
+ useValue: {
+ isLegacyRecordAccessOpen: async () => false,
+ isRecordSharingEnabled: async () => sharingEnabled,
+ },
},
{
provide: WebhookRateLimitService,
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 1d49d06f11f..10213ac3ba2 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
@@ -106,7 +106,10 @@ describe('ObjectRecordEventPublisher', () => {
>
>;
let mockRecordSharingFeatureService: jest.Mocked<
- Pick<RecordSharingFeatureService, 'isRecordSharingEnabled'>
+ Pick<
+ RecordSharingFeatureService,
+ 'isRecordSharingEnabled' | 'isLegacyRecordAccessOpen'
+ >
>;
let mockRecordShareService: jest.Mocked<
Pick<RecordShareService, 'findByRecordIds'>
@@ -208,6 +211,8 @@ describe('ObjectRecordEventPublisher', () => {
const createPermissionsContext = (
overrides: PermissionsContextOverrides = {},
) => ({
+ flatObjectMetadataMaps: { byUniversalIdentifier: {} },
+ billingEntitlements: {},
flatRowLevelPermissionPredicateMaps: {
byId: {},
idByUniversalIdentifier: {},
@@ -283,6 +288,7 @@ describe('ObjectRecordEventPublisher', () => {
};
mockRecordSharingFeatureService = {
+ isLegacyRecordAccessOpen: jest.fn().mockResolvedValue(false),
isRecordSharingEnabled: jest.fn().mockResolvedValue(false),
};
@@ -552,16 +558,12 @@ describe('ObjectRecordEventPublisher', () => {
});
});
- it('should only publish events of a private object for records shared with the subscriber', async () => {
+ it('only publishes shared private records after metadata activation', async () => {
const privateObjectMetadata: FlatObjectMetadata = {
...companyObjectMetadata,
readability: MetadataReadability.PRIVATE,
};
- mockRecordSharingFeatureService.isRecordSharingEnabled.mockResolvedValue(
- true,
- );
-
mockRecordShareService.findByRecordIds.mockResolvedValue([
{
id: 'record-share-1',
@@ -608,7 +610,7 @@ describe('ObjectRecordEventPublisher', () => {
).toEqual(['record-1']);
});
- it('should read the record sharing entitlement once for a batch whatever the subscriber count', async () => {
+ it('publishes a batch without consulting the sharing rollout flag', async () => {
mockRecordSharingFeatureService.isRecordSharingEnabled.mockResolvedValue(
true,
);
@@ -633,7 +635,7 @@ describe('ObjectRecordEventPublisher', () => {
).toHaveBeenCalledTimes(3);
expect(
mockRecordSharingFeatureService.isRecordSharingEnabled,
- ).toHaveBeenCalledTimes(1);
+ ).not.toHaveBeenCalled();
});
it('should not publish events when record does not match RLS filter', async () => {
diff --git a/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.ts b/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.ts
new file mode 100644
index 00000000000..dc429c833f0
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.ts
@@ -0,0 +1,50 @@
+import { Test } from '@nestjs/testing';
+
+import { RecordSharingFeatureService } from 'src/engine/core-modules/record-share/services/record-sharing-feature.service';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { WorkspaceDataSourceService } from 'src/engine/twenty-orm/datasource/workspace-data-source.service';
+import { getWorkspaceContext } from 'src/engine/twenty-orm/storage/orm-workspace-context.storage';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+describe('workspace context sharing enforcement', () => {
+ it.each([true, false])(
+ 'uses the same rollout decision (%s) in lite and full contexts',
+ async (isLegacyRecordAccessOpen) => {
+ const module = await Test.createTestingModule({
+ providers: [
+ WorkspaceOrmManager,
+ { provide: WorkspaceDataSourceService, useValue: {} },
+ {
+ provide: WorkspaceCacheService,
+ useValue: {
+ getOrRecompute: jest.fn().mockResolvedValue({
+ flatObjectMetadataMaps: createEmptyFlatEntityMaps(),
+ }),
+ },
+ },
+ {
+ provide: RecordSharingFeatureService,
+ useValue: {
+ isLegacyRecordAccessOpen: jest
+ .fn()
+ .mockResolvedValue(isLegacyRecordAccessOpen),
+ },
+ },
+ ],
+ }).compile();
+ const manager = module.get(WorkspaceOrmManager);
+ const authContext = buildSystemAuthContext('workspace');
+ for (const lite of [true, false]) {
+ const decision = await manager.executeInWorkspaceContext(
+ () => getWorkspaceContext().isLegacyRecordAccessOpen,
+ authContext,
+ { lite },
+ );
+ expect(decision).toBe(isLegacyRecordAccessOpen);
+ }
+ await module.close();
+ },
+ );
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts b/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts
index b5d77c17f1c..b2a2fc2fc77 100644
--- a/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts
@@ -122,7 +122,7 @@ export class WorkspaceDataSourceService
objectIdByNameSingular: workspaceContext.objectIdByNameSingular,
featureFlagsMap: workspaceContext.featureFlagsMap,
billingEntitlements: workspaceContext.billingEntitlements,
- isRecordSharingEnabled: workspaceContext.isRecordSharingEnabled,
+ isLegacyRecordAccessOpen: workspaceContext.isLegacyRecordAccessOpen,
userWorkspaceRoleMap: workspaceContext.userWorkspaceRoleMap,
apiKeyRoleMap: workspaceContext.apiKeyRoleMap,
eventEmitterService: this.workspaceEventEmitter,
diff --git a/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts b/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts
index 01a331d5266..26871e5287c 100644
--- a/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts
@@ -22,7 +22,7 @@ export interface WorkspaceInternalContext {
objectIdByNameSingular: Record<string, string>;
featureFlagsMap: Record<FeatureFlagKey, boolean>;
billingEntitlements: BillingEntitlements;
- isRecordSharingEnabled: boolean;
+ isLegacyRecordAccessOpen?: boolean;
userWorkspaceRoleMap: UserWorkspaceRoleMap;
apiKeyRoleMap: Record<string, string>;
eventEmitterService: Pick<WorkspaceEventEmitter, 'emitDatabaseBatchEvent'>;
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 cfe6287bb74..2c0f3a7a4c7 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
@@ -1339,7 +1339,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
private shouldValidateInheritedParents(): boolean {
return (
!this.options.shouldBypassPermissionChecks &&
- this.isRecordSharingEnabled()
+ this.isRecordSharingEnforced()
);
}
@@ -1420,8 +1420,8 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
});
}
- private isRecordSharingEnabled(): boolean {
- return this.options.internalContext.isRecordSharingEnabled;
+ private isRecordSharingEnforced(): boolean {
+ return !this.options.internalContext.isLegacyRecordAccessOpen;
}
private async resolveWritableRecordIds({
@@ -1619,7 +1619,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
if (
records.length === 0 ||
flatObjectMetadata.readability !== MetadataReadability.INHERITED ||
- !this.isRecordSharingEnabled()
+ !this.isRecordSharingEnforced()
) {
return undefined;
}
@@ -1991,7 +1991,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
private resolveRowAccessPolicyEnvironment(): RowAccessPolicyEnvironment {
return {
- isRecordSharingEnabled: this.isRecordSharingEnabled(),
+ isRecordSharingEnabled: this.isRecordSharingEnforced(),
flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,
flatObjectMetadataMaps:
this.options.internalContext.flatObjectMetadataMaps,
diff --git a/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts b/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts
index 17e6ae0f1e1..3ded27684e7 100644
--- a/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts
@@ -23,7 +23,7 @@ export type ORMWorkspaceContext = {
objectIdByNameSingular: Record<string, string>;
featureFlagsMap: Record<FeatureFlagKey, boolean>;
billingEntitlements: BillingEntitlements;
- isRecordSharingEnabled: boolean;
+ isLegacyRecordAccessOpen?: boolean;
permissionsPerRoleId: ObjectsPermissionsByRoleId;
userWorkspaceRoleMap: UserWorkspaceRoleMap;
apiKeyRoleMap: Record<string, string>;
diff --git a/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts b/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts
index 58f077e0278..7aae1692ff3 100644
--- a/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts
@@ -96,7 +96,16 @@ export class WorkspaceOrmManager {
? await this.loadLiteWorkspaceContext(resolvedAuthContext)
: await this.loadWorkspaceContext(resolvedAuthContext);
- return withWorkspaceContext(context, fn);
+ return withWorkspaceContext(
+ {
+ ...context,
+ isLegacyRecordAccessOpen:
+ await this.recordSharingFeatureService.isLegacyRecordAccessOpen(
+ resolvedAuthContext.workspace.id,
+ ),
+ },
+ fn,
+ );
}
private async loadWorkspaceContext(
@@ -141,10 +150,6 @@ export class WorkspaceOrmManager {
objectIdByNameSingular,
featureFlagsMap,
billingEntitlements,
- isRecordSharingEnabled:
- await this.recordSharingFeatureService.isRecordSharingEnabled(
- workspaceId,
- ),
permissionsPerRoleId,
userWorkspaceRoleMap,
apiKeyRoleMap,
@@ -191,7 +196,6 @@ export class WorkspaceOrmManager {
objectIdByNameSingular,
featureFlagsMap: {} as ORMWorkspaceContext['featureFlagsMap'],
billingEntitlements,
- isRecordSharingEnabled: false,
permissionsPerRoleId: {},
userWorkspaceRoleMap: {},
apiKeyRoleMap: {},
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 6790ff0756e..686eabe0569 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
@@ -30,13 +30,17 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
let workspaceCacheService: jest.Mocked<WorkspaceCacheService>;
let recordShareService: jest.Mocked<RecordShareService>;
let recordSharingFeatureService: jest.Mocked<
- Pick<RecordSharingFeatureService, 'isRecordSharingEnabled'>
+ Pick<
+ RecordSharingFeatureService,
+ 'isRecordSharingEnabled' | 'isLegacyRecordAccessOpen'
+ >
>;
const setTriggerMap = (
listeners: Array<{ workflowId: string; settings: object; type?: unknown }>,
) => {
workspaceCacheService.getOrRecompute.mockResolvedValue({
+ flatObjectMetadataMaps: { byUniversalIdentifier: {} },
featureFlagsMap: {},
flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
flatRoleMaps: { byUniversalIdentifier: {} },
@@ -99,6 +103,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
workspaceCacheService = {
getOrRecompute: jest.fn().mockResolvedValue({
+ flatObjectMetadataMaps: { byUniversalIdentifier: {} },
featureFlagsMap: {},
flatApplicationMaps: { byId: {}, idByUniversalIdentifier: {} },
flatRoleMaps: { byUniversalIdentifier: {} },
@@ -111,6 +116,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
} as unknown as jest.Mocked<RecordShareService>;
recordSharingFeatureService = {
+ isLegacyRecordAccessOpen: jest.fn().mockResolvedValue(false),
isRecordSharingEnabled: jest.fn().mockResolvedValue(false),
};
@@ -441,6 +447,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
Promise.resolve(
!keys.includes('workflowAutomatedTriggerMaps')
? {
+ flatObjectMetadataMaps: { byUniversalIdentifier: {} },
featureFlagsMap: {},
flatApplicationMaps: {
byId: {
@@ -526,6 +533,7 @@ describe('WorkflowDatabaseEventTriggerListener', () => {
Promise.resolve(
!keys.includes('workflowAutomatedTriggerMaps')
? {
+ flatObjectMetadataMaps: { byUniversalIdentifier: {} },
featureFlagsMap: {},
flatApplicationMaps: {
byId: {},
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 151029c68fd..c71e13aa38f 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
@@ -666,62 +666,140 @@ describe('createShareWithObjectRecordsPermissions', () => {
});
});
- describe('PRIVATE readability with record sharing disabled', () => {
- beforeAll(async () => {
- await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
- await setRecordSharingEnabled(false);
- });
-
- it('should accept an api key create without shareWith and grant everyone FULL access', async () => {
- const recordId = trackRecordId();
-
- const response = await makeGraphqlAPIRequestWithApiKey(
- createOneOperation({
- data: { id: recordId, name: 'api key without shareWith' },
- }),
- );
+ describe.each([MetadataReadability.SYSTEM, MetadataReadability.PRIVATE])(
+ 'PRIVATE creates with the flag off and conversation readability %s',
+ (conversationReadability) => {
+ let conversationObjectMetadata: ObjectMetadataEntity;
+ const isLegacyOpen =
+ conversationReadability === MetadataReadability.SYSTEM;
+
+ beforeAll(async () => {
+ conversationObjectMetadata =
+ await getCoreRepository<ObjectMetadataEntity>(
+ ObjectMetadataEntity,
+ ).findOneOrFail({
+ where: {
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ nameSingular: 'agentChatThread',
+ },
+ });
+ await setObjectReadability(
+ conversationObjectMetadata.id,
+ conversationReadability,
+ );
+ await setObjectReadability(
+ objectMetadataId,
+ MetadataReadability.PRIVATE,
+ );
+ await setRecordSharingEnabled(false);
+ });
- expect(response.body.errors).toBeUndefined();
- expect(response.body.data.createShareWithTestObject.id).toBe(recordId);
+ afterAll(async () => {
+ await setObjectReadability(
+ conversationObjectMetadata.id,
+ conversationObjectMetadata.readability,
+ );
+ });
- expect(await findRecordShares(recordId)).toEqual([
- expect.objectContaining({
- recordId,
- principalId: EVERYONE_PRINCIPAL_ID,
- principalType: RecordSharePrincipalType.EVERYONE,
- accessLevel: RecordShareAccessLevel.FULL,
- rowCause: RecordShareRowCause.APPLICATION,
- sourceId: objectMetadataId,
- }),
- ]);
- });
+ it('requires an explicit API sharing target after activation', async () => {
+ const recordId = trackRecordId();
+ const response = await makeGraphqlAPIRequestWithApiKey(
+ createOneOperation({
+ data: { id: recordId, name: 'API create without shareWith' },
+ }),
+ );
- it('should give the creating member the owner row and everyone FULL access, so the record stays open once the flag turns on', async () => {
- const recordId = trackRecordId();
+ if (isLegacyOpen) {
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.createShareWithTestObject.id).toBe(
+ recordId,
+ );
+ expect(await findRecordShares(recordId)).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ principalType: RecordSharePrincipalType.EVERYONE,
+ accessLevel: RecordShareAccessLevel.FULL,
+ rowCause: RecordShareRowCause.APPLICATION,
+ sourceId: objectMetadataId,
+ }),
+ ]),
+ );
+ } else {
+ expect(response.body.errors[0].message).toBe(
+ SHARE_WITH_REQUIRED_MESSAGE,
+ );
+ expect(await findRecordShares(recordId)).toEqual([]);
+ }
+ });
- const response = await makeGraphqlAPIRequest(
- createOneOperation({
- data: { id: recordId, name: 'member with flag off' },
- }),
- );
+ it('keeps new member records private after activation', async () => {
+ const recordId = trackRecordId();
+ const response = await makeGraphqlAPIRequest(
+ createOneOperation({
+ data: { id: recordId, name: 'Member create with flag off' },
+ }),
+ );
+ expect(response.body.errors).toBeUndefined();
+ const shares = await findRecordShares(recordId);
+ expect(shares).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining(
+ ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
+ ),
+ ]),
+ );
+ expect(shares).toHaveLength(isLegacyOpen ? 2 : 1);
- expect(response.body.errors).toBeUndefined();
+ const otherMemberResponse = await makeGraphqlAPIRequestWithMemberRole(
+ findManyOperation(recordId),
+ );
+ expect(otherMemberResponse.body.errors).toBeUndefined();
+ expect(
+ otherMemberResponse.body.data.shareWithTestObjects.edges,
+ ).toHaveLength(isLegacyOpen ? 1 : 0);
+ const ownerResponse = await makeGraphqlAPIRequest(
+ findManyOperation(recordId),
+ );
+ expect(ownerResponse.body.errors).toBeUndefined();
+ expect(ownerResponse.body.data.shareWithTestObjects.edges).toHaveLength(
+ 1,
+ );
+ });
- expect(await findRecordShares(recordId)).toEqual(
- expect.arrayContaining([
- expect.objectContaining(
- ownerRowFor(recordId, WORKSPACE_MEMBER_DATA_SEED_IDS.JANE),
- ),
- expect.objectContaining({
- recordId,
- principalId: EVERYONE_PRINCIPAL_ID,
- accessLevel: RecordShareAccessLevel.FULL,
+ it('honors explicit API targets without creating an everyone grant', async () => {
+ const recordId = trackRecordId();
+ const response = await makeGraphqlAPIRequestWithApiKey(
+ createOneOperation({
+ data: { id: recordId, name: 'API create with explicit sharing' },
+ shareWith: [
+ {
+ roleId: memberRoleId,
+ accessLevel: RecordShareAccessLevel.READ,
+ },
+ ],
}),
- ]),
- );
- expect(await findRecordShares(recordId)).toHaveLength(2);
- });
- });
+ );
+ expect(response.body.errors).toBeUndefined();
+ expect(await findRecordShares(recordId)).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining(apiKeyRoleRowFor(recordId, adminRoleId)),
+ expect.objectContaining({
+ principalId: memberRoleId,
+ accessLevel: RecordShareAccessLevel.READ,
+ }),
+ ]),
+ );
+ expect(await findRecordShares(recordId)).toHaveLength(2);
+ const readerResponse = await makeGraphqlAPIRequestWithMemberRole(
+ findManyOperation(recordId),
+ );
+ expect(readerResponse.body.errors).toBeUndefined();
+ expect(
+ readerResponse.body.data.shareWithTestObjects.edges,
+ ).toHaveLength(1);
+ });
+ },
+ );
describe('OPEN readability', () => {
beforeAll(async () => {