Skip to content

The open alternative to Salesforce, designed for AI.

Record-level sharing 1/5: restrict records of objects open by default (#27045)

Félix Malfait29f892b40cce
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
index 14a0e6ebab3..632f170d9c8 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
@@ -1775,6 +1775,7 @@ type RecordSharingGrantDTO {
}
enum RecordShareAccessLevel {
+ NONE
READ
READ_WRITE
FULL
@@ -1790,6 +1791,9 @@ type RecordSharingDTO {
permissions: RecordPermissionsDTO!
isEnabled: Boolean!
hasInheritedAccess: Boolean!
+ isOpenByDefault: Boolean!
+ generalAccessLevel: RecordShareAccessLevel
+ isGeneralAccessDefault: Boolean!
roles: [RecordSharingRoleDTO!]!
shares: [RecordSharingGrantDTO!]!
}
@@ -2086,6 +2090,7 @@ enum FeatureFlagKey {
IS_LOGS_SETTINGS_SECTION_ENABLED
IS_CONVERSATIONS_TAB_ENABLED
IS_VALIDATION_RULES_ENABLED
+ IS_RECORD_LEVEL_SHARING_ENABLED
}
type WorkspaceUrls {
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.ts b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
index c1c9c73f398..20b41eb8e9c 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
@@ -1390,7 +1390,7 @@ export interface RecordSharingGrantDTO {
__typename: 'RecordSharingGrantDTO'
}
-export type RecordShareAccessLevel = 'READ' | 'READ_WRITE' | 'FULL'
+export type RecordShareAccessLevel = 'NONE' | 'READ' | 'READ_WRITE' | 'FULL'
export interface RecordSharingRoleDTO {
id: Scalars['UUID']
@@ -1403,6 +1403,9 @@ export interface RecordSharingDTO {
permissions: RecordPermissionsDTO
isEnabled: Scalars['Boolean']
hasInheritedAccess: Scalars['Boolean']
+ isOpenByDefault: Scalars['Boolean']
+ generalAccessLevel?: RecordShareAccessLevel
+ isGeneralAccessDefault: Scalars['Boolean']
roles: RecordSharingRoleDTO[]
shares: RecordSharingGrantDTO[]
__typename: 'RecordSharingDTO'
@@ -1683,7 +1686,7 @@ export interface FeatureFlag {
__typename: 'FeatureFlag'
}
-export type FeatureFlagKey = 'IS_APPLICATION_WORKFLOWS_ENABLED' | 'IS_ASYNC_CSV_EXPORT_ENABLED' | 'IS_CONFIGURABLE_SEARCH_FIELDS_ENABLED' | 'IS_JSON_FILTER_ENABLED' | 'IS_MESSAGE_CAMPAIGN_ENABLED' | 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT' | 'IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED' | 'IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED' | 'IS_AI_CHAT_SHARING_DROPDOWN_ENABLED' | 'IS_INITIAL_OBJECT_VIEW_ENABLED' | 'IS_WEBHOOK_RATE_LIMIT_ENABLED' | 'IS_DEFERRED_WORKSPACE_MIGRATION_ACTIONS_ENABLED' | 'IS_EXECUTION_QUOTA_ENABLED' | 'IS_RECORD_CREATION_FORM_ENABLED' | 'IS_LOGS_SETTINGS_SECTION_ENABLED' | 'IS_CONVERSATIONS_TAB_ENABLED' | 'IS_VALIDATION_RULES_ENABLED'
+export type FeatureFlagKey = 'IS_APPLICATION_WORKFLOWS_ENABLED' | 'IS_ASYNC_CSV_EXPORT_ENABLED' | 'IS_CONFIGURABLE_SEARCH_FIELDS_ENABLED' | 'IS_JSON_FILTER_ENABLED' | 'IS_MESSAGE_CAMPAIGN_ENABLED' | 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT' | 'IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED' | 'IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED' | 'IS_AI_CHAT_SHARING_DROPDOWN_ENABLED' | 'IS_INITIAL_OBJECT_VIEW_ENABLED' | 'IS_WEBHOOK_RATE_LIMIT_ENABLED' | 'IS_DEFERRED_WORKSPACE_MIGRATION_ACTIONS_ENABLED' | 'IS_EXECUTION_QUOTA_ENABLED' | 'IS_RECORD_CREATION_FORM_ENABLED' | 'IS_LOGS_SETTINGS_SECTION_ENABLED' | 'IS_CONVERSATIONS_TAB_ENABLED' | 'IS_VALIDATION_RULES_ENABLED' | 'IS_RECORD_LEVEL_SHARING_ENABLED'
export interface WorkspaceUrls {
customUrl?: Scalars['String']
@@ -5218,6 +5221,9 @@ export interface RecordSharingDTOGenqlSelection{
permissions?: RecordPermissionsDTOGenqlSelection
isEnabled?: boolean | number
hasInheritedAccess?: boolean | number
+ isOpenByDefault?: boolean | number
+ generalAccessLevel?: boolean | number
+ isGeneralAccessDefault?: boolean | number
roles?: RecordSharingRoleDTOGenqlSelection
shares?: RecordSharingGrantDTOGenqlSelection
__typename?: boolean | number
@@ -11238,6 +11244,7 @@ export const enumNavigationMenuItemType = {
}
export const enumRecordShareAccessLevel = {
+ NONE: 'NONE' as const,
READ: 'READ' as const,
READ_WRITE: 'READ_WRITE' as const,
FULL: 'FULL' as const
@@ -11291,7 +11298,8 @@ export const enumFeatureFlagKey = {
IS_RECORD_CREATION_FORM_ENABLED: 'IS_RECORD_CREATION_FORM_ENABLED' as const,
IS_LOGS_SETTINGS_SECTION_ENABLED: 'IS_LOGS_SETTINGS_SECTION_ENABLED' as const,
IS_CONVERSATIONS_TAB_ENABLED: 'IS_CONVERSATIONS_TAB_ENABLED' as const,
- IS_VALIDATION_RULES_ENABLED: 'IS_VALIDATION_RULES_ENABLED' as const
+ IS_VALIDATION_RULES_ENABLED: 'IS_VALIDATION_RULES_ENABLED' as const,
+ IS_RECORD_LEVEL_SHARING_ENABLED: 'IS_RECORD_LEVEL_SHARING_ENABLED' as const
}
export const enumIdentityProviderType = {
diff --git a/packages/twenty-client-sdk/src/metadata/generated/types.ts b/packages/twenty-client-sdk/src/metadata/generated/types.ts
index 7514951f980..c817d411865 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/types.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/types.ts
@@ -3443,6 +3443,15 @@ export default {
"hasInheritedAccess": [
8
],
+ "isOpenByDefault": [
+ 8
+ ],
+ "generalAccessLevel": [
+ 171
+ ],
+ "isGeneralAccessDefault": [
+ 8
+ ],
"roles": [
172
],
diff --git a/packages/twenty-front/src/generated-admin/graphql.ts b/packages/twenty-front/src/generated-admin/graphql.ts
index 0c40e342798..9a039ea5164 100644
--- a/packages/twenty-front/src/generated-admin/graphql.ts
+++ b/packages/twenty-front/src/generated-admin/graphql.ts
@@ -488,6 +488,7 @@ export enum FeatureFlagKey {
IS_LOGS_SETTINGS_SECTION_ENABLED = 'IS_LOGS_SETTINGS_SECTION_ENABLED',
IS_MESSAGE_CAMPAIGN_ENABLED = 'IS_MESSAGE_CAMPAIGN_ENABLED',
IS_RECORD_CREATION_FORM_ENABLED = 'IS_RECORD_CREATION_FORM_ENABLED',
+ IS_RECORD_LEVEL_SHARING_ENABLED = 'IS_RECORD_LEVEL_SHARING_ENABLED',
IS_REST_METADATA_API_NEW_FORMAT_DIRECT = 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT',
IS_VALIDATION_RULES_ENABLED = 'IS_VALIDATION_RULES_ENABLED',
IS_WEBHOOK_RATE_LIMIT_ENABLED = 'IS_WEBHOOK_RATE_LIMIT_ENABLED',
diff --git a/packages/twenty-front/src/generated-metadata/graphql.ts b/packages/twenty-front/src/generated-metadata/graphql.ts
index 1350e34bcf5..38eba66fc3c 100644
--- a/packages/twenty-front/src/generated-metadata/graphql.ts
+++ b/packages/twenty-front/src/generated-metadata/graphql.ts
@@ -2143,6 +2143,7 @@ export enum FeatureFlagKey {
IS_LOGS_SETTINGS_SECTION_ENABLED = 'IS_LOGS_SETTINGS_SECTION_ENABLED',
IS_MESSAGE_CAMPAIGN_ENABLED = 'IS_MESSAGE_CAMPAIGN_ENABLED',
IS_RECORD_CREATION_FORM_ENABLED = 'IS_RECORD_CREATION_FORM_ENABLED',
+ IS_RECORD_LEVEL_SHARING_ENABLED = 'IS_RECORD_LEVEL_SHARING_ENABLED',
IS_REST_METADATA_API_NEW_FORMAT_DIRECT = 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT',
IS_VALIDATION_RULES_ENABLED = 'IS_VALIDATION_RULES_ENABLED',
IS_WEBHOOK_RATE_LIMIT_ENABLED = 'IS_WEBHOOK_RATE_LIMIT_ENABLED',
@@ -5834,6 +5835,7 @@ export type RecordPermissionsTargetInput = {
export enum RecordShareAccessLevel {
FULL = 'FULL',
+ NONE = 'NONE',
READ = 'READ',
READ_WRITE = 'READ_WRITE'
}
@@ -5846,8 +5848,11 @@ export type RecordSharePrincipalInput = {
export type RecordSharingDto = {
__typename?: 'RecordSharingDTO';
+ generalAccessLevel?: Maybe<RecordShareAccessLevel>;
hasInheritedAccess: Scalars['Boolean']['output'];
isEnabled: Scalars['Boolean']['output'];
+ isGeneralAccessDefault: Scalars['Boolean']['output'];
+ isOpenByDefault: Scalars['Boolean']['output'];
permissions: RecordPermissionsDto;
roles: Array<RecordSharingRoleDto>;
shares: Array<RecordSharingGrantDto>;
diff --git a/packages/twenty-front/src/modules/settings/admin-panel/constants/SettingsAdminFeatureFlagMetadata.ts b/packages/twenty-front/src/modules/settings/admin-panel/constants/SettingsAdminFeatureFlagMetadata.ts
index fe8ce9e0123..5d76d942453 100644
--- a/packages/twenty-front/src/modules/settings/admin-panel/constants/SettingsAdminFeatureFlagMetadata.ts
+++ b/packages/twenty-front/src/modules/settings/admin-panel/constants/SettingsAdminFeatureFlagMetadata.ts
@@ -46,6 +46,10 @@ export const SETTINGS_ADMIN_FEATURE_FLAG_METADATA: Partial<
label: msg`AI chat sharing dropdown`,
description: msg`Show the sharing dropdown on AI conversations when record sharing is enabled.`,
},
+ [FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED]: {
+ label: msg`Record sharing`,
+ description: msg`Let people restrict and share individual records.`,
+ },
[FeatureFlagKey.IS_WEBHOOK_RATE_LIMIT_ENABLED]: {
label: msg`Webhook rate limits`,
description: msg`Limit the rate of outgoing webhook deliveries.`,
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-upgrade-version-command.module.ts
index 80f3158e66f..f4b5d069c38 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-upgrade-version-command.module.ts
@@ -1,6 +1,7 @@
import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
+import { AddRecordShareNoneAccessLevelCommand } from 'src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790876639146-add-record-share-none-access-level.command';
import { RestrictExportRecordsToIndexPageCommand } from 'src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790837443029-restrict-export-records-to-index-page.command';
import { GateWorkflowCommandsOnRecordUpdatePermissionCommand } from 'src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790853316722-gate-workflow-commands-on-record-update-permission.command';
import { RemoveSeeVersionWorkflowRunCommandMenuItemCommand } from 'src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790860694324-remove-see-version-workflow-run-command-menu-item.command';
@@ -15,6 +16,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
],
providers: [
RestrictExportRecordsToIndexPageCommand,
+ AddRecordShareNoneAccessLevelCommand,
GateWorkflowCommandsOnRecordUpdatePermissionCommand,
RemoveSeeVersionWorkflowRunCommandMenuItemCommand,
],
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790876639146-add-record-share-none-access-level.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790876639146-add-record-share-none-access-level.command.ts
new file mode 100644
index 00000000000..57373a68016
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790876639146-add-record-share-none-access-level.command.ts
@@ -0,0 +1,171 @@
+import { InjectDataSource } from '@nestjs/typeorm';
+
+import { Command } from 'nest-commander';
+import { TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER } from 'twenty-shared/application';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { DataSource } from 'typeorm';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { buildRecordShareNoneAccessLevelOptionSyncOperations } from 'src/database/commands/upgrade-version-command/2-45/utils/build-record-share-none-access-level-option-sync-operations.util';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
+
+@RegisteredWorkspaceCommand('2.45.0', 1790876639146)
+@Command({
+ name: 'upgrade:2-45:add-record-share-none-access-level',
+ description:
+ 'Add the NONE access level that restricts a record of an object open by default',
+})
+export class AddRecordShareNoneAccessLevelCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ @InjectDataSource() private readonly dataSource: DataSource,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.up(args);
+ }
+
+ async up(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.syncNoneAccessLevelOption(args, 'up');
+ }
+
+ async down(args: RunOnWorkspaceArgs): Promise<void> {
+ await this.syncNoneAccessLevelOption(args, 'down');
+ }
+
+ private async syncNoneAccessLevelOption(
+ { workspaceId, options }: RunOnWorkspaceArgs,
+ direction: 'up' | 'down',
+ ): Promise<void> {
+ const { flatFieldMetadataMaps, flatObjectMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMaps',
+ 'flatObjectMetadataMaps',
+ ]);
+
+ const fieldMetadataOperations =
+ buildRecordShareNoneAccessLevelOptionSyncOperations({
+ existingFlatFieldMetadataMaps: flatFieldMetadataMaps,
+ now: new Date().toISOString(),
+ direction,
+ });
+
+ const isOptionInSync =
+ fieldMetadataOperations.flatEntityToUpdate.length === 0;
+ const recordShareObjectMetadata =
+ flatObjectMetadataMaps.byUniversalIdentifier[
+ STANDARD_OBJECTS.recordShare.universalIdentifier
+ ];
+ const recordShareTable = isDefined(recordShareObjectMetadata)
+ ? `${escapeIdentifier(getWorkspaceSchemaName(workspaceId))}.${escapeIdentifier(computeObjectTargetTable(recordShareObjectMetadata))}`
+ : undefined;
+
+ // A rollback retried after the option went away can still find restrictions
+ if (
+ isOptionInSync &&
+ (direction === 'up' || !isDefined(recordShareTable))
+ ) {
+ return;
+ }
+
+ this.logger.log(
+ `${options.dryRun ? '[DRY RUN] ' : ''}Workspace ${workspaceId}: ${direction === 'up' ? 'adding' : 'removing'} the NONE record share access level`,
+ );
+
+ if (options.dryRun) {
+ return;
+ }
+
+ // Postgres cannot drop an enum value still in use, and a restriction
+ // without the gate that reads it means nothing once rolled back
+ const deletedRestrictions =
+ direction === 'down' && isDefined(recordShareTable)
+ ? await this.deleteRestrictions(recordShareTable)
+ : [];
+
+ if (isOptionInSync) {
+ return;
+ }
+
+ try {
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunLegacyWorkspaceMigration(
+ {
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,
+ allFlatEntityOperationByMetadataName: {
+ fieldMetadata: fieldMetadataOperations,
+ },
+ },
+ );
+
+ if (result.status === 'fail') {
+ this.logger.error(
+ `Failed to ${direction === 'up' ? 'add' : 'remove'} the NONE record share access level for workspace ${workspaceId}:\n${JSON.stringify(result, null, 2)}`,
+ );
+ throw new WorkspaceMigrationBuilderException(result);
+ }
+ } catch (error) {
+ if (isDefined(recordShareTable)) {
+ await this.restoreRestrictions(
+ recordShareTable,
+ deletedRestrictions,
+ ).catch((restoreError) =>
+ this.logger.error(
+ `Failed to restore ${deletedRestrictions.length} record restrictions for workspace ${workspaceId}`,
+ restoreError,
+ ),
+ );
+ }
+ throw error;
+ }
+ }
+
+ private async deleteRestrictions(
+ recordShareTable: string,
+ ): Promise<Record<string, unknown>[]> {
+ const [rows]: [{ restriction: Record<string, unknown> }[], number] =
+ await this.dataSource.query(
+ `DELETE FROM ${recordShareTable} AS "recordShare" WHERE "accessLevel"::text = $1 RETURNING to_jsonb("recordShare") - 'searchVector' AS "restriction"`,
+ [RecordShareAccessLevel.NONE],
+ );
+
+ return rows.map(({ restriction }) => restriction);
+ }
+
+ // The metadata migration runs in its own transaction, so restrictions
+ // deleted ahead of it are put back when it fails
+ private async restoreRestrictions(
+ recordShareTable: string,
+ restrictions: Record<string, unknown>[],
+ ): Promise<void> {
+ if (restrictions.length === 0) {
+ return;
+ }
+
+ const columns = Object.keys(restrictions[0])
+ .map(escapeIdentifier)
+ .join(', ');
+
+ await this.dataSource.query(
+ `INSERT INTO ${recordShareTable} (${columns}) SELECT ${columns} FROM jsonb_populate_recordset(NULL::${recordShareTable}, $1::jsonb)`,
+ [JSON.stringify(restrictions)],
+ );
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/utils/__tests__/build-record-share-none-access-level-option-sync-operations.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/utils/__tests__/build-record-share-none-access-level-option-sync-operations.util.spec.ts
new file mode 100644
index 00000000000..db5dfd52563
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/utils/__tests__/build-record-share-none-access-level-option-sync-operations.util.spec.ts
@@ -0,0 +1,143 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import {
+ type FieldMetadataComplexOption,
+ RecordShareAccessLevel,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import {
+ buildRecordShareNoneAccessLevelOptionSyncOperations,
+ RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE,
+ RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION,
+} from 'src/database/commands/upgrade-version-command/2-45/utils/build-record-share-none-access-level-option-sync-operations.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { computeTwentyStandardApplicationAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant';
+
+const NOW = '2026-10-01T12:00:00.000Z';
+const ACCESS_LEVEL_FIELD_UNIVERSAL_IDENTIFIER =
+ STANDARD_OBJECTS.recordShare.fields.accessLevel.universalIdentifier;
+
+const { allFlatEntityMaps } = computeTwentyStandardApplicationAllFlatEntityMaps(
+ {
+ now: '2026-09-30T12:00:00.000Z',
+ workspaceId: '20202020-1111-4111-8111-111111111111',
+ twentyStandardApplicationId: '20202020-2222-4222-8222-222222222222',
+ },
+);
+
+const standardAccessLevelField =
+ allFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier[
+ ACCESS_LEVEL_FIELD_UNIVERSAL_IDENTIFIER
+ ];
+
+if (!isDefined(standardAccessLevelField)) {
+ throw new Error('Standard recordShare accessLevel field missing');
+}
+
+const getOptions = (field: { options?: unknown }) =>
+ (field.options ?? []) as FieldMetadataComplexOption[];
+
+const buildMaps = (
+ field: FlatFieldMetadata | undefined,
+): Pick<FlatEntityMaps<FlatFieldMetadata>, 'byUniversalIdentifier'> => ({
+ byUniversalIdentifier: isDefined(field)
+ ? { [ACCESS_LEVEL_FIELD_UNIVERSAL_IDENTIFIER]: field }
+ : {},
+});
+
+const fieldWithoutNoneOption: FlatFieldMetadata = {
+ ...standardAccessLevelField,
+ defaultValue: null,
+ options: getOptions(standardAccessLevelField).filter(
+ (option) => option.value !== RecordShareAccessLevel.NONE,
+ ),
+};
+
+describe('buildRecordShareNoneAccessLevelOptionSyncOperations', () => {
+ it('should match the option declared on the standard field', () => {
+ expect(getOptions(standardAccessLevelField)).toContainEqual(
+ expect.objectContaining({
+ id: RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION.id,
+ value: RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION.value,
+ position: RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION.position,
+ color: RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION.color,
+ }),
+ );
+ });
+
+ it('should match the default declared on the standard field', () => {
+ expect(standardAccessLevelField.defaultValue).toBe(
+ RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE,
+ );
+ });
+
+ it('should give the field the default it needs to be updated', () => {
+ const { flatEntityToUpdate } =
+ buildRecordShareNoneAccessLevelOptionSyncOperations({
+ existingFlatFieldMetadataMaps: buildMaps(fieldWithoutNoneOption),
+ now: NOW,
+ direction: 'up',
+ });
+
+ expect(flatEntityToUpdate[0].defaultValue).toBe(
+ RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE,
+ );
+ });
+
+ it('should append the NONE option when it is missing', () => {
+ const { flatEntityToUpdate } =
+ buildRecordShareNoneAccessLevelOptionSyncOperations({
+ existingFlatFieldMetadataMaps: buildMaps(fieldWithoutNoneOption),
+ now: NOW,
+ direction: 'up',
+ });
+
+ expect(flatEntityToUpdate).toHaveLength(1);
+ expect(getOptions(flatEntityToUpdate[0]).map(({ value }) => value)).toEqual(
+ [
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+ RecordShareAccessLevel.NONE,
+ ],
+ );
+ expect(flatEntityToUpdate[0].updatedAt).toBe(NOW);
+ });
+
+ it('should do nothing when the option is already there', () => {
+ expect(
+ buildRecordShareNoneAccessLevelOptionSyncOperations({
+ existingFlatFieldMetadataMaps: buildMaps(standardAccessLevelField),
+ now: NOW,
+ direction: 'up',
+ }).flatEntityToUpdate,
+ ).toEqual([]);
+ });
+
+ it('should remove the option on the way down', () => {
+ const { flatEntityToUpdate } =
+ buildRecordShareNoneAccessLevelOptionSyncOperations({
+ existingFlatFieldMetadataMaps: buildMaps(standardAccessLevelField),
+ now: NOW,
+ direction: 'down',
+ });
+
+ expect(
+ getOptions(flatEntityToUpdate[0]).map(({ value }) => value),
+ ).not.toContain(RecordShareAccessLevel.NONE);
+ expect(flatEntityToUpdate[0].defaultValue).toBe(
+ RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE,
+ );
+ });
+
+ it('should do nothing when the record share object is not provisioned', () => {
+ expect(
+ buildRecordShareNoneAccessLevelOptionSyncOperations({
+ existingFlatFieldMetadataMaps: buildMaps(undefined),
+ now: NOW,
+ direction: 'up',
+ }).flatEntityToUpdate,
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/utils/build-record-share-none-access-level-option-sync-operations.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/utils/build-record-share-none-access-level-option-sync-operations.util.ts
new file mode 100644
index 00000000000..6cac4e6d73f
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-45/utils/build-record-share-none-access-level-option-sync-operations.util.ts
@@ -0,0 +1,101 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import {
+ type FieldMetadataComplexOption,
+ FieldMetadataType,
+ RecordShareAccessLevel,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type FlatEntityToCreateDeleteUpdate } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-to-create-delete-update.type';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+
+const RECORD_SHARE_ACCESS_LEVEL_FIELD_UNIVERSAL_IDENTIFIER =
+ STANDARD_OBJECTS.recordShare.fields.accessLevel.universalIdentifier;
+
+export const RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION: FieldMetadataComplexOption =
+ {
+ id: 'b6c22171-178e-4b2d-b858-02ed48c925b1',
+ value: RecordShareAccessLevel.NONE,
+ label: 'Restricted',
+ position: 3,
+ color: 'gray',
+ };
+
+// A non-nullable select can only be updated once it has a default, and the
+// field was created without one; READ is also the level setRecordShare grants
+// when none is given
+export const RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE = `'${RecordShareAccessLevel.READ}'`;
+
+const NO_OPERATIONS: FlatEntityToCreateDeleteUpdate<'fieldMetadata'> = {
+ flatEntityToCreate: [],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+};
+
+export const buildRecordShareNoneAccessLevelOptionSyncOperations = ({
+ existingFlatFieldMetadataMaps,
+ now,
+ direction,
+}: {
+ existingFlatFieldMetadataMaps: Pick<
+ FlatEntityMaps<FlatFieldMetadata>,
+ 'byUniversalIdentifier'
+ >;
+ now: string;
+ direction: 'up' | 'down';
+}): FlatEntityToCreateDeleteUpdate<'fieldMetadata'> => {
+ const accessLevelField =
+ existingFlatFieldMetadataMaps.byUniversalIdentifier[
+ RECORD_SHARE_ACCESS_LEVEL_FIELD_UNIVERSAL_IDENTIFIER
+ ];
+
+ if (
+ !isDefined(accessLevelField) ||
+ accessLevelField.type !== FieldMetadataType.SELECT
+ ) {
+ return NO_OPERATIONS;
+ }
+
+ const existingOptions = (accessLevelField.options ??
+ []) as FieldMetadataComplexOption[];
+ const hasNoneOption = existingOptions.some(
+ (option) => option.value === RecordShareAccessLevel.NONE,
+ );
+
+ if (direction === 'up' && !hasNoneOption) {
+ return {
+ ...NO_OPERATIONS,
+ flatEntityToUpdate: [
+ {
+ ...accessLevelField,
+ options: [...existingOptions, RECORD_SHARE_NONE_ACCESS_LEVEL_OPTION],
+ defaultValue:
+ accessLevelField.defaultValue ??
+ RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE,
+ updatedAt: now,
+ },
+ ],
+ };
+ }
+
+ if (direction === 'down' && hasNoneOption) {
+ return {
+ ...NO_OPERATIONS,
+ flatEntityToUpdate: [
+ {
+ ...accessLevelField,
+ options: existingOptions.filter(
+ (option) => option.value !== RecordShareAccessLevel.NONE,
+ ),
+ defaultValue:
+ accessLevelField.defaultValue ??
+ RECORD_SHARE_ACCESS_LEVEL_DEFAULT_VALUE,
+ updatedAt: now,
+ },
+ ],
+ };
+ }
+
+ return NO_OPERATIONS;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/constants/grantable-record-share-access-levels.constant.ts b/packages/twenty-server/src/engine/core-modules/record-share/constants/grantable-record-share-access-levels.constant.ts
new file mode 100644
index 00000000000..3dc6edc6416
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/constants/grantable-record-share-access-levels.constant.ts
@@ -0,0 +1,9 @@
+/* @license Enterprise */
+
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+
+export const GRANTABLE_RECORD_SHARE_ACCESS_LEVELS: RecordShareAccessLevel[] = [
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+];
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/dtos/record-sharing.dto.ts b/packages/twenty-server/src/engine/core-modules/record-share/dtos/record-sharing.dto.ts
index 27debf0eef1..9de407b33dc 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/dtos/record-sharing.dto.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/dtos/record-sharing.dto.ts
@@ -66,6 +66,15 @@ export class RecordSharingDTO {
@Field(() => Boolean)
hasInheritedAccess: boolean;
+ @Field(() => Boolean)
+ isOpenByDefault: boolean;
+
+ @Field(() => RecordShareAccessLevel, { nullable: true })
+ generalAccessLevel: RecordShareAccessLevel | null;
+
+ @Field(() => Boolean)
+ isGeneralAccessDefault: boolean;
+
@Field(() => [RecordSharingRoleDTO])
roles: RecordSharingRoleDTO[];
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 f5203ade587..ff130a66434 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 { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';
import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import { isNonEmptyString } from '@sniptt/guards';
import { In, MoreThanOrEqual } from 'typeorm';
@@ -18,7 +18,9 @@ import {
type EventRecordSnapshot,
resolveEventRecordSnapshots,
} from 'src/engine/core-modules/record-share/utils/resolve-event-record-snapshots.util';
+import { resolveRecordIdsRestrictedForPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util';
import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';
+import { isRecordShareExceptionObject } from 'src/engine/core-modules/record-share/utils/is-record-share-exception-object.util';
import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';
import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/core-modules/record-share/constants/max-inherited-readability-depth.constant';
import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';
@@ -173,7 +175,12 @@ export class RecordAccessPolicyService {
switch (gateKind) {
case 'open':
- return new Set(snapshots.map((snapshot) => snapshot.id));
+ return (await this.areRecordShareExceptionsEnforced(evaluation))
+ ? this.resolveSnapshotIdsNotRestrictedForSubject(
+ evaluation,
+ fetchRecordShares,
+ )
+ : new Set(snapshots.map((snapshot) => snapshot.id));
case 'deny':
return new Set();
case 'private':
@@ -196,6 +203,45 @@ export class RecordAccessPolicyService {
}
}
+ private async areRecordShareExceptionsEnforced({
+ workspaceId,
+ objectMetadata,
+ }: SnapshotEvaluation): Promise<boolean> {
+ if (!isRecordShareExceptionObject(objectMetadata)) {
+ return false;
+ }
+
+ const { featureFlagsMap } = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['featureFlagsMap'],
+ );
+
+ return (
+ featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ?? false
+ );
+ }
+
+ private async resolveSnapshotIdsNotRestrictedForSubject(
+ { 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 restrictedRecordIds = resolveRecordIdsRestrictedForPrincipals({
+ recordShares: await fetchRecordShares(),
+ principalIds: subject.principalIds,
+ accessLevels: resolveRequiredRecordShareAccessLevels('select'),
+ });
+
+ return new Set(
+ snapshotIds.filter((snapshotId) => !restrictedRecordIds.has(snapshotId)),
+ );
+ }
+
private async resolveSnapshotIdsSharedWithSubject(
{ snapshots, subject }: SnapshotEvaluation,
fetchRecordShares: FetchRecordShares,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts
index 6f25d660a0b..b289cbdd978 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts
@@ -3,9 +3,12 @@ import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target
import { Injectable } from '@nestjs/common';
import {
+ FeatureFlagKey,
MetadataReadability,
+ type ObjectRecord,
RecordShareAccessLevel,
RecordSharePrincipalType,
+ RecordShareRowCause,
} from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
@@ -18,12 +21,18 @@ import {
type RecordSharePrincipalInput,
} from 'src/engine/core-modules/record-share/dtos/record-sharing.dto';
import { RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
+import { type RecordShareInput } from 'src/engine/core-modules/record-share/types/record-share-input.type';
+import { isRecordShareExceptionObject } from 'src/engine/core-modules/record-share/utils/is-record-share-exception-object.util';
+import { resolveRecordGeneralAccess } from 'src/engine/core-modules/record-share/utils/resolve-record-general-access.util';
import { resolveShareWithPrincipalOrThrow } from 'src/engine/core-modules/record-share/utils/resolve-share-with-principal-or-throw.util';
+import { resolveViewerRecordShareAccessLevel } from 'src/engine/core-modules/record-share/utils/resolve-viewer-record-share-access-level.util';
import { validateShareWithPrincipalsOrThrow } from 'src/engine/core-modules/record-share/utils/validate-share-with-principals-or-throw.util';
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+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 { type OperationType } from 'src/engine/twenty-orm/repository/permissions.utils';
import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { resolvePrincipalIdsFromAuthContext } from 'src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
@@ -35,6 +44,14 @@ type RecordSharingArgs = RecordSharingTargetInput & {
withDeleted?: boolean;
};
+const CREATED_BY_FIELD_NAME = 'createdBy';
+const CREATED_BY_WORKSPACE_MEMBER_ID_COLUMN_NAME = 'createdByWorkspaceMemberId';
+
+type RecordSharingObject = {
+ objectMetadata: FlatObjectMetadata;
+ isRecordShareExceptionObject: boolean;
+};
+
@Injectable()
export class RecordSharingService {
constructor(
@@ -54,7 +71,7 @@ export class RecordSharingService {
async getPermissionsForRecords(
args: Omit<RecordSharingArgs, 'recordId'> & { recordIds: string[] },
): Promise<Map<string, RecordPermissionsDTO>> {
- const objectMetadata = await this.getObjectMetadata(args);
+ const { objectMetadata } = await this.getSharingObject(args);
return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
const repository =
this.workspaceOrmManager.getRepositoryWithContextPermissions(
@@ -94,25 +111,26 @@ export class RecordSharingService {
}
async getSharing(args: RecordSharingArgs): Promise<RecordSharingDTO> {
- const objectMetadata = await this.getObjectMetadata(args);
+ const sharingObject = await this.getSharingObject(args);
const permissions = await this.getPermissions(args);
if (!permissions.canRead) {
throw new NotFoundError('Record not found');
}
- return this.buildSharingResponse({ args, objectMetadata, permissions });
+ return this.buildSharingResponse({ args, sharingObject, permissions });
}
private async buildSharingResponse({
args,
- objectMetadata,
+ sharingObject,
permissions,
}: {
args: RecordSharingArgs;
- objectMetadata: FlatObjectMetadata;
+ sharingObject: RecordSharingObject;
permissions: RecordPermissionsDTO;
}): Promise<RecordSharingDTO> {
- const isEnabled = this.isShareable(objectMetadata);
- const { shares, viewerAccessLevel } = await this.getRecordShares(args);
+ const { objectMetadata, isRecordShareExceptionObject } = sharingObject;
+ const { shares, viewerAccessLevel, generalAccess } =
+ await this.getRecordShares({ ...args, sharingObject });
const canChangeSharing =
permissions.canUpdate &&
viewerAccessLevel === RecordShareAccessLevel.FULL;
@@ -122,20 +140,26 @@ export class RecordSharingService {
['flatRoleMaps'],
)
: { flatRoleMaps: undefined };
+ const grants = shares.filter(
+ (share) => share.accessLevel !== RecordShareAccessLevel.NONE,
+ );
return {
permissions,
viewerAccessLevel,
- isEnabled,
+ isEnabled: this.isShareable(sharingObject),
hasInheritedAccess:
objectMetadata.readability === MetadataReadability.INHERITED,
- shares: canChangeSharing ? shares : [],
+ isOpenByDefault: isRecordShareExceptionObject,
+ generalAccessLevel: generalAccess.accessLevel,
+ isGeneralAccessDefault: generalAccess.isDefault,
+ shares: canChangeSharing ? grants : [],
roles: isDefined(flatRoleMaps)
? Object.values(flatRoleMaps.byUniversalIdentifier)
.filter(isDefined)
.filter(
(role) =>
role.canBeAssignedToUsers ||
- shares.some(
+ grants.some(
(share) =>
share.principalType === RecordSharePrincipalType.ROLE &&
share.principalId === role.id,
@@ -153,12 +177,19 @@ export class RecordSharingService {
enabled: boolean;
},
): Promise<RecordSharingDTO> {
- const objectMetadata = await this.getObjectMetadata(args);
+ const sharingObject = await this.getSharingObject(args);
+ const { objectMetadata, isRecordShareExceptionObject } = sharingObject;
const workspaceId = args.authContext.workspace.id;
- if (!this.isShareable(objectMetadata)) {
+ if (!this.isShareable(sharingObject)) {
throw new NotFoundError('Record not found');
}
- const shareWith = { ...args.principal, accessLevel: args.accessLevel };
+ // Withdrawing a share ignores its level, which may be NONE on the way out
+ const shareWith = {
+ ...args.principal,
+ accessLevel: args.enabled
+ ? args.accessLevel
+ : RecordShareAccessLevel.READ,
+ };
const principal = resolveShareWithPrincipalOrThrow(shareWith);
await this.workspaceOrmManager.executeInWorkspaceContext(
() =>
@@ -193,10 +224,12 @@ export class RecordSharingService {
if (writableIds.length !== 1) {
throw new NotFoundError('Record not found');
}
- const { viewerAccessLevel } = await this.getRecordShares({
- ...args,
- transactionScope,
- });
+ const { viewerAccessLevel, creatorWorkspaceMemberId } =
+ await this.getRecordShares({
+ ...args,
+ sharingObject,
+ transactionScope,
+ });
if (viewerAccessLevel !== RecordShareAccessLevel.FULL) {
throw new NotFoundError('Record not found');
}
@@ -210,16 +243,31 @@ export class RecordSharingService {
...maps,
});
}
+ const share = {
+ ...principal,
+ objectMetadataId: args.objectMetadataId,
+ recordId: args.recordId,
+ sourceId: args.recordId,
+ };
+ if (
+ isRecordShareExceptionObject &&
+ principal.principalType === RecordSharePrincipalType.EVERYONE
+ ) {
+ await this.setGeneralAccessOfRecordOpenByDefault({
+ workspaceId,
+ transactionScope,
+ share,
+ enabled: args.enabled,
+ creatorWorkspaceMemberId,
+ actingWorkspaceMemberId: args.authContext.workspaceMemberId,
+ });
+ return;
+ }
await this.recordShareStorageService.setManualShare({
workspaceId,
transactionScope,
enabled: args.enabled,
- share: {
- ...principal,
- objectMetadataId: args.objectMetadataId,
- recordId: args.recordId,
- sourceId: args.recordId,
- },
+ share,
});
},
),
@@ -233,19 +281,99 @@ export class RecordSharingService {
viewerAccessLevel: null,
isEnabled: false,
hasInheritedAccess: false,
+ isOpenByDefault: false,
+ generalAccessLevel: null,
+ isGeneralAccessDefault: true,
roles: [],
shares: [],
};
}
- return this.buildSharingResponse({ args, objectMetadata, permissions });
+ return this.buildSharingResponse({ args, sharingObject, permissions });
+ }
+
+ // Everyone keeps the general access of a record open by default unless a
+ // row lowers it, so restricting writes a row and editing for everyone
+ // removes it. The creator owns the record implicitly, and gets a grant once
+ // a restriction would otherwise lock them out.
+ private async setGeneralAccessOfRecordOpenByDefault({
+ workspaceId,
+ transactionScope,
+ share,
+ enabled,
+ creatorWorkspaceMemberId,
+ actingWorkspaceMemberId,
+ }: {
+ workspaceId: string;
+ transactionScope: WorkspaceTransactionScope;
+ share: Omit<RecordShareInput, 'rowCause'>;
+ enabled: boolean;
+ creatorWorkspaceMemberId: string | undefined;
+ actingWorkspaceMemberId: string | undefined;
+ }): Promise<void> {
+ const accessLevel = enabled
+ ? share.accessLevel
+ : RecordShareAccessLevel.NONE;
+ const isDefaultAccess = accessLevel === RecordShareAccessLevel.READ_WRITE;
+ const isRestriction =
+ accessLevel === RecordShareAccessLevel.NONE ||
+ accessLevel === RecordShareAccessLevel.READ;
+
+ // Whoever restricts may only manage the record through the general
+ // access they are lowering, so they keep a grant alongside the creator
+ const ownerWorkspaceMemberIds = [
+ ...new Set([creatorWorkspaceMemberId, actingWorkspaceMemberId]),
+ ].filter(isDefined);
+
+ if (isRestriction && ownerWorkspaceMemberIds.length > 0) {
+ await this.recordShareStorageService.insertMany({
+ workspaceId,
+ transactionScope,
+ recordShares: ownerWorkspaceMemberIds.map((ownerWorkspaceMemberId) => ({
+ recordId: share.recordId,
+ objectMetadataId: share.objectMetadataId,
+ principalId: ownerWorkspaceMemberId,
+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
+ accessLevel: RecordShareAccessLevel.FULL,
+ rowCause: RecordShareRowCause.OWNER,
+ sourceId: share.recordId,
+ })),
+ });
+ }
+
+ // On a record open by default, owner rows only exist to keep a
+ // restriction manageable, so they go once the record follows the default
+ if (isDefaultAccess) {
+ await this.recordShareStorageService.deleteMatching({
+ workspaceId,
+ transactionScope,
+ criteria: [
+ {
+ objectMetadataId: share.objectMetadataId,
+ recordId: share.recordId,
+ rowCause: RecordShareRowCause.OWNER,
+ },
+ ],
+ });
+ }
+
+ await this.recordShareStorageService.setManualShare({
+ workspaceId,
+ transactionScope,
+ enabled: !isDefaultAccess,
+ share: { ...share, accessLevel },
+ });
}
private async getRecordShares({
authContext,
objectMetadataId,
recordId,
+ sharingObject,
transactionScope,
- }: RecordSharingArgs & { transactionScope?: WorkspaceTransactionScope }) {
+ }: RecordSharingArgs & {
+ sharingObject: RecordSharingObject;
+ transactionScope?: WorkspaceTransactionScope;
+ }) {
const workspaceId = authContext.workspace.id;
const { userWorkspaceRoleMap, apiKeyRoleMap } =
await this.workspaceCacheService.getOrRecompute(workspaceId, [
@@ -264,36 +392,100 @@ export class RecordSharingService {
recordIds: [recordId],
transactionScope,
});
- const viewerAccessLevel =
- [
- RecordShareAccessLevel.FULL,
- RecordShareAccessLevel.READ_WRITE,
- RecordShareAccessLevel.READ,
- ].find((accessLevel) =>
- shares.some(
- (share) =>
- principalIds.includes(share.principalId) &&
- share.accessLevel === accessLevel,
- ),
- ) ?? null;
+ const generalAccess = resolveRecordGeneralAccess({
+ readability: sharingObject.objectMetadata.readability,
+ isRecordShareExceptionObject: sharingObject.isRecordShareExceptionObject,
+ recordShares: shares,
+ });
+ const creatorWorkspaceMemberId = sharingObject.isRecordShareExceptionObject
+ ? await this.findCreatorWorkspaceMemberId({
+ workspaceId,
+ objectMetadata: sharingObject.objectMetadata,
+ recordId,
+ })
+ : undefined;
+ const viewerAccessLevel = resolveViewerRecordShareAccessLevel({
+ recordShares: shares,
+ principalIds,
+ implicitAccessLevels: sharingObject.isRecordShareExceptionObject
+ ? [
+ generalAccess.accessLevel,
+ creatorWorkspaceMemberId === authContext.workspaceMemberId
+ ? RecordShareAccessLevel.FULL
+ : null,
+ ]
+ : [],
+ });
+
+ return {
+ shares,
+ viewerAccessLevel,
+ generalAccess,
+ creatorWorkspaceMemberId,
+ };
+ }
+
+ private async findCreatorWorkspaceMemberId({
+ workspaceId,
+ objectMetadata,
+ recordId,
+ }: {
+ workspaceId: string;
+ objectMetadata: FlatObjectMetadata;
+ recordId: string;
+ }): Promise<string | undefined> {
+ const { flatFieldMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMaps',
+ ]);
+ const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(
+ flatFieldMetadataMaps,
+ objectMetadata,
+ );
+
+ if (!isDefined(fieldIdByName[CREATED_BY_FIELD_NAME])) {
+ return undefined;
+ }
+
+ const [record] = await this.workspaceOrmManager.executeInWorkspaceContext(
+ () =>
+ this.workspaceOrmManager
+ .getRepository(objectMetadata.nameSingular, {
+ shouldBypassPermissionChecks: true,
+ })
+ .createQueryBuilder()
+ .select(['id', CREATED_BY_WORKSPACE_MEMBER_ID_COLUMN_NAME])
+ .where({ id: recordId })
+ .withDeleted()
+ .getMany<ObjectRecord>({ noFormatting: true }),
+ buildSystemAuthContext(workspaceId),
+ );
+ const creatorWorkspaceMemberId =
+ record?.[CREATED_BY_WORKSPACE_MEMBER_ID_COLUMN_NAME];
- return { shares, viewerAccessLevel };
+ return typeof creatorWorkspaceMemberId === 'string'
+ ? creatorWorkspaceMemberId
+ : undefined;
}
- private isShareable(objectMetadata: FlatObjectMetadata): boolean {
+ private isShareable({
+ objectMetadata,
+ isRecordShareExceptionObject,
+ }: RecordSharingObject): boolean {
return (
+ isRecordShareExceptionObject ||
objectMetadata.readability === MetadataReadability.PRIVATE ||
objectMetadata.readability === MetadataReadability.INHERITED
);
}
- private async getObjectMetadata(
+ private async getSharingObject(
args: Omit<RecordSharingArgs, 'recordId'>,
- ): Promise<FlatObjectMetadata> {
- const { flatObjectMetadataMaps } =
+ ): Promise<RecordSharingObject> {
+ const { flatObjectMetadataMaps, featureFlagsMap } =
await this.workspaceCacheService.getOrRecompute(
args.authContext.workspace.id,
- ['flatObjectMetadataMaps'],
+ ['flatObjectMetadataMaps', 'featureFlagsMap'],
);
const objectMetadata = findFlatEntityByIdInFlatEntityMaps({
flatEntityId: args.objectMetadataId,
@@ -302,6 +494,12 @@ export class RecordSharingService {
if (!isDefined(objectMetadata)) {
throw new NotFoundError('Record not found');
}
- return objectMetadata;
+ return {
+ objectMetadata,
+ isRecordShareExceptionObject:
+ (featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ??
+ false) &&
+ isRecordShareExceptionObject(objectMetadata),
+ };
}
}
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-exception-condition.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-exception-condition.util.spec.ts
new file mode 100644
index 00000000000..5abc8f7dbfd
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-record-share-exception-condition.util.spec.ts
@@ -0,0 +1,87 @@
+/* @license Enterprise */
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { compileNamedParameters } from 'src/engine/twenty-orm/sql/utils/compile-named-parameters.util';
+import { buildRecordShareExceptionCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util';
+
+const OBJECT_METADATA_ID = 'object-metadata-1';
+const PRINCIPAL_IDS = ['principal-1', EVERYONE_PRINCIPAL_ID];
+
+const build = (accessLevels: RecordShareAccessLevel[]) =>
+ buildRecordShareExceptionCondition({
+ tableAlias: 'company',
+ recordShareTableExpression: '"workspace_abc"."recordShare"',
+ objectMetadataId: OBJECT_METADATA_ID,
+ principalIds: PRINCIPAL_IDS,
+ accessLevels,
+ });
+
+describe('buildRecordShareExceptionCondition', () => {
+ it('should render a single NOT EXISTS on restrictions not lifted by a grant', () => {
+ const { sql, parameters } = build([
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+ ]);
+
+ const { text, values } = compileNamedParameters(sql, parameters);
+
+ expect({
+ text: text.replace(
+ /recordShare(Restriction|Grant)_[0-9a-f]{10}/g,
+ 'recordShare$1',
+ ),
+ values,
+ }).toEqual({
+ text: 'NOT EXISTS (SELECT 1 FROM "workspace_abc"."recordShare" AS "recordShareRestriction" WHERE "recordShareRestriction"."recordId" = "company"."id" AND "recordShareRestriction"."objectMetadataId" = $1 AND "recordShareRestriction"."principalId" = $2 AND "recordShareRestriction"."accessLevel" IN ($3, $4) AND "recordShareRestriction"."deletedAt" IS NULL AND NOT EXISTS (SELECT 1 FROM "workspace_abc"."recordShare" AS "recordShareGrant" WHERE "recordShareGrant"."recordId" = "recordShareRestriction"."recordId" AND "recordShareGrant"."objectMetadataId" = $1 AND "recordShareGrant"."principalId" = ANY($5) AND "recordShareGrant"."accessLevel" IN ($6, $7) AND "recordShareGrant"."deletedAt" IS NULL))',
+ values: [
+ OBJECT_METADATA_ID,
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.NONE,
+ RecordShareAccessLevel.READ,
+ PRINCIPAL_IDS,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+ ],
+ });
+ });
+
+ it('should keep its aliases apart whatever the length of the table alias', () => {
+ const { sql } = buildRecordShareExceptionCondition({
+ tableAlias: 'a'.repeat(80),
+ recordShareTableExpression: '"workspace_abc"."recordShare"',
+ objectMetadataId: OBJECT_METADATA_ID,
+ principalIds: PRINCIPAL_IDS,
+ accessLevels: [RecordShareAccessLevel.FULL],
+ });
+
+ const aliases = [...sql.matchAll(/ AS "([^"]+)"/g)].map(([, alias]) =>
+ Buffer.from(alias).subarray(0, 63).toString(),
+ );
+
+ expect(aliases).toHaveLength(2);
+ expect(new Set(aliases).size).toBe(2);
+ });
+
+ it('should only treat levels below the required ones as restrictions', () => {
+ const { parameters } = build([
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+ ]);
+
+ const restrictedAccessLevels = Object.entries(parameters).find(([name]) =>
+ name.startsWith('recordShareExceptionRestrictedAccessLevels_'),
+ )?.[1];
+
+ expect(restrictedAccessLevels).toEqual([RecordShareAccessLevel.NONE]);
+ });
+
+ it('should not reuse parameter names between two conditions', () => {
+ const first = Object.keys(build([RecordShareAccessLevel.FULL]).parameters);
+ const second = Object.keys(build([RecordShareAccessLevel.FULL]).parameters);
+
+ expect(first.filter((name) => second.includes(name))).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-general-access.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-general-access.util.spec.ts
new file mode 100644
index 00000000000..d5235592666
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-general-access.util.spec.ts
@@ -0,0 +1,80 @@
+/* @license Enterprise */
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import {
+ MetadataReadability,
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { resolveRecordGeneralAccess } from 'src/engine/core-modules/record-share/utils/resolve-record-general-access.util';
+
+const buildEveryoneShare = (
+ accessLevel: RecordShareAccessLevel,
+ rowCause = RecordShareRowCause.MANUAL,
+): RecordShare => ({
+ id: 'share-1',
+ recordId: 'record-1',
+ objectMetadataId: 'object-1',
+ principalId: EVERYONE_PRINCIPAL_ID,
+ principalType: RecordSharePrincipalType.EVERYONE,
+ accessLevel,
+ rowCause,
+ sourceId: 'record-1',
+});
+
+describe('resolveRecordGeneralAccess', () => {
+ it.each([
+ [MetadataReadability.OPEN, true, RecordShareAccessLevel.READ_WRITE],
+ [MetadataReadability.PRIVATE, false, RecordShareAccessLevel.NONE],
+ [MetadataReadability.INHERITED, false, null],
+ ])(
+ 'should fall back to the default of a %s object',
+ (readability, isRecordShareExceptionObject, accessLevel) => {
+ expect(
+ resolveRecordGeneralAccess({
+ readability,
+ isRecordShareExceptionObject,
+ recordShares: [],
+ }),
+ ).toEqual({ accessLevel, isDefault: true });
+ },
+ );
+
+ it('should read a restriction of a record open by default', () => {
+ expect(
+ resolveRecordGeneralAccess({
+ readability: MetadataReadability.OPEN,
+ isRecordShareExceptionObject: true,
+ recordShares: [buildEveryoneShare(RecordShareAccessLevel.NONE)],
+ }),
+ ).toEqual({ accessLevel: RecordShareAccessLevel.NONE, isDefault: false });
+ });
+
+ it('should read a manual opening of a private record', () => {
+ expect(
+ resolveRecordGeneralAccess({
+ readability: MetadataReadability.PRIVATE,
+ isRecordShareExceptionObject: false,
+ recordShares: [buildEveryoneShare(RecordShareAccessLevel.READ)],
+ }),
+ ).toEqual({ accessLevel: RecordShareAccessLevel.READ, isDefault: false });
+ });
+
+ it('should ignore everyone grants managed by a rule', () => {
+ expect(
+ resolveRecordGeneralAccess({
+ readability: MetadataReadability.PRIVATE,
+ isRecordShareExceptionObject: false,
+ recordShares: [
+ buildEveryoneShare(
+ RecordShareAccessLevel.FULL,
+ RecordShareRowCause.RULE,
+ ),
+ ],
+ }),
+ ).toEqual({ accessLevel: RecordShareAccessLevel.NONE, isDefault: true });
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts
new file mode 100644
index 00000000000..0986cd1715f
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts
@@ -0,0 +1,130 @@
+/* @license Enterprise */
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import {
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { resolveRecordIdsRestrictedForPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util';
+
+const MEMBER_ID = 'member-1';
+const SELECT_ACCESS_LEVELS = [
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+];
+const UPDATE_ACCESS_LEVELS = [
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+];
+
+const buildShare = (
+ recordId: string,
+ principalId: string,
+ accessLevel: RecordShareAccessLevel,
+): RecordShare => ({
+ id: `${recordId}-${principalId}`,
+ recordId,
+ objectMetadataId: 'object-1',
+ principalId,
+ principalType:
+ principalId === EVERYONE_PRINCIPAL_ID
+ ? RecordSharePrincipalType.EVERYONE
+ : RecordSharePrincipalType.WORKSPACE_MEMBER,
+ accessLevel,
+ rowCause: RecordShareRowCause.MANUAL,
+ sourceId: recordId,
+});
+
+describe('resolveRecordIdsRestrictedForPrincipals', () => {
+ it('should restrict a record whose everyone row is below the required level', () => {
+ expect(
+ resolveRecordIdsRestrictedForPrincipals({
+ recordShares: [
+ buildShare(
+ 'restricted',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.NONE,
+ ),
+ buildShare(
+ 'view-only',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.READ,
+ ),
+ ],
+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
+ accessLevels: SELECT_ACCESS_LEVELS,
+ }),
+ ).toEqual(new Set(['restricted']));
+ });
+
+ it('should restrict a view-only record for an update', () => {
+ expect(
+ resolveRecordIdsRestrictedForPrincipals({
+ recordShares: [
+ buildShare(
+ 'view-only',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.READ,
+ ),
+ ],
+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
+ accessLevels: UPDATE_ACCESS_LEVELS,
+ }),
+ ).toEqual(new Set(['view-only']));
+ });
+
+ it('should lift a restriction for a principal holding a sufficient grant', () => {
+ expect(
+ resolveRecordIdsRestrictedForPrincipals({
+ recordShares: [
+ buildShare(
+ 'restricted',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.NONE,
+ ),
+ buildShare('restricted', MEMBER_ID, RecordShareAccessLevel.READ),
+ ],
+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
+ accessLevels: SELECT_ACCESS_LEVELS,
+ }),
+ ).toEqual(new Set());
+ });
+
+ it('should keep a restriction when the grant is below the required level', () => {
+ expect(
+ resolveRecordIdsRestrictedForPrincipals({
+ recordShares: [
+ buildShare(
+ 'restricted',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.NONE,
+ ),
+ buildShare('restricted', MEMBER_ID, RecordShareAccessLevel.READ),
+ ],
+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
+ accessLevels: UPDATE_ACCESS_LEVELS,
+ }),
+ ).toEqual(new Set(['restricted']));
+ });
+
+ it('should ignore grants to other principals', () => {
+ expect(
+ resolveRecordIdsRestrictedForPrincipals({
+ recordShares: [
+ buildShare(
+ 'restricted',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.NONE,
+ ),
+ buildShare('restricted', 'member-2', RecordShareAccessLevel.FULL),
+ ],
+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
+ accessLevels: SELECT_ACCESS_LEVELS,
+ }),
+ ).toEqual(new Set(['restricted']));
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-viewer-record-share-access-level.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-viewer-record-share-access-level.util.spec.ts
new file mode 100644
index 00000000000..515f81acd8a
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-viewer-record-share-access-level.util.spec.ts
@@ -0,0 +1,71 @@
+/* @license Enterprise */
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import {
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { resolveViewerRecordShareAccessLevel } from 'src/engine/core-modules/record-share/utils/resolve-viewer-record-share-access-level.util';
+
+const MEMBER_ID = 'member-1';
+const PRINCIPAL_IDS = [EVERYONE_PRINCIPAL_ID, MEMBER_ID];
+
+const buildShare = (
+ principalId: string,
+ accessLevel: RecordShareAccessLevel,
+): RecordShare => ({
+ id: `${principalId}-${accessLevel}`,
+ recordId: 'record-1',
+ objectMetadataId: 'object-1',
+ principalId,
+ principalType:
+ principalId === EVERYONE_PRINCIPAL_ID
+ ? RecordSharePrincipalType.EVERYONE
+ : RecordSharePrincipalType.WORKSPACE_MEMBER,
+ accessLevel,
+ rowCause: RecordShareRowCause.MANUAL,
+ sourceId: 'record-1',
+});
+
+describe('resolveViewerRecordShareAccessLevel', () => {
+ it('should keep the highest grant held by the viewer', () => {
+ expect(
+ resolveViewerRecordShareAccessLevel({
+ recordShares: [
+ buildShare(EVERYONE_PRINCIPAL_ID, RecordShareAccessLevel.READ),
+ buildShare(MEMBER_ID, RecordShareAccessLevel.READ_WRITE),
+ buildShare('member-2', RecordShareAccessLevel.FULL),
+ ],
+ principalIds: PRINCIPAL_IDS,
+ implicitAccessLevels: [],
+ }),
+ ).toBe(RecordShareAccessLevel.READ_WRITE);
+ });
+
+ it('should never report a restriction as an access level', () => {
+ expect(
+ resolveViewerRecordShareAccessLevel({
+ recordShares: [
+ buildShare(EVERYONE_PRINCIPAL_ID, RecordShareAccessLevel.NONE),
+ ],
+ principalIds: PRINCIPAL_IDS,
+ implicitAccessLevels: [RecordShareAccessLevel.NONE, null],
+ }),
+ ).toBeNull();
+ });
+
+ it('should count implicit access such as the ownership of the creator', () => {
+ expect(
+ resolveViewerRecordShareAccessLevel({
+ recordShares: [
+ buildShare(EVERYONE_PRINCIPAL_ID, RecordShareAccessLevel.NONE),
+ ],
+ principalIds: PRINCIPAL_IDS,
+ implicitAccessLevels: [RecordShareAccessLevel.FULL],
+ }),
+ ).toBe(RecordShareAccessLevel.FULL);
+ });
+});
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 c261b124cb6..237a63b67d8 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
@@ -114,6 +114,19 @@ describe('validateShareWithArgOrThrow', () => {
);
});
+ it('should reject the NONE access level, which only withdraws access', () => {
+ expect(() =>
+ validateShareWithArgOrThrow({
+ authContext: userAuthContext,
+ shareWith: [
+ { everyone: true, accessLevel: RecordShareAccessLevel.NONE },
+ ],
+ }),
+ ).toThrow(
+ 'shareWith access level "NONE" must be one of READ, READ_WRITE, FULL',
+ );
+ });
+
it('should reject a workspaceMemberId that is not a uuid', () => {
expect(() =>
validateShareWithArgOrThrow({
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util.ts
new file mode 100644
index 00000000000..861b5d330fd
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util.ts
@@ -0,0 +1,73 @@
+/* @license Enterprise */
+
+import { randomBytes } from 'node:crypto';
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+import { type ObjectLiteral } from 'typeorm';
+
+import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
+
+// A record of an object open by default carries share rows only when it
+// departs from that default: an everyone row below the required level
+// restricts it, and a grant to one of the principals lifts the restriction.
+// Kept as a single NOT EXISTS so the planner can use an anti-join instead of
+// a per-row subplan, which an OR with the grant check would force.
+export const buildRecordShareExceptionCondition = ({
+ tableAlias,
+ recordShareTableExpression,
+ objectMetadataId,
+ principalIds,
+ accessLevels,
+}: {
+ tableAlias: string;
+ recordShareTableExpression: string;
+ objectMetadataId: string;
+ principalIds: string[];
+ accessLevels: RecordShareAccessLevel[];
+}): { sql: string; parameters: ObjectLiteral } => {
+ const parameterSuffix = randomBytes(5).toString('hex');
+ const objectMetadataIdParameterName = `recordShareExceptionObjectMetadataId_${parameterSuffix}`;
+ const everyonePrincipalIdParameterName = `recordShareExceptionEveryonePrincipalId_${parameterSuffix}`;
+ const restrictedAccessLevelsParameterName = `recordShareExceptionRestrictedAccessLevels_${parameterSuffix}`;
+ const principalIdsParameterName = `recordShareExceptionPrincipalIds_${parameterSuffix}`;
+ const accessLevelsParameterName = `recordShareExceptionAccessLevels_${parameterSuffix}`;
+
+ // Derived from the table alias, these would collide once Postgres
+ // truncates a long alias to 63 bytes and the grant would shadow the
+ // restriction it must correlate with
+ const restrictionAlias = escapeIdentifier(
+ `recordShareRestriction_${parameterSuffix}`,
+ );
+ const grantAlias = escapeIdentifier(`recordShareGrant_${parameterSuffix}`);
+
+ const grantConditions = [
+ `${grantAlias}."recordId" = ${restrictionAlias}."recordId"`,
+ `${grantAlias}."objectMetadataId" = :${objectMetadataIdParameterName}`,
+ `${grantAlias}."principalId" = ANY(:${principalIdsParameterName})`,
+ `${grantAlias}."accessLevel" IN (:...${accessLevelsParameterName})`,
+ `${grantAlias}."deletedAt" IS NULL`,
+ ];
+
+ const restrictionConditions = [
+ `${restrictionAlias}."recordId" = ${escapeIdentifier(tableAlias)}."id"`,
+ `${restrictionAlias}."objectMetadataId" = :${objectMetadataIdParameterName}`,
+ `${restrictionAlias}."principalId" = :${everyonePrincipalIdParameterName}`,
+ `${restrictionAlias}."accessLevel" IN (:...${restrictedAccessLevelsParameterName})`,
+ `${restrictionAlias}."deletedAt" IS NULL`,
+ `NOT EXISTS (SELECT 1 FROM ${recordShareTableExpression} AS ${grantAlias} WHERE ${grantConditions.join(' AND ')})`,
+ ];
+
+ return {
+ sql: `NOT EXISTS (SELECT 1 FROM ${recordShareTableExpression} AS ${restrictionAlias} WHERE ${restrictionConditions.join(' AND ')})`,
+ parameters: {
+ [objectMetadataIdParameterName]: objectMetadataId,
+ [everyonePrincipalIdParameterName]: EVERYONE_PRINCIPAL_ID,
+ [restrictedAccessLevelsParameterName]: Object.values(
+ RecordShareAccessLevel,
+ ).filter((accessLevel) => !accessLevels.includes(accessLevel)),
+ [principalIdsParameterName]: principalIds,
+ [accessLevelsParameterName]: accessLevels,
+ },
+ };
+};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
index 6292a5449a2..27c6ff119fb 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
@@ -11,6 +11,8 @@ import {
type InheritedReadabilityParentCondition,
} from 'src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util';
import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';
+import { buildRecordShareExceptionCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util';
+import { isRecordShareExceptionObject } from 'src/engine/core-modules/record-share/utils/is-record-share-exception-object.util';
import { isOpenWhenDetachedObject } from 'src/engine/core-modules/record-share/utils/is-open-when-detached-object.util';
import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';
import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';
@@ -43,7 +45,10 @@ export const buildRecordShareGate = ({
});
switch (gateKind) {
case 'open':
- return { kind: 'open' };
+ return context.environment.isRecordSharingEnabled &&
+ isRecordShareExceptionObject(target.flatObjectMetadata)
+ ? buildRecordShareExceptionGate(context, target)
+ : { kind: 'open' };
case 'deny':
return { kind: 'denied' };
case 'inherited':
@@ -100,6 +105,28 @@ const buildOwnRecordShareGate = (
};
};
+const buildRecordShareExceptionGate = (
+ context: RowAccessPolicyContext,
+ target: RowAccessPolicyTarget,
+): RowAccessPolicy => {
+ const principals = resolveRecordSharePrincipals(context, target);
+
+ if (!isDefined(principals)) {
+ return { kind: 'open' };
+ }
+
+ return {
+ kind: 'gated',
+ condition: buildRecordShareExceptionCondition({
+ tableAlias: target.tableAlias,
+ recordShareTableExpression:
+ context.environment.recordShareTableExpression,
+ objectMetadataId: target.flatObjectMetadata.id,
+ ...principals,
+ }),
+ };
+};
+
const buildInheritedReadabilityGate = ({
context,
target,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/is-record-share-exception-object.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/is-record-share-exception-object.util.ts
new file mode 100644
index 00000000000..94d57b604e4
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/is-record-share-exception-object.util.ts
@@ -0,0 +1,13 @@
+/* @license Enterprise */
+
+import { MetadataReadability } from 'twenty-shared/types';
+
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+// Records of an object open by default can depart from that default one by
+// one; system objects stay out since nobody shares them from the product
+export const isRecordShareExceptionObject = (
+ flatObjectMetadata: Pick<FlatObjectMetadata, 'readability' | 'isSystem'>,
+): boolean =>
+ flatObjectMetadata.readability === MetadataReadability.OPEN &&
+ !flatObjectMetadata.isSystem;
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-general-access.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-general-access.util.ts
new file mode 100644
index 00000000000..c107ce299d3
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-general-access.util.ts
@@ -0,0 +1,62 @@
+/* @license Enterprise */
+
+import {
+ MetadataReadability,
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export type RecordGeneralAccess = {
+ // null: the record follows the records it is linked to
+ accessLevel: RecordShareAccessLevel | null;
+ isDefault: boolean;
+};
+
+const resolveDefaultGeneralAccessLevel = ({
+ readability,
+ isRecordShareExceptionObject,
+}: {
+ readability: FlatObjectMetadata['readability'];
+ isRecordShareExceptionObject: boolean;
+}): RecordShareAccessLevel | null => {
+ if (isRecordShareExceptionObject) {
+ return RecordShareAccessLevel.READ_WRITE;
+ }
+
+ return readability === MetadataReadability.INHERITED
+ ? null
+ : RecordShareAccessLevel.NONE;
+};
+
+export const resolveRecordGeneralAccess = ({
+ readability,
+ isRecordShareExceptionObject,
+ recordShares,
+}: {
+ readability: FlatObjectMetadata['readability'];
+ isRecordShareExceptionObject: boolean;
+ recordShares: RecordShare[];
+}): RecordGeneralAccess => {
+ const everyoneManualShare = recordShares.find(
+ (recordShare) =>
+ recordShare.principalType === RecordSharePrincipalType.EVERYONE &&
+ recordShare.rowCause === RecordShareRowCause.MANUAL,
+ );
+
+ if (isDefined(everyoneManualShare)) {
+ return { accessLevel: everyoneManualShare.accessLevel, isDefault: false };
+ }
+
+ return {
+ accessLevel: resolveDefaultGeneralAccessLevel({
+ readability,
+ isRecordShareExceptionObject,
+ }),
+ isDefault: true,
+ };
+};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts
new file mode 100644
index 00000000000..15642eeeacc
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts
@@ -0,0 +1,35 @@
+/* @license Enterprise */
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { type RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';
+
+// Mirrors buildRecordShareExceptionCondition for records already in memory
+export const resolveRecordIdsRestrictedForPrincipals = ({
+ recordShares,
+ principalIds,
+ accessLevels,
+}: {
+ recordShares: RecordShare[];
+ principalIds: string[];
+ accessLevels: RecordShareAccessLevel[];
+}): Set<string> => {
+ const liftedRecordIds = resolveRecordIdsSharedWithPrincipals({
+ recordShares,
+ principalIds,
+ accessLevels,
+ });
+
+ return new Set(
+ recordShares
+ .filter(
+ (recordShare) =>
+ recordShare.principalId === EVERYONE_PRINCIPAL_ID &&
+ !accessLevels.includes(recordShare.accessLevel) &&
+ !liftedRecordIds.has(recordShare.recordId),
+ )
+ .map((recordShare) => recordShare.recordId),
+ );
+};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-share-with-principal-or-throw.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-share-with-principal-or-throw.util.ts
index 6120e4ded0f..ff0e7168206 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-share-with-principal-or-throw.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-share-with-principal-or-throw.util.ts
@@ -5,6 +5,7 @@ import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
import { RecordSharePrincipalType } from 'twenty-shared/types';
import { isDefined, isValidUuid } from 'twenty-shared/utils';
+import { GRANTABLE_RECORD_SHARE_ACCESS_LEVELS } from 'src/engine/core-modules/record-share/constants/grantable-record-share-access-levels.constant';
import {
RecordShareException,
RecordShareExceptionCode,
@@ -66,5 +67,16 @@ export const resolveShareWithPrincipalOrThrow = (
);
}
+ // NONE only withdraws the default access of a record and is never granted
+ if (
+ !GRANTABLE_RECORD_SHARE_ACCESS_LEVELS.includes(shareWithEntry.accessLevel)
+ ) {
+ throw new RecordShareException(
+ `shareWith access level "${shareWithEntry.accessLevel}" must be one of ${GRANTABLE_RECORD_SHARE_ACCESS_LEVELS.join(', ')}`,
+ RecordShareExceptionCode.INVALID_SHARE_WITH,
+ { userFriendlyMessage: msg`Invalid access level.` },
+ );
+ }
+
return { ...principal, accessLevel: shareWithEntry.accessLevel };
};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-viewer-record-share-access-level.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-viewer-record-share-access-level.util.ts
new file mode 100644
index 00000000000..98974fc1e85
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-viewer-record-share-access-level.util.ts
@@ -0,0 +1,32 @@
+/* @license Enterprise */
+
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+
+const RECORD_SHARE_ACCESS_LEVELS_BY_PRECEDENCE = [
+ RecordShareAccessLevel.FULL,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.READ,
+];
+
+// The creator of a record open by default owns it without a grant, and
+// everyone holds its general access until a row says otherwise
+export const resolveViewerRecordShareAccessLevel = ({
+ recordShares,
+ principalIds,
+ implicitAccessLevels,
+}: {
+ recordShares: RecordShare[];
+ principalIds: string[];
+ implicitAccessLevels: (RecordShareAccessLevel | null)[];
+}): RecordShareAccessLevel | null =>
+ RECORD_SHARE_ACCESS_LEVELS_BY_PRECEDENCE.find(
+ (accessLevel) =>
+ implicitAccessLevels.includes(accessLevel) ||
+ recordShares.some(
+ (recordShare) =>
+ principalIds.includes(recordShare.principalId) &&
+ recordShare.accessLevel === accessLevel,
+ ),
+ ) ?? null;
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 04a816c23d8..d71dfb736c4 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
@@ -2,6 +2,7 @@ import { msg } from '@lingui/core/macro';
import { isNonEmptyString } from '@sniptt/guards';
import { QUERY_MAX_RECORDS } from 'twenty-shared/constants';
import {
+ FeatureFlagKey,
MetadataReadability,
type ObjectRecord,
type ObjectsPermissions,
@@ -2166,6 +2167,10 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
),
resolveTableExpression: (objectMetadataId) =>
this.getTableExpression(objectMetadataId),
+ isRecordSharingEnabled:
+ this.options.internalContext.featureFlagsMap[
+ FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED
+ ] ?? false,
};
}
diff --git a/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts
index 0c9f684fe13..9ca322d41a1 100644
--- a/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts
@@ -33,6 +33,7 @@ export type RowAccessPolicyEnvironment = {
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
recordShareTableExpression: string;
resolveTableExpression: (objectMetadataId: string) => string;
+ isRecordSharingEnabled: boolean;
};
export type RowAccessPolicyContext = {
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
index bec9b3ed892..2b4c481a702 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
@@ -54,6 +54,7 @@ const environment: RowAccessPolicyEnvironment = {
recordShareTableExpression: '"workspace"."recordShare"',
resolveTableExpression: (objectMetadataId) =>
`"workspace"."${objectMetadataId}"`,
+ isRecordSharingEnabled: false,
};
const readEverything: RowAccessPolicySubject = {
@@ -150,6 +151,53 @@ describe('buildRowAccessPolicy', () => {
expect(build(readEverything, note)).toEqual({ kind: 'open' });
});
+ it('gates an OPEN object on its restrictions once record sharing is enabled', () => {
+ const company = buildObject({
+ id: 'company',
+ readability: MetadataReadability.OPEN,
+ });
+ const policy = buildRowAccessPolicy({
+ subject: readEverything,
+ environment: { ...environment, isRecordSharingEnabled: true },
+ tableAlias: 'company',
+ flatObjectMetadata: company,
+ operationType: 'select',
+ depth: 0,
+ });
+
+ expect(policy.kind).toBe('gated');
+ if (policy.kind !== 'gated') throw new Error('Expected an exception gate');
+ expect(policy.condition.sql).toMatch(
+ /^\(NOT EXISTS \(SELECT 1 FROM "workspace"."recordShare" AS "recordShareRestriction_[0-9a-f]{10}"/,
+ );
+ });
+
+ it('keeps an OPEN system object open when record sharing is enabled', () => {
+ expect(
+ buildRowAccessPolicy({
+ subject: readEverything,
+ environment: { ...environment, isRecordSharingEnabled: true },
+ tableAlias: 'note',
+ flatObjectMetadata: { ...note, isSystem: true },
+ operationType: 'select',
+ depth: 0,
+ }),
+ ).toEqual({ kind: 'open' });
+ });
+
+ it('leaves an OPEN object open to inserts when record sharing is enabled', () => {
+ expect(
+ buildRowAccessPolicy({
+ subject: readEverything,
+ environment: { ...environment, isRecordSharingEnabled: true },
+ tableAlias: 'note',
+ flatObjectMetadata: note,
+ operationType: 'insert',
+ depth: 0,
+ }),
+ ).toEqual({ kind: 'open' });
+ });
+
it('denies an object the subject has no permission on', () => {
expect(build({ ...readEverything, objectsPermissions: {} }, note)).toEqual({
kind: 'denied',
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts
index 30471d2ab12..97e52dd3c3d 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts
@@ -12,6 +12,7 @@ const DEFAULT_SEEDED_FEATURE_FLAGS: Partial<Record<FeatureFlagKey, boolean>> = {
[FeatureFlagKey.IS_LOGS_SETTINGS_SECTION_ENABLED]: true,
[FeatureFlagKey.IS_CONVERSATIONS_TAB_ENABLED]: false,
[FeatureFlagKey.IS_VALIDATION_RULES_ENABLED]: true,
+ [FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED]: false,
};
type SeedFeatureFlagsArgs = {
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-record-share-standard-flat-field-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-record-share-standard-flat-field-metadata.util.ts
index aec6b2a30cf..50e82da9161 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-record-share-standard-flat-field-metadata.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/field-metadata/compute-record-share-standard-flat-field-metadata.util.ts
@@ -274,6 +274,7 @@ export const buildRecordShareStandardFlatFieldMetadatas = ({
icon: 'IconLock',
isSystem: true,
isNullable: false,
+ defaultValue: `'${RecordShareAccessLevel.READ}'`,
isUIEditable: false,
options: [
{
@@ -303,6 +304,15 @@ export const buildRecordShareStandardFlatFieldMetadatas = ({
position: 2,
color: 'purple',
},
+ {
+ id: 'b6c22171-178e-4b2d-b858-02ed48c925b1',
+ value: RecordShareAccessLevel.NONE,
+ label: i18nLabel(
+ msg({ message: `Restricted`, context: 'fieldMetadata.label' }),
+ ),
+ position: 3,
+ color: 'gray',
+ },
],
},
standardObjectMetadataRelatedEntityIds,
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-level-sharing-open-object.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-level-sharing-open-object.integration-spec.ts
new file mode 100644
index 00000000000..d77358e9f3d
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-level-sharing-open-object.integration-spec.ts
@@ -0,0 +1,373 @@
+import { randomUUID } from 'node:crypto';
+
+import { parse } from 'graphql';
+import {
+ FeatureFlagKey,
+ FieldMetadataType,
+ RecordShareAccessLevel,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';
+import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+import { type RecordSharePrincipalInput } from 'src/engine/core-modules/record-share/dtos/record-sharing.dto';
+import { type RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const OBJECT_NAME = 'openSharingRecord';
+const OBJECT_PLURAL = 'openSharingRecords';
+const RECORD_ID = randomUUID();
+const workspaceId = SEED_APPLE_WORKSPACE_ID;
+const JONY = { workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY };
+const EVERYONE = { everyone: true };
+const fields =
+ 'viewerAccessLevel isEnabled isOpenByDefault generalAccessLevel isGeneralAccessDefault permissions { canRead canUpdate } shares { principalId rowCause accessLevel }';
+const READ_SHARING = parse(
+ `query RecordSharing($target: RecordSharingTargetInput!) { recordSharing(target: $target) { ${fields} } }`,
+);
+const SET_SHARE = parse(
+ `mutation SetShare($target: RecordSharingTargetInput!, $principal: RecordSharePrincipalInput!, $enabled: Boolean!, $accessLevel: RecordShareAccessLevel) { setRecordShare(target: $target, principal: $principal, enabled: $enabled, accessLevel: $accessLevel) { ${fields} } }`,
+);
+
+describe('Record-level sharing on an object open by default', () => {
+ let objectMetadataId: string;
+ let shares: RecordShareStorageService;
+ const target = () => ({ objectMetadataId, recordId: RECORD_ID });
+
+ const setRecordSharingEnabled = (value: boolean) =>
+ updateFeatureFlag({
+ featureFlag: FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED,
+ value,
+ expectToFail: false,
+ });
+
+ const readSharing = (token = APPLE_JANE_ADMIN_ACCESS_TOKEN) =>
+ makeMetadataApiRequest(
+ { query: READ_SHARING, variables: { target: target() } },
+ token,
+ );
+
+ const setShare = ({
+ principal,
+ enabled,
+ accessLevel = RecordShareAccessLevel.READ,
+ token = APPLE_JANE_ADMIN_ACCESS_TOKEN,
+ }: {
+ principal: RecordSharePrincipalInput;
+ enabled: boolean;
+ accessLevel?: RecordShareAccessLevel;
+ token?: string;
+ }) =>
+ makeMetadataApiRequest(
+ {
+ query: SET_SHARE,
+ variables: { target: target(), principal, enabled, accessLevel },
+ },
+ token,
+ );
+
+ const findRecordIds = async (token: string) => {
+ const response = await makeGraphqlApiRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: OBJECT_NAME,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: 'id',
+ filter: { id: { eq: RECORD_ID } },
+ }),
+ token,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data[OBJECT_PLURAL].edges.map(
+ ({ node }: { node: { id: string } }) => node.id,
+ );
+ };
+
+ const rename = (name: string, token: string) =>
+ makeGraphqlApiRequest(
+ updateOneOperationFactory({
+ objectMetadataSingularName: OBJECT_NAME,
+ gqlFields: 'id name',
+ recordId: RECORD_ID,
+ data: { name },
+ }),
+ token,
+ );
+
+ beforeAll(async () => {
+ shares = getAppProviderByClassName<RecordShareStorageService>(
+ 'RecordShareStorageService',
+ );
+ const { data } = await createOneObjectMetadata({
+ input: {
+ nameSingular: OBJECT_NAME,
+ namePlural: OBJECT_PLURAL,
+ labelSingular: 'Open sharing record',
+ labelPlural: 'Open sharing records',
+ icon: 'IconShare',
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ objectMetadataId = data.createOneObject.id;
+ await createOneFieldMetadata({
+ input: {
+ name: 'name',
+ label: 'Name',
+ type: FieldMetadataType.TEXT,
+ objectMetadataId,
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ const created = await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: OBJECT_NAME,
+ gqlFields: 'id',
+ data: { id: RECORD_ID, name: 'Created by Jane' },
+ }),
+ );
+
+ expect(created.body.errors).toBeUndefined();
+ await setRecordSharingEnabled(true);
+ });
+
+ beforeEach(async () => {
+ await shares.deleteByRecordIds({
+ workspaceId,
+ objectMetadataId,
+ recordIds: [RECORD_ID],
+ });
+ });
+
+ afterAll(async () => {
+ await setRecordSharingEnabled(false);
+ await shares.deleteByRecordIds({
+ workspaceId,
+ objectMetadataId,
+ recordIds: [RECORD_ID],
+ });
+ await makeGraphqlApiRequest(
+ destroyManyOperationFactory({
+ objectMetadataSingularName: OBJECT_NAME,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: 'id',
+ filter: { id: { eq: RECORD_ID } },
+ }),
+ );
+ await updateOneObjectMetadata({
+ input: {
+ idToUpdate: objectMetadataId,
+ updatePayload: { isActive: false },
+ },
+ expectToFail: false,
+ });
+ await deleteOneObjectMetadata({ input: { idToDelete: objectMetadataId } });
+ });
+
+ it('should write no share row for a record that follows the default', async () => {
+ const response = await readSharing();
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.recordSharing).toMatchObject({
+ isEnabled: true,
+ isOpenByDefault: true,
+ generalAccessLevel: RecordShareAccessLevel.READ_WRITE,
+ isGeneralAccessDefault: true,
+ viewerAccessLevel: RecordShareAccessLevel.FULL,
+ shares: [],
+ });
+ expect(
+ await shares.findByRecordIds({
+ workspaceId,
+ objectMetadataId,
+ recordIds: [RECORD_ID],
+ }),
+ ).toEqual([]);
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ });
+
+ it('should hide a restricted record from everyone but its creator', async () => {
+ const restricted = await setShare({ principal: EVERYONE, enabled: false });
+
+ expect(restricted.body.errors).toBeUndefined();
+ expect(restricted.body.data.setRecordShare).toMatchObject({
+ generalAccessLevel: RecordShareAccessLevel.NONE,
+ isGeneralAccessDefault: false,
+ shares: [
+ expect.objectContaining({
+ principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
+ rowCause: RecordShareRowCause.OWNER,
+ accessLevel: RecordShareAccessLevel.FULL,
+ }),
+ ],
+ });
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([]);
+ expect(await findRecordIds(APPLE_JANE_ADMIN_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ expect(
+ (await readSharing(APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.errors,
+ ).toBeDefined();
+ });
+
+ it('should let a grant lift a restriction up to its level', async () => {
+ await setShare({ principal: EVERYONE, enabled: false });
+ await setShare({ principal: JONY, enabled: true });
+
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ expect(
+ (await rename('Read only', APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.errors,
+ ).toBeDefined();
+
+ await setShare({
+ principal: JONY,
+ enabled: true,
+ accessLevel: RecordShareAccessLevel.READ_WRITE,
+ });
+
+ expect(
+ (await rename('Edited by Jony', APPLE_JONY_MEMBER_ACCESS_TOKEN)).body
+ .errors,
+ ).toBeUndefined();
+ });
+
+ it('should let everyone view without editing', async () => {
+ const viewOnly = await setShare({
+ principal: EVERYONE,
+ enabled: true,
+ accessLevel: RecordShareAccessLevel.READ,
+ });
+
+ expect(viewOnly.body.data.setRecordShare).toMatchObject({
+ generalAccessLevel: RecordShareAccessLevel.READ,
+ isGeneralAccessDefault: false,
+ });
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ expect(
+ (await rename('Not allowed', APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.errors,
+ ).toBeDefined();
+ expect(
+ (await readSharing(APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.data
+ .recordSharing,
+ ).toMatchObject({
+ viewerAccessLevel: RecordShareAccessLevel.READ,
+ permissions: { canRead: true, canUpdate: false },
+ });
+ });
+
+ it('should drop the exception row when general access returns to the default', async () => {
+ await setShare({ principal: EVERYONE, enabled: false });
+ const reopened = await setShare({
+ principal: EVERYONE,
+ enabled: true,
+ accessLevel: RecordShareAccessLevel.READ_WRITE,
+ });
+
+ expect(reopened.body.data.setRecordShare).toMatchObject({
+ generalAccessLevel: RecordShareAccessLevel.READ_WRITE,
+ isGeneralAccessDefault: true,
+ });
+ expect(
+ await shares.findByRecordIds({
+ workspaceId,
+ objectMetadataId,
+ recordIds: [RECORD_ID],
+ }),
+ ).toEqual([]);
+ expect(
+ (await rename('Open again', APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.errors,
+ ).toBeUndefined();
+ });
+
+ it('should keep sharing in the hands of the creator and full access holders', async () => {
+ const response = await setShare({
+ principal: EVERYONE,
+ enabled: false,
+ token: APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ });
+
+ expect(response.body.errors).toBeDefined();
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ expect(
+ (await readSharing(APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.data
+ .recordSharing,
+ ).toMatchObject({
+ viewerAccessLevel: RecordShareAccessLevel.READ_WRITE,
+ shares: [],
+ });
+ });
+
+ it('should keep a full access holder who restricts the record in charge of it', async () => {
+ await setShare({
+ principal: EVERYONE,
+ enabled: true,
+ accessLevel: RecordShareAccessLevel.FULL,
+ });
+
+ const restricted = await setShare({
+ principal: EVERYONE,
+ enabled: false,
+ token: APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ });
+
+ expect(restricted.body.errors).toBeUndefined();
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ expect(
+ (await readSharing(APPLE_JONY_MEMBER_ACCESS_TOKEN)).body.data
+ .recordSharing.viewerAccessLevel,
+ ).toBe(RecordShareAccessLevel.FULL);
+ });
+
+ it('should refuse NONE as a granted access level', async () => {
+ const response = await setShare({
+ principal: JONY,
+ enabled: true,
+ accessLevel: RecordShareAccessLevel.NONE,
+ });
+
+ expect(response.body.errors).toBeDefined();
+ });
+
+ it('should leave open objects untouched while the flag is off', async () => {
+ await setShare({ principal: EVERYONE, enabled: false });
+ await setRecordSharingEnabled(false);
+
+ try {
+ expect(await findRecordIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ RECORD_ID,
+ ]);
+ expect((await readSharing()).body.data.recordSharing.isEnabled).toBe(
+ false,
+ );
+ expect(
+ (await setShare({ principal: EVERYONE, enabled: false })).body.errors,
+ ).toBeDefined();
+ } finally {
+ await setRecordSharingEnabled(true);
+ }
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-level-sharing-restricted-record-surfaces.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-level-sharing-restricted-record-surfaces.integration-spec.ts
new file mode 100644
index 00000000000..da735807e80
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-level-sharing-restricted-record-surfaces.integration-spec.ts
@@ -0,0 +1,453 @@
+import { randomUUID } from 'node:crypto';
+
+import { parse } from 'graphql';
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { type ObjectRecordEvent } from 'twenty-shared/database-events';
+import { FeatureFlagKey, RecordShareAccessLevel } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';
+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { findOneOperationFactory } from 'test/integration/graphql/utils/find-one-operation-factory.util';
+import { groupByOperationFactory } from 'test/integration/graphql/utils/group-by-operation-factory.util';
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';
+import { searchFactory } from 'test/integration/graphql/utils/search-factory.util';
+import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';
+import { makeRestApiRequest } from 'test/integration/rest/utils/make-rest-api-request.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+
+import { type RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
+import { type RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const workspaceId = SEED_APPLE_WORKSPACE_ID;
+const SEARCH_TERM = `Quorvex${randomUUID().slice(0, 8)}`;
+const RESTRICTED_COMPANY_ID = randomUUID();
+const OPEN_COMPANY_ID = randomUUID();
+const COMPANY_IDS = [RESTRICTED_COMPANY_ID, OPEN_COMPANY_ID];
+const PERSON_ID = randomUUID();
+const NOTE_ID = randomUUID();
+const NOTE_TARGET_ID = randomUUID();
+
+const SET_SHARE = parse(
+ `mutation SetShare($target: RecordSharingTargetInput!, $principal: RecordSharePrincipalInput!, $enabled: Boolean!, $accessLevel: RecordShareAccessLevel) { setRecordShare(target: $target, principal: $principal, enabled: $enabled, accessLevel: $accessLevel) { generalAccessLevel } }`,
+);
+
+const FIND_COMPANIES = parse(
+ `query Companies($filter: CompanyFilterInput) { companies(filter: $filter) { totalCount edges { node { id } } } }`,
+);
+
+const collectIds = (edges: { node: { id: string } }[]) =>
+ edges.map(({ node }) => node.id).sort();
+
+describe('A restricted record on an object open by default', () => {
+ let companyObjectMetadataId: string;
+ let shares: RecordShareStorageService;
+
+ const setShare = (
+ principal: { everyone: true } | { workspaceMemberId: string },
+ enabled: boolean,
+ accessLevel = RecordShareAccessLevel.READ,
+ ) =>
+ makeMetadataApiRequest(
+ {
+ query: SET_SHARE,
+ variables: {
+ target: {
+ objectMetadataId: companyObjectMetadataId,
+ recordId: RESTRICTED_COMPANY_ID,
+ },
+ principal,
+ enabled,
+ accessLevel,
+ },
+ },
+ APPLE_JANE_ADMIN_ACCESS_TOKEN,
+ );
+
+ const findCompanyIds = async (token: string) => {
+ const response = await makeGraphqlApiRequest(
+ {
+ query: FIND_COMPANIES,
+ variables: { filter: { id: { in: COMPANY_IDS } } },
+ },
+ token,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return {
+ ids: collectIds(response.body.data.companies.edges),
+ totalCount: response.body.data.companies.totalCount,
+ };
+ };
+
+ const createRecord = async (
+ objectMetadataSingularName: string,
+ data: Record<string, unknown>,
+ ) => {
+ const response = await makeGraphqlApiRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName,
+ gqlFields: 'id',
+ data,
+ }),
+ APPLE_JANE_ADMIN_ACCESS_TOKEN,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ };
+
+ beforeAll(async () => {
+ shares = getAppProviderByClassName<RecordShareStorageService>(
+ 'RecordShareStorageService',
+ );
+ companyObjectMetadataId = (
+ await getCoreRepository<ObjectMetadataEntity>(
+ ObjectMetadataEntity,
+ ).findOneOrFail({ where: { workspaceId, nameSingular: 'company' } })
+ ).id;
+
+ await updateFeatureFlag({
+ featureFlag: FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED,
+ value: true,
+ expectToFail: false,
+ });
+
+ await createRecord('company', {
+ id: RESTRICTED_COMPANY_ID,
+ name: `${SEARCH_TERM} restricted`,
+ });
+ await createRecord('company', {
+ id: OPEN_COMPANY_ID,
+ name: `${SEARCH_TERM} open`,
+ });
+ await createRecord('person', {
+ id: PERSON_ID,
+ name: { firstName: 'Works at', lastName: 'Restricted' },
+ companyId: RESTRICTED_COMPANY_ID,
+ });
+ await createRecord('note', { id: NOTE_ID, title: 'On the restricted' });
+ await createRecord('noteTarget', {
+ id: NOTE_TARGET_ID,
+ noteId: NOTE_ID,
+ targetCompanyId: RESTRICTED_COMPANY_ID,
+ });
+
+ const restricted = await setShare({ everyone: true }, false);
+
+ expect(restricted.body.errors).toBeUndefined();
+ expect(restricted.body.data.setRecordShare.generalAccessLevel).toBe(
+ RecordShareAccessLevel.NONE,
+ );
+ });
+
+ afterAll(async () => {
+ await updateFeatureFlag({
+ featureFlag: FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED,
+ value: false,
+ expectToFail: false,
+ });
+ await shares.deleteByRecordIds({
+ workspaceId,
+ objectMetadataId: companyObjectMetadataId,
+ recordIds: COMPANY_IDS,
+ });
+
+ for (const [singular, plural, ids] of [
+ ['noteTarget', 'noteTargets', [NOTE_TARGET_ID]],
+ ['note', 'notes', [NOTE_ID]],
+ ['person', 'people', [PERSON_ID]],
+ ['company', 'companies', COMPANY_IDS],
+ ] as const) {
+ await makeGraphqlApiRequest(
+ destroyManyOperationFactory({
+ objectMetadataSingularName: singular,
+ objectMetadataPluralName: plural,
+ gqlFields: 'id',
+ filter: { id: { in: [...ids] } },
+ }),
+ );
+ }
+ });
+
+ it('should leave it out of lists and their total count', async () => {
+ expect(await findCompanyIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual({
+ ids: [OPEN_COMPANY_ID],
+ totalCount: 1,
+ });
+ expect(await findCompanyIds(APPLE_JANE_ADMIN_ACCESS_TOKEN)).toEqual({
+ ids: [...COMPANY_IDS].sort(),
+ totalCount: 2,
+ });
+ });
+
+ it('should not find it by id', async () => {
+ const response = await makeGraphqlApiRequest(
+ findOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: 'id',
+ filter: { id: { eq: RESTRICTED_COMPANY_ID } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(response.body.data?.company ?? null).toBeNull();
+ });
+
+ it('should leave it out of group counts', async () => {
+ const response = await makeGraphqlApiRequest(
+ groupByOperationFactory({
+ objectMetadataSingularName: 'company',
+ objectMetadataPluralName: 'companies',
+ groupBy: [{ name: true }],
+ filter: { id: { in: COMPANY_IDS } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(
+ response.body.data.companiesGroupBy.map(
+ (group: { groupByDimensionValues: string[] }) =>
+ group.groupByDimensionValues,
+ ),
+ ).toEqual([[`${SEARCH_TERM} open`]]);
+ });
+
+ it('should hide it behind the relation of a record that points at it', async () => {
+ const readCompanyOfPerson = async (token: string) => {
+ const response = await makeGraphqlApiRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id company { id }',
+ filter: { id: { eq: PERSON_ID } },
+ }),
+ token,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.people.edges[0]?.node.company ?? null;
+ };
+
+ expect(
+ await readCompanyOfPerson(APPLE_JONY_MEMBER_ACCESS_TOKEN),
+ ).toBeNull();
+ expect(await readCompanyOfPerson(APPLE_JANE_ADMIN_ACCESS_TOKEN)).toEqual({
+ id: RESTRICTED_COMPANY_ID,
+ });
+ });
+
+ it('should leave it out of search', async () => {
+ const searchCompanyIds = async (token: string) => {
+ const response = await makeGraphqlApiRequest(
+ searchFactory({
+ searchInput: SEARCH_TERM,
+ includedObjectNameSingulars: ['company'],
+ limit: 50,
+ }),
+ token,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.search.edges
+ .map(({ node }: { node: { recordId: string } }) => node.recordId)
+ .sort();
+ };
+
+ expect(await searchCompanyIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([
+ OPEN_COMPANY_ID,
+ ]);
+ expect(await searchCompanyIds(APPLE_JANE_ADMIN_ACCESS_TOKEN)).toEqual(
+ [...COMPANY_IDS].sort(),
+ );
+ });
+
+ it('should leave it out of the REST API', async () => {
+ const response = await makeRestApiRequest({
+ method: 'get',
+ path: `/companies?filter=id[in]:["${RESTRICTED_COMPANY_ID}","${OPEN_COMPANY_ID}"]`,
+ bearer: APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ });
+
+ expect(response.status).toBe(200);
+ expect(
+ response.body.data.companies.map(({ id }: { id: string }) => id),
+ ).toEqual([OPEN_COMPANY_ID]);
+ });
+
+ it('should hide the note attached to it only', async () => {
+ const findNoteIds = async (token: string) => {
+ const response = await makeGraphqlApiRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'note',
+ objectMetadataPluralName: 'notes',
+ gqlFields: 'id',
+ filter: { id: { eq: NOTE_ID } },
+ }),
+ token,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return collectIds(response.body.data.notes.edges);
+ };
+
+ expect(await findNoteIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).toEqual([]);
+ expect(await findNoteIds(APPLE_JANE_ADMIN_ACCESS_TOKEN)).toEqual([NOTE_ID]);
+ });
+
+ it('should leave it out of the events delivered to others', async () => {
+ const memberRole = await findOneRoleByLabel({ label: 'Member' });
+ const { rolesPermissions, flatObjectMetadataMaps } =
+ await getAppProviderByClassName<WorkspaceCacheService>(
+ 'WorkspaceCacheService',
+ ).getOrRecompute(workspaceId, [
+ 'rolesPermissions',
+ 'flatObjectMetadataMaps',
+ ]);
+ const companyObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: companyObjectMetadataId,
+ flatEntityMaps: flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(companyObjectMetadata)) {
+ throw new Error('Company object metadata is missing');
+ }
+
+ const admittedRecordIds =
+ await getAppProviderByClassName<RecordAccessPolicyService>(
+ 'RecordAccessPolicyService',
+ )
+ .buildEventRecordAccessGate({
+ name: 'company.updated',
+ workspaceId,
+ objectMetadata: companyObjectMetadata,
+ events: COMPANY_IDS.map((recordId) => ({
+ recordId,
+ properties: { after: { id: recordId } },
+ })) as ObjectRecordEvent[],
+ })
+ .resolveAdmittedRecordIds({
+ isSystemContext: false,
+ objectsPermissions: rolesPermissions[memberRole.id],
+ principalIds: [
+ EVERYONE_PRINCIPAL_ID,
+ WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ memberRole.id,
+ ],
+ isOwningApplication: () => false,
+ resolveRowLevelPermissionRecordFilter: () => null,
+ });
+
+ expect([...admittedRecordIds]).toEqual([OPEN_COMPANY_ID]);
+ });
+
+ it('should leave it untouched by bulk updates and deletes that match it', async () => {
+ const updated = await makeGraphqlApiRequest(
+ updateManyOperationFactory({
+ objectMetadataSingularName: 'company',
+ objectMetadataPluralName: 'companies',
+ gqlFields: 'id',
+ data: { employees: 42 },
+ filter: { id: { in: COMPANY_IDS } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(updated.body.errors).toBeUndefined();
+ expect(
+ updated.body.data.updateCompanies.map(({ id }: { id: string }) => id),
+ ).toEqual([OPEN_COMPANY_ID]);
+
+ const deleted = await makeGraphqlApiRequest(
+ deleteManyOperationFactory({
+ objectMetadataSingularName: 'company',
+ objectMetadataPluralName: 'companies',
+ gqlFields: 'id',
+ filter: { id: { in: COMPANY_IDS } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(deleted.body.errors).toBeUndefined();
+ expect(
+ deleted.body.data.deleteCompanies.map(({ id }: { id: string }) => id),
+ ).toEqual([OPEN_COMPANY_ID]);
+
+ const restricted = await makeGraphqlApiRequest(
+ findOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: 'id employees deletedAt',
+ filter: { id: { eq: RESTRICTED_COMPANY_ID } },
+ }),
+ APPLE_JANE_ADMIN_ACCESS_TOKEN,
+ );
+
+ expect(restricted.body.data.company).toMatchObject({
+ employees: null,
+ deletedAt: null,
+ });
+
+ await makeGraphqlApiRequest(
+ restoreManyOperationFactory({
+ objectMetadataSingularName: 'company',
+ objectMetadataPluralName: 'companies',
+ gqlFields: 'id',
+ filter: { id: { eq: OPEN_COMPANY_ID } },
+ }),
+ );
+ });
+
+ it('should show it on every surface once it is shared with the member', async () => {
+ const shared = await setShare(
+ { workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY },
+ true,
+ );
+
+ expect(shared.body.errors).toBeUndefined();
+ expect((await findCompanyIds(APPLE_JONY_MEMBER_ACCESS_TOKEN)).ids).toEqual(
+ [...COMPANY_IDS].sort(),
+ );
+
+ const person = await makeGraphqlApiRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id company { id }',
+ filter: { id: { eq: PERSON_ID } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(person.body.data.people.edges[0].node.company).toEqual({
+ id: RESTRICTED_COMPANY_ID,
+ });
+
+ const notes = await makeGraphqlApiRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'note',
+ objectMetadataPluralName: 'notes',
+ gqlFields: 'id',
+ filter: { id: { eq: NOTE_ID } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(collectIds(notes.body.data.notes.edges)).toEqual([NOTE_ID]);
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts
index 051dd71df5b..5fc203f7077 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-sharing-api.integration-spec.ts
@@ -34,6 +34,7 @@ import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/
import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { GRANTABLE_RECORD_SHARE_ACCESS_LEVELS } from 'src/engine/core-modules/record-share/constants/grantable-record-share-access-levels.constant';
import { type RecordSharePrincipalInput } from 'src/engine/core-modules/record-share/dtos/record-sharing.dto';
import { type RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
@@ -497,7 +498,7 @@ describe('Generic sharing API on an ordinary private object', () => {
const principal = {
workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
};
- for (const accessLevel of Object.values(RecordShareAccessLevel)) {
+ for (const accessLevel of GRANTABLE_RECORD_SHARE_ACCESS_LEVELS) {
const response = await change(
principal,
true,
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-45-workspace-command-1790876639146-add-record-share-none-access-level.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-45-workspace-command-1790876639146-add-record-share-none-access-level.integration-spec.ts
new file mode 100644
index 00000000000..b84dc9645fc
--- /dev/null
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-45-workspace-command-1790876639146-add-record-share-none-access-level.integration-spec.ts
@@ -0,0 +1,189 @@
+import { randomUUID } from 'node:crypto';
+
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import {
+ type FieldMetadataComplexOption,
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+
+import { type AddRecordShareNoneAccessLevelCommand } from 'src/database/commands/upgrade-version-command/2-45/2-45-workspace-command-1790876639146-add-record-share-none-access-level.command';
+import { type RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
+import { type UpgradeCommandRegistryService } from 'src/engine/core-modules/upgrade/services/upgrade-command-registry.service';
+import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+import { type WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
+import { type WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const workspaceId = SEED_APPLE_WORKSPACE_ID;
+const authContext = buildSystemAuthContext(workspaceId);
+const RECORD_ID = randomUUID();
+const OBJECT_METADATA_ID = randomUUID();
+
+describe('2-45 workspace command 1790876639146 - AddRecordShareNoneAccessLevelCommand (integration)', () => {
+ let command: AddRecordShareNoneAccessLevelCommand;
+ let workspaceOrmManager: WorkspaceOrmManager;
+ let shares: RecordShareStorageService;
+
+ const run = (
+ direction: 'up' | 'down',
+ { dryRun = false }: { dryRun?: boolean } = {},
+ ) =>
+ workspaceOrmManager.executeInWorkspaceContext(
+ () =>
+ command[direction]({
+ workspaceId,
+ options: { dryRun },
+ index: 0,
+ total: 1,
+ }),
+ authContext,
+ );
+
+ const findAccessLevelValues = async () => {
+ const { options } = await getCoreRepository<FieldMetadataEntity>(
+ FieldMetadataEntity,
+ ).findOneOrFail({
+ where: {
+ universalIdentifier:
+ STANDARD_OBJECTS.recordShare.fields.accessLevel.universalIdentifier,
+ workspaceId,
+ },
+ });
+
+ return ((options ?? []) as FieldMetadataComplexOption[]).map(
+ ({ value }) => value,
+ );
+ };
+
+ const insertRestriction = () =>
+ shares.insertMany({
+ workspaceId,
+ recordShares: [
+ {
+ objectMetadataId: OBJECT_METADATA_ID,
+ recordId: RECORD_ID,
+ principalId: EVERYONE_PRINCIPAL_ID,
+ principalType: RecordSharePrincipalType.EVERYONE,
+ accessLevel: RecordShareAccessLevel.NONE,
+ rowCause: RecordShareRowCause.MANUAL,
+ sourceId: RECORD_ID,
+ },
+ ],
+ });
+
+ const findRestrictions = () =>
+ shares.findByRecordIds({
+ workspaceId,
+ objectMetadataId: OBJECT_METADATA_ID,
+ recordIds: [RECORD_ID],
+ });
+
+ beforeAll(() => {
+ command = getAppProviderByClassName<AddRecordShareNoneAccessLevelCommand>(
+ 'AddRecordShareNoneAccessLevelCommand',
+ );
+ workspaceOrmManager = getAppProviderByClassName<WorkspaceOrmManager>(
+ 'WorkspaceOrmManager',
+ );
+ shares = getAppProviderByClassName<RecordShareStorageService>(
+ 'RecordShareStorageService',
+ );
+ });
+
+ afterAll(async () => {
+ await run('up');
+ await shares.deleteByRecordIds({
+ workspaceId,
+ objectMetadataId: OBJECT_METADATA_ID,
+ recordIds: [RECORD_ID],
+ });
+ });
+
+ it('is registered in the 2.45 bundle', () => {
+ const registry = getAppProviderByClassName<UpgradeCommandRegistryService>(
+ 'UpgradeCommandRegistryService',
+ );
+
+ expect(registry.getBundleForVersion('2.45.0').workspaceCommands).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ command, timestamp: 1790876639146 }),
+ ]),
+ );
+ });
+
+ it('removes restrictions and the option on the way down', async () => {
+ await run('up');
+ await insertRestriction();
+
+ await run('down');
+
+ expect(await findAccessLevelValues()).not.toContain(
+ RecordShareAccessLevel.NONE,
+ );
+ expect(await findRestrictions()).toEqual([]);
+ await expect(insertRestriction()).rejects.toThrow();
+ });
+
+ it('keeps a workspace without the option untouched on a dry run', async () => {
+ await run('down');
+ await run('up', { dryRun: true });
+
+ expect(await findAccessLevelValues()).not.toContain(
+ RecordShareAccessLevel.NONE,
+ );
+ });
+
+ it('adds the option so restrictions can be stored, once', async () => {
+ await run('down');
+ await run('up');
+ await run('up');
+
+ const values = await findAccessLevelValues();
+
+ expect(
+ values.filter((value) => value === RecordShareAccessLevel.NONE),
+ ).toHaveLength(1);
+ await insertRestriction();
+ expect(await findRestrictions()).toEqual([
+ expect.objectContaining({ accessLevel: RecordShareAccessLevel.NONE }),
+ ]);
+ });
+
+ it('puts restrictions back when the downgrade fails', async () => {
+ await run('up');
+ await shares.deleteByRecordIds({
+ workspaceId,
+ objectMetadataId: OBJECT_METADATA_ID,
+ recordIds: [RECORD_ID],
+ });
+ await insertRestriction();
+
+ const migrationSpy = jest
+ .spyOn(
+ getAppProviderByClassName<WorkspaceMigrationValidateBuildAndRunService>(
+ 'WorkspaceMigrationValidateBuildAndRunService',
+ ),
+ 'validateBuildAndRunLegacyWorkspaceMigration',
+ )
+ .mockRejectedValueOnce(new Error('Migration failed'));
+
+ try {
+ await expect(run('down')).rejects.toThrow('Migration failed');
+ } finally {
+ migrationSpy.mockRestore();
+ }
+
+ expect(await findAccessLevelValues()).toContain(
+ RecordShareAccessLevel.NONE,
+ );
+ expect(await findRestrictions()).toEqual([
+ expect.objectContaining({ accessLevel: RecordShareAccessLevel.NONE }),
+ ]);
+ });
+});
diff --git a/packages/twenty-shared/src/types/FeatureFlagKey.ts b/packages/twenty-shared/src/types/FeatureFlagKey.ts
index 4b93bb1856c..30d40f04128 100644
--- a/packages/twenty-shared/src/types/FeatureFlagKey.ts
+++ b/packages/twenty-shared/src/types/FeatureFlagKey.ts
@@ -16,4 +16,5 @@ export enum FeatureFlagKey {
IS_LOGS_SETTINGS_SECTION_ENABLED = 'IS_LOGS_SETTINGS_SECTION_ENABLED',
IS_CONVERSATIONS_TAB_ENABLED = 'IS_CONVERSATIONS_TAB_ENABLED',
IS_VALIDATION_RULES_ENABLED = 'IS_VALIDATION_RULES_ENABLED',
+ IS_RECORD_LEVEL_SHARING_ENABLED = 'IS_RECORD_LEVEL_SHARING_ENABLED',
}
diff --git a/packages/twenty-shared/src/types/RecordShareAccessLevel.ts b/packages/twenty-shared/src/types/RecordShareAccessLevel.ts
index ea78e7aa0a8..38b0fa79ab2 100644
--- a/packages/twenty-shared/src/types/RecordShareAccessLevel.ts
+++ b/packages/twenty-shared/src/types/RecordShareAccessLevel.ts
@@ -1,4 +1,5 @@
export enum RecordShareAccessLevel {
+ NONE = 'NONE',
READ = 'READ',
READ_WRITE = 'READ_WRITE',
FULL = 'FULL',