Skip to content

The open alternative to Salesforce, designed for AI.

Record-level sharing 5: one row access policy for queries, events and writes (#27068)

Félix Malfait46362ca1e86d
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts
index c28efcc1198..a90b0d9f90d 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-access-policy.service.ts
@@ -2,62 +2,41 @@
import { Injectable } from '@nestjs/common';
+import { isNonEmptyString } from '@sniptt/guards';
+import groupBy from 'lodash.groupby';
import { type ObjectRecordEvent } from 'twenty-shared/database-events';
import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';
-import { assertUnreachable, isDefined } from 'twenty-shared/utils';
-import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
import { In, MoreThanOrEqual } from 'typeorm';
-import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
-import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
-import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { RecordShareStorageService } from 'src/engine/core-modules/record-share/services/record-share-storage.service';
import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';
import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import {
+ evaluateRowAccessPolicy,
+ type RowAccessEvaluationContext,
+} from 'src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util';
import {
type EventRecordSnapshot,
resolveEventRecordSnapshots,
} from 'src/engine/core-modules/record-share/utils/resolve-event-record-snapshots.util';
-import { resolveNamedPrincipalIds } from 'src/engine/core-modules/record-share/utils/resolve-named-principal-ids.util';
-import { resolveRecordIdsRestrictedForPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util';
-import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';
-import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';
-import { shouldEnforceRecordShareExceptions } from 'src/engine/core-modules/record-share/utils/should-enforce-record-share-exceptions.util';
-import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';
-import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/core-modules/record-share/constants/max-inherited-readability-depth.constant';
-import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';
-import { type InheritedReadabilityChildrenParent } from 'src/engine/core-modules/record-share/types/inherited-readability-children-parent.type';
-import { type InheritedReadabilityColumnParent } from 'src/engine/core-modules/record-share/types/inherited-readability-column-parent.type';
-import { type RowAccessPolicySubject } from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { type InheritedReadabilityParentExpression } from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { buildRowAccessPolicy } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';
import { isChildRecordBoundAtDeletion } from 'src/engine/twenty-orm/utils/is-child-record-bound-at-deletion.util';
-import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';
-import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';
-import { isOpenWhenDetachedObject } from 'src/engine/core-modules/record-share/utils/is-open-when-detached-object.util';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
-type ReadabilityMaps = {
- flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
- flatFieldMetadataMapsOrm: FlatEntityMaps<OrmFlatFieldMetadata>;
-};
+type ColumnParentExpression = Extract<
+ InheritedReadabilityParentExpression,
+ { kind: 'column' }
+>;
-type SnapshotEvaluation = {
- workspaceId: string;
- objectMetadata: FlatObjectMetadata;
- snapshots: EventRecordSnapshot[];
- subject: RowAccessPolicySubject;
- depth: number;
- maps?: ReadabilityMaps;
-};
-
-type SnapshotEvaluationInContext = SnapshotEvaluation & {
- maps: ReadabilityMaps;
-};
-
-type FetchRecordShares = () => Promise<RecordShare[]>;
+type ChildrenParentExpression = Extract<
+ InheritedReadabilityParentExpression,
+ { kind: 'children' }
+>;
type SnapshotIdsThroughParent = {
readableSnapshotIds: Set<string>;
@@ -72,320 +51,154 @@ export class RecordAccessPolicyService {
private readonly recordShareStorageService: RecordShareStorageService,
) {}
- // Mirrors the query gate: role read, then the row-level filter on the event snapshot, then the share gate.
+ // A subject receives the records a query would return it: the event
+ // snapshots are run through the same row access policy as its queries.
buildEventRecordAccessGate({
workspaceId,
objectMetadata,
events,
}: WorkspaceEventBatch<ObjectRecordEvent>): EventRecordAccessGate {
- let recordSharesPromise: Promise<RecordShare[]> | undefined;
- const fetchRecordShares: FetchRecordShares = () =>
- (recordSharesPromise ??= this.recordShareStorageService.findByRecordIds({
- workspaceId,
- objectMetadataId: objectMetadata.id,
- recordIds: events.map((event) => event.recordId),
- }));
-
- return {
- resolveAdmittedRecordIds: async (subject) => {
- const eventSnapshots = resolveEventRecordSnapshots(events);
- const snapshots = await this.resolveSnapshotsReadableByRole({
- workspaceId,
- objectMetadata,
- snapshots: eventSnapshots,
- subject,
- depth: 0,
- });
-
- const admittedSnapshotIds =
- snapshots.length === 0
- ? new Set<string>()
- : await this.resolveSnapshotIdsAdmittedByRecordShareGate(
- {
- workspaceId,
- objectMetadata,
- snapshots,
- subject,
- depth: 0,
- },
- fetchRecordShares,
- );
-
- return new Set([
- ...admittedSnapshotIds,
- ...(await this.resolveSnapshotIdsGrantedBeyondRole(
- { workspaceId, objectMetadata, snapshots: eventSnapshots, subject },
- fetchRecordShares,
- )),
- ]);
- },
- };
- }
-
- private async resolveSnapshotsReadableByRole({
- workspaceId,
- objectMetadata,
- snapshots,
- subject,
- maps,
- }: SnapshotEvaluation): Promise<EventRecordSnapshot[]> {
- if (snapshots.length === 0) {
- return [];
- }
-
- if (
- isDefined(subject.objectsPermissions) &&
- !isObjectOperationPermitted({
- objectMetadata,
- operationType: 'select',
- objectsPermissions: subject.objectsPermissions,
- })
- ) {
- return [];
- }
-
- const rowLevelPermissionRecordFilter =
- subject.resolveRowLevelPermissionRecordFilter(objectMetadata);
-
- if (
- !isDefined(rowLevelPermissionRecordFilter) ||
- Object.keys(rowLevelPermissionRecordFilter).length === 0
- ) {
- return snapshots;
- }
-
- const flatFieldMetadataMaps =
- maps?.flatFieldMetadataMapsOrm ??
- (
- await this.workspaceCacheService.getOrRecompute(workspaceId, [
- 'flatFieldMetadataMapsOrm',
- ])
- ).flatFieldMetadataMapsOrm;
-
- return snapshots.filter((snapshot) =>
- isRecordMatchingRLSRowLevelPermissionPredicate({
- record: snapshot,
- filter: rowLevelPermissionRecordFilter,
- flatObjectMetadata: objectMetadata,
- flatFieldMetadataMaps,
- shouldIgnoreSoftDeleteDefaultFilter: true,
- }),
- );
- }
-
- private async resolveSnapshotIdsAdmittedByRecordShareGate(
- evaluation: SnapshotEvaluation,
- fetchRecordShares: FetchRecordShares,
- ): Promise<Set<string>> {
- const { objectMetadata, snapshots, subject } = evaluation;
- const gateKind = resolveRecordShareGateKind({
- readability: objectMetadata.readability,
- isOwningApplication: subject.isOwningApplication(objectMetadata),
- });
-
- switch (gateKind) {
- case 'open':
- return (await this.areRecordShareExceptionsEnforced(evaluation))
- ? this.resolveSnapshotIdsNotRestrictedForSubject(
- evaluation,
- fetchRecordShares,
- )
- : new Set(snapshots.map((snapshot) => snapshot.id));
- case 'deny':
- return new Set();
- case 'private':
- return this.resolveSnapshotIdsSharedWithSubject(
- evaluation,
- fetchRecordShares,
- );
- case 'inherited':
- return new Set([
- ...(await this.resolveSnapshotIdsSharedWithSubject(
- evaluation,
- fetchRecordShares,
- )),
- ...(await this.resolveSnapshotIdsReadableThroughParents({
- ...evaluation,
- })),
- ]);
- default:
- return assertUnreachable(gateKind);
- }
- }
-
- // A record shared by name reaches its recipients whatever their role or row
- // filter says about the object, as the row access policy does
- private async resolveSnapshotIdsGrantedBeyondRole(
- {
- workspaceId,
- objectMetadata,
- snapshots,
- subject,
- }: Omit<SnapshotEvaluation, 'depth'>,
- fetchRecordShares: FetchRecordShares,
- ): Promise<Set<string>> {
- const namedPrincipalIds = resolveNamedPrincipalIds(subject);
-
- if (
- snapshots.length === 0 ||
- namedPrincipalIds.length === 0 ||
- !isRecordGrantBeyondRoleAllowed({
- flatObjectMetadata: objectMetadata,
- operationType: 'select',
- isRecordSharingEnabled: await this.isRecordSharingEnabled(workspaceId),
- })
- ) {
- return new Set();
- }
-
- const grantedRecordIds = resolveRecordIdsSharedWithPrincipals({
- recordShares: await fetchRecordShares(),
- principalIds: namedPrincipalIds,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
- });
-
- return new Set(
- snapshots
- .map((snapshot) => snapshot.id)
- .filter((snapshotId) => grantedRecordIds.has(snapshotId)),
- );
- }
-
- private async isRecordSharingEnabled(workspaceId: string): Promise<boolean> {
- const { featureFlagsMap } = await this.workspaceCacheService.getOrRecompute(
- workspaceId,
- ['featureFlagsMap'],
- );
-
- return (
- featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ?? false
- );
- }
-
- private async areRecordShareExceptionsEnforced({
- workspaceId,
- objectMetadata,
- subject,
- }: SnapshotEvaluation): Promise<boolean> {
- return shouldEnforceRecordShareExceptions({
- flatObjectMetadata: objectMetadata,
- isRecordSharingEnabled: await this.isRecordSharingEnabled(workspaceId),
- canAccessAllRecords: subject.canAccessAllRecords,
- });
- }
-
- private async resolveSnapshotIdsNotRestrictedForSubject(
- { snapshots, subject }: SnapshotEvaluation,
- fetchRecordShares: FetchRecordShares,
- ): Promise<Set<string>> {
- const snapshotIds = snapshots.map((snapshot) => snapshot.id);
-
- if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {
- return new Set(snapshotIds);
- }
-
- const restrictedRecordIds = resolveRecordIdsRestrictedForPrincipals({
- recordShares: await fetchRecordShares(),
- principalIds: subject.principalIds,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
- });
-
- return new Set(
- snapshotIds.filter((snapshotId) => !restrictedRecordIds.has(snapshotId)),
- );
- }
-
- private async resolveSnapshotIdsSharedWithSubject(
- { snapshots, subject }: SnapshotEvaluation,
- fetchRecordShares: FetchRecordShares,
- ): Promise<Set<string>> {
- const snapshotIds = snapshots.map((snapshot) => snapshot.id);
-
- if (!isDefined(subject.principalIds) || snapshotIds.length === 0) {
- return new Set(snapshotIds);
- }
-
- const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({
- recordShares: await fetchRecordShares(),
- principalIds: subject.principalIds,
- accessLevels: resolveRequiredRecordShareAccessLevels('select'),
- });
-
- return new Set(
- snapshotIds.filter((snapshotId) => sharedRecordIds.has(snapshotId)),
- );
- }
-
- private async resolveSnapshotIdsReadableThroughParents(
- evaluation: SnapshotEvaluation,
- ): Promise<Set<string>> {
- const { workspaceId, objectMetadata, maps } = evaluation;
-
- if (!isDefined(maps)) {
- const loadedMaps = await this.workspaceCacheService.getOrRecompute(
- workspaceId,
- ['flatObjectMetadataMaps', 'flatFieldMetadataMapsOrm'],
+ // One lookup per object for the whole batch: operands only ever ask for
+ // records of the batch, so later calls are served from what was fetched
+ const recordSharesByRecordIdByObject = new Map<
+ string,
+ Map<string, Promise<RecordShare[]>>
+ >();
+ const fetchRecordShares = async ({
+ objectMetadataId,
+ recordIds,
+ }: {
+ objectMetadataId: string;
+ recordIds: string[];
+ }) => {
+ const recordSharesByRecordId =
+ recordSharesByRecordIdByObject.get(objectMetadataId) ??
+ new Map<string, Promise<RecordShare[]>>();
+
+ recordSharesByRecordIdByObject.set(
+ objectMetadataId,
+ recordSharesByRecordId,
);
- return this.workspaceOrmManager.executeInWorkspaceContext(
- () =>
- this.resolveSnapshotIdsReadableThroughParents({
- ...evaluation,
- maps: loadedMaps,
- }),
- buildSystemAuthContext(workspaceId),
+ const uniqueRecordIds = [...new Set(recordIds)];
+ const missingRecordIds = uniqueRecordIds.filter(
+ (recordId) => !recordSharesByRecordId.has(recordId),
);
- }
- const parents = resolveInheritedReadabilityParents({
- flatObjectMetadata: objectMetadata,
- flatFieldMetadataMaps: maps.flatFieldMetadataMapsOrm,
- flatObjectMetadataMaps: maps.flatObjectMetadataMaps,
- });
- const readableSnapshotIds = new Set<string>();
- const attachedSnapshotIds = new Set<string>();
-
- for (const parent of parents) {
- const snapshotIdsThroughParent =
- parent.kind === 'column'
- ? await this.resolveSnapshotIdsReadableThroughColumnParent({
- ...evaluation,
- maps,
- parent,
- })
- : await this.resolveSnapshotIdsReadableThroughChildren({
- ...evaluation,
- maps,
- parent,
- });
-
- for (const readableId of snapshotIdsThroughParent.readableSnapshotIds) {
- readableSnapshotIds.add(readableId);
+ if (missingRecordIds.length > 0) {
+ const groupedRecordShares = this.recordShareStorageService
+ .findByRecordIds({
+ workspaceId,
+ objectMetadataId,
+ recordIds: missingRecordIds,
+ })
+ .then((recordShares) =>
+ groupBy(recordShares, (recordShare) => recordShare.recordId),
+ );
+
+ for (const recordId of missingRecordIds) {
+ recordSharesByRecordId.set(
+ recordId,
+ groupedRecordShares.then(
+ (recordSharesOfRecord) => recordSharesOfRecord[recordId] ?? [],
+ ),
+ );
+ }
}
- for (const attachedId of snapshotIdsThroughParent.attachedSnapshotIds) {
- attachedSnapshotIds.add(attachedId);
- }
- }
+ const recordSharesPerRecord = await Promise.all(
+ uniqueRecordIds.map(
+ (recordId) => recordSharesByRecordId.get(recordId) ?? [],
+ ),
+ );
- if (isOpenWhenDetachedObject(objectMetadata)) {
- for (const snapshot of evaluation.snapshots) {
- if (!attachedSnapshotIds.has(snapshot.id)) {
- readableSnapshotIds.add(snapshot.id);
- }
- }
- }
+ return recordSharesPerRecord.flat();
+ };
- return readableSnapshotIds;
+ return {
+ resolveAdmittedRecordIds: async (subject) => {
+ const {
+ flatObjectMetadataMaps,
+ flatFieldMetadataMapsOrm,
+ featureFlagsMap,
+ } = await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ 'flatFieldMetadataMapsOrm',
+ 'featureFlagsMap',
+ ]);
+ const context: RowAccessEvaluationContext<EventRecordSnapshot> = {
+ flatFieldMetadataMaps: flatFieldMetadataMapsOrm,
+ shouldIgnoreSoftDeleteDefaultFilter: true,
+ fetchRecordShares,
+ // Parents and children are only reached through their tables
+ resolveRecordIdsReadableThroughParents: ({ expression, records }) =>
+ this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const readableSnapshotIds = new Set<string>();
+ const attachedSnapshotIds = new Set<string>();
+
+ for (const parent of expression.parents) {
+ const throughParent =
+ parent.kind === 'column'
+ ? await this.resolveSnapshotIdsReadableThroughColumnParent({
+ parent,
+ snapshots: records,
+ })
+ : await this.resolveSnapshotIdsReadableThroughChildren({
+ parent,
+ snapshots: records,
+ isOpenWhenDetached: expression.isOpenWhenDetached,
+ context,
+ });
+
+ throughParent.readableSnapshotIds.forEach((id) =>
+ readableSnapshotIds.add(id),
+ );
+ throughParent.attachedSnapshotIds.forEach((id) =>
+ attachedSnapshotIds.add(id),
+ );
+ }
+
+ if (expression.isOpenWhenDetached) {
+ for (const record of records) {
+ if (!attachedSnapshotIds.has(record.id)) {
+ readableSnapshotIds.add(record.id);
+ }
+ }
+ }
+
+ return readableSnapshotIds;
+ }, buildSystemAuthContext(workspaceId)),
+ };
+
+ return evaluateRowAccessPolicy({
+ policy: buildRowAccessPolicy({
+ subject,
+ environment: {
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps: flatFieldMetadataMapsOrm,
+ isRecordSharingEnabled:
+ featureFlagsMap[
+ FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED
+ ] ?? false,
+ },
+ tableAlias: objectMetadata.nameSingular,
+ flatObjectMetadata: objectMetadata,
+ operationType: 'select',
+ depth: 0,
+ }),
+ records: resolveEventRecordSnapshots(events),
+ context,
+ });
+ },
+ };
}
private async resolveSnapshotIdsReadableThroughColumnParent({
- snapshots,
- subject,
- depth,
parent,
- }: SnapshotEvaluationInContext & {
- parent: InheritedReadabilityColumnParent;
+ snapshots,
+ }: {
+ parent: ColumnParentExpression;
+ snapshots: EventRecordSnapshot[];
}): Promise<SnapshotIdsThroughParent> {
const parentIdBySnapshotId = new Map(
snapshots.flatMap((snapshot) => {
@@ -394,12 +207,15 @@ export class RecordAccessPolicyService {
return isNonEmptyString(parentId) ? [[snapshot.id, parentId]] : [];
}),
);
- const readableParentIds = await this.selectReadableRecordIds({
- objectMetadata: parent.parentFlatObjectMetadata,
- recordIds: [...new Set(parentIdBySnapshotId.values())],
- subject,
- depth: depth + 1,
- });
+ const readableParentIds = await this.workspaceOrmManager
+ .getRepository(parent.parentFlatObjectMetadata.nameSingular, {
+ shouldBypassPermissionChecks: true,
+ })
+ .findRecordIdsAdmittedByRowAccessPolicy({
+ recordIds: [...new Set(parentIdBySnapshotId.values())],
+ policy: parent.policy,
+ tableAlias: parent.parentTableAlias,
+ });
return {
readableSnapshotIds: new Set(
@@ -412,15 +228,15 @@ export class RecordAccessPolicyService {
}
private async resolveSnapshotIdsReadableThroughChildren({
- workspaceId,
- objectMetadata,
- snapshots,
- subject,
- depth,
- maps,
parent,
- }: SnapshotEvaluationInContext & {
- parent: InheritedReadabilityChildrenParent;
+ snapshots,
+ isOpenWhenDetached,
+ context,
+ }: {
+ parent: ChildrenParentExpression;
+ snapshots: EventRecordSnapshot[];
+ isOpenWhenDetached: boolean;
+ context: RowAccessEvaluationContext<EventRecordSnapshot>;
}): Promise<SnapshotIdsThroughParent> {
const childNameSingular = parent.childFlatObjectMetadata.nameSingular;
const capturedChildSnapshotsBySnapshotId = new Map(
@@ -468,12 +284,12 @@ export class RecordAccessPolicyService {
.select(['id', parent.childJoinColumnName])
.where({ [parent.childJoinColumnName]: In(liveSnapshotIds) })
.getMany<ObjectRecord>({ noFormatting: true });
- const readableChildIds = await this.selectReadableRecordIds({
- objectMetadata: parent.childFlatObjectMetadata,
- recordIds: childRows.map((childRow) => String(childRow.id)),
- subject,
- depth: depth + 1,
- });
+ const readableChildIds =
+ await childRepository.findRecordIdsAdmittedByRowAccessPolicy({
+ recordIds: childRows.map((childRow) => String(childRow.id)),
+ policy: parent.policy,
+ tableAlias: parent.childTableAlias,
+ });
for (const childRow of childRows) {
const snapshotId = String(childRow[parent.childJoinColumnName]);
@@ -491,10 +307,7 @@ export class RecordAccessPolicyService {
isDefined(snapshot.deletedAt),
);
- if (
- isOpenWhenDetachedObject(objectMetadata) &&
- trashedSnapshots.length > 0
- ) {
+ if (isOpenWhenDetached && trashedSnapshots.length > 0) {
const snapshotById = new Map(
trashedSnapshots.map((snapshot) => [snapshot.id, snapshot]),
);
@@ -505,7 +318,8 @@ export class RecordAccessPolicyService {
),
),
);
- // Rows trashed along with the record still attach it, as in the query gate; rows trashed earlier do not.
+ // A row trashed along with the record still attaches it, as in the
+ // query gate; rows trashed before any of these records cannot
const trashedChildRows = await childRepository
.createQueryBuilder()
.select(['id', parent.childJoinColumnName, 'deletedAt'])
@@ -533,13 +347,10 @@ export class RecordAccessPolicyService {
}
}
- const readableCapturedChildIds = await this.resolveReadableSnapshotIds({
- workspaceId,
- objectMetadata: parent.childFlatObjectMetadata,
- snapshots: [...capturedChildSnapshotsBySnapshotId.values()].flat(),
- subject,
- depth: depth + 1,
- maps,
+ const readableCapturedChildIds = await evaluateRowAccessPolicy({
+ policy: parent.policy,
+ records: [...capturedChildSnapshotsBySnapshotId.values()].flat(),
+ context,
});
for (const [
@@ -557,75 +368,4 @@ export class RecordAccessPolicyService {
return { readableSnapshotIds, attachedSnapshotIds };
}
-
- private async resolveReadableSnapshotIds(
- evaluation: SnapshotEvaluationInContext,
- ): Promise<Set<string>> {
- const { workspaceId, objectMetadata, depth } = evaluation;
-
- if (depth > MAX_INHERITED_READABILITY_DEPTH) {
- return new Set();
- }
-
- const candidateSnapshots =
- await this.resolveSnapshotsReadableByRole(evaluation);
-
- if (candidateSnapshots.length === 0) {
- return new Set();
- }
-
- return this.resolveSnapshotIdsAdmittedByRecordShareGate(
- { ...evaluation, snapshots: candidateSnapshots },
- () =>
- this.recordShareStorageService.findByRecordIds({
- workspaceId,
- objectMetadataId: objectMetadata.id,
- recordIds: candidateSnapshots.map((snapshot) => snapshot.id),
- }),
- );
- }
-
- private async selectReadableRecordIds({
- objectMetadata,
- recordIds,
- subject,
- depth,
- }: {
- objectMetadata: FlatObjectMetadata;
- recordIds: string[];
- subject: RowAccessPolicySubject;
- depth: number;
- }): Promise<Set<string>> {
- if (recordIds.length === 0) {
- return new Set();
- }
-
- const repository = this.workspaceOrmManager.getRepository(
- objectMetadata.nameSingular,
- { shouldBypassPermissionChecks: true },
- );
- const policy = repository.buildRowAccessPolicy({
- subject,
- operationType: 'select',
- depth,
- });
-
- switch (policy.kind) {
- case 'open':
- return new Set(recordIds);
- case 'denied':
- return new Set();
- case 'gated': {
- const rows = await repository
- .createQueryBuilder()
- .select(['id'])
- .where({ id: In(recordIds) })
- .withDeleted()
- .andWhere(policy.condition.sql, policy.condition.parameters)
- .getMany<ObjectRecord>({ noFormatting: true });
-
- return new Set(rows.map((row) => String(row.id)));
- }
- }
- }
}
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts
index cd22142c122..94008c04dc1 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/services/record-sharing.service.ts
@@ -14,7 +14,7 @@ import {
RecordSharePrincipalType,
RecordShareRowCause,
} from 'twenty-shared/types';
-import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+import { isDefined } from 'twenty-shared/utils';
import { type UserWorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { NotFoundError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
@@ -709,20 +709,13 @@ export class RecordSharingService {
},
operationType: 'select',
});
- const isRecordReachable =
- policy.kind === 'open' ||
- (policy.kind === 'gated' &&
- isNonEmptyArray(
- await repository
- .createQueryBuilder()
- .select(['id'])
- .where({ id: recordId })
- .withDeleted()
- .andWhere(policy.condition.sql, policy.condition.parameters)
- .getMany<ObjectRecord>({ noFormatting: true }),
- ));
-
- if (!isRecordReachable) {
+ const reachableRecordIds =
+ await repository.findRecordIdsAdmittedByRowAccessPolicy({
+ recordIds: [recordId],
+ policy,
+ });
+
+ if (!reachableRecordIds.has(recordId)) {
throw new RecordShareException(
`Principal ${principal.principalId} cannot see record ${recordId} through its role`,
RecordShareExceptionCode.INVALID_SHARE_WITH,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/types/record-share-grant.type.ts b/packages/twenty-server/src/engine/core-modules/record-share/types/record-share-grant.type.ts
new file mode 100644
index 00000000000..6d1e04a9a79
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/types/record-share-grant.type.ts
@@ -0,0 +1,8 @@
+/* @license Enterprise */
+
+import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+
+export type RecordShareGrant = Pick<
+ RecordShare,
+ 'recordId' | 'principalId' | 'accessLevel'
+>;
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts
index 44e4caf4504..c335d405e66 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/build-inherited-readability-condition.util.spec.ts
@@ -20,7 +20,7 @@ const countOccurrences = (haystack: string, needle: string): number =>
const build = (
parents: InheritedReadabilityParentCondition[],
- { isOpenWhenDetached }: { isOpenWhenDetached?: boolean } = {},
+ { isOpenWhenDetached = false }: { isOpenWhenDetached?: boolean } = {},
) =>
buildInheritedReadabilityCondition({
tableAlias: 'attachment',
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/evaluate-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/evaluate-row-access-policy.util.spec.ts
new file mode 100644
index 00000000000..bef301516bf
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/evaluate-row-access-policy.util.spec.ts
@@ -0,0 +1,215 @@
+/* @license Enterprise */
+
+import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
+import { FieldMetadataType, RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';
+import {
+ evaluateRowAccessPolicy,
+ type RowAccessEvaluationContext,
+ type RowAccessRecord,
+} from 'src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
+import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
+import {
+ type RecordShareExpressionTarget,
+ type RowAccessExpression,
+} from 'src/engine/twenty-orm/types/row-access-policy.type';
+
+const MEMBER_ID = 'member-1';
+
+const statusField = getFlatFieldMetadataMock({
+ objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,
+ type: FieldMetadataType.TEXT,
+ name: 'status',
+ universalIdentifier: 'company-status-field-universal-id',
+});
+
+const flatObjectMetadata = {
+ ...COMPANY_FLAT_OBJECT_MOCK,
+ fieldIds: [statusField.id],
+};
+
+const flatFieldMetadataMaps = addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: statusField,
+ flatEntityMaps:
+ createEmptyFlatEntityMaps() as FlatEntityMaps<FlatFieldMetadata>,
+});
+
+const shareTarget: RecordShareExpressionTarget = {
+ tableAlias: 'company',
+ objectMetadataId: flatObjectMetadata.id,
+ principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
+ accessLevels: [
+ RecordShareAccessLevel.READ,
+ RecordShareAccessLevel.READ_WRITE,
+ ],
+};
+
+const activeFilter: RowAccessExpression = {
+ kind: 'roleFilter',
+ tableAlias: 'company',
+ flatObjectMetadata,
+ recordFilter: { status: { eq: 'active' } },
+ condition: { sql: 'TRUE', parameters: {} },
+};
+
+const records: RowAccessRecord[] = [
+ { id: 'active-shared', status: 'active', deletedAt: null },
+ { id: 'active-private', status: 'active', deletedAt: null },
+ { id: 'archived-shared', status: 'archived', deletedAt: null },
+];
+
+const recordShares: RecordShareGrant[] = [
+ {
+ recordId: 'active-shared',
+ principalId: MEMBER_ID,
+ accessLevel: RecordShareAccessLevel.READ,
+ },
+ {
+ recordId: 'archived-shared',
+ principalId: MEMBER_ID,
+ accessLevel: RecordShareAccessLevel.READ_WRITE,
+ },
+ {
+ recordId: 'active-private',
+ principalId: EVERYONE_PRINCIPAL_ID,
+ accessLevel: RecordShareAccessLevel.NONE,
+ },
+];
+
+const buildContext = (
+ overrides: Partial<RowAccessEvaluationContext<RowAccessRecord>> = {},
+): RowAccessEvaluationContext<RowAccessRecord> => ({
+ flatFieldMetadataMaps,
+ shouldIgnoreSoftDeleteDefaultFilter: false,
+ fetchRecordShares: jest.fn(async ({ recordIds }) =>
+ recordShares.filter((recordShare) =>
+ recordIds.includes(recordShare.recordId),
+ ),
+ ),
+ resolveRecordIdsReadableThroughParents: jest.fn(
+ async () => new Set<string>(),
+ ),
+ ...overrides,
+});
+
+const evaluate = (expression: RowAccessExpression, context = buildContext()) =>
+ evaluateRowAccessPolicy({
+ policy: { kind: 'gated', expression },
+ records,
+ context,
+ });
+
+describe('evaluateRowAccessPolicy', () => {
+ it('admits every record when open and none when denied', async () => {
+ const context = buildContext();
+
+ expect(
+ await evaluateRowAccessPolicy({
+ policy: { kind: 'open' },
+ records,
+ context,
+ }),
+ ).toEqual(new Set(records.map((record) => record.id)));
+ expect(
+ await evaluateRowAccessPolicy({
+ policy: { kind: 'denied' },
+ records,
+ context,
+ }),
+ ).toEqual(new Set());
+ });
+
+ it('matches role filters on the record values', async () => {
+ expect(await evaluate(activeFilter)).toEqual(
+ new Set(['active-shared', 'active-private']),
+ );
+ });
+
+ it('admits records shared with the principals', async () => {
+ expect(await evaluate({ kind: 'recordShared', ...shareTarget })).toEqual(
+ new Set(['active-shared', 'archived-shared']),
+ );
+ });
+
+ it('keeps out records restricted for everyone', async () => {
+ expect(
+ await evaluate({ kind: 'recordNotRestricted', ...shareTarget }),
+ ).toEqual(new Set(['active-shared', 'archived-shared']));
+ });
+
+ it('only fetches shares for records still in play after an and', async () => {
+ const context = buildContext();
+
+ expect(
+ await evaluate(
+ {
+ kind: 'and',
+ operands: [activeFilter, { kind: 'recordShared', ...shareTarget }],
+ },
+ context,
+ ),
+ ).toEqual(new Set(['active-shared']));
+ expect(context.fetchRecordShares).toHaveBeenCalledWith({
+ objectMetadataId: flatObjectMetadata.id,
+ recordIds: ['active-shared', 'active-private'],
+ });
+ });
+
+ it('admits through either operand of an or, asking later operands only about records not yet admitted', async () => {
+ const context = buildContext();
+
+ expect(
+ await evaluate(
+ {
+ kind: 'or',
+ operands: [
+ {
+ kind: 'and',
+ operands: [
+ activeFilter,
+ { kind: 'recordNotRestricted', ...shareTarget },
+ ],
+ },
+ { kind: 'recordShared', ...shareTarget },
+ ],
+ },
+ context,
+ ),
+ ).toEqual(new Set(['active-shared', 'archived-shared']));
+ expect(context.fetchRecordShares).toHaveBeenLastCalledWith({
+ objectMetadataId: flatObjectMetadata.id,
+ recordIds: ['active-private', 'archived-shared'],
+ });
+ });
+
+ it('asks parents only about records not shared directly', async () => {
+ const context = buildContext({
+ resolveRecordIdsReadableThroughParents: jest.fn(
+ async () => new Set(['active-private']),
+ ),
+ });
+
+ expect(
+ await evaluate(
+ {
+ kind: 'inheritedReadability',
+ parents: [],
+ isOpenWhenDetached: false,
+ ...shareTarget,
+ },
+ context,
+ ),
+ ).toEqual(new Set(['active-shared', 'archived-shared', 'active-private']));
+ expect(context.resolveRecordIdsReadableThroughParents).toHaveBeenCalledWith(
+ expect.objectContaining({
+ records: [expect.objectContaining({ id: 'active-private' })],
+ }),
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts
index 91830476c69..e1ef209bbad 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/__tests__/resolve-record-ids-restricted-for-principals.util.spec.ts
@@ -112,6 +112,16 @@ describe('resolveRecordIdsRestrictedForPrincipals', () => {
});
it('should not let another everyone row lift a restriction', () => {
+ const applicationEveryoneShare: RecordShare = {
+ ...buildShare(
+ 'restricted',
+ EVERYONE_PRINCIPAL_ID,
+ RecordShareAccessLevel.FULL,
+ ),
+ rowCause: RecordShareRowCause.APPLICATION,
+ sourceId: 'application-1',
+ };
+
expect(
resolveRecordIdsRestrictedForPrincipals({
recordShares: [
@@ -120,15 +130,7 @@ describe('resolveRecordIdsRestrictedForPrincipals', () => {
EVERYONE_PRINCIPAL_ID,
RecordShareAccessLevel.NONE,
),
- {
- ...buildShare(
- 'restricted',
- EVERYONE_PRINCIPAL_ID,
- RecordShareAccessLevel.FULL,
- ),
- rowCause: RecordShareRowCause.APPLICATION,
- sourceId: 'application-1',
- },
+ applicationEveryoneShare,
],
principalIds: [EVERYONE_PRINCIPAL_ID, MEMBER_ID],
accessLevels: SELECT_ACCESS_LEVELS,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts
index d33a23b990b..6b489a5d630 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util.ts
@@ -4,7 +4,7 @@ import { type RecordShareAccessLevel } from 'twenty-shared/types';
import { type ObjectLiteral } from 'typeorm';
import {
- type RowAccessPolicy,
+ type CompiledRowAccessPolicy,
type SqlCondition,
} from 'src/engine/twenty-orm/types/row-access-policy.type';
import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';
@@ -16,14 +16,14 @@ export type InheritedReadabilityParentCondition =
joinColumnName: string;
parentTableAlias: string;
parentTableExpression: string;
- policy: RowAccessPolicy;
+ policy: CompiledRowAccessPolicy;
}
| {
kind: 'children';
childTableAlias: string;
childTableExpression: string;
childJoinColumnName: string;
- policy: RowAccessPolicy;
+ policy: CompiledRowAccessPolicy;
};
const buildChildLinkBoundCondition = ({
@@ -61,7 +61,7 @@ export const buildInheritedReadabilityCondition = ({
recordShareTableExpression,
principalIds,
accessLevels,
- isOpenWhenDetached = false,
+ isOpenWhenDetached,
}: {
tableAlias: string;
objectMetadataId: string;
@@ -69,7 +69,7 @@ export const buildInheritedReadabilityCondition = ({
recordShareTableExpression: string;
principalIds: string[];
accessLevels: RecordShareAccessLevel[];
- isOpenWhenDetached?: boolean;
+ isOpenWhenDetached: boolean;
}): SqlCondition => {
const parameters: ObjectLiteral = {};
const quotedTableAlias = escapeIdentifier(tableAlias);
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util.ts
similarity index 70%
rename from packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util.ts
rename to packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util.ts
index 1b6ff733858..3bbbe06b435 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util.ts
@@ -2,19 +2,18 @@
import { isNonEmptyArray } from 'twenty-shared/utils';
-import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';
import { resolveNamedPrincipalIds } from 'src/engine/core-modules/record-share/utils/resolve-named-principal-ids.util';
import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';
import {
+ type RowAccessExpression,
type RowAccessPolicyContext,
type RowAccessPolicyTarget,
- type SqlCondition,
} from 'src/engine/twenty-orm/types/row-access-policy.type';
-export const buildNamedRecordGrantCondition = (
- { subject, environment }: RowAccessPolicyContext,
+export const buildNamedRecordGrantExpression = (
+ { subject }: Pick<RowAccessPolicyContext, 'subject'>,
{ tableAlias, flatObjectMetadata, operationType }: RowAccessPolicyTarget,
-): SqlCondition | undefined => {
+): RowAccessExpression | undefined => {
const principalIds = resolveNamedPrincipalIds(subject);
const accessLevels = resolveRequiredRecordShareAccessLevels(operationType);
@@ -22,12 +21,12 @@ export const buildNamedRecordGrantCondition = (
return undefined;
}
- return buildRecordShareCondition({
+ return {
+ kind: 'recordShared',
+ isUncorrelated: true,
tableAlias,
- recordShareTableExpression: environment.recordShareTableExpression,
objectMetadataId: flatObjectMetadata.id,
principalIds,
accessLevels,
- isUncorrelated: true,
- });
+ };
};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
index 7c106776504..6fbf4be42a3 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/build-record-share-gate.util.ts
@@ -6,17 +6,12 @@ import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import { MAX_INHERITED_READABILITY_DEPTH } from 'src/engine/core-modules/record-share/constants/max-inherited-readability-depth.constant';
import { type InheritedReadabilityParent } from 'src/engine/core-modules/record-share/types/inherited-readability-parent.type';
-import {
- buildInheritedReadabilityCondition,
- type InheritedReadabilityParentCondition,
-} from 'src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util';
-import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';
-import { buildRecordShareExceptionCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util';
import { isOpenWhenDetachedObject } from 'src/engine/core-modules/record-share/utils/is-open-when-detached-object.util';
import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';
import { shouldEnforceRecordShareExceptions } from 'src/engine/core-modules/record-share/utils/should-enforce-record-share-exceptions.util';
import { resolveRequiredRecordShareAccessLevels } from 'src/engine/core-modules/record-share/utils/resolve-required-record-share-access-levels.util';
import {
+ type InheritedReadabilityParentExpression,
type RowAccessPolicy,
type RowAccessPolicyContext,
type RowAccessPolicyTarget,
@@ -98,13 +93,12 @@ const buildOwnRecordShareGate = (
return {
kind: 'gated',
- condition: buildRecordShareCondition({
+ expression: {
+ kind: 'recordShared',
tableAlias: target.tableAlias,
- recordShareTableExpression:
- context.environment.recordShareTableExpression,
objectMetadataId: target.flatObjectMetadata.id,
...principals,
- }),
+ },
};
};
@@ -120,13 +114,12 @@ const buildRecordShareExceptionGate = (
return {
kind: 'gated',
- condition: buildRecordShareExceptionCondition({
+ expression: {
+ kind: 'recordNotRestricted',
tableAlias: target.tableAlias,
- recordShareTableExpression:
- context.environment.recordShareTableExpression,
objectMetadataId: target.flatObjectMetadata.id,
...principals,
- }),
+ },
};
};
@@ -176,33 +169,31 @@ const buildInheritedReadabilityGate = ({
return {
kind: 'gated',
- condition: buildInheritedReadabilityCondition({
+ expression: {
+ kind: 'inheritedReadability',
tableAlias,
objectMetadataId: flatObjectMetadata.id,
+ ...principals,
+ isOpenWhenDetached,
parents: parents.map((parent) =>
- buildInheritedReadabilityParentCondition({
+ buildInheritedReadabilityParentExpression({
context,
target,
parent,
buildParentPolicy,
}),
),
- recordShareTableExpression:
- context.environment.recordShareTableExpression,
- ...principals,
- isOpenWhenDetached,
- }),
+ },
};
};
-const buildInheritedReadabilityParentCondition = ({
- context,
+const buildInheritedReadabilityParentExpression = ({
target: { tableAlias, operationType, depth },
parent,
buildParentPolicy,
}: RecordShareGateArgs & {
parent: InheritedReadabilityParent;
-}): InheritedReadabilityParentCondition => {
+}): InheritedReadabilityParentExpression => {
if (parent.kind === 'column') {
const parentTableAlias = `${tableAlias}_${parent.joinColumnName}`;
@@ -210,9 +201,7 @@ const buildInheritedReadabilityParentCondition = ({
kind: 'column',
joinColumnName: parent.joinColumnName,
parentTableAlias,
- parentTableExpression: context.environment.resolveTableExpression(
- parent.parentFlatObjectMetadata.id,
- ),
+ parentFlatObjectMetadata: parent.parentFlatObjectMetadata,
policy: buildParentPolicy({
tableAlias: parentTableAlias,
flatObjectMetadata: parent.parentFlatObjectMetadata,
@@ -227,10 +216,8 @@ const buildInheritedReadabilityParentCondition = ({
return {
kind: 'children',
childTableAlias,
- childTableExpression: context.environment.resolveTableExpression(
- parent.childFlatObjectMetadata.id,
- ),
childJoinColumnName: parent.childJoinColumnName,
+ childFlatObjectMetadata: parent.childFlatObjectMetadata,
policy: buildParentPolicy({
tableAlias: childTableAlias,
flatObjectMetadata: parent.childFlatObjectMetadata,
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util.ts
new file mode 100644
index 00000000000..a2c9893217d
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util.ts
@@ -0,0 +1,188 @@
+/* @license Enterprise */
+
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';
+import { resolveRecordIdsRestrictedForPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util';
+import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import {
+ type RowAccessExpression,
+ type RowAccessPolicy,
+} from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { isRecordMatchingRLSRowLevelPermissionPredicate } from 'src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util';
+
+export type RowAccessRecord = { id: string } & Record<string, unknown>;
+
+type InheritedReadabilityExpression = Extract<
+ RowAccessExpression,
+ { kind: 'inheritedReadability' }
+>;
+
+export type RowAccessEvaluationContext<TRecord extends RowAccessRecord> = {
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+ shouldIgnoreSoftDeleteDefaultFilter: boolean;
+ fetchRecordShares: (args: {
+ objectMetadataId: string;
+ recordIds: string[];
+ }) => Promise<RecordShareGrant[]>;
+ // Parents live in other tables, so whoever holds the records resolves them
+ resolveRecordIdsReadableThroughParents: (args: {
+ expression: InheritedReadabilityExpression;
+ records: TRecord[];
+ }) => Promise<Set<string>>;
+};
+
+// The in-memory counterpart of compileRowAccessPolicy: both read the same
+// policy, so a record admitted by a query is admitted here and vice versa
+export const evaluateRowAccessPolicy = async <TRecord extends RowAccessRecord>({
+ policy,
+ records,
+ context,
+}: {
+ policy: RowAccessPolicy;
+ records: TRecord[];
+ context: RowAccessEvaluationContext<TRecord>;
+}): Promise<Set<string>> => {
+ switch (policy.kind) {
+ case 'open':
+ return new Set(records.map((record) => record.id));
+ case 'denied':
+ return new Set();
+ case 'gated':
+ return evaluateRowAccessExpression({
+ expression: policy.expression,
+ records,
+ context,
+ });
+ default:
+ return assertUnreachable(policy);
+ }
+};
+
+const evaluateRowAccessExpression = async <TRecord extends RowAccessRecord>({
+ expression,
+ records,
+ context,
+}: {
+ expression: RowAccessExpression;
+ records: TRecord[];
+ context: RowAccessEvaluationContext<TRecord>;
+}): Promise<Set<string>> => {
+ if (records.length === 0) {
+ return new Set();
+ }
+
+ const recordIds = records.map((record) => record.id);
+
+ switch (expression.kind) {
+ case 'and': {
+ let admittedRecords = records;
+
+ for (const operand of expression.operands) {
+ const admittedIds = await evaluateRowAccessExpression({
+ expression: operand,
+ records: admittedRecords,
+ context,
+ });
+
+ admittedRecords = admittedRecords.filter((record) =>
+ admittedIds.has(record.id),
+ );
+ }
+
+ return new Set(admittedRecords.map((record) => record.id));
+ }
+ case 'or': {
+ const admittedIds = new Set<string>();
+
+ for (const operand of expression.operands) {
+ const remainingRecords = records.filter(
+ (record) => !admittedIds.has(record.id),
+ );
+ const operandAdmittedIds = await evaluateRowAccessExpression({
+ expression: operand,
+ records: remainingRecords,
+ context,
+ });
+
+ for (const admittedId of operandAdmittedIds) {
+ admittedIds.add(admittedId);
+ }
+ }
+
+ return admittedIds;
+ }
+ case 'roleFilter': {
+ const matchingRecordIds = records
+ .filter((record) =>
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record,
+ filter: expression.recordFilter,
+ flatObjectMetadata: expression.flatObjectMetadata,
+ flatFieldMetadataMaps: context.flatFieldMetadataMaps,
+ shouldIgnoreSoftDeleteDefaultFilter:
+ context.shouldIgnoreSoftDeleteDefaultFilter,
+ }),
+ )
+ .map((record) => record.id);
+
+ return new Set(matchingRecordIds);
+ }
+ case 'recordShared': {
+ const sharedRecordIds = resolveRecordIdsSharedWithPrincipals({
+ recordShares: await context.fetchRecordShares({
+ objectMetadataId: expression.objectMetadataId,
+ recordIds,
+ }),
+ principalIds: expression.principalIds,
+ accessLevels: expression.accessLevels,
+ });
+
+ const admittedRecordIds = recordIds.filter((id) =>
+ sharedRecordIds.has(id),
+ );
+
+ return new Set(admittedRecordIds);
+ }
+ case 'recordNotRestricted': {
+ const restrictedRecordIds = resolveRecordIdsRestrictedForPrincipals({
+ recordShares: await context.fetchRecordShares({
+ objectMetadataId: expression.objectMetadataId,
+ recordIds,
+ }),
+ principalIds: expression.principalIds,
+ accessLevels: expression.accessLevels,
+ });
+
+ const admittedRecordIds = recordIds.filter(
+ (id) => !restrictedRecordIds.has(id),
+ );
+
+ return new Set(admittedRecordIds);
+ }
+ case 'inheritedReadability': {
+ const sharedRecordIds = await evaluateRowAccessExpression({
+ expression: {
+ kind: 'recordShared',
+ tableAlias: expression.tableAlias,
+ objectMetadataId: expression.objectMetadataId,
+ principalIds: expression.principalIds,
+ accessLevels: expression.accessLevels,
+ },
+ records,
+ context,
+ });
+ const readableThroughParentIds =
+ await context.resolveRecordIdsReadableThroughParents({
+ expression,
+ records: records.filter((record) => !sharedRecordIds.has(record.id)),
+ });
+
+ return new Set([...sharedRecordIds, ...readableThroughParentIds]);
+ }
+ default:
+ return assertUnreachable(expression);
+ }
+};
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts
index 9f05ec547de..a0bf6f2a09a 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-restricted-for-principals.util.ts
@@ -3,7 +3,7 @@
import { EVERYONE_PRINCIPAL_ID } from 'twenty-shared/constants';
import { type RecordShareAccessLevel } from 'twenty-shared/types';
-import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';
import { resolveRecordIdsSharedWithPrincipals } from 'src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util';
// Mirrors buildRecordShareExceptionCondition for records already in memory
@@ -12,7 +12,7 @@ export const resolveRecordIdsRestrictedForPrincipals = ({
principalIds,
accessLevels,
}: {
- recordShares: RecordShare[];
+ recordShares: RecordShareGrant[];
principalIds: string[];
accessLevels: RecordShareAccessLevel[];
}): Set<string> => {
diff --git a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts
index eff44f61040..c89e1c54e3b 100644
--- a/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/record-share/utils/resolve-record-ids-shared-with-principals.util.ts
@@ -2,14 +2,14 @@
import { type RecordShareAccessLevel } from 'twenty-shared/types';
-import { type RecordShare } from 'src/engine/core-modules/record-share/types/record-share.type';
+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';
export const resolveRecordIdsSharedWithPrincipals = ({
recordShares,
principalIds,
accessLevels,
}: {
- recordShares: RecordShare[];
+ recordShares: RecordShareGrant[];
principalIds: string[];
accessLevels: RecordShareAccessLevel[];
}): Set<string> =>
diff --git a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts
index fd4a24d14c5..58cb1f1aa02 100644
--- a/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/webhook/jobs/__tests__/call-webhook-jobs.job.spec.ts
@@ -61,6 +61,8 @@ describe('webhook mandatory visibility', () => {
]) {
getOrRecompute.mockResolvedValue({
flatObjectMetadataMaps,
+ flatFieldMetadataMapsOrm: maps,
+ featureFlagsMap: {},
flatWebhookMaps: {
...maps,
byUniversalIdentifier: {
diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts
index 51bfef2fcd3..292cea9a361 100644
--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts
+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts
@@ -118,8 +118,6 @@ describe('ObjectRecordEventPublisher', () => {
getRepository: jest.Mock;
};
- const companyObjectMetadata: FlatObjectMetadata = COMPANY_FLAT_OBJECT_MOCK;
-
const companyNameField = getFlatFieldMetadataMock({
objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,
type: FieldMetadataType.TEXT,
@@ -129,9 +127,29 @@ describe('ObjectRecordEventPublisher', () => {
workspaceId,
});
- const mockFlatFieldMetadataMaps = buildFlatFieldMetadataMaps([
- companyNameField,
- ]);
+ const rowLevelPermissionFilteredFields = [
+ 'status',
+ 'assigneeId',
+ 'locale',
+ ].map((name) =>
+ getFlatFieldMetadataMock({
+ objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,
+ type: FieldMetadataType.TEXT,
+ name,
+ label: name,
+ universalIdentifier: `company-${name}-field-universal-id`,
+ workspaceId,
+ }),
+ );
+
+ const companyFields = [companyNameField, ...rowLevelPermissionFilteredFields];
+
+ const companyObjectMetadata: FlatObjectMetadata = {
+ ...COMPANY_FLAT_OBJECT_MOCK,
+ fieldIds: companyFields.map((field) => field.id),
+ };
+
+ const mockFlatFieldMetadataMaps = buildFlatFieldMetadataMaps(companyFields);
const mockUserWorkspaceRoleMap: Record<string, string> = {
[userWorkspaceId]: roleId,
@@ -218,6 +236,8 @@ describe('ObjectRecordEventPublisher', () => {
},
flatFieldMetadataMaps:
overrides.flatFieldMetadataMaps ?? mockFlatFieldMetadataMaps,
+ flatFieldMetadataMapsOrm:
+ overrides.flatFieldMetadataMaps ?? mockFlatFieldMetadataMaps,
userWorkspaceRoleMap:
overrides.userWorkspaceRoleMap ?? mockUserWorkspaceRoleMap,
rolesPermissions: overrides.rolesPermissions ?? mockRolesPermissions,
diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
index 93deb209b7d..fa75592349f 100644
--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
@@ -6,12 +6,10 @@ import {
} from 'twenty-shared/constants';
import { type ObjectRecordEvent } from 'twenty-shared/database-events';
import {
- FeatureFlagKey,
Nullable,
ObjectRecord,
type ObjectsPermissions,
type ObjectsPermissionsByRoleId,
- type RecordGqlOperationFilter,
type RecordGqlOperationSignature,
} from 'twenty-shared/types';
import {
@@ -39,7 +37,6 @@ import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metada
import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';
import { RecordAccessPolicyService } from 'src/engine/core-modules/record-share/services/record-access-policy.service';
import { type EventRecordAccessGate } from 'src/engine/core-modules/record-share/types/event-record-access-gate.type';
-import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';
import { omitInheritedReadabilityChildRecords } from 'src/engine/core-modules/record-share/utils/omit-inherited-readability-child-records.util';
import { omitRestrictedFieldsFromEvent } from 'src/engine/core-modules/record-share/utils/omit-restricted-fields-from-event.util';
import { EventStreamService } from 'src/engine/subscriptions/event-stream.service';
@@ -69,7 +66,6 @@ type StreamPermissionsContext = {
rolesPermissions: ObjectsPermissionsByRoleId;
roleIdsWithAllRecordsAccess: string[];
flatApplicationMaps: FlatApplicationCacheMaps;
- isRecordSharingEnabled: boolean;
};
@Injectable()
@@ -187,20 +183,6 @@ export class ObjectRecordEventPublisher {
return;
}
- const objectPermissions =
- objectsPermissions[workspaceEventBatch.objectMetadata.id];
- // The access gate then admits only the records named for the subscriber
- // beyond their role and row filter
- const isGrantBeyondRoleAllowed = isRecordGrantBeyondRoleAllowed({
- flatObjectMetadata: workspaceEventBatch.objectMetadata,
- operationType: 'select',
- isRecordSharingEnabled: permissionsContext.isRecordSharingEnabled,
- });
-
- if (!objectPermissions?.canReadObjectRecords && !isGrantBeyondRoleAllowed) {
- return;
- }
-
const objectNameSingular = workspaceEventBatch.objectMetadata.nameSingular;
if (
@@ -226,16 +208,6 @@ export class ObjectRecordEventPublisher {
}),
};
- const subscriberRLSFilter = isGrantBeyondRoleAllowed
- ? null
- : this.buildSubscriberRLSFilter(
- subscriberAuthContext,
- roleIds,
- workspaceEventBatch.objectMetadata,
- permissionsContext,
- flatWorkspaceMemberMaps,
- );
-
const admittedRecordIds =
await eventRecordAccessGate.resolveAdmittedRecordIds(
this.buildSubscriberRowAccessPolicySubject({
@@ -247,7 +219,13 @@ export class ObjectRecordEventPublisher {
}),
);
- const restrictedFields = objectPermissions?.restrictedFields ?? {};
+ if (admittedRecordIds.size === 0) {
+ return;
+ }
+
+ const restrictedFields =
+ objectsPermissions[workspaceEventBatch.objectMetadata.id]
+ ?.restrictedFields ?? {};
for (const event of workspaceEventBatch.events) {
const { action } = parseEventNameOrThrow(workspaceEventBatch.name);
@@ -282,7 +260,6 @@ export class ObjectRecordEventPublisher {
const matchedQueryIds = this.getMatchingObjectRecordQueryIds({
queries: streamData.queries,
event: filteredEvent,
- subscriberRLSFilter,
objectMetadata: workspaceEventBatch.objectMetadata,
flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,
});
@@ -466,33 +443,6 @@ export class ObjectRecordEventPublisher {
return computePermissionIntersection(allRolePermissions);
}
- private buildSubscriberRLSFilter(
- subscriberAuthContext: SerializableAuthContext,
- roleIds: string[],
- objectMetadata: FlatObjectMetadata,
- permissionsContext: {
- flatRowLevelPermissionPredicateMaps: FlatRowLevelPermissionPredicateMaps;
- flatRowLevelPermissionPredicateGroupMaps: FlatRowLevelPermissionPredicateGroupMaps;
- flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
- },
- flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps,
- ): RecordGqlOperationFilter | null {
- const workspaceMember = isDefined(subscriberAuthContext.workspaceMemberId)
- ? flatWorkspaceMemberMaps.byId[subscriberAuthContext.workspaceMemberId]
- : undefined;
-
- return buildRowLevelPermissionRecordFilter({
- flatRowLevelPermissionPredicateMaps:
- permissionsContext.flatRowLevelPermissionPredicateMaps,
- flatRowLevelPermissionPredicateGroupMaps:
- permissionsContext.flatRowLevelPermissionPredicateGroupMaps,
- flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,
- objectMetadata,
- roleIds,
- workspaceMember,
- });
- }
-
private buildWorkspaceMemberIdByUserId(
flatWorkspaceMemberMaps: FlatWorkspaceMemberMaps,
): Map<string, string> {
@@ -567,13 +517,20 @@ export class ObjectRecordEventPublisher {
isDefined(objectMetadata.applicationId) &&
subscriberAuthContext.applicationId === objectMetadata.applicationId,
resolveRowLevelPermissionRecordFilter: (objectMetadata) => {
- const recordFilter = this.buildSubscriberRLSFilter(
- subscriberAuthContext,
- roleIds,
+ const recordFilter = buildRowLevelPermissionRecordFilter({
+ flatRowLevelPermissionPredicateMaps:
+ permissionsContext.flatRowLevelPermissionPredicateMaps,
+ flatRowLevelPermissionPredicateGroupMaps:
+ permissionsContext.flatRowLevelPermissionPredicateGroupMaps,
+ flatFieldMetadataMaps: permissionsContext.flatFieldMetadataMaps,
objectMetadata,
- permissionsContext,
- flatWorkspaceMemberMaps,
- );
+ roleIds,
+ workspaceMember: isDefined(subscriberAuthContext.workspaceMemberId)
+ ? flatWorkspaceMemberMaps.byId[
+ subscriberAuthContext.workspaceMemberId
+ ]
+ : undefined,
+ });
return isDefined(recordFilter) && Object.keys(recordFilter).length > 0
? recordFilter
@@ -585,13 +542,11 @@ export class ObjectRecordEventPublisher {
private getMatchingObjectRecordQueryIds({
queries,
event,
- subscriberRLSFilter,
objectMetadata,
flatFieldMetadataMaps,
}: {
queries: Record<string, RecordOrMetadataGqlOperationSignature>;
event: ObjectRecordSubscriptionEvent;
- subscriberRLSFilter: RecordGqlOperationFilter | null;
objectMetadata: FlatObjectMetadata;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
}): string[] {
@@ -606,7 +561,6 @@ export class ObjectRecordEventPublisher {
this.isQueryMatchingObjectRecordEvent({
operationSignature,
event,
- subscriberRLSFilter,
objectMetadata,
flatFieldMetadataMaps,
})
@@ -621,13 +575,11 @@ export class ObjectRecordEventPublisher {
private isQueryMatchingObjectRecordEvent({
operationSignature,
event,
- subscriberRLSFilter,
objectMetadata,
flatFieldMetadataMaps,
}: {
operationSignature: RecordGqlOperationSignature;
event: ObjectRecordSubscriptionEvent;
- subscriberRLSFilter: RecordGqlOperationFilter | null;
objectMetadata: FlatObjectMetadata;
flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
}): boolean {
@@ -650,20 +602,6 @@ export class ObjectRecordEventPublisher {
event.action === DatabaseEventAction.DELETED ||
event.action === DatabaseEventAction.RESTORED;
- if (
- isDefined(subscriberRLSFilter) &&
- Object.keys(subscriberRLSFilter).length > 0 &&
- !isRecordMatchingRLSRowLevelPermissionPredicate({
- record: deliveredRecord,
- filter: subscriberRLSFilter,
- flatObjectMetadata: objectMetadata,
- flatFieldMetadataMaps,
- shouldIgnoreSoftDeleteDefaultFilter,
- })
- ) {
- return false;
- }
-
const queryFilter = operationSignature.variables?.filter ?? {};
if (Object.keys(queryFilter).length === 0) {
@@ -697,7 +635,6 @@ export class ObjectRecordEventPublisher {
rolesPermissions,
roleIdsWithAllRecordsAccess,
flatApplicationMaps,
- featureFlagsMap,
} = await this.workspaceCacheService.getOrRecompute(workspaceId, [
'flatRowLevelPermissionPredicateMaps',
'flatRowLevelPermissionPredicateGroupMaps',
@@ -706,7 +643,6 @@ export class ObjectRecordEventPublisher {
'rolesPermissions',
'roleIdsWithAllRecordsAccess',
'flatApplicationMaps',
- 'featureFlagsMap',
]);
return {
@@ -717,9 +653,6 @@ export class ObjectRecordEventPublisher {
rolesPermissions,
roleIdsWithAllRecordsAccess,
flatApplicationMaps,
- isRecordSharingEnabled:
- featureFlagsMap[FeatureFlagKey.IS_RECORD_LEVEL_SHARING_ENABLED] ??
- false,
};
}
}
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 4eb5fc06084..e58e7b2beec 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
@@ -38,13 +38,23 @@ import { type InheritedReadabilityColumnParent } from 'src/engine/core-modules/r
import { type InheritedReadabilityParent } from 'src/engine/core-modules/record-share/types/inherited-readability-parent.type';
import { type InheritedReadabilityParentLink } from 'src/engine/core-modules/record-share/types/inherited-readability-parent-link.type';
import {
+ type RowAccessExpression,
type RowAccessPolicy,
+ type RowAccessCompilationEnvironment,
type RowAccessPolicyEnvironment,
type RowAccessPolicySubject,
+ type SqlCondition,
} from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { compileRowAccessExpression } from 'src/engine/twenty-orm/utils/compile-row-access-policy.util';
import { resolveRecordShareGateKind } from 'src/engine/core-modules/record-share/utils/resolve-record-share-gate-kind.util';
import { buildRowAccessPolicy } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';
-import { buildNamedRecordGrantCondition } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util';
+import { type RecordShareGrant } from 'src/engine/core-modules/record-share/types/record-share-grant.type';
+import {
+ evaluateRowAccessPolicy,
+ type RowAccessEvaluationContext,
+ type RowAccessRecord,
+} from 'src/engine/core-modules/record-share/utils/evaluate-row-access-policy.util';
+import { isRowAccessExpressionReadingRoleFilter } from 'src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util';
import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';
import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';
import { formatData } from 'src/engine/twenty-orm/utils/format-data.util';
@@ -1056,9 +1066,13 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
updatedColumns: insertedColumns,
});
- this.validateRLSPredicatesForWrittenRecords(
- this.formatResult<ObjectRecord[]>(formattedRecords),
- );
+ validateRLSPredicatesForRecords({
+ records: this.formatResult<ObjectRecord[]>(formattedRecords),
+ objectMetadata: this.options.flatObjectMetadata,
+ internalContext: this.options.internalContext,
+ authContext: this.options.authContext,
+ shouldBypassPermissionChecks: this.options.shouldBypassPermissionChecks,
+ });
await this.validateInheritedParentsAreWritableOrThrow({
writtenRecords: formattedRecords,
@@ -1213,13 +1227,11 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
}
await this.validateRLSPredicatesForUpdatedRecords(
- this.formatResult<ObjectRecord[]>(
- setColumnsByInputIndex.flatMap((setColumns, index) =>
- rawBeforeByInputIndex[index].map((record) => ({
- ...record,
- ...setColumns,
- })),
- ),
+ setColumnsByInputIndex.flatMap((setColumns, index) =>
+ rawBeforeByInputIndex[index].map((rawRecordBefore) => ({
+ rawRecordBefore,
+ setColumns,
+ })),
),
);
@@ -1700,9 +1712,10 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
if (kind === 'update' && isDefined(setColumns)) {
await this.validateRLSPredicatesForUpdatedRecords(
- this.formatResult<ObjectRecord[]>(
- recordsBefore.map((record) => ({ ...record, ...setColumns })),
- ),
+ recordsBefore.map((rawRecordBefore) => ({
+ rawRecordBefore,
+ setColumns,
+ })),
);
}
@@ -1910,83 +1923,121 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
});
}
- // A record shared by name for editing stays editable whatever the row
- // filter of the role says, as the row access policy let it through
+ // An update must not move a record out of the update policy. Records it
+ // did not admit before are left to the update query, which skips them
private async validateRLSPredicatesForUpdatedRecords(
- records: ObjectRecord[],
+ updates: {
+ rawRecordBefore: ObjectRecord;
+ setColumns: Record<string, unknown>;
+ }[],
): Promise<void> {
- const recordIdsGrantedForUpdate =
- await this.findRecordIdsGrantedForUpdateByName(
- records.map((record) => record.id).filter(isDefined),
- );
+ if (this.options.shouldBypassPermissionChecks) {
+ return;
+ }
- this.validateRLSPredicatesForWrittenRecords(
- records.filter(
- (record) =>
- !isDefined(record.id) || !recordIdsGrantedForUpdate.has(record.id),
- ),
- 'Updated record does not satisfy row-level security constraints of your current role',
- );
- }
+ const policy = this.buildRowAccessPolicy({
+ subject: this.resolveRowAccessPolicySubject(),
+ operationType: 'update',
+ });
- private async findRecordIdsGrantedForUpdateByName(
- recordIds: string[],
- ): Promise<Set<string>> {
+ // Without a role filter the policy reads nothing an update can change:
+ // shares are keyed by id and parents are checked on their own
if (
- this.options.shouldBypassPermissionChecks ||
- recordIds.length === 0 ||
- !isRecordGrantBeyondRoleAllowed({
- flatObjectMetadata: this.options.flatObjectMetadata,
- operationType: 'update',
- isRecordSharingEnabled: this.isRecordSharingEnabled,
- })
+ policy.kind !== 'gated' ||
+ !isRowAccessExpressionReadingRoleFilter(policy.expression)
) {
- return new Set();
+ return;
}
- const tableAlias = this.options.tableShape.nameSingular;
- const namedRecordGrantCondition = buildNamedRecordGrantCondition(
- {
- subject: this.resolveRowAccessPolicySubject(),
- environment: this.resolveRowAccessPolicyEnvironment(),
- },
- {
- tableAlias,
- flatObjectMetadata: this.options.flatObjectMetadata,
- operationType: 'update',
- depth: 0,
- },
+ const context = this.buildWriteRowAccessEvaluationContext(
+ updates.map(({ rawRecordBefore }) => String(rawRecordBefore.id)),
);
+ const evaluate = (records: ObjectRecord[]) =>
+ evaluateRowAccessPolicy({
+ policy,
+ records: this.formatResult<ObjectRecord[]>(records).filter(
+ (record): record is RowAccessRecord => isNonEmptyString(record.id),
+ ),
+ context,
+ });
- if (!isDefined(namedRecordGrantCondition)) {
- return new Set();
+ const admittedRecordIdsBefore = await evaluate(
+ updates.map(({ rawRecordBefore }) => rawRecordBefore),
+ );
+ const admittedRecordIdsAfter = await evaluate(
+ updates
+ .filter(({ rawRecordBefore }) =>
+ admittedRecordIdsBefore.has(String(rawRecordBefore.id)),
+ )
+ .map(({ rawRecordBefore, setColumns }) => ({
+ ...rawRecordBefore,
+ ...setColumns,
+ })),
+ );
+
+ if (
+ [...admittedRecordIdsBefore].some((id) => !admittedRecordIdsAfter.has(id))
+ ) {
+ throw new TwentyOrmException(
+ 'Updated record does not satisfy row-level security constraints of your current role',
+ TwentyOrmExceptionCode.RLS_VALIDATION_FAILED,
+ );
}
+ }
- const grantedRecords = await this.buildIdsEventSnapshotQueryBuilder(
- recordIds,
- )
- .select(['id'])
- .andWhere(
- namedRecordGrantCondition.sql,
- namedRecordGrantCondition.parameters,
- )
- .getMany<ObjectRecord>({ noFormatting: true });
+ private buildWriteRowAccessEvaluationContext(
+ recordIds: string[],
+ ): RowAccessEvaluationContext<RowAccessRecord> {
+ const recordShareGrantsByObjectMetadataId = new Map<
+ string,
+ Promise<RecordShareGrant[]>
+ >();
+
+ return {
+ flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,
+ shouldIgnoreSoftDeleteDefaultFilter: false,
+ fetchRecordShares: async ({
+ objectMetadataId,
+ recordIds: requestedRecordIds,
+ }) => {
+ const recordShareGrants =
+ recordShareGrantsByObjectMetadataId.get(objectMetadataId) ??
+ this.findRecordShareGrants({ objectMetadataId, recordIds });
+
+ recordShareGrantsByObjectMetadataId.set(
+ objectMetadataId,
+ recordShareGrants,
+ );
- return new Set(grantedRecords.map((record) => String(record.id)));
+ const requestedRecordIdSet = new Set(requestedRecordIds);
+
+ return (await recordShareGrants).filter((recordShareGrant) =>
+ requestedRecordIdSet.has(recordShareGrant.recordId),
+ );
+ },
+ // Writes check parents before and after through
+ // validateInheritedParentsAreWritableOrThrow, so this branch only has to
+ // leave the rest of the policy to decide
+ resolveRecordIdsReadableThroughParents: async ({ records }) =>
+ new Set(records.map((record) => record.id)),
+ };
}
- private validateRLSPredicatesForWrittenRecords(
- records: ObjectRecord[],
- errorMessage?: string,
- ): void {
- validateRLSPredicatesForRecords({
- records,
- objectMetadata: this.options.flatObjectMetadata,
- internalContext: this.options.internalContext,
- authContext: this.options.authContext,
- shouldBypassPermissionChecks: this.options.shouldBypassPermissionChecks,
- ...(isDefined(errorMessage) ? { errorMessage } : {}),
- });
+ private async findRecordShareGrants({
+ objectMetadataId,
+ recordIds,
+ }: {
+ objectMetadataId: string;
+ recordIds: string[];
+ }): Promise<RecordShareGrant[]> {
+ if (recordIds.length === 0) {
+ return [];
+ }
+
+ return this.executeRaw<RecordShareGrant>(
+ `SELECT "recordId", "principalId", "accessLevel" FROM ${this.resolveRowAccessPolicyEnvironment().recordShareTableExpression} WHERE "objectMetadataId" = :objectMetadataId AND "recordId" = ANY(:recordIds) AND "deletedAt" IS NULL`,
+ { objectMetadataId, recordIds },
+ );
}
private emitMutationEvent({
@@ -2163,7 +2214,11 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return;
case 'gated':
- this.addConditionForAlias({ queryBuilder, alias, ...policy.condition });
+ this.addConditionForAlias({
+ queryBuilder,
+ alias,
+ ...this.compileRowAccessExpression(policy.expression),
+ });
return;
default:
@@ -2171,6 +2226,47 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
}
}
+ // Records already in hand, deleted ones included, filtered by a policy;
+ // the alias must be the one the policy was built with
+ async findRecordIdsAdmittedByRowAccessPolicy({
+ recordIds,
+ policy,
+ tableAlias = this.options.tableShape.nameSingular,
+ }: {
+ recordIds: string[];
+ policy: RowAccessPolicy;
+ tableAlias?: string;
+ }): Promise<Set<string>> {
+ if (recordIds.length === 0 || policy.kind === 'denied') {
+ return new Set();
+ }
+
+ if (policy.kind === 'open') {
+ return new Set(recordIds);
+ }
+
+ const condition = this.compileRowAccessExpression(policy.expression);
+ const admittedRecords = await this.buildBypassingEventSelectQueryBuilder(
+ tableAlias,
+ )
+ .where({ id: In(recordIds) })
+ .withDeleted()
+ .select(['id'])
+ .andWhere(condition.sql, condition.parameters)
+ .getMany<ObjectRecord>({ noFormatting: true });
+
+ return new Set(admittedRecords.map((record) => String(record.id)));
+ }
+
+ private compileRowAccessExpression(
+ expression: RowAccessExpression,
+ ): SqlCondition {
+ return compileRowAccessExpression({
+ expression,
+ environment: this.resolveRowAccessPolicyEnvironment(),
+ });
+ }
+
// Whether the role alone permits the operation, regardless of any record
// grant that may reach beyond it
isObjectOperationPermittedByRole(operationType: OperationType): boolean {
@@ -2260,7 +2356,8 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
};
}
- private resolveRowAccessPolicyEnvironment(): RowAccessPolicyEnvironment {
+ private resolveRowAccessPolicyEnvironment(): RowAccessPolicyEnvironment &
+ RowAccessCompilationEnvironment {
return {
flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,
flatObjectMetadataMaps:
diff --git a/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts
index da891d76d9f..719c056a411 100644
--- a/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/types/row-access-policy.type.ts
@@ -3,6 +3,7 @@ import { type ObjectLiteral } from 'typeorm';
import {
type ObjectsPermissions,
type RecordGqlOperationFilter,
+ type RecordShareAccessLevel,
} from 'twenty-shared/types';
import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
@@ -13,7 +14,60 @@ import { type WorkspaceRelationShape } from 'src/engine/twenty-orm/table-shape/t
export type SqlCondition = { sql: string; parameters: ObjectLiteral };
+// One description of who may access which rows, compiled to SQL for queries
+// and evaluated on records in memory for writes and events, so both always
+// decide the same way
+export type RowAccessExpression =
+ | { kind: 'and'; operands: RowAccessExpression[] }
+ | { kind: 'or'; operands: RowAccessExpression[] }
+ | {
+ kind: 'roleFilter';
+ tableAlias: string;
+ flatObjectMetadata: FlatObjectMetadata;
+ recordFilter: RecordGqlOperationFilter;
+ condition: SqlCondition;
+ }
+ | ({
+ kind: 'recordShared';
+ // Compiled as a grant list read once, so it can be ORed with an indexed filter
+ isUncorrelated?: boolean;
+ } & RecordShareExpressionTarget)
+ | ({ kind: 'recordNotRestricted' } & RecordShareExpressionTarget)
+ | ({
+ kind: 'inheritedReadability';
+ parents: InheritedReadabilityParentExpression[];
+ isOpenWhenDetached: boolean;
+ } & RecordShareExpressionTarget);
+
+export type RecordShareExpressionTarget = {
+ tableAlias: string;
+ objectMetadataId: string;
+ principalIds: string[];
+ accessLevels: RecordShareAccessLevel[];
+};
+
+export type InheritedReadabilityParentExpression =
+ | {
+ kind: 'column';
+ joinColumnName: string;
+ parentTableAlias: string;
+ parentFlatObjectMetadata: FlatObjectMetadata;
+ policy: RowAccessPolicy;
+ }
+ | {
+ kind: 'children';
+ childTableAlias: string;
+ childJoinColumnName: string;
+ childFlatObjectMetadata: FlatObjectMetadata;
+ policy: RowAccessPolicy;
+ };
+
export type RowAccessPolicy =
+ | { kind: 'open' }
+ | { kind: 'denied' }
+ | { kind: 'gated'; expression: RowAccessExpression };
+
+export type CompiledRowAccessPolicy =
| { kind: 'open' }
| { kind: 'denied' }
| { kind: 'gated'; condition: SqlCondition };
@@ -32,9 +86,12 @@ export type RowAccessPolicySubject = {
export type RowAccessPolicyEnvironment = {
flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ isRecordSharingEnabled: boolean;
+};
+
+export type RowAccessCompilationEnvironment = {
recordShareTableExpression: string;
resolveTableExpression: (objectMetadataId: string) => string;
- isRecordSharingEnabled: boolean;
};
export type RowAccessPolicyContext = {
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
index 0fb2d6bff94..a4429d65cc9 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-row-access-policy.util.spec.ts
@@ -9,10 +9,12 @@ import {
import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import {
+ type RowAccessCompilationEnvironment,
type RowAccessPolicyEnvironment,
type RowAccessPolicySubject,
} from 'src/engine/twenty-orm/types/row-access-policy.type';
import { buildRowAccessPolicy } from 'src/engine/twenty-orm/utils/build-row-access-policy.util';
+import { compileRowAccessPolicy } from 'src/engine/twenty-orm/utils/compile-row-access-policy.util';
import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';
import { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';
@@ -54,7 +56,8 @@ const person = buildObject({
readability: MetadataReadability.PRIVATE,
});
-const environment: RowAccessPolicyEnvironment = {
+const environment: RowAccessPolicyEnvironment &
+ RowAccessCompilationEnvironment = {
flatFieldMetadataMaps: { byId: {} } as never,
flatObjectMetadataMaps: { byId: {} } as never,
recordShareTableExpression: '"workspace"."recordShare"',
@@ -63,6 +66,16 @@ const environment: RowAccessPolicyEnvironment = {
isRecordSharingEnabled: false,
};
+const buildCompiledRowAccessPolicy = (
+ args: Parameters<typeof buildRowAccessPolicy>[0] & {
+ environment: typeof environment;
+ },
+) =>
+ compileRowAccessPolicy({
+ policy: buildRowAccessPolicy(args),
+ environment: args.environment,
+ });
+
const readEverything: RowAccessPolicySubject = {
isSystemContext: false,
objectsPermissions: undefined,
@@ -76,7 +89,7 @@ const build = (
subject: RowAccessPolicySubject,
flatObjectMetadata: FlatObjectMetadata,
) =>
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject,
environment,
tableAlias: flatObjectMetadata.nameSingular,
@@ -125,7 +138,7 @@ describe('buildRowAccessPolicy', () => {
(readability) => {
for (const operationType of ['select', 'update', 'delete'] as const) {
expect(
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject: {
...readEverything,
isSystemContext: true,
@@ -163,7 +176,7 @@ describe('buildRowAccessPolicy', () => {
id: 'company',
readability: MetadataReadability.OPEN,
});
- const policy = buildRowAccessPolicy({
+ const policy = buildCompiledRowAccessPolicy({
subject: readEverything,
environment: { ...environment, isRecordSharingEnabled: true },
tableAlias: 'company',
@@ -181,7 +194,7 @@ describe('buildRowAccessPolicy', () => {
it('lifts the restrictions of an OPEN object for a subject with access to all records', () => {
expect(
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject: { ...readEverything, canAccessAllRecords: true },
environment: { ...environment, isRecordSharingEnabled: true },
tableAlias: 'note',
@@ -200,7 +213,7 @@ describe('buildRowAccessPolicy', () => {
it('keeps an OPEN system object open when record sharing is enabled', () => {
expect(
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject: readEverything,
environment: { ...environment, isRecordSharingEnabled: true },
tableAlias: 'note',
@@ -213,7 +226,7 @@ describe('buildRowAccessPolicy', () => {
it('leaves an OPEN object open to inserts when record sharing is enabled', () => {
expect(
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject: readEverything,
environment: { ...environment, isRecordSharingEnabled: true },
tableAlias: 'note',
@@ -234,7 +247,7 @@ describe('buildRowAccessPolicy', () => {
subject: RowAccessPolicySubject,
operationType: 'select' | 'update' | 'delete' = 'select',
) =>
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject,
environment: sharingEnvironment,
tableAlias: 'company',
@@ -316,7 +329,7 @@ describe('buildRowAccessPolicy', () => {
it('keeps the role limits when the object restricts sharing to the role', () => {
expect(
- buildRowAccessPolicy({
+ buildCompiledRowAccessPolicy({
subject: withoutObjectPermission,
environment: sharingEnvironment,
tableAlias: 'company',
@@ -412,7 +425,7 @@ describe('buildRowAccessPolicy', () => {
},
},
]);
- const policy = buildRowAccessPolicy({
+ const policy = buildCompiledRowAccessPolicy({
subject: readEverything,
environment,
tableAlias: 'attachment',
@@ -428,7 +441,7 @@ describe('buildRowAccessPolicy', () => {
);
it('keeps private records gated regardless of the sharing UI flag', () => {
- const policy = buildRowAccessPolicy({
+ const policy = buildCompiledRowAccessPolicy({
subject: readEverything,
environment,
tableAlias: 'person',
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts
index d971b33d86e..ebb4ecb5dc6 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-record-matching-rls-row-level-permission-predicate.util.spec.ts
@@ -142,6 +142,16 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {
},
),
createMockFlatFieldMetadata('users-id', 'users', FieldMetadataType.ARRAY),
+ createMockFlatFieldMetadata(
+ 'created-by-id',
+ 'createdBy',
+ FieldMetadataType.ACTOR,
+ ),
+ createMockFlatFieldMetadata(
+ 'emails-id',
+ 'emails',
+ FieldMetadataType.EMAILS,
+ ),
];
const flatObjectMetadata = createMockFlatObjectMetadata(
@@ -161,6 +171,15 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {
},
companyId: 'company-1',
users: ['user-1', 'user-2'],
+ createdBy: {
+ source: 'MANUAL',
+ name: 'Jane Doe',
+ workspaceMemberId: 'member-1',
+ },
+ emails: {
+ primaryEmail: '[email protected]',
+ additionalEmails: ['[email protected]'],
+ },
deletedAt: null,
id: 'record-1',
createdAt: new Date().toISOString(),
@@ -288,26 +307,154 @@ describe('isRecordMatchingRLSRowLevelPermissionPredicate', () => {
expect(result).toBe(false);
});
- it('matches composite address filters using at least one sub-field', () => {
- const result = isRecordMatchingRLSRowLevelPermissionPredicate({
- record: baseRecord,
- filter: {
- address: {
- addressStreet1: {
- eq: 'Main Street',
+ it.each([
+ ['London', false],
+ ['Paris', true],
+ ])(
+ 'requires every composite sub-field to match, as SQL does (city %s)',
+ (addressCity, expected) => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: {
+ address: {
+ addressStreet1: { eq: 'Main Street' },
+ addressCity: { eq: addressCity },
+ },
},
- addressCity: {
- eq: 'London',
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(expected);
+ },
+ );
+
+ it('never matches a composite sub-field it cannot read', () => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: {
+ address: {
+ addressCity: { eq: 'Paris' },
+ addressPlanet: { eq: 'Earth' },
},
+ } as RecordGqlOperationFilter,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(false);
+ });
+
+ it.each([
+ ['the creator', 'member-1', true],
+ ['another member', 'member-2', false],
+ ])(
+ 'matches an actor on its workspace member, for %s',
+ (_, workspaceMemberId, expected) => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: {
+ createdBy: { workspaceMemberId: { eq: workspaceMemberId } },
+ },
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(expected);
+ },
+ );
+
+ it('treats a null actor source as no constraint', () => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: {
+ createdBy: { source: null, name: { eq: 'Jane Doe' } },
+ } as RecordGqlOperationFilter,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(true);
+ });
+
+ it.each([
+ ['%jane.doe%', true],
+ ['%john%', false],
+ ])('matches additional emails like %s', (like, expected) => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: { emails: { additionalEmails: { like } } },
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(expected);
+ });
+
+ it('never lets a null JSON sub-field match a like pattern', () => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: {
+ ...baseRecord,
+ emails: { primaryEmail: '[email protected]', additionalEmails: null },
},
- },
- flatObjectMetadata,
- flatFieldMetadataMaps,
- });
+ filter: { emails: { additionalEmails: { like: '%null%' } } },
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(false);
+ });
- expect(result).toBe(true);
+ it('matches address coordinates', () => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: {
+ ...baseRecord,
+ address: { ...baseRecord.address, addressLat: 48.85 },
+ },
+ filter: {
+ address: { addressLat: { gte: 48 } },
+ } as RecordGqlOperationFilter,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(true);
});
+ it('treats null and empty sub-field filters as no constraint', () => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: baseRecord,
+ filter: {
+ name: { firstName: null, lastName: { eq: 'Doe' } },
+ address: { addressLat: {}, addressCity: { eq: 'Paris' } },
+ } as RecordGqlOperationFilter,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(true);
+ });
+
+ it.each([
+ ['createdBy', { context: { is: 'NULL' } }, true],
+ ['createdBy', { context: { is: 'NOT_NULL' } }, false],
+ ['address', { addressLat: { is: 'NULL' } }, true],
+ ['address', { addressCity: { eq: 'Paris' } }, false],
+ ['name', { firstName: { is: 'NULL' } }, true],
+ ])(
+ 'reads a null %s as null sub-fields for %j',
+ (fieldName, subFieldFilter, expected) => {
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: { ...baseRecord, [fieldName]: null },
+ filter: { [fieldName]: subFieldFilter } as RecordGqlOperationFilter,
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ }),
+ ).toBe(expected);
+ },
+ );
+
it('supports relation join column filters', () => {
const result = isRecordMatchingRLSRowLevelPermissionPredicate({
record: baseRecord,
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-row-access-expression-reading-role-filter.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-row-access-expression-reading-role-filter.util.spec.ts
new file mode 100644
index 00000000000..36268579ffe
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/is-row-access-expression-reading-role-filter.util.spec.ts
@@ -0,0 +1,52 @@
+/* @license Enterprise */
+
+import { RecordShareAccessLevel } from 'twenty-shared/types';
+
+import { COMPANY_FLAT_OBJECT_MOCK } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/company-flat-object.mock';
+import { type RowAccessExpression } from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { isRowAccessExpressionReadingRoleFilter } from 'src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util';
+
+const recordShared: RowAccessExpression = {
+ kind: 'recordShared',
+ tableAlias: 'company',
+ objectMetadataId: COMPANY_FLAT_OBJECT_MOCK.id,
+ principalIds: ['member-1'],
+ accessLevels: [RecordShareAccessLevel.READ_WRITE],
+};
+
+const roleFilter: RowAccessExpression = {
+ kind: 'roleFilter',
+ tableAlias: 'company',
+ flatObjectMetadata: COMPANY_FLAT_OBJECT_MOCK,
+ recordFilter: { name: { eq: 'Acme' } },
+ condition: { sql: 'TRUE', parameters: {} },
+};
+
+describe('isRowAccessExpressionReadingRoleFilter', () => {
+ it('finds a role filter nested in and/or', () => {
+ expect(
+ isRowAccessExpressionReadingRoleFilter({
+ kind: 'or',
+ operands: [{ kind: 'and', operands: [roleFilter] }, recordShared],
+ }),
+ ).toBe(true);
+ });
+
+ it('ignores expressions reading only shares', () => {
+ expect(
+ isRowAccessExpressionReadingRoleFilter({
+ kind: 'and',
+ operands: [
+ recordShared,
+ { ...recordShared, kind: 'recordNotRestricted' },
+ {
+ ...recordShared,
+ kind: 'inheritedReadability',
+ parents: [],
+ isOpenWhenDetached: false,
+ },
+ ],
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts
index 8b2fc53fa85..0b250d39841 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-row-access-policy.util.ts
@@ -1,16 +1,15 @@
import { isMetadataWritePermitted } from 'src/engine/twenty-orm/utils/is-metadata-write-permitted.util';
import { isDefined } from 'twenty-shared/utils';
-import { buildNamedRecordGrantCondition } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-condition.util';
+import { buildNamedRecordGrantExpression } from 'src/engine/core-modules/record-share/utils/build-named-record-grant-expression.util';
import { buildRecordShareGate } from 'src/engine/core-modules/record-share/utils/build-record-share-gate.util';
import { isRecordGrantBeyondRoleAllowed } from 'src/engine/core-modules/record-share/utils/is-record-grant-beyond-role-allowed.util';
import {
+ type RowAccessExpression,
type RowAccessPolicy,
type RowAccessPolicyContext,
type RowAccessPolicyTarget,
- type SqlCondition,
} from 'src/engine/twenty-orm/types/row-access-policy.type';
-import { combineSqlConditions } from 'src/engine/twenty-orm/utils/combine-sql-conditions.util';
import { isObjectOperationPermitted } from 'src/engine/twenty-orm/utils/is-object-operation-permitted.util';
import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';
@@ -38,12 +37,12 @@ export const buildRowAccessPolicy = ({
return { kind: 'denied' };
}
- const namedRecordGrantCondition = isRecordGrantBeyondRoleAllowed({
+ const namedRecordGrant = isRecordGrantBeyondRoleAllowed({
flatObjectMetadata: target.flatObjectMetadata,
operationType: target.operationType,
isRecordSharingEnabled: environment.isRecordSharingEnabled,
})
- ? buildNamedRecordGrantCondition(context, target)
+ ? buildNamedRecordGrantExpression(context, target)
: undefined;
if (
@@ -54,8 +53,8 @@ export const buildRowAccessPolicy = ({
objectsPermissions: subject.objectsPermissions,
})
) {
- return isDefined(namedRecordGrantCondition)
- ? { kind: 'gated', condition: namedRecordGrantCondition }
+ return isDefined(namedRecordGrant)
+ ? { kind: 'gated', expression: namedRecordGrant }
: { kind: 'denied' };
}
@@ -70,35 +69,35 @@ export const buildRowAccessPolicy = ({
return { kind: 'denied' };
}
- const rolePredicate = buildRolePredicate(context, target);
- const conditions = [
- rolePredicate,
- recordShareGate.kind === 'gated' ? recordShareGate.condition : undefined,
+ const roleFilter = buildRoleFilterExpression(context, target);
+ const operands = [
+ roleFilter,
+ recordShareGate.kind === 'gated' ? recordShareGate.expression : undefined,
].filter(isDefined);
- if (conditions.length === 0) {
+ if (operands.length === 0) {
return { kind: 'open' };
}
- // The share gate already admits named grants, so only a role predicate
- // keeps one out and needs the grant as an alternative
- if (isDefined(rolePredicate) && isDefined(namedRecordGrantCondition)) {
+ // The share gate already admits named grants, so only a role filter keeps
+ // one out and needs the grant as an alternative
+ if (isDefined(roleFilter) && isDefined(namedRecordGrant)) {
return {
kind: 'gated',
- condition: combineSqlConditions(
- [combineSqlConditions(conditions), namedRecordGrantCondition],
- 'OR',
- ),
+ expression: {
+ kind: 'or',
+ operands: [{ kind: 'and', operands }, namedRecordGrant],
+ },
};
}
- return { kind: 'gated', condition: combineSqlConditions(conditions) };
+ return { kind: 'gated', expression: { kind: 'and', operands } };
};
-const buildRolePredicate = (
+const buildRoleFilterExpression = (
{ subject, environment }: RowAccessPolicyContext,
{ tableAlias, flatObjectMetadata }: RowAccessPolicyTarget,
-): SqlCondition | undefined => {
+): RowAccessExpression | undefined => {
const recordFilter =
subject.resolveRowLevelPermissionRecordFilter(flatObjectMetadata);
@@ -106,12 +105,23 @@ const buildRolePredicate = (
return undefined;
}
- return (
- renderRowLevelPermissionFilterToSql({
- recordFilter,
- tableAlias,
- objectMetadata: flatObjectMetadata,
- flatFieldMetadataMaps: environment.flatFieldMetadataMaps,
- }) ?? undefined
- );
+ const condition = renderRowLevelPermissionFilterToSql({
+ recordFilter,
+ tableAlias,
+ objectMetadata: flatObjectMetadata,
+ flatFieldMetadataMaps: environment.flatFieldMetadataMaps,
+ });
+
+ // A filter whose predicates all cancel out restricts nothing
+ if (condition === null) {
+ return undefined;
+ }
+
+ return {
+ kind: 'roleFilter',
+ tableAlias,
+ flatObjectMetadata,
+ recordFilter,
+ condition,
+ };
};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/compile-row-access-policy.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/compile-row-access-policy.util.ts
new file mode 100644
index 00000000000..7d95fbb72c7
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/compile-row-access-policy.util.ts
@@ -0,0 +1,99 @@
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { buildInheritedReadabilityCondition } from 'src/engine/core-modules/record-share/utils/build-inherited-readability-condition.util';
+import { buildRecordShareCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-condition.util';
+import { buildRecordShareExceptionCondition } from 'src/engine/core-modules/record-share/utils/build-record-share-exception-condition.util';
+import {
+ type CompiledRowAccessPolicy,
+ type RowAccessExpression,
+ type RowAccessPolicy,
+ type RowAccessCompilationEnvironment,
+ type SqlCondition,
+} from 'src/engine/twenty-orm/types/row-access-policy.type';
+import { combineSqlConditions } from 'src/engine/twenty-orm/utils/combine-sql-conditions.util';
+
+export const compileRowAccessPolicy = ({
+ policy,
+ environment,
+}: {
+ policy: RowAccessPolicy;
+ environment: RowAccessCompilationEnvironment;
+}): CompiledRowAccessPolicy =>
+ policy.kind === 'gated'
+ ? {
+ kind: 'gated',
+ condition: compileRowAccessExpression({
+ expression: policy.expression,
+ environment,
+ }),
+ }
+ : policy;
+
+export const compileRowAccessExpression = ({
+ expression,
+ environment,
+}: {
+ expression: RowAccessExpression;
+ environment: RowAccessCompilationEnvironment;
+}): SqlCondition => {
+ switch (expression.kind) {
+ case 'and':
+ case 'or':
+ return combineSqlConditions(
+ expression.operands.map((operand) =>
+ compileRowAccessExpression({ expression: operand, environment }),
+ ),
+ expression.kind === 'or' ? 'OR' : 'AND',
+ );
+ case 'roleFilter':
+ return expression.condition;
+ case 'recordShared':
+ return buildRecordShareCondition({
+ ...expression,
+ recordShareTableExpression: environment.recordShareTableExpression,
+ });
+ case 'recordNotRestricted':
+ return buildRecordShareExceptionCondition({
+ ...expression,
+ recordShareTableExpression: environment.recordShareTableExpression,
+ });
+ case 'inheritedReadability':
+ return buildInheritedReadabilityCondition({
+ tableAlias: expression.tableAlias,
+ objectMetadataId: expression.objectMetadataId,
+ principalIds: expression.principalIds,
+ accessLevels: expression.accessLevels,
+ isOpenWhenDetached: expression.isOpenWhenDetached,
+ recordShareTableExpression: environment.recordShareTableExpression,
+ parents: expression.parents.map((parent) =>
+ parent.kind === 'column'
+ ? {
+ kind: 'column',
+ joinColumnName: parent.joinColumnName,
+ parentTableAlias: parent.parentTableAlias,
+ parentTableExpression: environment.resolveTableExpression(
+ parent.parentFlatObjectMetadata.id,
+ ),
+ policy: compileRowAccessPolicy({
+ policy: parent.policy,
+ environment,
+ }),
+ }
+ : {
+ kind: 'children',
+ childTableAlias: parent.childTableAlias,
+ childJoinColumnName: parent.childJoinColumnName,
+ childTableExpression: environment.resolveTableExpression(
+ parent.childFlatObjectMetadata.id,
+ ),
+ policy: compileRowAccessPolicy({
+ policy: parent.policy,
+ environment,
+ }),
+ },
+ ),
+ });
+ default:
+ return assertUnreachable(expression);
+ }
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts
index 1f76bdf15d5..c9e6034962b 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-record-matching-rls-row-level-permission-predicate.util.ts
@@ -3,23 +3,17 @@
import { isObject } from '@sniptt/guards';
import {
FieldMetadataType,
- type ActorFilter,
- type AddressFilter,
type AndObjectRecordFilter,
type ArrayFilter,
type BooleanFilter,
type CurrencyFilter,
type DateFilter,
- type EmailsFilter,
type FloatFilter,
- type FullNameFilter,
type IsFilter,
type LeafObjectRecordFilter,
- type LinksFilter,
type MultiSelectFilter,
type NotObjectRecordFilter,
type OrObjectRecordFilter,
- type PhonesFilter,
type RatingFilter,
type RawJsonFilter,
type RecordGqlOperationFilter,
@@ -74,6 +68,115 @@ const isNotFilter = (
filter: RecordGqlOperationFilter,
): filter is NotObjectRecordFilter => 'not' in filter && !!filter.not;
+type SubFieldMatcher = (subFieldFilter: object, value: unknown) => boolean;
+
+const matchString: SubFieldMatcher = (subFieldFilter, value) =>
+ isMatchingStringFilter({
+ stringFilter: subFieldFilter as StringFilter,
+ value: value as string,
+ });
+
+const matchRawJson: SubFieldMatcher = (subFieldFilter, value) =>
+ isMatchingRawJsonFilter({
+ rawJsonFilter: subFieldFilter as RawJsonFilter,
+ value: value as string,
+ });
+
+const matchFloat: SubFieldMatcher = (subFieldFilter, value) =>
+ isMatchingFloatFilter({
+ floatFilter: subFieldFilter as FloatFilter,
+ value: value as number,
+ });
+
+const matchSelect: SubFieldMatcher = (subFieldFilter, value) =>
+ isMatchingSelectFilter({
+ selectFilter: subFieldFilter as SelectFilter,
+ value: value as string,
+ });
+
+const matchUuid: SubFieldMatcher = (subFieldFilter, value) =>
+ isMatchingUUIDFilter({
+ uuidFilter: subFieldFilter as UUIDFilter,
+ value: value as string,
+ });
+
+// Row-level predicates can target sub-fields the GraphQL filter types omit,
+// such as address coordinates, the actor context or the phone country code
+const SUB_FIELD_MATCHERS_BY_COMPOSITE_TYPE: Partial<
+ Record<FieldMetadataType, Record<string, SubFieldMatcher>>
+> = {
+ [FieldMetadataType.FULL_NAME]: {
+ firstName: matchString,
+ lastName: matchString,
+ },
+ [FieldMetadataType.ADDRESS]: {
+ addressStreet1: matchString,
+ addressStreet2: matchString,
+ addressCity: matchString,
+ addressState: matchString,
+ addressCountry: matchString,
+ addressPostcode: matchString,
+ addressLat: matchFloat,
+ addressLng: matchFloat,
+ },
+ [FieldMetadataType.LINKS]: {
+ primaryLinkLabel: matchString,
+ primaryLinkUrl: matchString,
+ secondaryLinks: matchRawJson,
+ },
+ [FieldMetadataType.ACTOR]: {
+ source: matchSelect,
+ name: matchString,
+ workspaceMemberId: matchUuid,
+ context: matchRawJson,
+ },
+ [FieldMetadataType.EMAILS]: {
+ primaryEmail: matchString,
+ additionalEmails: matchRawJson,
+ },
+ [FieldMetadataType.PHONES]: {
+ primaryPhoneNumber: matchString,
+ primaryPhoneCountryCode: matchString,
+ primaryPhoneCallingCode: matchString,
+ additionalPhones: matchRawJson,
+ },
+};
+
+// Sub-fields are ANDed as in SQL. An absent or empty sub-field filter is no
+// constraint, one this matcher cannot read never matches, and a null
+// sub-field, of a null composite too, only matches IS NULL
+const isMatchingCompositeFilter = ({
+ compositeFilter,
+ compositeValue,
+ subFieldMatchers,
+}: {
+ compositeFilter: Record<string, { is?: IsFilter } | null | undefined>;
+ compositeValue: Record<string, unknown> | null | undefined;
+ subFieldMatchers: Record<string, SubFieldMatcher>;
+}): boolean =>
+ Object.entries(compositeFilter).every(([subFieldName, subFieldFilter]) => {
+ if (
+ !isDefined(subFieldFilter) ||
+ Object.keys(subFieldFilter).length === 0
+ ) {
+ return true;
+ }
+
+ const isMatching = subFieldMatchers[subFieldName];
+
+ if (!isDefined(isMatching)) {
+ return false;
+ }
+
+ const value = compositeValue?.[subFieldName];
+
+ if (!isDefined(value)) {
+ return subFieldFilter.is === 'NULL';
+ }
+
+ return isMatching(subFieldFilter, value);
+ });
+
export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
record,
filter,
@@ -223,6 +326,17 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
);
}
+ const subFieldMatchers =
+ SUB_FIELD_MATCHERS_BY_COMPOSITE_TYPE[objectMetadataField.type];
+
+ if (isDefined(subFieldMatchers)) {
+ return isMatchingCompositeFilter({
+ compositeFilter: filterValue as Record<string, { is?: IsFilter }>,
+ compositeValue: record[filterKey],
+ subFieldMatchers,
+ });
+ }
+
const recordFieldValue = record[filterKey];
if (!isDefined(recordFieldValue)) {
@@ -275,65 +389,6 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
value: recordFieldValue,
});
}
- case FieldMetadataType.FULL_NAME: {
- const fullNameFilter = filterValue as FullNameFilter;
-
- return (
- (fullNameFilter.firstName === undefined ||
- isMatchingStringFilter({
- stringFilter: fullNameFilter.firstName,
- value: recordFieldValue.firstName,
- })) &&
- (fullNameFilter.lastName === undefined ||
- isMatchingStringFilter({
- stringFilter: fullNameFilter.lastName,
- value: recordFieldValue.lastName,
- }))
- );
- }
- case FieldMetadataType.ADDRESS: {
- const addressFilter = filterValue as AddressFilter;
-
- const keys = [
- 'addressStreet1',
- 'addressStreet2',
- 'addressCity',
- 'addressState',
- 'addressCountry',
- 'addressPostcode',
- ] as const;
-
- return keys.some((key) => {
- const value = addressFilter[key];
-
- if (value === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: value,
- value: recordFieldValue[key],
- });
- });
- }
- case FieldMetadataType.LINKS: {
- const linksFilter = filterValue as LinksFilter;
-
- const keys = ['primaryLinkLabel', 'primaryLinkUrl'] as const;
-
- return keys.some((key) => {
- const value = linksFilter[key];
-
- if (value === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: value,
- value: recordFieldValue[key],
- });
- });
- }
case FieldMetadataType.DATE:
case FieldMetadataType.DATE_TIME: {
return isMatchingDateFilter({
@@ -366,54 +421,6 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
value: recordFieldValue,
});
}
- case FieldMetadataType.ACTOR: {
- const actorFilter = filterValue as ActorFilter;
-
- if (isDefined(actorFilter.source)) {
- return isMatchingSelectFilter({
- selectFilter: actorFilter.source,
- value: recordFieldValue.source,
- });
- }
-
- return (
- actorFilter.name === undefined ||
- isMatchingStringFilter({
- stringFilter: actorFilter.name,
- value: recordFieldValue.name,
- })
- );
- }
- case FieldMetadataType.EMAILS: {
- const emailsFilter = filterValue as EmailsFilter;
-
- if (emailsFilter.primaryEmail === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: emailsFilter.primaryEmail,
- value: recordFieldValue.primaryEmail,
- });
- }
- case FieldMetadataType.PHONES: {
- const phonesFilter = filterValue as PhonesFilter;
-
- const keys: (keyof PhonesFilter)[] = ['primaryPhoneNumber'];
-
- return keys.some((key) => {
- const value = phonesFilter[key];
-
- if (value === undefined) {
- return false;
- }
-
- return isMatchingStringFilter({
- stringFilter: value,
- value: recordFieldValue[key],
- });
- });
- }
case FieldMetadataType.RELATION:
case FieldMetadataType.MORPH_RELATION: {
const isJoinColumn =
@@ -430,7 +437,7 @@ export const isRecordMatchingRLSRowLevelPermissionPredicate = ({
return isMatchingUUIDFilter({
uuidFilter: filterValue as UUIDFilter,
- value: recordFieldValue?.id ?? null,
+ value: recordFieldValue.id ?? null,
});
}
case FieldMetadataType.TS_VECTOR: {
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util.ts
new file mode 100644
index 00000000000..03d522dfccc
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-row-access-expression-reading-role-filter.util.ts
@@ -0,0 +1,25 @@
+/* @license Enterprise */
+
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { type RowAccessExpression } from 'src/engine/twenty-orm/types/row-access-policy.type';
+
+// Parent policies are left out: writes check parents on their own through
+// validateInheritedParentsAreWritableOrThrow
+export const isRowAccessExpressionReadingRoleFilter = (
+ expression: RowAccessExpression,
+): boolean => {
+ switch (expression.kind) {
+ case 'and':
+ case 'or':
+ return expression.operands.some(isRowAccessExpressionReadingRoleFilter);
+ case 'roleFilter':
+ return true;
+ case 'recordShared':
+ case 'recordNotRestricted':
+ case 'inheritedReadability':
+ return false;
+ default:
+ return assertUnreachable(expression);
+ }
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts
index 8f04e09c278..7de247f9b0b 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util.ts
@@ -239,6 +239,11 @@ const renderCompositeFieldCondition = (
const conditions = Object.entries(
filterValue as Record<string, Record<string, unknown>>,
).flatMap(([subFieldName, subFieldFilter]) => {
+ // An absent sub-field filter is no constraint, as for the in-memory matcher
+ if (!isDefined(subFieldFilter)) {
+ return [];
+ }
+
const isKnownSubField = compositeType.properties.some(
(property) => property.name === subFieldName,
);
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts
index 0df499aec9c..62c2c8f9b42 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util.ts
@@ -21,7 +21,6 @@ type ValidateRLSPredicatesForRecordsArgs<T extends ObjectLiteral> = {
internalContext: WorkspaceInternalContext;
authContext: WorkspaceAuthContext;
shouldBypassPermissionChecks: boolean;
- errorMessage?: string;
};
export const validateRLSPredicatesForRecords = <T extends ObjectLiteral>({
@@ -30,7 +29,6 @@ export const validateRLSPredicatesForRecords = <T extends ObjectLiteral>({
internalContext,
authContext,
shouldBypassPermissionChecks,
- errorMessage = 'Record does not satisfy row-level security constraints of your current role',
}: ValidateRLSPredicatesForRecordsArgs<T>): void => {
if (shouldBypassPermissionChecks) {
return;
@@ -56,7 +54,7 @@ export const validateRLSPredicatesForRecords = <T extends ObjectLiteral>({
if (!matchesRLS) {
throw new TwentyOrmException(
- errorMessage,
+ 'Record does not satisfy row-level security constraints of your current role',
TwentyOrmExceptionCode.RLS_VALIDATION_FAILED,
);
}