Skip to content

The open alternative to Salesforce, designed for AI.

Record sharing 3/14: gate reads and writes on private objects with record share rows (#25426)

martmull6875bfc773f8
diff --git a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
index e1f08b97a69..95a36772be9 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.graphql
@@ -1917,6 +1917,7 @@ enum FeatureFlagKey {
IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED
IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED
IS_RECORD_CREATION_FORM_ENABLED
+ IS_RECORD_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 06bdcaab4fd..7ef89540053 100644
--- a/packages/twenty-client-sdk/src/metadata/generated/schema.ts
+++ b/packages/twenty-client-sdk/src/metadata/generated/schema.ts
@@ -1533,7 +1533,7 @@ export interface FeatureFlag {
__typename: 'FeatureFlag'
}
-export type FeatureFlagKey = 'IS_APP_CLAIMING_ENABLED' | 'IS_UNIQUE_INDEXES_ENABLED' | 'IS_CONFIGURABLE_SEARCH_FIELDS_ENABLED' | 'IS_JSON_FILTER_ENABLED' | 'IS_EMAIL_GROUP_ENABLED' | 'IS_JUNCTION_RELATIONS_ENABLED' | 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT' | 'IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED' | 'IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED' | 'IS_API_RATE_LIMIT_V2_ENABLED' | 'IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED' | 'IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED' | 'IS_RECORD_CREATION_FORM_ENABLED'
+export type FeatureFlagKey = 'IS_APP_CLAIMING_ENABLED' | 'IS_UNIQUE_INDEXES_ENABLED' | 'IS_CONFIGURABLE_SEARCH_FIELDS_ENABLED' | 'IS_JSON_FILTER_ENABLED' | 'IS_EMAIL_GROUP_ENABLED' | 'IS_JUNCTION_RELATIONS_ENABLED' | 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT' | 'IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED' | 'IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED' | 'IS_API_RATE_LIMIT_V2_ENABLED' | 'IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED' | 'IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED' | 'IS_RECORD_CREATION_FORM_ENABLED' | 'IS_RECORD_SHARING_ENABLED'
export interface WorkspaceUrls {
customUrl?: Scalars['String']
@@ -10398,7 +10398,8 @@ export const enumFeatureFlagKey = {
IS_API_RATE_LIMIT_V2_ENABLED: 'IS_API_RATE_LIMIT_V2_ENABLED' as const,
IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED: 'IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED' as const,
IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED: 'IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED' as const,
- IS_RECORD_CREATION_FORM_ENABLED: 'IS_RECORD_CREATION_FORM_ENABLED' as const
+ IS_RECORD_CREATION_FORM_ENABLED: 'IS_RECORD_CREATION_FORM_ENABLED' as const,
+ IS_RECORD_SHARING_ENABLED: 'IS_RECORD_SHARING_ENABLED' as const
}
export const enumIdentityProviderType = {
diff --git a/packages/twenty-docs/developers/extend/apps/data/objects.mdx b/packages/twenty-docs/developers/extend/apps/data/objects.mdx
index 987d740715d..f6cfb689872 100644
--- a/packages/twenty-docs/developers/extend/apps/data/objects.mdx
+++ b/packages/twenty-docs/developers/extend/apps/data/objects.mdx
@@ -81,7 +81,7 @@ export default defineObject({
- The `fields` array is optional — you can define objects without custom fields.
- `openRecordIn` sets where records of this object open when clicked: `ObjectOpenRecordIn.USER_CHOICE` (the default, following each workspace member's own preference from Settings → Experience), `ObjectOpenRecordIn.SIDE_PANEL`, or `ObjectOpenRecordIn.RECORD_PAGE`. Pin it to `RECORD_PAGE` for records that need a full page to be usable, the way workflows and dashboards do, or to `SIDE_PANEL` for records that only make sense as a quick panel, the way calendar events do.
- `writability` controls who may write records of the object at all, before role permissions apply: `MetadataWritability.OPEN` (the default — workspace roles decide), `MetadataWritability.APPLICATION` (only your app's own logic functions can create, update, or delete records; use this for configuration-like objects whose records grant behavior, so workspace members with broad record access cannot edit them through the API), or `MetadataWritability.SYSTEM` (reserved for platform-managed data). Reads are unaffected — this is enforced server-side, unlike `isUIEditable`, which only hides UI affordances. It also exists per field, where it can only be stricter than the object's level.
-- `readability` declares who may read records of the object: `MetadataReadability.OPEN` (the default — workspace roles decide), `MetadataReadability.PRIVATE` (only principals the record was shared with), `MetadataReadability.INHERITED` (whoever reads the parent record), `MetadataReadability.APPLICATION` (only your app's own logic functions) or `MetadataReadability.SYSTEM` (platform-managed data). Only `OPEN` is enforced today; the other levels are being rolled out and behave like `OPEN` until then.
+- `readability` declares who may read records of the object: `MetadataReadability.OPEN` (the default — workspace roles decide), `MetadataReadability.PRIVATE` (only principals the record was shared with), `MetadataReadability.INHERITED` (whoever reads the parent record), `MetadataReadability.APPLICATION` (only your app's own logic functions) or `MetadataReadability.SYSTEM` (platform-managed data). `SYSTEM` is always enforced. `PRIVATE` and `APPLICATION` are enforced on workspaces where record sharing is enabled (`IS_RECORD_SHARING_ENABLED`); elsewhere they still behave like `OPEN`. `INHERITED` is still being rolled out and behaves like `OPEN` until its parent gate lands.
- `color` sets the accent color of the object in the UI. Omit it and Twenty picks one for the object.
- `imageIdentifierFieldMetadataUniversalIdentifier` names the field whose value is shown as the record avatar. Omit it to let Twenty pick the default.
- `isLabelSyncedWithName`, on an object or on a field, keeps the API name in sync with the label when the label is edited in Settings. It defaults to `false`, so a renamed label leaves the name untouched.
diff --git a/packages/twenty-front/src/generated-admin/graphql.ts b/packages/twenty-front/src/generated-admin/graphql.ts
index 26ab741cd85..44bf8042601 100644
--- a/packages/twenty-front/src/generated-admin/graphql.ts
+++ b/packages/twenty-front/src/generated-admin/graphql.ts
@@ -410,6 +410,7 @@ export enum FeatureFlagKey {
IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED = 'IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED',
IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED = 'IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED',
IS_RECORD_CREATION_FORM_ENABLED = 'IS_RECORD_CREATION_FORM_ENABLED',
+ IS_RECORD_SHARING_ENABLED = 'IS_RECORD_SHARING_ENABLED',
IS_REST_METADATA_API_NEW_FORMAT_DIRECT = 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT',
IS_UNIQUE_INDEXES_ENABLED = 'IS_UNIQUE_INDEXES_ENABLED',
IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED = 'IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED'
diff --git a/packages/twenty-front/src/generated-metadata/graphql.ts b/packages/twenty-front/src/generated-metadata/graphql.ts
index 2016582003d..e839bd84353 100644
--- a/packages/twenty-front/src/generated-metadata/graphql.ts
+++ b/packages/twenty-front/src/generated-metadata/graphql.ts
@@ -1956,6 +1956,7 @@ export enum FeatureFlagKey {
IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED = 'IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED',
IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED = 'IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED',
IS_RECORD_CREATION_FORM_ENABLED = 'IS_RECORD_CREATION_FORM_ENABLED',
+ IS_RECORD_SHARING_ENABLED = 'IS_RECORD_SHARING_ENABLED',
IS_REST_METADATA_API_NEW_FORMAT_DIRECT = 'IS_REST_METADATA_API_NEW_FORMAT_DIRECT',
IS_UNIQUE_INDEXES_ENABLED = 'IS_UNIQUE_INDEXES_ENABLED',
IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED = 'IS_WORKFLOW_CORE_INDEX_PAGE_ENABLED'
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
index 8a2404df073..c24da9049f4 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
@@ -471,6 +471,7 @@ export abstract class CommonBaseQueryRunnerService<
alias,
filter,
commonQueryParser,
+ kind,
});
return writeRepository.runMutation({
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/build-mutation-query-builder.util.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/build-mutation-query-builder.util.ts
index 0c6a53dda54..9185a18c629 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/utils/build-mutation-query-builder.util.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/utils/build-mutation-query-builder.util.ts
@@ -3,12 +3,14 @@ import { type ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-
import { type GraphqlQueryParser } from 'src/engine/api/graphql/graphql-query-runner/graphql-query-parsers/graphql-query.parser';
import { type WorkspaceSelectQueryBuilder } from 'src/engine/twenty-orm/query-builder/workspace-select-query-builder';
import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
+import { type MutationKind } from 'src/engine/twenty-orm/sql/utils/build-mutation-statement.util';
type BuildMutationQueryBuilderArgs = {
repository: WorkspaceRepository;
alias: string;
filter: Partial<ObjectRecordFilter>;
commonQueryParser: GraphqlQueryParser;
+ kind: MutationKind;
};
export const buildMutationQueryBuilder = ({
@@ -16,6 +18,7 @@ export const buildMutationQueryBuilder = ({
alias,
filter,
commonQueryParser,
+ kind,
}: BuildMutationQueryBuilderArgs): {
selectQueryBuilder: WorkspaceSelectQueryBuilder;
rowLevelPermissionsApplied: boolean;
@@ -37,7 +40,7 @@ export const buildMutationQueryBuilder = ({
.select(`${alias}.id`)
.withDeleted();
- repository.applyWriteRowLevelPermissions(idSubQueryBuilder);
+ repository.applyWriteRowLevelPermissions(idSubQueryBuilder, kind);
const selectQueryBuilder = repository
.createQueryBuilder(alias)
diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util.ts b/packages/twenty-server/src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util.ts
new file mode 100644
index 00000000000..bdc40f04160
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util.ts
@@ -0,0 +1,26 @@
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { type OperationType } from 'src/engine/twenty-orm/repository/permissions.utils';
+
+const REQUIRED_RECORD_SHARE_ACCESS_LEVELS_BY_OPERATION_TYPE: Record<
+ OperationType,
+ RecordShareAccessLevel[]
+> = {
+ select: [
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+ ],
+ // an insert has no record yet, so no share row can exist to check: whether
+ // the caller may create at all stays the role's object-level decision
+ insert: [],
+ update: [RecordShareAccessLevel.READ_WRITE, RecordShareAccessLevel.FULL],
+ 'soft-delete': [RecordShareAccessLevel.FULL],
+ restore: [RecordShareAccessLevel.FULL],
+ delete: [RecordShareAccessLevel.FULL],
+};
+
+export const resolveRequiredRecordShareAccessLevels = (
+ operationType: OperationType,
+): RecordShareAccessLevel[] =>
+ REQUIRED_RECORD_SHARE_ACCESS_LEVELS_BY_OPERATION_TYPE[operationType];
diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/validate-writability-or-throw.util.ts b/packages/twenty-server/src/engine/twenty-orm/repository/validate-writability-or-throw.util.ts
index 62a9accaec7..bf591e8500e 100644
--- a/packages/twenty-server/src/engine/twenty-orm/repository/validate-writability-or-throw.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/validate-writability-or-throw.util.ts
@@ -12,6 +12,7 @@ import {
PermissionsExceptionMessage,
} from 'src/engine/metadata-modules/permissions/permissions.exception';
import { type OperationType } from 'src/engine/twenty-orm/repository/permissions.utils';
+import { isOwningApplicationAuthContext } from 'src/engine/twenty-orm/utils/is-owning-application-auth-context.util';
const isWritePermittedByWritability = ({
writability,
@@ -34,13 +35,9 @@ const isWritePermittedByWritability = ({
}
if (writability === MetadataWritability.APPLICATION) {
- // Only APPLICATION_ACCESS tokens ever carry an application, so reading it
- // off a user-bound context cannot let an ordinary session through.
return (
isDefined(authContext) &&
- isDefined(owningApplicationId) &&
- (authContext.type === 'application' || authContext.type === 'user') &&
- authContext.application?.id === owningApplicationId
+ isOwningApplicationAuthContext({ authContext, owningApplicationId })
);
}
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 9b893b77932..34ef173279b 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,10 +2,12 @@ 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,
} from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
+import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import {
DeleteResult,
In,
@@ -17,9 +19,19 @@ import {
import { DatabaseEventAction } from 'src/engine/api/graphql/graphql-query-runner/enums/database-event-action';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import {
+ PermissionsException,
+ PermissionsExceptionCode,
+ PermissionsExceptionMessage,
+} from 'src/engine/metadata-modules/permissions/permissions.exception';
import { FilesFieldSync } from 'src/engine/twenty-orm/field-operations/files-field-sync/files-field-sync';
-import { validateOperationIsPermittedOrThrow } from 'src/engine/twenty-orm/repository/permissions.utils';
+import {
+ type OperationType,
+ validateOperationIsPermittedOrThrow,
+} from 'src/engine/twenty-orm/repository/permissions.utils';
+import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';
import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';
+import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.util';
import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
import { formatResult } from 'src/engine/twenty-orm/utils/format-result.util';
import { formatTwentyOrmEventToDatabaseBatchEvent } from 'src/engine/twenty-orm/utils/format-twenty-orm-event-to-database-batch-event.util';
@@ -27,7 +39,9 @@ import {
getUpdateEventRecords,
mergeRecordsWithUpdateValues,
} from 'src/engine/twenty-orm/utils/merge-records-with-update-values.util';
+import { isOwningApplicationAuthContext } from 'src/engine/twenty-orm/utils/is-owning-application-auth-context.util';
import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';
+import { resolvePrincipalIdsFromAuthContext } from 'src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util';
import { resolveRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/resolve-row-level-permission-record-filter.util';
import { validateRLSPredicatesForRecords } from 'src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util';
import {
@@ -79,6 +93,8 @@ import {
type WorkspaceTableShape,
} from 'src/engine/twenty-orm/table-shape/types/workspace-table-shape.type';
+const ALWAYS_FALSE_CONDITION = '1=0';
+
const MUTATION_EVENT_ACTIONS_BY_KIND: Record<
MutationKind,
DatabaseEventAction[]
@@ -194,8 +210,9 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
applyWriteRowLevelPermissions(
queryBuilder: WorkspaceSelectQueryBuilder,
+ kind: MutationKind,
): void {
- this.applyRowLevelPermissionPredicates(queryBuilder);
+ this.applyRowLevelPermissionPredicates(queryBuilder, kind);
}
getInternalContext(): WorkspaceInternalContext {
@@ -977,6 +994,14 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return { identifiers: [], generatedMaps: [], raw: [] };
}
+ const writableRecordIds = await this.resolveWritableRecordIds({
+ ids: inputs.map((input) => input.id),
+ operationType: 'update',
+ });
+ const writableInputs = inputs.filter((input) =>
+ writableRecordIds.has(input.id),
+ );
+
const recordsBefore: ObjectRecord[] = [];
const recordsAfter: ObjectRecord[] = [];
const generatedMaps: ObjectRecord[] = [];
@@ -988,7 +1013,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
const rawBeforeByInputIndex: ObjectRecord[][] = [];
const existingRecordsMapById: Record<string, ObjectRecord> = {};
- for (const input of inputs) {
+ for (const input of writableInputs) {
const rawBefore = await this.buildIdsEventSnapshotQueryBuilder([
input.id,
]).getMany<ObjectRecord>({ noFormatting: true });
@@ -1004,7 +1029,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
}
}
- let dataByInputIndex = inputs.map((input) => input.data);
+ let dataByInputIndex = writableInputs.map((input) => input.data);
let filesFieldFileIds = null;
const filesFieldDiff =
@@ -1026,7 +1051,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
dataByInputIndex = enriched.entities as Partial<ObjectRecord>[];
}
- for (const [index, input] of inputs.entries()) {
+ for (const [index, input] of writableInputs.entries()) {
const { id: _id, ...setColumns } = this.formatWriteData(
dataByInputIndex[index],
);
@@ -1039,8 +1064,6 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
const rawBeforeForInput = rawBeforeByInputIndex[index];
- recordsBefore.push(...rawBeforeForInput);
-
this.validateRLSPredicatesForWrittenRecords(
this.formatResult<ObjectRecord[]>(
rawBeforeForInput.map((record) => ({ ...record, ...setColumns })),
@@ -1052,7 +1075,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
id: input.id,
});
- this.applyRowLevelPermissionPredicates(selectQueryBuilder);
+ this.applyRowLevelPermissionPredicates(selectQueryBuilder, 'update');
const result = await selectQueryBuilder
.update()
@@ -1062,6 +1085,12 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
generatedMaps.push(...(result.generatedMaps as ObjectRecord[]));
+ if (result.generatedMaps.length === 0) {
+ continue;
+ }
+
+ recordsBefore.push(...rawBeforeForInput);
+
const recordsAfterWrite = this.options.shouldSkipEventEmission
? []
: await this.buildIdsEventSnapshotQueryBuilder([
@@ -1211,6 +1240,31 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
.withDeleted();
}
+ private async resolveWritableRecordIds({
+ ids,
+ operationType,
+ }: {
+ ids: string[];
+ operationType: OperationType;
+ }): Promise<Set<string>> {
+ if (this.options.shouldBypassPermissionChecks) {
+ return new Set(ids);
+ }
+
+ const queryBuilder = this.createQueryBuilder()
+ .where({ id: In(ids) })
+ .withDeleted();
+
+ this.applyRowLevelPermissionPredicates(queryBuilder, operationType);
+ queryBuilder.select(['id']);
+
+ const rows = await queryBuilder.getMany<ObjectRecord>({
+ noFormatting: true,
+ });
+
+ return new Set(rows.map((row) => String(row.id)));
+ }
+
async runMutation({
selectQueryBuilder,
rowLevelPermissionsApplied,
@@ -1225,7 +1279,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
data?: Partial<ObjectRecord>;
}): Promise<ObjectRecord[]> {
if (!rowLevelPermissionsApplied) {
- this.applyRowLevelPermissionPredicates(selectQueryBuilder);
+ this.applyRowLevelPermissionPredicates(selectQueryBuilder, kind);
}
const eventSelectQueryBuilder =
@@ -1503,6 +1557,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
private applyRowLevelPermissionPredicates(
queryBuilder: WorkspaceSelectQueryBuilder,
+ operationType: OperationType = 'select',
): void {
if (this.options.shouldBypassPermissionChecks) {
return;
@@ -1512,6 +1567,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
queryBuilder,
alias: queryBuilder.alias,
flatObjectMetadata: this.options.flatObjectMetadata,
+ operationType,
});
for (const joinAlias of queryBuilder.getJoinAliases()) {
@@ -1527,6 +1583,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
flatObjectMetadata: this.options.flatObjectMetadataByObjectMetadataId(
joinedTableShape.objectMetadataId,
),
+ operationType: 'select',
});
}
}
@@ -1535,15 +1592,39 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
queryBuilder,
alias,
flatObjectMetadata,
+ operationType,
}: {
queryBuilder: WorkspaceSelectQueryBuilder;
alias: string;
flatObjectMetadata: FlatObjectMetadata;
+ operationType: OperationType;
}): void {
if (!queryBuilder.markRowLevelPermissionApplied(alias)) {
return;
}
+ this.applyRolePredicateForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ });
+ this.applyRecordShareGateForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ operationType,
+ });
+ }
+
+ private applyRolePredicateForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ }: {
+ queryBuilder: WorkspaceSelectQueryBuilder;
+ alias: string;
+ flatObjectMetadata: FlatObjectMetadata;
+ }): void {
const recordFilter = resolveRowLevelPermissionRecordFilter({
internalContext: this.options.internalContext,
authContext: this.options.authContext,
@@ -1565,16 +1646,151 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return;
}
+ this.addConditionForAlias({
+ queryBuilder,
+ alias,
+ sql: renderedCondition.sql,
+ parameters: renderedCondition.parameters,
+ });
+ }
+
+ private applyRecordShareGateForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ operationType,
+ }: {
+ queryBuilder: WorkspaceSelectQueryBuilder;
+ alias: string;
+ flatObjectMetadata: FlatObjectMetadata;
+ operationType: OperationType;
+ }): void {
+ const isRecordSharingEnabled =
+ this.options.internalContext.featureFlagsMap[
+ FeatureFlagKey.IS_RECORD_SHARING_ENABLED
+ ];
+ const isOwningApplication = isOwningApplicationAuthContext({
+ authContext: this.options.authContext,
+ owningApplicationId: flatObjectMetadata.applicationId,
+ });
+
+ switch (flatObjectMetadata.readability) {
+ case MetadataReadability.OPEN:
+ case MetadataReadability.INHERITED:
+ return;
+ case MetadataReadability.SYSTEM:
+ // recordShare rows are SYSTEM and hold the whole ACL, so they stay
+ // unreadable whether or not the workspace has enabled record sharing
+ this.denyAccessForAlias({ queryBuilder, alias, flatObjectMetadata });
+
+ return;
+ case MetadataReadability.APPLICATION:
+ if (isRecordSharingEnabled && !isOwningApplication) {
+ this.denyAccessForAlias({ queryBuilder, alias, flatObjectMetadata });
+ }
+
+ return;
+ case MetadataReadability.PRIVATE:
+ // the owning application syncs and backfills every record of its
+ // object, so it reads them all instead of holding share rows
+ if (!isRecordSharingEnabled || isOwningApplication) {
+ return;
+ }
+
+ this.applyRecordShareConditionForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ operationType,
+ });
+
+ return;
+ default:
+ assertUnreachable(flatObjectMetadata.readability);
+ }
+ }
+
+ private applyRecordShareConditionForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ operationType,
+ }: {
+ queryBuilder: WorkspaceSelectQueryBuilder;
+ alias: string;
+ flatObjectMetadata: FlatObjectMetadata;
+ operationType: OperationType;
+ }): void {
+ const principalIds = resolvePrincipalIdsFromAuthContext({
+ authContext: this.options.authContext,
+ userWorkspaceRoleMap: this.options.internalContext.userWorkspaceRoleMap,
+ apiKeyRoleMap: this.options.internalContext.apiKeyRoleMap,
+ });
+
+ if (!isDefined(principalIds)) {
+ return;
+ }
+
+ const accessLevels = resolveRequiredRecordShareAccessLevels(operationType);
+
+ if (accessLevels.length === 0) {
+ return;
+ }
+
+ const recordShareTableShape = this.options.tableShapeByObjectMetadataId(
+ this.options.internalContext.objectIdByNameSingular.recordShare,
+ );
+
+ const condition = buildRecordShareCondition({
+ tableAlias: alias,
+ recordShareTableExpression: `${escapeIdentifier(
+ recordShareTableShape.schemaName,
+ )}.${escapeIdentifier(recordShareTableShape.tableName)}`,
+ objectMetadataId: flatObjectMetadata.id,
+ principalIds,
+ accessLevels,
+ });
+
+ this.addConditionForAlias({ queryBuilder, alias, ...condition });
+ }
+
+ private denyAccessForAlias({
+ queryBuilder,
+ alias,
+ flatObjectMetadata,
+ }: {
+ queryBuilder: WorkspaceSelectQueryBuilder;
+ alias: string;
+ flatObjectMetadata: FlatObjectMetadata;
+ }): void {
if (alias === queryBuilder.alias) {
- queryBuilder.andWhere(
- renderedCondition.sql,
- renderedCondition.parameters,
+ throw new PermissionsException(
+ `${PermissionsExceptionMessage.PERMISSION_DENIED}: records of "${flatObjectMetadata.nameSingular}" are not readable through the API`,
+ PermissionsExceptionCode.PERMISSION_DENIED,
);
+ }
+
+ queryBuilder.addJoinCondition(alias, ALWAYS_FALSE_CONDITION);
+ }
+
+ private addConditionForAlias({
+ queryBuilder,
+ alias,
+ sql,
+ parameters,
+ }: {
+ queryBuilder: WorkspaceSelectQueryBuilder;
+ alias: string;
+ sql: string;
+ parameters: ObjectLiteral;
+ }): void {
+ if (alias === queryBuilder.alias) {
+ queryBuilder.andWhere(sql, parameters);
return;
}
- queryBuilder.addJoinCondition(alias, renderedCondition.sql);
- queryBuilder.setParameters(renderedCondition.parameters);
+ queryBuilder.addJoinCondition(alias, sql);
+ queryBuilder.setParameters(parameters);
}
}
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts
new file mode 100644
index 00000000000..9d69567463b
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-record-share-condition.util.spec.ts
@@ -0,0 +1,84 @@
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { compileNamedParameters } from 'src/engine/twenty-orm/sql/utils/compile-named-parameters.util';
+import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.util';
+
+const OBJECT_METADATA_ID = 'object-metadata-1';
+const PRINCIPAL_IDS = ['principal-1', 'principal-2'];
+const ACCESS_LEVELS = [
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+];
+
+const build = () =>
+ buildRecordShareCondition({
+ tableAlias: 'company',
+ recordShareTableExpression: '"workspace_abc"."recordShare"',
+ objectMetadataId: OBJECT_METADATA_ID,
+ principalIds: PRINCIPAL_IDS,
+ accessLevels: ACCESS_LEVELS,
+ });
+
+describe('buildRecordShareCondition', () => {
+ it('should render a correlated EXISTS on the record share table', () => {
+ const { sql, parameters } = build();
+ const parameterNames = Object.keys(parameters);
+
+ const [objectMetadataIdParameterName] = parameterNames.filter((name) =>
+ name.startsWith('recordShareObjectMetadataId_'),
+ );
+ const [principalIdsParameterName] = parameterNames.filter((name) =>
+ name.startsWith('recordSharePrincipalIds_'),
+ );
+ const [accessLevelsParameterName] = parameterNames.filter((name) =>
+ name.startsWith('recordShareAccessLevels_'),
+ );
+
+ expect(sql).toBe(
+ `EXISTS (SELECT 1 FROM "workspace_abc"."recordShare" AS "company_recordShare" WHERE "company_recordShare"."recordId" = "company"."id" AND "company_recordShare"."objectMetadataId" = :${objectMetadataIdParameterName} AND "company_recordShare"."principalId" = ANY(:${principalIdsParameterName}) AND "company_recordShare"."accessLevel" IN (:...${accessLevelsParameterName}) AND "company_recordShare"."deletedAt" IS NULL)`,
+ );
+ expect(parameters).toEqual({
+ [objectMetadataIdParameterName]: OBJECT_METADATA_ID,
+ [principalIdsParameterName]: PRINCIPAL_IDS,
+ [accessLevelsParameterName]: ACCESS_LEVELS,
+ });
+ });
+
+ it('should compile to positional parameters with the access levels spread', () => {
+ const { sql, parameters } = build();
+
+ expect(compileNamedParameters(sql, parameters)).toEqual({
+ text: 'EXISTS (SELECT 1 FROM "workspace_abc"."recordShare" AS "company_recordShare" WHERE "company_recordShare"."recordId" = "company"."id" AND "company_recordShare"."objectMetadataId" = $1 AND "company_recordShare"."principalId" = ANY($2) AND "company_recordShare"."accessLevel" IN ($3, $4) AND "company_recordShare"."deletedAt" IS NULL)',
+ values: [
+ OBJECT_METADATA_ID,
+ PRINCIPAL_IDS,
+ RecordShareAccessLevel.READ_WRITE,
+ RecordShareAccessLevel.FULL,
+ ],
+ });
+ });
+
+ it('should use distinct parameter names on every call', () => {
+ const first = build();
+ const second = build();
+
+ expect(
+ Object.keys(first.parameters).filter(
+ (parameterName) => parameterName in second.parameters,
+ ),
+ ).toEqual([]);
+ });
+
+ it('should escape the alias it derives', () => {
+ const { sql } = buildRecordShareCondition({
+ tableAlias: 'per"son',
+ recordShareTableExpression: '"workspace_abc"."recordShare"',
+ objectMetadataId: OBJECT_METADATA_ID,
+ principalIds: PRINCIPAL_IDS,
+ accessLevels: ACCESS_LEVELS,
+ });
+
+ expect(sql).toContain('AS "per""son_recordShare"');
+ expect(sql).toContain('= "per""son"."id"');
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-principal-ids-from-auth-context.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-principal-ids-from-auth-context.util.spec.ts
new file mode 100644
index 00000000000..b85e950bddc
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-principal-ids-from-auth-context.util.spec.ts
@@ -0,0 +1,111 @@
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { resolvePrincipalIdsFromAuthContext } from 'src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util';
+
+const USER_WORKSPACE_ID = 'user-workspace-1';
+const USER_ROLE_ID = 'user-role-1';
+const WORKSPACE_MEMBER_ID = 'workspace-member-1';
+const APPLICATION_ROLE_ID = 'application-role-1';
+const API_KEY_ID = 'api-key-1';
+const API_KEY_ROLE_ID = 'api-key-role-1';
+
+const userWorkspaceRoleMap = { [USER_WORKSPACE_ID]: USER_ROLE_ID };
+const apiKeyRoleMap = { [API_KEY_ID]: API_KEY_ROLE_ID };
+
+const resolve = (authContext: WorkspaceAuthContext) =>
+ resolvePrincipalIdsFromAuthContext({
+ authContext,
+ userWorkspaceRoleMap,
+ apiKeyRoleMap,
+ });
+
+describe('resolvePrincipalIdsFromAuthContext', () => {
+ it('should resolve everyone, the workspace member and the role for a user', () => {
+ expect(
+ resolve({
+ type: 'user',
+ workspace: { id: 'workspace-1' },
+ userWorkspaceId: USER_WORKSPACE_ID,
+ user: { id: 'user-1' },
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ workspaceMember: { id: WORKSPACE_MEMBER_ID },
+ } as unknown as WorkspaceAuthContext),
+ ).toEqual([EVERYONE_PRINCIPAL_ID, WORKSPACE_MEMBER_ID, USER_ROLE_ID]);
+ });
+
+ it('should add the application role when an application acts on the user behalf', () => {
+ expect(
+ resolve({
+ type: 'user',
+ workspace: { id: 'workspace-1' },
+ userWorkspaceId: USER_WORKSPACE_ID,
+ user: { id: 'user-1' },
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ workspaceMember: { id: WORKSPACE_MEMBER_ID },
+ application: { defaultRoleId: APPLICATION_ROLE_ID },
+ } as unknown as WorkspaceAuthContext),
+ ).toEqual([
+ EVERYONE_PRINCIPAL_ID,
+ WORKSPACE_MEMBER_ID,
+ USER_ROLE_ID,
+ APPLICATION_ROLE_ID,
+ ]);
+ });
+
+ it('should resolve everyone alone for a user without a role', () => {
+ expect(
+ resolve({
+ type: 'user',
+ workspace: { id: 'workspace-1' },
+ userWorkspaceId: 'unknown-user-workspace',
+ user: { id: 'user-1' },
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ workspaceMember: { id: WORKSPACE_MEMBER_ID },
+ } as unknown as WorkspaceAuthContext),
+ ).toEqual([EVERYONE_PRINCIPAL_ID, WORKSPACE_MEMBER_ID]);
+ });
+
+ it('should resolve everyone and the api key role for an api key', () => {
+ expect(
+ resolve({
+ type: 'apiKey',
+ workspace: { id: 'workspace-1' },
+ apiKey: { id: API_KEY_ID },
+ } as unknown as WorkspaceAuthContext),
+ ).toEqual([EVERYONE_PRINCIPAL_ID, API_KEY_ROLE_ID]);
+ });
+
+ it('should resolve everyone and the application role for an application', () => {
+ expect(
+ resolve({
+ type: 'application',
+ workspace: { id: 'workspace-1' },
+ application: {
+ id: 'application-1',
+ defaultRoleId: APPLICATION_ROLE_ID,
+ },
+ } as unknown as WorkspaceAuthContext),
+ ).toEqual([EVERYONE_PRINCIPAL_ID, APPLICATION_ROLE_ID]);
+ });
+
+ it('should resolve everyone alone for a pending activation user', () => {
+ expect(
+ resolve({
+ type: 'pendingActivationUser',
+ workspace: { id: 'workspace-1' },
+ userWorkspaceId: USER_WORKSPACE_ID,
+ user: { id: 'user-1' },
+ } as unknown as WorkspaceAuthContext),
+ ).toEqual([EVERYONE_PRINCIPAL_ID]);
+ });
+
+ it('should resolve no gate for a system request', () => {
+ expect(
+ resolve({
+ type: 'system',
+ workspace: { id: 'workspace-1' },
+ } as unknown as WorkspaceAuthContext),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts
new file mode 100644
index 00000000000..fe3b0f4870b
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-record-share-condition.util.ts
@@ -0,0 +1,45 @@
+import { randomBytes } from 'node:crypto';
+
+import { type RecordShareAccessLevel } from 'twenty-shared/types';
+import { type ObjectLiteral } from 'typeorm';
+
+import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';
+
+export const buildRecordShareCondition = ({
+ 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 = `recordShareObjectMetadataId_${parameterSuffix}`;
+ const principalIdsParameterName = `recordSharePrincipalIds_${parameterSuffix}`;
+ const accessLevelsParameterName = `recordShareAccessLevels_${parameterSuffix}`;
+
+ const recordShareAlias = escapeIdentifier(`${tableAlias}_recordShare`);
+ const quotedTableAlias = escapeIdentifier(tableAlias);
+
+ const conditions = [
+ `${recordShareAlias}."recordId" = ${quotedTableAlias}."id"`,
+ `${recordShareAlias}."objectMetadataId" = :${objectMetadataIdParameterName}`,
+ `${recordShareAlias}."principalId" = ANY(:${principalIdsParameterName})`,
+ `${recordShareAlias}."accessLevel" IN (:...${accessLevelsParameterName})`,
+ `${recordShareAlias}."deletedAt" IS NULL`,
+ ];
+
+ return {
+ sql: `EXISTS (SELECT 1 FROM ${recordShareTableExpression} AS ${recordShareAlias} WHERE ${conditions.join(' AND ')})`,
+ parameters: {
+ [objectMetadataIdParameterName]: objectMetadataId,
+ [principalIdsParameterName]: principalIds,
+ [accessLevelsParameterName]: accessLevels,
+ },
+ };
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-owning-application-auth-context.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-owning-application-auth-context.util.ts
new file mode 100644
index 00000000000..4be48457789
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-owning-application-auth-context.util.ts
@@ -0,0 +1,16 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { isApplicationAuthContext } from 'src/engine/core-modules/auth/guards/is-application-auth-context.guard';
+import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+
+export const isOwningApplicationAuthContext = ({
+ authContext,
+ owningApplicationId,
+}: {
+ authContext: WorkspaceAuthContext;
+ owningApplicationId: string | undefined;
+}): boolean =>
+ isDefined(owningApplicationId) &&
+ (isUserAuthContext(authContext) || isApplicationAuthContext(authContext)) &&
+ authContext.application?.id === owningApplicationId;
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util.ts
new file mode 100644
index 00000000000..4b37e5d6483
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util.ts
@@ -0,0 +1,36 @@
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { isDefined } from 'twenty-shared/utils';
+
+import { isSystemAuthContext } from 'src/engine/core-modules/auth/guards/is-system-auth-context.guard';
+import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { type UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map';
+import { resolveRoleIdsFromAuthContext } from 'src/engine/twenty-orm/utils/resolve-role-ids-from-auth-context.util';
+
+export const resolvePrincipalIdsFromAuthContext = ({
+ authContext,
+ userWorkspaceRoleMap,
+ apiKeyRoleMap,
+}: {
+ authContext: WorkspaceAuthContext;
+ userWorkspaceRoleMap: UserWorkspaceRoleMap;
+ apiKeyRoleMap: Record<string, string>;
+}): string[] | undefined => {
+ if (isSystemAuthContext(authContext)) {
+ return undefined;
+ }
+
+ const roleIds = resolveRoleIdsFromAuthContext({
+ authContext,
+ userWorkspaceRoleMap,
+ apiKeyRoleMap,
+ });
+
+ const principalIds = [
+ EVERYONE_PRINCIPAL_ID,
+ isUserAuthContext(authContext) ? authContext.workspaceMemberId : undefined,
+ ...roleIds,
+ ].filter(isDefined);
+
+ return [...new Set(principalIds)];
+};
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 6d9033125ee..8539f535af7 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
@@ -11,6 +11,7 @@ const DEFAULT_SEEDED_FEATURE_FLAGS: Partial<Record<FeatureFlagKey, boolean>> = {
[FeatureFlagKey.IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED]: true,
[FeatureFlagKey.IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED]: false,
[FeatureFlagKey.IS_RECORD_CREATION_FORM_ENABLED]: false,
+ [FeatureFlagKey.IS_RECORD_SHARING_ENABLED]: false,
};
type SeedFeatureFlagsArgs = {
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/readability-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/readability-object-records-permissions.integration-spec.ts
new file mode 100644
index 00000000000..c2c5bd93dc0
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/readability-object-records-permissions.integration-spec.ts
@@ -0,0 +1,614 @@
+import { randomUUID } from 'node:crypto';
+
+import gql from 'graphql-tag';
+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 { makeGraphqlAPIRequestWithApiKey } from 'test/integration/graphql/utils/make-graphql-api-request-with-api-key.util';
+import { makeGraphqlAPIRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';
+import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { deleteOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/delete-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 { upsertObjectPermissions } from 'test/integration/metadata/suites/object-permission/utils/upsert-object-permissions.util';
+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import {
+ FeatureFlagKey,
+ FieldMetadataType,
+ MetadataReadability,
+ RecordShareAccessLevel,
+ RecordSharePrincipalType,
+ RecordShareRowCause,
+} from 'twenty-shared/types';
+import { capitalize } from 'twenty-shared/utils';
+
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { type RecordShareService } from 'src/engine/record-share/services/record-share.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_SINGULAR = 'readabilityTestObject';
+const OBJECT_PLURAL = 'readabilityTestObjects';
+const UPDATE_RESPONSE_KEY = `update${capitalize(OBJECT_PLURAL)}`;
+const DELETE_RESPONSE_KEY = `delete${capitalize(OBJECT_PLURAL)}`;
+const RESTORE_RESPONSE_KEY = `restore${capitalize(OBJECT_PLURAL)}`;
+const DESTROY_RESPONSE_KEY = `destroy${capitalize(OBJECT_PLURAL)}`;
+const GROUP_BY_RESPONSE_KEY = `${OBJECT_PLURAL}GroupBy`;
+const RECORD_GQL_FIELDS = `
+ id
+ name
+`;
+
+const RECORD_IDS = {
+ SHARED_READ_WITH_JONY: randomUUID(),
+ SHARED_READ_WRITE_WITH_MEMBER_ROLE: randomUUID(),
+ SHARED_FULL_WITH_EVERYONE: randomUUID(),
+ SHARED_FULL_WITH_ADMIN_ROLE: randomUUID(),
+ UNSHARED: randomUUID(),
+};
+
+const PERSON_IDS = {
+ SHARED_READ_WITH_JONY: randomUUID(),
+ SHARED_READ_WRITE_WITH_MEMBER_ROLE: randomUUID(),
+ SHARED_FULL_WITH_EVERYONE: randomUUID(),
+ SHARED_FULL_WITH_ADMIN_ROLE: randomUUID(),
+ UNSHARED: randomUUID(),
+};
+
+const ALL_RECORD_IDS = Object.values(RECORD_IDS);
+const ALL_PERSON_IDS = Object.values(PERSON_IDS);
+
+const ALL_RECORDS_FILTER = { id: { in: ALL_RECORD_IDS } };
+const ALL_PEOPLE_FILTER = { id: { in: ALL_PERSON_IDS } };
+
+const collectIds = (edges: { node: { id: string } }[]): string[] =>
+ edges.map((edge) => edge.node.id).sort();
+
+const collectRecordIds = (records: { id: string }[]): string[] =>
+ records.map((record) => record.id).sort();
+
+const findManyOperation = findManyOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: RECORD_GQL_FIELDS,
+ filter: ALL_RECORDS_FILTER,
+});
+
+const totalCountOperation = {
+ query: gql`
+ query ReadabilityTestObjectsTotalCount(
+ $filter: ReadabilityTestObjectFilterInput
+ ) {
+ readabilityTestObjects(filter: $filter) {
+ totalCount
+ }
+ }
+ `,
+ variables: { filter: ALL_RECORDS_FILTER },
+};
+
+const setObjectReadability = async (
+ objectMetadataId: string,
+ readability: MetadataReadability,
+) => {
+ await getCoreRepository<ObjectMetadataEntity>(ObjectMetadataEntity).update(
+ objectMetadataId,
+ { readability },
+ );
+
+ const { errors } = await updateOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ idToUpdate: objectMetadataId,
+ updatePayload: { description: `readability set to ${readability}` },
+ },
+ });
+
+ expect(errors).toBeUndefined();
+};
+
+const setRecordSharingEnabled = (value: boolean) =>
+ updateFeatureFlag({
+ featureFlag: FeatureFlagKey.IS_RECORD_SHARING_ENABLED,
+ value,
+ expectToFail: false,
+ });
+
+describe('readabilityObjectRecordsPermissions', () => {
+ let recordShareService: RecordShareService;
+ let objectMetadataId: string;
+ let personRelationFieldMetadataId: string;
+
+ const sourceId = randomUUID();
+
+ beforeAll(async () => {
+ recordShareService =
+ getAppProviderByClassName<RecordShareService>('RecordShareService');
+
+ const { data } = await createOneObjectMetadata({
+ input: {
+ nameSingular: OBJECT_SINGULAR,
+ namePlural: OBJECT_PLURAL,
+ labelSingular: 'Readability Test Object',
+ labelPlural: 'Readability Test Objects',
+ icon: 'IconLock',
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ objectMetadataId = data.createOneObject.id;
+
+ await createOneFieldMetadata({
+ input: {
+ name: 'name',
+ label: 'Name',
+ type: FieldMetadataType.TEXT,
+ objectMetadataId,
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ const personObjectMetadata = await getCoreRepository<ObjectMetadataEntity>(
+ ObjectMetadataEntity,
+ ).findOneOrFail({
+ where: { workspaceId: SEED_APPLE_WORKSPACE_ID, nameSingular: 'person' },
+ });
+
+ const { data: personRelationFieldData } = await createOneFieldMetadata({
+ input: {
+ name: OBJECT_SINGULAR,
+ label: 'Readability Test Object',
+ type: FieldMetadataType.RELATION,
+ objectMetadataId: personObjectMetadata.id,
+ isLabelSyncedWithName: false,
+ relationCreationPayload: {
+ targetObjectMetadataId: objectMetadataId,
+ targetFieldLabel: 'People',
+ targetFieldIcon: 'IconUser',
+ type: RelationType.MANY_TO_ONE,
+ },
+ },
+ });
+
+ personRelationFieldMetadataId = personRelationFieldData.createOneField.id;
+
+ for (const [name, id] of Object.entries(RECORD_IDS)) {
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ gqlFields: RECORD_GQL_FIELDS,
+ data: { id, name },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ }
+
+ for (const [name, id] of Object.entries(PERSON_IDS)) {
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: {
+ id,
+ name: { firstName: name },
+ [`${OBJECT_SINGULAR}Id`]:
+ RECORD_IDS[name as keyof typeof RECORD_IDS],
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ }
+
+ const memberRole = await findOneRoleByLabel({ label: 'Member' });
+ const adminRole = await findOneRoleByLabel({ label: 'Admin' });
+
+ const buildRecordShare = ({
+ recordId,
+ principalId,
+ principalType,
+ accessLevel,
+ }: {
+ recordId: string;
+ principalId: string;
+ principalType: RecordSharePrincipalType;
+ accessLevel: RecordShareAccessLevel;
+ }) => ({
+ recordId,
+ objectMetadataId,
+ principalId,
+ principalType,
+ accessLevel,
+ rowCause: RecordShareRowCause.MANUAL,
+ sourceId,
+ });
+
+ await recordShareService.insertMany({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ recordShares: [
+ buildRecordShare({
+ recordId: RECORD_IDS.SHARED_READ_WITH_JONY,
+ principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,
+ accessLevel: RecordShareAccessLevel.READ,
+ }),
+ buildRecordShare({
+ recordId: RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
+ principalId: memberRole.id,
+ principalType: RecordSharePrincipalType.ROLE,
+ accessLevel: RecordShareAccessLevel.READ_WRITE,
+ }),
+ buildRecordShare({
+ recordId: RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ principalId: EVERYONE_PRINCIPAL_ID,
+ principalType: RecordSharePrincipalType.EVERYONE,
+ accessLevel: RecordShareAccessLevel.FULL,
+ }),
+ buildRecordShare({
+ recordId: RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
+ principalId: adminRole.id,
+ principalType: RecordSharePrincipalType.ROLE,
+ accessLevel: RecordShareAccessLevel.FULL,
+ }),
+ ],
+ });
+ });
+
+ afterAll(async () => {
+ await setRecordSharingEnabled(false);
+ await recordShareService.deleteBySourceId({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ sourceId,
+ });
+ await setObjectReadability(objectMetadataId, MetadataReadability.OPEN);
+ await makeGraphqlAPIRequest(
+ destroyManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id',
+ filter: ALL_PEOPLE_FILTER,
+ }),
+ );
+ await deleteOneFieldMetadata({
+ input: { idToDelete: personRelationFieldMetadataId },
+ expectToFail: false,
+ });
+ await updateOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ idToUpdate: objectMetadataId,
+ updatePayload: { isActive: false },
+ },
+ });
+ await deleteOneObjectMetadata({
+ input: { idToDelete: objectMetadataId },
+ });
+ });
+
+ describe('PRIVATE readability with record sharing enabled', () => {
+ beforeAll(async () => {
+ await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
+ await setRecordSharingEnabled(true);
+ });
+
+ it('should only return records shared with the admin principals', async () => {
+ const response = await makeGraphqlAPIRequest(findManyOperation);
+
+ expect(response.body.errors).toBeUndefined();
+ expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
+ [
+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
+ ].sort(),
+ );
+ });
+
+ it('should only return records shared with the member, their role or everyone', async () => {
+ const response =
+ await makeGraphqlAPIRequestWithMemberRole(findManyOperation);
+
+ expect(response.body.errors).toBeUndefined();
+ expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
+ [
+ RECORD_IDS.SHARED_READ_WITH_JONY,
+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ ].sort(),
+ );
+ });
+
+ it('should keep the role as the ceiling: a share row grants nothing the role refuses', async () => {
+ const memberRole = await findOneRoleByLabel({ label: 'Member' });
+ const setMemberCanReadObjectRecords = (canReadObjectRecords: boolean) =>
+ upsertObjectPermissions({
+ expectToFail: false,
+ input: {
+ roleId: memberRole.id,
+ objectPermissions: [
+ {
+ objectMetadataId,
+ canReadObjectRecords,
+ canUpdateObjectRecords: canReadObjectRecords,
+ canSoftDeleteObjectRecords: canReadObjectRecords,
+ canDestroyObjectRecords: canReadObjectRecords,
+ },
+ ],
+ },
+ });
+
+ await setMemberCanReadObjectRecords(false);
+
+ try {
+ const response =
+ await makeGraphqlAPIRequestWithMemberRole(findManyOperation);
+
+ expect(response.body.errors).toBeDefined();
+ expect(response.body.data?.[OBJECT_PLURAL] ?? null).toBeNull();
+ } finally {
+ await setMemberCanReadObjectRecords(true);
+ }
+
+ const restoredResponse =
+ await makeGraphqlAPIRequestWithMemberRole(findManyOperation);
+
+ expect(restoredResponse.body.errors).toBeUndefined();
+ expect(
+ collectIds(restoredResponse.body.data[OBJECT_PLURAL].edges),
+ ).toEqual(
+ [
+ RECORD_IDS.SHARED_READ_WITH_JONY,
+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ ].sort(),
+ );
+ });
+
+ it('should only return records shared with the api key role or everyone', async () => {
+ const response = await makeGraphqlAPIRequestWithApiKey(findManyOperation);
+
+ expect(response.body.errors).toBeUndefined();
+ expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
+ [
+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ RECORD_IDS.SHARED_FULL_WITH_ADMIN_ROLE,
+ ].sort(),
+ );
+ });
+
+ it('should count only the records visible to the member', async () => {
+ const response =
+ await makeGraphqlAPIRequestWithMemberRole(totalCountOperation);
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data[OBJECT_PLURAL].totalCount).toBe(3);
+ });
+
+ it('should group only the records visible to the member', async () => {
+ const response = await makeGraphqlAPIRequestWithMemberRole(
+ groupByOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ groupBy: [{ name: true }],
+ filter: ALL_RECORDS_FILTER,
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const groupedNames = response.body.data[GROUP_BY_RESPONSE_KEY].flatMap(
+ (group: { groupByDimensionValues: string[] }) =>
+ group.groupByDimensionValues,
+ ).sort();
+
+ expect(groupedNames).toEqual([
+ 'SHARED_FULL_WITH_EVERYONE',
+ 'SHARED_READ_WITH_JONY',
+ 'SHARED_READ_WRITE_WITH_MEMBER_ROLE',
+ ]);
+ });
+
+ it('should only hydrate the visible records on a nested relation read', async () => {
+ const response = await makeGraphqlAPIRequestWithMemberRole(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: `
+ id
+ ${OBJECT_SINGULAR} {
+ id
+ }
+ `,
+ filter: ALL_PEOPLE_FILTER,
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const relatedRecordIdByPersonId = Object.fromEntries(
+ response.body.data.people.edges.map(
+ (edge: {
+ node: { id: string; [OBJECT_SINGULAR]: { id: string } };
+ }) => [edge.node.id, edge.node[OBJECT_SINGULAR]?.id ?? null],
+ ),
+ );
+
+ expect(relatedRecordIdByPersonId).toEqual({
+ [PERSON_IDS.SHARED_READ_WITH_JONY]: RECORD_IDS.SHARED_READ_WITH_JONY,
+ [PERSON_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE]:
+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
+ [PERSON_IDS.SHARED_FULL_WITH_EVERYONE]:
+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ [PERSON_IDS.SHARED_FULL_WITH_ADMIN_ROLE]: null,
+ [PERSON_IDS.UNSHARED]: null,
+ });
+ });
+
+ it('should only match relation filters through the visible records', async () => {
+ const findPeopleThroughRecordName = (name: string) =>
+ makeGraphqlAPIRequestWithMemberRole(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id',
+ filter: { [OBJECT_SINGULAR]: { name: { eq: name } } },
+ }),
+ );
+
+ const hiddenResponse = await findPeopleThroughRecordName('UNSHARED');
+ const visibleResponse = await findPeopleThroughRecordName(
+ 'SHARED_READ_WITH_JONY',
+ );
+
+ expect(hiddenResponse.body.errors).toBeUndefined();
+ expect(hiddenResponse.body.data.people.edges).toHaveLength(0);
+ expect(visibleResponse.body.errors).toBeUndefined();
+ expect(collectIds(visibleResponse.body.data.people.edges)).toEqual([
+ PERSON_IDS.SHARED_READ_WITH_JONY,
+ ]);
+ });
+
+ it('should only update the records shared with at least READ_WRITE access', async () => {
+ const response = await makeGraphqlAPIRequestWithMemberRole(
+ updateManyOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: RECORD_GQL_FIELDS,
+ data: { name: 'updated by member' },
+ filter: ALL_RECORDS_FILTER,
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(collectRecordIds(response.body.data[UPDATE_RESPONSE_KEY])).toEqual(
+ [
+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
+ RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ ].sort(),
+ );
+
+ const readOnlyRecordResponse = await makeGraphqlAPIRequestWithMemberRole(
+ findOneOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ gqlFields: RECORD_GQL_FIELDS,
+ filter: { id: { eq: RECORD_IDS.SHARED_READ_WITH_JONY } },
+ }),
+ );
+
+ expect(readOnlyRecordResponse.body.data[OBJECT_SINGULAR].name).toBe(
+ 'SHARED_READ_WITH_JONY',
+ );
+ });
+
+ it('should only soft delete, restore and destroy the records shared with FULL access', async () => {
+ const deleteResponse = await makeGraphqlAPIRequestWithMemberRole(
+ deleteManyOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: RECORD_GQL_FIELDS,
+ filter: ALL_RECORDS_FILTER,
+ }),
+ );
+
+ expect(deleteResponse.body.errors).toBeUndefined();
+ expect(
+ collectRecordIds(deleteResponse.body.data[DELETE_RESPONSE_KEY]),
+ ).toEqual([RECORD_IDS.SHARED_FULL_WITH_EVERYONE]);
+
+ const restoreResponse = await makeGraphqlAPIRequestWithMemberRole(
+ restoreManyOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: RECORD_GQL_FIELDS,
+ filter: ALL_RECORDS_FILTER,
+ }),
+ );
+
+ expect(restoreResponse.body.errors).toBeUndefined();
+ expect(
+ collectRecordIds(restoreResponse.body.data[RESTORE_RESPONSE_KEY]),
+ ).toEqual([RECORD_IDS.SHARED_FULL_WITH_EVERYONE]);
+
+ const destroyResponse = await makeGraphqlAPIRequestWithMemberRole(
+ destroyManyOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ objectMetadataPluralName: OBJECT_PLURAL,
+ gqlFields: RECORD_GQL_FIELDS,
+ filter: ALL_RECORDS_FILTER,
+ }),
+ );
+
+ expect(destroyResponse.body.errors).toBeUndefined();
+ expect(
+ collectRecordIds(destroyResponse.body.data[DESTROY_RESPONSE_KEY]),
+ ).toEqual([RECORD_IDS.SHARED_FULL_WITH_EVERYONE]);
+
+ const remainingResponse =
+ await makeGraphqlAPIRequestWithMemberRole(findManyOperation);
+
+ expect(
+ collectIds(remainingResponse.body.data[OBJECT_PLURAL].edges),
+ ).toEqual(
+ [
+ RECORD_IDS.SHARED_READ_WITH_JONY,
+ RECORD_IDS.SHARED_READ_WRITE_WITH_MEMBER_ROLE,
+ ].sort(),
+ );
+ });
+ });
+
+ describe('SYSTEM readability with record sharing enabled', () => {
+ beforeAll(async () => {
+ await setObjectReadability(objectMetadataId, MetadataReadability.SYSTEM);
+ await setRecordSharingEnabled(true);
+ });
+
+ it('should refuse reads even for an admin', async () => {
+ const response = await makeGraphqlAPIRequest(findManyOperation);
+
+ expect(response.body.errors).toBeDefined();
+ expect(response.body.errors[0].message).toContain('not readable');
+ });
+ });
+
+ describe('PRIVATE readability with record sharing disabled', () => {
+ beforeAll(async () => {
+ await setObjectReadability(objectMetadataId, MetadataReadability.PRIVATE);
+ await setRecordSharingEnabled(false);
+
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: OBJECT_SINGULAR,
+ gqlFields: RECORD_GQL_FIELDS,
+ data: {
+ id: RECORD_IDS.SHARED_FULL_WITH_EVERYONE,
+ name: 'SHARED_FULL_WITH_EVERYONE',
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ });
+
+ it('should return every record', async () => {
+ const response = await makeGraphqlAPIRequest(findManyOperation);
+
+ expect(response.body.errors).toBeUndefined();
+ expect(collectIds(response.body.data[OBJECT_PLURAL].edges)).toEqual(
+ Object.values(RECORD_IDS).sort(),
+ );
+ });
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts
index 87be14eda10..daa5316a54e 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/record-share-object.integration-spec.ts
@@ -1,10 +1,13 @@
import { randomUUID } from 'node:crypto';
import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-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 { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';
import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
import {
+ FeatureFlagKey,
RecordShareAccessLevel,
RecordSharePrincipalType,
RecordShareRowCause,
@@ -50,12 +53,39 @@ describe('recordShare object', () => {
});
afterAll(async () => {
+ await updateFeatureFlag({
+ featureFlag: FeatureFlagKey.IS_RECORD_SHARING_ENABLED,
+ value: false,
+ expectToFail: false,
+ });
await recordShareService.deleteBySourceId({
workspaceId: SEED_APPLE_WORKSPACE_ID,
sourceId,
});
});
+ it.each([false, true])(
+ 'refuses reads through the GraphQL API even for an admin when record sharing is %s',
+ async (isRecordSharingEnabled) => {
+ await updateFeatureFlag({
+ featureFlag: FeatureFlagKey.IS_RECORD_SHARING_ENABLED,
+ value: isRecordSharingEnabled,
+ expectToFail: false,
+ });
+
+ const response = await makeGraphqlAPIRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'recordShare',
+ objectMetadataPluralName: 'recordShares',
+ gqlFields: 'id',
+ }),
+ );
+
+ expect(response.body.errors).toBeDefined();
+ expect(response.body.errors[0].message).toContain('not readable');
+ },
+ );
+
it('refuses creation through the GraphQL API even for an admin', async () => {
const response = await makeGraphqlAPIRequest(
createOneOperationFactory({
diff --git a/packages/twenty-shared/src/types/FeatureFlagKey.ts b/packages/twenty-shared/src/types/FeatureFlagKey.ts
index d3aa278dfac..21150d74962 100644
--- a/packages/twenty-shared/src/types/FeatureFlagKey.ts
+++ b/packages/twenty-shared/src/types/FeatureFlagKey.ts
@@ -12,4 +12,5 @@ export enum FeatureFlagKey {
IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED = 'IS_MESSAGE_CALENDAR_TARGET_READ_ENABLED',
IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED = 'IS_QUOTA_ENGINE_CREDIT_BOUND_ENABLED',
IS_RECORD_CREATION_FORM_ENABLED = 'IS_RECORD_CREATION_FORM_ENABLED',
+ IS_RECORD_SHARING_ENABLED = 'IS_RECORD_SHARING_ENABLED',
}