Skip to content

The open alternative to Salesforce, designed for AI.

fix(server): validate row level permission predicate values at write time (#23999)

Thomas Trompette0b77edf8ebbb
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/__tests__/flat-row-level-permission-predicate-validator.service.spec.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/__tests__/flat-row-level-permission-predicate-validator.service.spec.ts
new file mode 100644
index 00000000000..dbd423e15a4
--- /dev/null
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/__tests__/flat-row-level-permission-predicate-validator.service.spec.ts
@@ -0,0 +1,246 @@
+import {
+ FieldMetadataType,
+ RowLevelPermissionPredicateOperand,
+} from 'twenty-shared/types';
+
+import { FlatRowLevelPermissionPredicateValidatorService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-validator.service';
+
+const PREDICATE_UNIVERSAL_IDENTIFIER = '00000000-0000-4000-8000-0000000000a1';
+const FIELD_UNIVERSAL_IDENTIFIER = '00000000-0000-4000-8000-0000000000b1';
+const OBJECT_UNIVERSAL_IDENTIFIER = '00000000-0000-4000-8000-0000000000c1';
+const ROLE_UNIVERSAL_IDENTIFIER = '00000000-0000-4000-8000-0000000000d1';
+const RECORD_ID = '20202020-1c25-4d02-bf25-6aeccf7ea419';
+
+const mapsFrom = (
+ entities: { universalIdentifier: string; [key: string]: unknown }[],
+) => ({
+ byUniversalIdentifier: Object.fromEntries(
+ entities.map((entity) => [entity.universalIdentifier, entity]),
+ ),
+});
+
+const buildPredicate = ({
+ operand,
+ value,
+ workspaceMemberFieldMetadataUniversalIdentifier = null,
+}: {
+ operand: RowLevelPermissionPredicateOperand;
+ value: unknown;
+ workspaceMemberFieldMetadataUniversalIdentifier?: string | null;
+}) => ({
+ universalIdentifier: PREDICATE_UNIVERSAL_IDENTIFIER,
+ fieldMetadataUniversalIdentifier: FIELD_UNIVERSAL_IDENTIFIER,
+ objectMetadataUniversalIdentifier: OBJECT_UNIVERSAL_IDENTIFIER,
+ roleUniversalIdentifier: ROLE_UNIVERSAL_IDENTIFIER,
+ rowLevelPermissionPredicateGroupUniversalIdentifier: null,
+ operand,
+ value,
+ subFieldName: null,
+ workspaceMemberFieldMetadataUniversalIdentifier,
+});
+
+const relatedMaps = (fieldType: FieldMetadataType) => ({
+ flatRowLevelPermissionPredicateGroupMaps: mapsFrom([]),
+ flatFieldMetadataMaps: mapsFrom([
+ {
+ universalIdentifier: FIELD_UNIVERSAL_IDENTIFIER,
+ type: fieldType,
+ label: 'Account Owner',
+ },
+ ]),
+ flatObjectMetadataMaps: mapsFrom([
+ { universalIdentifier: OBJECT_UNIVERSAL_IDENTIFIER },
+ ]),
+ flatRoleMaps: mapsFrom([{ universalIdentifier: ROLE_UNIVERSAL_IDENTIFIER }]),
+});
+
+const buildCreationArgs = ({
+ fieldType,
+ operand,
+ value,
+ workspaceMemberFieldMetadataUniversalIdentifier = null,
+}: {
+ fieldType: FieldMetadataType;
+ operand: RowLevelPermissionPredicateOperand;
+ value: unknown;
+ workspaceMemberFieldMetadataUniversalIdentifier?: string | null;
+}) =>
+ ({
+ flatEntityToValidate: buildPredicate({
+ operand,
+ value,
+ workspaceMemberFieldMetadataUniversalIdentifier,
+ }),
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatRowLevelPermissionPredicateMaps: mapsFrom([]),
+ ...relatedMaps(fieldType),
+ },
+ }) as unknown as Parameters<
+ FlatRowLevelPermissionPredicateValidatorService['validateFlatRowLevelPermissionPredicateCreation']
+ >[0];
+
+const buildUpdateArgs = ({
+ fieldType,
+ operand,
+ value,
+ flatEntityUpdate,
+ workspaceMemberFieldMetadataUniversalIdentifier = null,
+}: {
+ fieldType: FieldMetadataType;
+ operand: RowLevelPermissionPredicateOperand;
+ value: unknown;
+ flatEntityUpdate: Record<string, unknown>;
+ workspaceMemberFieldMetadataUniversalIdentifier?: string | null;
+}) =>
+ ({
+ universalIdentifier: PREDICATE_UNIVERSAL_IDENTIFIER,
+ flatEntityUpdate,
+ optimisticFlatEntityMapsAndRelatedFlatEntityMaps: {
+ flatRowLevelPermissionPredicateMaps: mapsFrom([
+ buildPredicate({
+ operand,
+ value,
+ workspaceMemberFieldMetadataUniversalIdentifier,
+ }),
+ ]),
+ ...relatedMaps(fieldType),
+ },
+ }) as unknown as Parameters<
+ FlatRowLevelPermissionPredicateValidatorService['validateFlatRowLevelPermissionPredicateUpdate']
+ >[0];
+
+describe('FlatRowLevelPermissionPredicateValidatorService', () => {
+ let service: FlatRowLevelPermissionPredicateValidatorService;
+
+ beforeEach(() => {
+ service = new FlatRowLevelPermissionPredicateValidatorService();
+ });
+
+ describe('creation', () => {
+ it('should reject a relation value that resolves to no record id', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value: { direction: 'NEXT', amount: 30, unit: 'DAY' },
+ }),
+ );
+
+ expect(result.errors).toHaveLength(1);
+ });
+
+ it('should reject the object form of a relative date predicate', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.DATE,
+ operand: RowLevelPermissionPredicateOperand.IS_RELATIVE,
+ value: { direction: 'NEXT', amount: 30, unit: 'DAY' },
+ }),
+ );
+
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('NEXT_30_DAY');
+ });
+
+ it('should accept a valid predicate value', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value: { selectedRecordIds: [RECORD_ID] },
+ }),
+ );
+
+ expect(result.errors).toEqual([]);
+ });
+
+ it.each([[''], ['[]'], [[]]])(
+ 'should reject %p on an operand that expects a value',
+ (value) => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value,
+ }),
+ );
+
+ expect(result.errors).toHaveLength(1);
+ expect(result.errors[0].message).toContain('requires a value');
+ },
+ );
+
+ it.each([[null], [undefined]])(
+ 'should accept %p, a predicate whose value is not filled in yet',
+ (value) => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.TEXT,
+ operand: RowLevelPermissionPredicateOperand.CONTAINS,
+ value,
+ }),
+ );
+
+ expect(result.errors).toEqual([]);
+ },
+ );
+
+ it('should accept a value-less operand with no value', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS_NOT_EMPTY,
+ value: null,
+ }),
+ );
+
+ expect(result.errors).toEqual([]);
+ });
+
+ it('should skip validation when the value is resolved from the workspace member', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateCreation(
+ buildCreationArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value: null,
+ workspaceMemberFieldMetadataUniversalIdentifier:
+ FIELD_UNIVERSAL_IDENTIFIER,
+ }),
+ );
+
+ expect(result.errors).toEqual([]);
+ });
+ });
+
+ describe('update', () => {
+ it('should validate the retained value when workspace member resolution is cleared', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateUpdate(
+ buildUpdateArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value: { direction: 'NEXT', amount: 30, unit: 'DAY' },
+ workspaceMemberFieldMetadataUniversalIdentifier:
+ FIELD_UNIVERSAL_IDENTIFIER,
+ flatEntityUpdate: {
+ workspaceMemberFieldMetadataUniversalIdentifier: null,
+ },
+ }),
+ );
+
+ expect(result.errors).toHaveLength(1);
+ });
+
+ it('should not validate the value when it is not part of the update', () => {
+ const result = service.validateFlatRowLevelPermissionPredicateUpdate(
+ buildUpdateArgs({
+ fieldType: FieldMetadataType.RELATION,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value: { direction: 'NEXT', amount: 30, unit: 'DAY' },
+ flatEntityUpdate: { positionInRowLevelPermissionPredicateGroup: 2 },
+ }),
+ );
+
+ expect(result.errors).toEqual([]);
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-validator.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-validator.service.ts
index 388a4861776..b394a1a93dc 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-validator.service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-builder/validators/services/flat-row-level-permission-predicate-validator.service.ts
@@ -3,8 +3,22 @@
import { Injectable } from '@nestjs/common';
import { msg, t } from '@lingui/core/macro';
+import { isNonEmptyString } from '@sniptt/guards';
import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
-import { isDefined } from 'twenty-shared/utils';
+import {
+ type FieldMetadataType,
+ type RowLevelPermissionPredicateOperand,
+ type ViewFilterOperand,
+} from 'twenty-shared/types';
+import {
+ convertViewFilterValueToString,
+ getFilterTypeFromFieldType,
+ getFilterValueValidationIssue,
+ isDefined,
+ isRecordFilterOperandExpectingValue,
+ isRecordFilterValueValid,
+ jsonRelationFilterValueSchema,
+} from 'twenty-shared/utils';
import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
import { RowLevelPermissionPredicateExceptionCode } from 'src/engine/metadata-modules/row-level-permission-predicate/exceptions/row-level-permission-predicate.exception';
@@ -64,6 +78,19 @@ export class FlatRowLevelPermissionPredicateValidatorService {
message: t`Field metadata not found`,
userFriendlyMessage: msg`Field metadata not found`,
});
+ } else {
+ const invalidValueError = this.getInvalidValueError({
+ fieldType: fieldMetadata.type,
+ operand: flatPredicateToValidate.operand,
+ subFieldName: flatPredicateToValidate.subFieldName,
+ value: flatPredicateToValidate.value,
+ workspaceMemberFieldMetadataUniversalIdentifier:
+ flatPredicateToValidate.workspaceMemberFieldMetadataUniversalIdentifier,
+ });
+
+ if (isDefined(invalidValueError)) {
+ validationResult.errors.push(invalidValueError);
+ }
}
const objectMetadata = flatObjectMetadataMaps
@@ -240,6 +267,25 @@ export class FlatRowLevelPermissionPredicateValidatorService {
message: t`Field metadata not found`,
userFriendlyMessage: msg`Field metadata not found`,
});
+ } else if (
+ 'value' in flatEntityUpdate ||
+ 'operand' in flatEntityUpdate ||
+ 'fieldMetadataUniversalIdentifier' in flatEntityUpdate ||
+ 'subFieldName' in flatEntityUpdate ||
+ 'workspaceMemberFieldMetadataUniversalIdentifier' in flatEntityUpdate
+ ) {
+ const invalidValueError = this.getInvalidValueError({
+ fieldType: fieldMetadata.type,
+ operand: updatedPredicate.operand,
+ subFieldName: updatedPredicate.subFieldName,
+ value: updatedPredicate.value,
+ workspaceMemberFieldMetadataUniversalIdentifier:
+ updatedPredicate.workspaceMemberFieldMetadataUniversalIdentifier,
+ });
+
+ if (isDefined(invalidValueError)) {
+ validationResult.errors.push(invalidValueError);
+ }
}
const objectMetadata = flatObjectMetadataMaps
@@ -296,4 +342,106 @@ export class FlatRowLevelPermissionPredicateValidatorService {
return validationResult;
}
+
+ // A row level permission predicate compiles without a current record, so a
+ // relation value resolving only through isCurrentRecordSelected yields no
+ // record id and removes the restriction instead of matching nothing. View
+ // filters do resolve it, so this cannot live in the shared schema.
+ private getUnresolvableRelationError({
+ fieldType,
+ operand,
+ value,
+ }: {
+ fieldType: FieldMetadataType;
+ operand: RowLevelPermissionPredicateOperand;
+ value: unknown;
+ }) {
+ if (getFilterTypeFromFieldType(fieldType) !== 'RELATION') {
+ return undefined;
+ }
+
+ const stringifiedValue = convertViewFilterValueToString(value);
+
+ const relationValue =
+ jsonRelationFilterValueSchema.safeParse(stringifiedValue);
+
+ if (
+ !relationValue.success ||
+ relationValue.data.selectedRecordIds.length > 0 ||
+ relationValue.data.isCurrentWorkspaceMemberSelected === true
+ ) {
+ return undefined;
+ }
+
+ return {
+ code: RowLevelPermissionPredicateExceptionCode.INVALID_ROW_LEVEL_PERMISSION_PREDICATE_DATA,
+ message: t`Value "${stringifiedValue}" resolves to no record for operand "${operand}", the current record is not available to a row level permission predicate`,
+ userFriendlyMessage: msg`Predicate value is not valid for this operand`,
+ };
+ }
+
+ private getInvalidValueError({
+ fieldType,
+ operand,
+ subFieldName,
+ value,
+ workspaceMemberFieldMetadataUniversalIdentifier,
+ }: {
+ fieldType: FieldMetadataType;
+ operand: RowLevelPermissionPredicateOperand;
+ subFieldName: string | null | undefined;
+ value: unknown;
+ workspaceMemberFieldMetadataUniversalIdentifier: string | null | undefined;
+ }) {
+ if (isDefined(workspaceMemberFieldMetadataUniversalIdentifier)) {
+ return undefined;
+ }
+
+ const recordFilterOperand = operand as unknown as ViewFilterOperand;
+
+ if (
+ isRecordFilterOperandExpectingValue(recordFilterOperand) &&
+ !isRecordFilterValueValid({
+ operand: recordFilterOperand,
+ value: convertViewFilterValueToString(value),
+ })
+ ) {
+ return {
+ code: RowLevelPermissionPredicateExceptionCode.INVALID_ROW_LEVEL_PERMISSION_PREDICATE_DATA,
+ message: t`Operand "${operand}" requires a value, an empty predicate would remove the row restriction entirely`,
+ userFriendlyMessage: msg`Predicate is missing a value`,
+ };
+ }
+
+ const unresolvableRelationError = this.getUnresolvableRelationError({
+ fieldType,
+ operand,
+ value,
+ });
+
+ if (isDefined(unresolvableRelationError)) {
+ return unresolvableRelationError;
+ }
+
+ const issue = getFilterValueValidationIssue({
+ fieldType,
+ operand: recordFilterOperand,
+ subFieldName,
+ value,
+ });
+
+ if (!isDefined(issue)) {
+ return undefined;
+ }
+
+ const { stringifiedValue, filterType, hint } = issue;
+
+ return {
+ code: RowLevelPermissionPredicateExceptionCode.INVALID_ROW_LEVEL_PERMISSION_PREDICATE_DATA,
+ message: isNonEmptyString(hint)
+ ? t`Value "${stringifiedValue}" is not valid for operand "${operand}" on field type "${filterType}". ${hint}`
+ : t`Value "${stringifiedValue}" is not valid for operand "${operand}" on field type "${filterType}".`,
+ userFriendlyMessage: msg`Predicate value is not valid for this operand`,
+ };
+ }
}
diff --git a/packages/twenty-server/test/integration/graphql/suites/uncompilable-rls-predicate.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/uncompilable-rls-predicate.integration-spec.ts
new file mode 100644
index 00000000000..e8d7e4dc32d
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/suites/uncompilable-rls-predicate.integration-spec.ts
@@ -0,0 +1,130 @@
+import { randomUUID } from 'crypto';
+
+import { COMPANY_GQL_FIELDS } from 'test/integration/constants/company-gql-fields.constants';
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import {
+ type AccountOwnerRlsRoleSetup,
+ cleanupAccountOwnerRlsRole,
+ setupAccountOwnerRlsRole,
+ upsertAccountOwnerRlsPredicate,
+} from 'test/integration/graphql/utils/setup-account-owner-rls-role.util';
+
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const OWNED_COMPANY_ID = randomUUID();
+const FOREIGN_COMPANY_ID = randomUUID();
+const OWNED_COMPANY_NAME = 'Uncompilable RLS Owned Co';
+const FOREIGN_COMPANY_NAME = 'Uncompilable RLS Foreign Co';
+const PREDICATE_ID = randomUUID();
+
+const findCompanyIdsAsRestrictedRole = async (): Promise<string[]> => {
+ const response = await makeGraphqlAPIRequest(
+ findManyOperationFactory({
+ objectMetadataSingularName: 'company',
+ objectMetadataPluralName: 'companies',
+ gqlFields: 'id',
+ filter: { id: { in: [OWNED_COMPANY_ID, FOREIGN_COMPANY_ID] } },
+ }),
+ APPLE_JONY_MEMBER_ACCESS_TOKEN,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.companies.edges.map(
+ (edge: { node: { id: string } }) => edge.node.id,
+ );
+};
+
+describe('row-level permission predicates that compile to nothing', () => {
+ let rlsRole: AccountOwnerRlsRoleSetup;
+
+ beforeAll(async () => {
+ for (const { id, name, accountOwnerId } of [
+ {
+ id: OWNED_COMPANY_ID,
+ name: OWNED_COMPANY_NAME,
+ accountOwnerId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ },
+ {
+ id: FOREIGN_COMPANY_ID,
+ name: FOREIGN_COMPANY_NAME,
+ accountOwnerId: WORKSPACE_MEMBER_DATA_SEED_IDS.TIM,
+ },
+ ]) {
+ await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: COMPANY_GQL_FIELDS,
+ data: { id, name, accountOwnerId },
+ }),
+ );
+ }
+
+ rlsRole = await setupAccountOwnerRlsRole({
+ label: 'Uncompilable RLS Predicate Test Role',
+ description: 'Role for testing RLS predicates that compile to nothing',
+ });
+ });
+
+ afterAll(async () => {
+ await cleanupAccountOwnerRlsRole(rlsRole);
+
+ for (const recordId of [OWNED_COMPANY_ID, FOREIGN_COMPANY_ID]) {
+ await makeGraphqlAPIRequest(
+ destroyOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: 'id',
+ recordId,
+ }),
+ );
+ }
+ });
+
+ it('restricts records to the selected account owner', async () => {
+ await upsertAccountOwnerRlsPredicate({
+ setup: rlsRole,
+ predicateId: PREDICATE_ID,
+ value: { selectedRecordIds: [WORKSPACE_MEMBER_DATA_SEED_IDS.JONY] },
+ });
+
+ expect(await findCompanyIdsAsRestrictedRole()).toEqual([OWNED_COMPANY_ID]);
+ });
+
+ it('rejects a predicate selecting no record', async () => {
+ await upsertAccountOwnerRlsPredicate({
+ setup: rlsRole,
+ predicateId: PREDICATE_ID,
+ value: { selectedRecordIds: [] },
+ expectToFail: true,
+ });
+ });
+
+ it('rejects a predicate resolving only through the current record', async () => {
+ await upsertAccountOwnerRlsPredicate({
+ setup: rlsRole,
+ predicateId: PREDICATE_ID,
+ value: { selectedRecordIds: [], isCurrentRecordSelected: true },
+ expectToFail: true,
+ });
+ });
+
+ it('accepts a selection resolving to the current workspace member', async () => {
+ await upsertAccountOwnerRlsPredicate({
+ setup: rlsRole,
+ predicateId: PREDICATE_ID,
+ value: { selectedRecordIds: [], isCurrentWorkspaceMemberSelected: true },
+ });
+ });
+
+ it('rejects a predicate value that is not valid for its field type and operand', async () => {
+ await upsertAccountOwnerRlsPredicate({
+ setup: rlsRole,
+ predicateId: PREDICATE_ID,
+ value: { direction: 'NEXT', amount: 30, unit: 'DAY' },
+ expectToFail: true,
+ });
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/utils/setup-account-owner-rls-role.util.ts b/packages/twenty-server/test/integration/graphql/utils/setup-account-owner-rls-role.util.ts
new file mode 100644
index 00000000000..93c1086fe42
--- /dev/null
+++ b/packages/twenty-server/test/integration/graphql/utils/setup-account-owner-rls-role.util.ts
@@ -0,0 +1,144 @@
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { upsertRowLevelPermissionPredicates } from 'test/integration/metadata/suites/row-level-permission-predicate/utils/upsert-row-level-permission-predicates.util';
+import { createOneRole } from 'test/integration/metadata/suites/role/utils/create-one-role.util';
+import { deleteOneRole } from 'test/integration/metadata/suites/role/utils/delete-one-role.util';
+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { updateWorkspaceMemberRole } from 'test/integration/metadata/suites/role/utils/update-workspace-member-role.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import {
+ type RowLevelPermissionPredicateValue,
+ RowLevelPermissionPredicateOperand,
+} from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+export type AccountOwnerRlsRoleSetup = {
+ customRoleId: string;
+ originalMemberRoleId: string;
+ companyObjectMetadataId: string;
+ accountOwnerFieldMetadataId: string;
+};
+
+export const setupAccountOwnerRlsRole = async ({
+ label,
+ description,
+}: {
+ label: string;
+ description: string;
+}): Promise<AccountOwnerRlsRoleSetup> => {
+ const memberRole = await findOneRoleByLabel({ label: 'Member' });
+
+ const { data: roleData } = await createOneRole({
+ expectToFail: false,
+ input: {
+ label,
+ description,
+ icon: 'IconSettings',
+ canUpdateAllSettings: false,
+ canAccessAllTools: true,
+ canReadAllObjectRecords: true,
+ canUpdateAllObjectRecords: true,
+ canSoftDeleteAllObjectRecords: false,
+ canDestroyAllObjectRecords: false,
+ canBeAssignedToUsers: true,
+ canBeAssignedToAgents: false,
+ canBeAssignedToApiKeys: false,
+ },
+ });
+
+ const customRoleId = roleData?.createOneRole?.id;
+
+ jestExpectToBeDefined(customRoleId);
+
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 1000 } },
+ gqlFields: `
+ id
+ nameSingular
+ fieldsList {
+ id
+ name
+ }
+ `,
+ });
+
+ jestExpectToBeDefined(objects);
+
+ const companyObjectMetadata = objects.find(
+ (object) => object.nameSingular === 'company',
+ );
+
+ jestExpectToBeDefined(companyObjectMetadata);
+
+ const accountOwnerFieldMetadata = companyObjectMetadata.fieldsList?.find(
+ (field) => field.name === 'accountOwner',
+ );
+
+ jestExpectToBeDefined(accountOwnerFieldMetadata);
+
+ await updateWorkspaceMemberRole({
+ input: {
+ roleId: customRoleId,
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ },
+ expectToFail: false,
+ });
+
+ return {
+ customRoleId,
+ originalMemberRoleId: memberRole.id,
+ companyObjectMetadataId: companyObjectMetadata.id,
+ accountOwnerFieldMetadataId: accountOwnerFieldMetadata.id,
+ };
+};
+
+export const upsertAccountOwnerRlsPredicate = async ({
+ setup,
+ predicateId,
+ value,
+ expectToFail = false,
+}: {
+ setup: AccountOwnerRlsRoleSetup;
+ predicateId: string;
+ value: RowLevelPermissionPredicateValue;
+ expectToFail?: boolean;
+}) =>
+ upsertRowLevelPermissionPredicates({
+ expectToFail,
+ input: {
+ roleId: setup.customRoleId,
+ objectMetadataId: setup.companyObjectMetadataId,
+ predicates: [
+ {
+ id: predicateId,
+ fieldMetadataId: setup.accountOwnerFieldMetadataId,
+ operand: RowLevelPermissionPredicateOperand.IS,
+ value,
+ },
+ ],
+ predicateGroups: [],
+ },
+ });
+
+export const cleanupAccountOwnerRlsRole = async (
+ setup: Partial<AccountOwnerRlsRoleSetup> = {},
+): Promise<void> => {
+ if (isDefined(setup.originalMemberRoleId)) {
+ await updateWorkspaceMemberRole({
+ input: {
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ roleId: setup.originalMemberRoleId,
+ },
+ expectToFail: false,
+ });
+ }
+
+ if (isDefined(setup.customRoleId)) {
+ await deleteOneRole({
+ expectToFail: false,
+ input: { idToDelete: setup.customRoleId },
+ });
+ }
+};
diff --git a/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts b/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts
index de11a73893c..f0424f7654b 100644
--- a/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts
@@ -194,6 +194,27 @@ describe('getFilterValueSchema', () => {
ISSUE_23397_VALUE,
);
});
+
+ it.each([
+ '{"selectedRecordIds":[]}',
+ '[]',
+ '{"selectedRecordIds":[],"isCurrentWorkspaceMemberSelected":false}',
+ ])('should reject %s, an empty selection', (value) => {
+ expectRejected(
+ { filterType: 'RELATION', operand: ViewFilterOperand.IS },
+ value,
+ );
+ });
+
+ it.each([
+ '{"selectedRecordIds":[],"isCurrentWorkspaceMemberSelected":true}',
+ '{"selectedRecordIds":[],"isCurrentRecordSelected":true}',
+ ])('should accept %s, resolved at read time', (value) => {
+ expectAccepted(
+ { filterType: 'RELATION', operand: ViewFilterOperand.IS },
+ value,
+ );
+ });
});
describe('uuid', () => {
diff --git a/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts b/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts
index d707d9c7e64..f8f9d1c3238 100644
--- a/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts
@@ -32,13 +32,31 @@ type FilterValueSchemasMap = {
Partial<Record<ViewFilterOperand, z.ZodType>>;
};
+// The reader drops a relation filter resolving to no record id, which turns a
+// row level permission rule into no restriction at all rather than no match.
const relationFilterValueSchema = jsonRelationFilterValueSchema
.refine(
({ selectedRecordIds }) =>
strictArrayOfUuidOrVariableSchema.safeParse(selectedRecordIds).success,
'Expected selectedRecordIds to contain UUIDs or variables',
)
- .or(strictArrayOfUuidOrVariableSchema);
+ .refine(
+ ({
+ selectedRecordIds,
+ isCurrentWorkspaceMemberSelected,
+ isCurrentRecordSelected,
+ }) =>
+ selectedRecordIds.length > 0 ||
+ isCurrentWorkspaceMemberSelected === true ||
+ isCurrentRecordSelected === true,
+ 'Expected at least one selected record',
+ )
+ .or(
+ strictArrayOfUuidOrVariableSchema.refine(
+ (recordIds) => recordIds.length > 0,
+ 'Expected at least one selected record',
+ ),
+ );
// Mirrors normalizeSelectFilterValues: a value that is not JSON is a legacy scalar option.
const selectFilterValueSchema = nonEmptyStringFilterValueSchema.refine(