The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.graphqlindex 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_ENABLEDIS_QUOTA_ENGINE_CREDIT_BOUND_ENABLEDIS_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.tsindex 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.mdxindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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',}