The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Validation rules (2/2): enforce rules on record writes (#26903)
Thomas Trompetteadf86da65401
diff --git a/packages/twenty-front/src/modules/side-panel/pages/record-creation-form/components/SidePanelRecordCreationFormPage.tsx b/packages/twenty-front/src/modules/side-panel/pages/record-creation-form/components/SidePanelRecordCreationFormPage.tsxindex a6a32fb7b02..f387f23dc14 100644--- a/packages/twenty-front/src/modules/side-panel/pages/record-creation-form/components/SidePanelRecordCreationFormPage.tsx+++ b/packages/twenty-front/src/modules/side-panel/pages/record-creation-form/components/SidePanelRecordCreationFormPage.tsx@@ -15,6 +15,10 @@ import { type ObjectRecord } from '@/object-record/types/ObjectRecord';import { recordCreationFormDraftComponentState } from '@/side-panel/pages/record-creation-form/states/recordCreationFormDraftComponentState';import { recordCreationFormRequestComponentState } from '@/side-panel/pages/record-creation-form/states/recordCreationFormRequestComponentState';import { SidePanelFooter } from '@/ui/layout/side-panel/components/SidePanelFooter';+import { useValidationRules } from '@/validation-rules/hooks/useValidationRules';+import { type DraftValidationRuleViolation } from '@/validation-rules/types/DraftValidationRuleViolation';+import { buildValidationRuleFieldDescriptors } from '@/validation-rules/utils/buildValidationRuleFieldDescriptors';+import { computeDraftValidationRuleViolations } from '@/validation-rules/utils/computeDraftValidationRuleViolations';import { useAtomComponentState } from '@/ui/utilities/state/jotai/hooks/useAtomComponentState';import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';import { useState } from 'react';@@ -34,11 +38,30 @@ const StyledContainer = styled.div`height: 100%;`;+const StyledValidationRuleError = styled.div`+ background: ${themeCssVariables.background.danger};+ border-radius: ${themeCssVariables.border.radius.sm};+ color: ${themeCssVariables.font.color.danger};+ font-size: ${themeCssVariables.font.size.sm};+ padding: ${themeCssVariables.spacing[2]} ${themeCssVariables.spacing[3]};+`;++const StyledValidationRuleErrors = styled.div`+ display: flex;+ flex-direction: column;+ flex-shrink: 0;+ gap: ${themeCssVariables.spacing[2]};+ max-height: 30%;+ overflow-y: auto;+ padding: ${themeCssVariables.spacing[2]} ${themeCssVariables.spacing[3]};+`;+const StyledContent = styled.div`display: flex;flex: 1;flex-direction: column;gap: ${themeCssVariables.spacing[4]};+ min-height: 0;overflow-y: auto;padding: ${themeCssVariables.spacing[4]};`;@@ -83,6 +106,11 @@ const SidePanelRecordCreationForm = ({useAtomComponentState(recordCreationFormDraftComponentState);const [isSubmitting, setIsSubmitting] = useState(false);+ const [validationRuleViolations, setValidationRuleViolations] = useState<+ DraftValidationRuleViolation[]+ >([]);++ const { validationRules } = useValidationRules({ objectMetadataId });const currentFocusId = useAtomStateValue(currentFocusIdSelector);const draftRecord = recordCreationFormDraft ?? initialDraftRecord;@@ -91,18 +119,43 @@ const SidePanelRecordCreationForm = ({objectMetadataItem,});- const handleFieldValueChange = (gqlFieldName: string, value: JsonValue) => {+ const computeViolations = (draftRecordToCheck: Partial<ObjectRecord>) =>+ computeDraftValidationRuleViolations({+ validationRules,+ draftRecord: draftRecordToCheck,+ fields: buildValidationRuleFieldDescriptors({+ objectMetadataItem,+ objectMetadataItems,+ }),+ serverFilledFieldNames: objectMetadataItem.fields+ .filter(+ (fieldMetadataItem) =>+ fieldMetadataItem.isSystem ||+ isDefined(fieldMetadataItem.defaultValue),+ )+ .map((fieldMetadataItem) => fieldMetadataItem.name),+ now: new Date().toISOString(),+ });++ const updateDraftRecord = (gqlFieldName: string, value: JsonValue) => {setRecordCreationFormDraft((previousDraftRecord) => ({...(previousDraftRecord ?? initialDraftRecord),[gqlFieldName]: value,}));++ if (validationRuleViolations.length > 0) {+ setValidationRuleViolations(+ computeViolations({ ...draftRecord, [gqlFieldName]: value }),+ );+ }+ };++ const handleFieldValueChange = (gqlFieldName: string, value: JsonValue) => {+ updateDraftRecord(gqlFieldName, value);};const handleFieldValueClear = (gqlFieldName: string) => {- setRecordCreationFormDraft((previousDraftRecord) => ({- ...(previousDraftRecord ?? initialDraftRecord),- [gqlFieldName]: null,- }));+ updateDraftRecord(gqlFieldName, null);};const handleCreateClick = async () => {@@ -110,6 +163,16 @@ const SidePanelRecordCreationForm = ({return;}+ if (validationRules.length > 0) {+ const draftViolations = computeViolations(draftRecord);++ setValidationRuleViolations(draftViolations);++ if (draftViolations.length > 0) {+ return;+ }+ }+setIsSubmitting(true);try {await settleRecordCreationDraft({@@ -157,6 +220,15 @@ const SidePanelRecordCreationForm = ({onFieldValueClear={handleFieldValueClear}/></StyledContent>+ {validationRuleViolations.length > 0 && (+ <StyledValidationRuleErrors>+ {validationRuleViolations.map((violation) => (+ <StyledValidationRuleError key={violation.ruleId} role="alert">+ {violation.message}+ </StyledValidationRuleError>+ ))}+ </StyledValidationRuleErrors>+ )}<SidePanelFooteractions={[<Buttondiff --git a/packages/twenty-front/src/modules/validation-rules/types/DraftValidationRuleViolation.ts b/packages/twenty-front/src/modules/validation-rules/types/DraftValidationRuleViolation.tsnew file mode 100644index 00000000000..2bcebad9a7c--- /dev/null+++ b/packages/twenty-front/src/modules/validation-rules/types/DraftValidationRuleViolation.ts@@ -0,0 +1,4 @@+export type DraftValidationRuleViolation = {+ ruleId: string;+ message: string;+};diff --git a/packages/twenty-front/src/modules/validation-rules/utils/__tests__/computeDraftValidationRuleViolations.test.ts b/packages/twenty-front/src/modules/validation-rules/utils/__tests__/computeDraftValidationRuleViolations.test.tsnew file mode 100644index 00000000000..7c6337b967c--- /dev/null+++ b/packages/twenty-front/src/modules/validation-rules/utils/__tests__/computeDraftValidationRuleViolations.test.ts@@ -0,0 +1,153 @@+import { type ValidationRule } from '@/validation-rules/types/ValidationRule';+import { computeDraftValidationRuleViolations } from '@/validation-rules/utils/computeDraftValidationRuleViolations';+import { FieldMetadataType, RelationType } from 'twenty-shared/types';++const FIELDS = [+ {+ name: 'stage',+ type: FieldMetadataType.SELECT,+ universalIdentifier: 'stage',+ },+ {+ name: 'amount',+ type: FieldMetadataType.CURRENCY,+ universalIdentifier: 'amount',+ },+ {+ name: 'company',+ type: FieldMetadataType.RELATION,+ universalIdentifier: 'company',+ relationType: RelationType.MANY_TO_ONE,+ relationTargetFields: [+ {+ name: 'employees',+ type: FieldMetadataType.NUMBER,+ universalIdentifier: 'company-employees',+ },+ ],+ },+];++const AMOUNT_RULE = {+ id: 'amount-rule',+ objectMetadataId: 'opportunity',+ name: 'Customer needs an amount',+ description: null,+ icon: null,+ errorFieldMetadataId: 'amount-field',+ expression: 'stage != "CUSTOMER" or not isEmpty(amount)',+ message: 'A customer deal needs an amount',+ isActive: true,+};++const COMPANY_RULE = {+ id: 'company-rule',+ objectMetadataId: 'opportunity',+ name: 'Company is big enough',+ description: null,+ icon: null,+ errorFieldMetadataId: null,+ expression: 'company.employees >= 10',+ message: 'Company is too small',+ isActive: true,+};++const compute = (+ draftRecord: Record<string, unknown>,+ validationRules: ValidationRule[] = [AMOUNT_RULE],+ serverFilledFieldNames: string[] = [],+) =>+ computeDraftValidationRuleViolations({+ validationRules,+ draftRecord,+ fields: FIELDS,+ serverFilledFieldNames,+ now: '2026-09-23T10:00:00.000Z',+ });++describe('computeDraftValidationRuleViolations', () => {+ it('should report the rule when the draft violates it', () => {+ expect(+ compute({+ stage: 'CUSTOMER',+ amount: { amountMicros: null, currencyCode: 'USD' },+ }),+ ).toEqual([+ {+ ruleId: 'amount-rule',+ message: 'A customer deal needs an amount',+ },+ ]);+ });++ it('should pass a draft that satisfies the rule', () => {+ expect(+ compute({+ stage: 'CUSTOMER',+ amount: { amountMicros: 1000000, currencyCode: 'USD' },+ }),+ ).toEqual([]);+ });++ it('should leave a rule to the server when it reads an absent field the server fills', () => {+ const draftWithoutStage = {+ amount: { amountMicros: null, currencyCode: 'USD' },+ };++ expect(+ compute(draftWithoutStage, [+ { ...AMOUNT_RULE, expression: 'stage == "WON" or not isEmpty(amount)' },+ ]).map((violation) => violation.ruleId),+ ).toEqual(['amount-rule']);+ expect(+ compute(+ draftWithoutStage,+ [+ {+ ...AMOUNT_RULE,+ expression: 'stage == "WON" or not isEmpty(amount)',+ },+ ],+ ['stage'],+ ),+ ).toEqual([]);+ expect(+ compute(+ { ...draftWithoutStage, stage: 'CUSTOMER' },+ [AMOUNT_RULE],+ ['stage'],+ ).map((violation) => violation.ruleId),+ ).toEqual(['amount-rule']);+ });++ it('should skip inactive rules', () => {+ expect(+ compute({ stage: 'CUSTOMER' }, [{ ...AMOUNT_RULE, isActive: false }]),+ ).toEqual([]);+ });++ it('should skip a rule whose related record is not loaded in the draft', () => {+ expect(compute({ companyId: 'company-id' }, [COMPANY_RULE])).toEqual([]);+ });++ it('should treat a set join column as a defined relation', () => {+ expect(+ compute({ companyId: 'company-id' }, [+ { ...COMPANY_RULE, expression: 'isDefined(company)' },+ ]),+ ).toEqual([]);+ expect(+ compute({ companyId: null }, [+ { ...COMPANY_RULE, expression: 'isDefined(company)' },+ ]).map((violation) => violation.ruleId),+ ).toEqual(['company-rule']);+ });++ it('should evaluate a rule whose related record is loaded', () => {+ expect(+ compute({ company: { employees: 3 } }, [COMPANY_RULE]).map(+ (violation) => violation.ruleId,+ ),+ ).toEqual(['company-rule']);+ });+});diff --git a/packages/twenty-front/src/modules/validation-rules/utils/computeDraftValidationRuleViolations.ts b/packages/twenty-front/src/modules/validation-rules/utils/computeDraftValidationRuleViolations.tsnew file mode 100644index 00000000000..6d733d612f3--- /dev/null+++ b/packages/twenty-front/src/modules/validation-rules/utils/computeDraftValidationRuleViolations.ts@@ -0,0 +1,109 @@+import { type DraftValidationRuleViolation } from '@/validation-rules/types/DraftValidationRuleViolation';+import { type ValidationRule } from '@/validation-rules/types/ValidationRule';+import { type ValidationRuleFieldDescriptor } from 'twenty-shared/types';+import {+ compileValidationRuleExpression,+ evaluateValidationRuleExpression,+ isDefined,+} from 'twenty-shared/utils';++const canEvaluateOnDraft = ({+ expression,+ fields,+ draftRecord,+ serverFilledFieldNames,+}: {+ expression: string;+ fields: ValidationRuleFieldDescriptor[];+ draftRecord: Record<string, unknown>;+ serverFilledFieldNames: string[];+}): boolean => {+ const compilationResult = compileValidationRuleExpression({+ expression,+ fields,+ });++ if (!compilationResult.isValid) {+ return false;+ }++ const bindingPaths = Object.keys(compilationResult.bindings);++ const isEveryReferencedRelationLoaded = bindingPaths+ .filter((bindingPath) => bindingPath.includes('.'))+ .map((bindingPath) => bindingPath.split('.')[0])+ .every((relationFieldName) => {+ const relatedRecord = draftRecord[relationFieldName];++ return typeof relatedRecord === 'object' && isDefined(relatedRecord);+ });++ const isEveryServerFilledFieldInDraft = bindingPaths+ .map((bindingPath) => bindingPath.split('.')[0])+ .filter((fieldName) => serverFilledFieldNames.includes(fieldName))+ .every((fieldName) => fieldName in draftRecord);++ return isEveryReferencedRelationLoaded && isEveryServerFilledFieldInDraft;+};++const withRelationPresenceFromJoinColumns = ({+ draftRecord,+ fields,+}: {+ draftRecord: Record<string, unknown>;+ fields: ValidationRuleFieldDescriptor[];+}): Record<string, unknown> =>+ fields+ .filter((field) => isDefined(field.relationTargetFields))+ .reduce<Record<string, unknown>>((evaluationRecord, relationField) => {+ const joinColumnValue = draftRecord[`${relationField.name}Id`];++ if (+ isDefined(evaluationRecord[relationField.name]) ||+ !isDefined(joinColumnValue)+ ) {+ return evaluationRecord;+ }++ return {+ ...evaluationRecord,+ [relationField.name]: { id: joinColumnValue },+ };+ }, draftRecord);++export const computeDraftValidationRuleViolations = ({+ validationRules,+ draftRecord,+ fields,+ serverFilledFieldNames,+ now,+}: {+ validationRules: ValidationRule[];+ draftRecord: Record<string, unknown>;+ fields: ValidationRuleFieldDescriptor[];+ serverFilledFieldNames: string[];+ now: string;+}): DraftValidationRuleViolation[] =>+ validationRules+ .filter((validationRule) => validationRule.isActive)+ .filter((validationRule) =>+ canEvaluateOnDraft({+ expression: validationRule.expression,+ fields,+ draftRecord,+ serverFilledFieldNames,+ }),+ )+ .filter(+ (validationRule) =>+ evaluateValidationRuleExpression({+ expression: validationRule.expression,+ record: withRelationPresenceFromJoinColumns({ draftRecord, fields }),+ fields,+ now,+ }).status === 'failed',+ )+ .map((validationRule) => ({+ ruleId: validationRule.id,+ message: validationRule.message,+ }));diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/utils/workspace-query-runner-graphql-api-exception-handler.util.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/utils/workspace-query-runner-graphql-api-exception-handler.util.tsindex 2e0c05d9367..e8c09411dba 100644--- a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/utils/workspace-query-runner-graphql-api-exception-handler.util.ts+++ b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/utils/workspace-query-runner-graphql-api-exception-handler.util.ts@@ -22,6 +22,8 @@ import { PermissionsException } from 'src/engine/metadata-modules/permissions/peimport { permissionGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/permissions/utils/permission-graphql-api-exception-handler.util';import { RecordShareException } from 'src/engine/core-modules/record-share/record-share.exception';import { recordShareGraphqlApiExceptionHandler } from 'src/engine/core-modules/record-share/utils/record-share-graphql-api-exception-handler.util';+import { RecordValidationRuleException } from 'src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception';+import { recordValidationRuleGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/validation-rule/utils/record-validation-rule-graphql-api-exception-handler.util';import { TwentyOrmException } from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';import { twentyOrmGraphqlApiExceptionHandler } from 'src/engine/twenty-orm/utils/twenty-orm-graphql-api-exception-handler.util';import { WorkflowQueryValidationException } from 'src/modules/workflow/common/exceptions/workflow-query-validation.exception';@@ -45,6 +47,8 @@ export const workspaceQueryRunnerGraphqlApiExceptionHandler = (return graphqlQueryRunnerExceptionHandler(error);case error instanceof TwentyOrmException:return twentyOrmGraphqlApiExceptionHandler(error);+ case error instanceof RecordValidationRuleException:+ return recordValidationRuleGraphqlApiExceptionHandler(error);case error instanceof CommonQueryRunnerException:return commonQueryRunnerToGraphqlApiExceptionHandler(error);case error instanceof RecordShareException:diff --git a/packages/twenty-server/src/engine/api/rest/utils/workspace-query-runner-rest-api-exception-handler.util.ts b/packages/twenty-server/src/engine/api/rest/utils/workspace-query-runner-rest-api-exception-handler.util.tsindex 468edbcef1e..014169a8323 100644--- a/packages/twenty-server/src/engine/api/rest/utils/workspace-query-runner-rest-api-exception-handler.util.ts+++ b/packages/twenty-server/src/engine/api/rest/utils/workspace-query-runner-rest-api-exception-handler.util.ts@@ -11,6 +11,8 @@ import { recordShareRestApiExceptionHandler } from 'src/engine/core-modules/recoimport { throttlerToRestApiExceptionHandler } from 'src/engine/core-modules/throttler/utils/throttler-to-rest-api-exception-handler.util';import { UsageLimitException } from 'src/engine/core-modules/usage-limit/exceptions/usage-limit.exception';import { usageLimitToRestApiExceptionHandler } from 'src/engine/core-modules/usage-limit/utils/usage-limit-to-rest-api-exception-handler.util';+import { RecordValidationRuleHttpException } from 'src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule-http.exception';+import { RecordValidationRuleException } from 'src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception';import { TwentyOrmException } from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';import { isTwentyOrmUserInputError } from 'src/engine/twenty-orm/utils/is-twenty-orm-user-input-error.util';@@ -30,6 +32,8 @@ export const workspaceQueryRunnerRestApiExceptionHandler = (throw new BadRequestException(error.message);case error instanceof UsageLimitException:return usageLimitToRestApiExceptionHandler(error);+ case error instanceof RecordValidationRuleException:+ throw new RecordValidationRuleHttpException(error);case error instanceof ThrottlerException:return throttlerToRestApiExceptionHandler(error);case error instanceof TwentyOrmException &&diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/constants/validation-rule-max-reported-violations.constant.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/constants/validation-rule-max-reported-violations.constant.tsnew file mode 100644index 00000000000..6d085f08f19--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/constants/validation-rule-max-reported-violations.constant.ts@@ -0,0 +1 @@+export const VALIDATION_RULE_MAX_REPORTED_VIOLATIONS = 100;diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/constants/validation-rule-record-chunk-size.constant.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/constants/validation-rule-record-chunk-size.constant.tsnew file mode 100644index 00000000000..7e6d6c4816c--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/constants/validation-rule-record-chunk-size.constant.ts@@ -0,0 +1 @@+export const VALIDATION_RULE_RECORD_CHUNK_SIZE = 500;diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule-http.exception.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule-http.exception.tsnew file mode 100644index 00000000000..320ee91346b--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule-http.exception.ts@@ -0,0 +1,54 @@+import { HttpException, HttpStatus } from '@nestjs/common';++import { type HttpExceptionWithRestResponse } from 'src/engine/core-modules/exception-handler/types/http-exception-with-rest-response.type';+import {+ type RecordValidationRuleException,+ RecordValidationRuleExceptionCode,+} from 'src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception';+import { type RecordValidationRuleViolation } from 'src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type';++type RecordValidationRuleRestResponseBody = {+ statusCode: HttpStatus;+ error: string;+ messages: string[];+ code: string;+ validationRuleViolations: RecordValidationRuleViolation[];+};++export class RecordValidationRuleHttpException+ extends HttpException+ implements HttpExceptionWithRestResponse+{+ private readonly responseBody: RecordValidationRuleRestResponseBody;++ constructor(exception: RecordValidationRuleException) {+ const isEvaluationFailure =+ exception.code ===+ RecordValidationRuleExceptionCode.VALIDATION_RULE_EVALUATION_FAILED;+ const statusCode = isEvaluationFailure+ ? HttpStatus.INTERNAL_SERVER_ERROR+ : HttpStatus.BAD_REQUEST;++ const responseBody: RecordValidationRuleRestResponseBody = {+ statusCode,+ error: isEvaluationFailure+ ? 'InternalServerErrorException'+ : 'BadRequestException',+ messages: [exception.message],+ code: exception.code,+ validationRuleViolations: exception.violations,+ };++ super(responseBody, statusCode);+ this.message = exception.message;+ this.responseBody = responseBody;+ }++ getResponseBody(): RecordValidationRuleRestResponseBody {+ return this.responseBody;+ }++ getResponseHeaders(): Record<string, string> {+ return {};+ }+}diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception.tsnew file mode 100644index 00000000000..3d613b76537--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception.ts@@ -0,0 +1,52 @@+import { type MessageDescriptor } from '@lingui/core';+import { msg } from '@lingui/core/macro';+import { assertUnreachable } from 'twenty-shared/utils';++import { type RecordValidationRuleViolation } from 'src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type';+import { CustomException } from 'src/utils/custom-exception';++export enum RecordValidationRuleExceptionCode {+ VALIDATION_RULE_VIOLATION = 'VALIDATION_RULE_VIOLATION',+ VALIDATION_RULE_EVALUATION_FAILED = 'VALIDATION_RULE_EVALUATION_FAILED',+}++const getRecordValidationRuleUserFriendlyMessage = ({+ code,+ violations,+}: {+ code: RecordValidationRuleExceptionCode;+ violations: RecordValidationRuleViolation[];+}): MessageDescriptor => {+ switch (code) {+ case RecordValidationRuleExceptionCode.VALIDATION_RULE_VIOLATION: {+ return {+ id: 'validation-rule-violation',+ message: '{ruleMessage}',+ values: { ruleMessage: violations[0]?.message ?? '' },+ };+ }+ case RecordValidationRuleExceptionCode.VALIDATION_RULE_EVALUATION_FAILED:+ return msg`A validation rule could not be evaluated. Ask an admin to review it.`;+ default:+ return assertUnreachable(code);+ }+};++export class RecordValidationRuleException extends CustomException<RecordValidationRuleExceptionCode> {+ readonly violations: RecordValidationRuleViolation[];++ constructor(+ message: string,+ code: RecordValidationRuleExceptionCode,+ violations: RecordValidationRuleViolation[],+ ) {+ super(message, code, {+ userFriendlyMessage: getRecordValidationRuleUserFriendlyMessage({+ code,+ violations,+ }),+ });++ this.violations = violations;+ }+}diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type.tsnew file mode 100644index 00000000000..10f2247deb5--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type.ts@@ -0,0 +1,7 @@+export type RecordValidationRuleViolation = {+ ruleId: string;+ message: string;+ fieldMetadataId: string | null;+ recordId: string;+ inputIndex: number | null;+};diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/__tests__/compute-record-validation-rule-violations.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/__tests__/compute-record-validation-rule-violations.util.spec.tsnew file mode 100644index 00000000000..27f686108ff--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/__tests__/compute-record-validation-rule-violations.util.spec.ts@@ -0,0 +1,130 @@+import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';++import { computeRecordValidationRuleViolations } from 'src/engine/metadata-modules/validation-rule/utils/compute-record-validation-rule-violations.util';++const FIELDS = [+ {+ name: 'stage',+ type: FieldMetadataType.SELECT,+ universalIdentifier: 'stage-universal-identifier',+ },+ {+ name: 'amount',+ type: FieldMetadataType.CURRENCY,+ universalIdentifier: 'amount-universal-identifier',+ },+];++const WON_WITHOUT_AMOUNT_RULE = {+ id: 'rule-won-without-amount',+ expression: 'stage != "WON" or not isEmpty(amount)',+ message: 'A won opportunity needs an amount',+ errorFieldMetadataId: 'amount-field-metadata-id',+};++const BROKEN_RULE = {+ id: 'rule-broken',+ expression: 'stage',+ message: 'Never shown',+ errorFieldMetadataId: null,+};++const compute = (+ records: ObjectRecord[],+ inputIndexByRecordId = new Map<string, number>(),+ maxViolations = 100,+) =>+ computeRecordValidationRuleViolations({+ records,+ validationRules: [WON_WITHOUT_AMOUNT_RULE],+ fields: FIELDS,+ now: '2026-09-23T10:00:00.000Z',+ inputIndexByRecordId,+ maxViolations,+ });++describe('computeRecordValidationRuleViolations', () => {+ it('should stop once the reported violations reach the cap', () => {+ const invalidRecords = ['first', 'second', 'third'].map((id) => ({+ id,+ stage: 'WON',+ amount: { amountMicros: null, currencyCode: 'USD' },+ }));++ expect(+ compute(invalidRecords, new Map(), 2).violations.map(+ (violation) => violation.recordId,+ ),+ ).toEqual(['first', 'second']);+ });++ it('should report the failing record with its rule, field and input index', () => {+ expect(+ compute(+ [+ {+ id: 'record-valid',+ stage: 'WON',+ amount: { amountMicros: 1000000, currencyCode: 'USD' },+ },+ {+ id: 'record-invalid',+ stage: 'WON',+ amount: { amountMicros: null, currencyCode: 'USD' },+ },+ ],+ new Map([+ ['record-valid', 0],+ ['record-invalid', 1],+ ]),+ ),+ ).toEqual({+ violations: [+ {+ ruleId: 'rule-won-without-amount',+ message: 'A won opportunity needs an amount',+ fieldMetadataId: 'amount-field-metadata-id',+ recordId: 'record-invalid',+ inputIndex: 1,+ },+ ],+ evaluationErrors: [],+ });+ });++ it('should leave the input index null when the write had no input array', () => {+ expect(+ compute([+ {+ id: 'record-invalid',+ stage: 'WON',+ amount: { amountMicros: null, currencyCode: 'USD' },+ },+ ]).violations[0].inputIndex,+ ).toBeNull();+ });++ it('should report a rule that cannot be evaluated as an evaluation error', () => {+ expect(+ computeRecordValidationRuleViolations({+ records: [{ id: 'record', stage: 'WON' }],+ validationRules: [BROKEN_RULE],+ fields: FIELDS,+ now: '2026-09-23T10:00:00.000Z',+ inputIndexByRecordId: new Map(),+ maxViolations: 100,+ }),+ ).toEqual({+ violations: [],+ evaluationErrors: [+ {+ ruleId: 'rule-broken',+ message: 'Never shown',+ fieldMetadataId: null,+ recordId: 'record',+ inputIndex: null,+ },+ ],+ });+ });+});diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/compute-record-validation-rule-violations.util.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/compute-record-validation-rule-violations.util.tsnew file mode 100644index 00000000000..65924cc57e5--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/compute-record-validation-rule-violations.util.ts@@ -0,0 +1,73 @@+import {+ type ObjectRecord,+ type ValidationRuleFieldDescriptor,+} from 'twenty-shared/types';+import { createValidationRuleEvaluator } from 'twenty-shared/utils';++import { type FlatValidationRule } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule.type';+import { type RecordValidationRuleViolation } from 'src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type';++type ComputeRecordValidationRuleViolationsResult = {+ violations: RecordValidationRuleViolation[];+ evaluationErrors: RecordValidationRuleViolation[];+};++export const computeRecordValidationRuleViolations = ({+ records,+ validationRules,+ fields,+ now,+ inputIndexByRecordId,+ maxViolations,+}: {+ records: ObjectRecord[];+ validationRules: Pick<+ FlatValidationRule,+ 'id' | 'expression' | 'message' | 'errorFieldMetadataId'+ >[];+ fields: ValidationRuleFieldDescriptor[];+ now: string;+ inputIndexByRecordId: Map<string, number>;+ maxViolations: number;+}): ComputeRecordValidationRuleViolationsResult => {+ const violations: RecordValidationRuleViolation[] = [];+ const evaluationErrors: RecordValidationRuleViolation[] = [];++ const ruleEvaluators = validationRules.map((validationRule) => ({+ validationRule,+ evaluate: createValidationRuleEvaluator({+ expression: validationRule.expression,+ fields,+ }),+ }));++ for (const record of records) {+ for (const { validationRule, evaluate } of ruleEvaluators) {+ if (violations.length + evaluationErrors.length >= maxViolations) {+ return { violations, evaluationErrors };+ }++ const evaluationResult = evaluate({ record, now });++ if (evaluationResult.status === 'passed') {+ continue;+ }++ const violation: RecordValidationRuleViolation = {+ ruleId: validationRule.id,+ message: validationRule.message,+ fieldMetadataId: validationRule.errorFieldMetadataId,+ recordId: String(record.id),+ inputIndex: inputIndexByRecordId.get(String(record.id)) ?? null,+ };++ if (evaluationResult.status === 'failed') {+ violations.push(violation);+ } else {+ evaluationErrors.push(violation);+ }+ }+ }++ return { violations, evaluationErrors };+};diff --git a/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/record-validation-rule-graphql-api-exception-handler.util.ts b/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/record-validation-rule-graphql-api-exception-handler.util.tsnew file mode 100644index 00000000000..01eeaea323f--- /dev/null+++ b/packages/twenty-server/src/engine/metadata-modules/validation-rule/utils/record-validation-rule-graphql-api-exception-handler.util.ts@@ -0,0 +1,24 @@+import {+ BaseGraphQLError,+ ErrorCode,+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';+import {+ type RecordValidationRuleException,+ RecordValidationRuleExceptionCode,+} from 'src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception';++export const recordValidationRuleGraphqlApiExceptionHandler = (+ error: RecordValidationRuleException,+): never => {+ const errorCode =+ error.code ===+ RecordValidationRuleExceptionCode.VALIDATION_RULE_EVALUATION_FAILED+ ? ErrorCode.INTERNAL_SERVER_ERROR+ : ErrorCode.BAD_USER_INPUT;++ throw new BaseGraphQLError(error.message, errorCode, {+ subCode: error.code,+ userFriendlyMessage: error.userFriendlyMessage,+ validationRuleViolations: error.violations,+ });+};diff --git a/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.ts b/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.tsindex c3983ab41f6..c414392929a 100644--- a/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/__tests__/workspace-orm.manager.spec.ts@@ -20,6 +20,7 @@ describe('workspace context sharing enforcement', () => {useValue: {getOrRecompute: jest.fn().mockResolvedValue({flatObjectMetadataMaps: createEmptyFlatEntityMaps(),+ featureFlagsMap: {},}),},},diff --git a/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts b/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.tsindex cc6a36ca264..af445631788 100644--- a/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts+++ b/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.service.ts@@ -119,6 +119,7 @@ export class WorkspaceDataSourceServiceworkspaceContext.flatRowLevelPermissionPredicateMaps,flatRowLevelPermissionPredicateGroupMaps:workspaceContext.flatRowLevelPermissionPredicateGroupMaps,+ flatValidationRuleMaps: workspaceContext.flatValidationRuleMaps,objectIdByNameSingular: workspaceContext.objectIdByNameSingular,featureFlagsMap: workspaceContext.featureFlagsMap,billingEntitlements: workspaceContext.billingEntitlements,diff --git a/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts b/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.tsindex d0a5f23f0a6..81b44f70c44 100644--- a/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts+++ b/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts@@ -7,6 +7,7 @@ import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/typimport { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type FlatValidationRuleMaps } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule-maps.type';import { type UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map.type';import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';@@ -19,6 +20,7 @@ export interface WorkspaceInternalContext {flatIndexMaps: FlatEntityMaps<FlatIndexMetadata>;flatRowLevelPermissionPredicateMaps: FlatRowLevelPermissionPredicateMaps;flatRowLevelPermissionPredicateGroupMaps: FlatRowLevelPermissionPredicateGroupMaps;+ flatValidationRuleMaps?: FlatValidationRuleMaps;objectIdByNameSingular: Record<string, string>;featureFlagsMap: Record<FeatureFlagKey, boolean>;billingEntitlements: BillingEntitlements;diff --git a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.tsindex 75c3915f35c..d65e7d4eba2 100644--- a/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts+++ b/packages/twenty-server/src/engine/twenty-orm/query-builder/workspace-select-query-builder.ts@@ -116,8 +116,11 @@ export class WorkspaceSelectQueryBuilder implements WhereExpressionLike {];}- clone(): WorkspaceSelectQueryBuilder {- const cloned = new WorkspaceSelectQueryBuilder(this.alias, this.context);+ clone(executor?: QueryExecutor): WorkspaceSelectQueryBuilder {+ const cloned = new WorkspaceSelectQueryBuilder(+ this.alias,+ isDefined(executor) ? { ...this.context, executor } : this.context,+ );cloned.whereClauses.push(...this.whereClauses);cloned.existsFilterClauses.push(diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.tsindex 3f17604a371..a74b152c23b 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@@ -56,6 +56,8 @@ import { resolveInheritedReadabilityChildLinks } from 'src/engine/core-modules/rimport { resolveInheritedReadabilityParents } from 'src/engine/core-modules/record-share/utils/resolve-inherited-readability-parents.util';import { resolveRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/resolve-row-level-permission-record-filter.util';import { validateRLSPredicatesForRecords } from 'src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util';+import { getActiveValidationRules } from 'src/engine/twenty-orm/utils/get-active-validation-rules.util';+import { validateRecordsAgainstValidationRulesOrThrow } from 'src/engine/twenty-orm/utils/validate-records-against-validation-rules.util';import {TwentyOrmException,TwentyOrmExceptionCode,@@ -116,6 +118,8 @@ const MUTATION_EVENT_ACTIONS_BY_KIND: Record<update: [DatabaseEventAction.UPDATED, DatabaseEventAction.UPSERTED],};+type ValidateWrittenRecords = (writtenRecords: ObjectRecord[]) => Promise<void>;+type WorkspaceRepositoryOptions<TEntity extends ObjectLiteral> = {tableShape: WorkspaceTableShape;flatObjectMetadata: FlatObjectMetadata;@@ -758,6 +762,39 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {: this.options.runInNewTransaction(work);}+ private runWithValidationRules<TResult>({+ write,+ inputRecordIds,+ }: {+ write: (+ repository: WorkspaceRepository<TEntity>,+ validateWrittenRecords?: ValidateWrittenRecords,+ ) => Promise<TResult>;+ inputRecordIds?: (string | undefined)[];+ }): Promise<TResult> {+ const validationRules = getActiveValidationRules({+ flatValidationRuleMaps:+ this.options.internalContext.flatValidationRuleMaps,+ objectMetadataId: this.options.flatObjectMetadata.id,+ });++ if (validationRules.length === 0) {+ return write(this);+ }++ return this.runAtomically((repository) =>+ write(repository, (writtenRecords) =>+ validateRecordsAgainstValidationRulesOrThrow({+ repository,+ tableShape: this.options.tableShape,+ validationRules,+ writtenRecords,+ inputRecordIds,+ }),+ ),+ );+ }+private async findExistingIds(ids: string[]): Promise<Set<string>> {if (ids.length === 0) {return new Set<string>();@@ -953,14 +990,32 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {}}- async runInsert({+ async runInsert(args: {+ records: Partial<ObjectRecord>[];+ columnsToReturn: string[];+ onConflictDoNothing?: boolean;+ }): Promise<{+ identifiers: { id: string }[];+ generatedMaps: ObjectRecord[];+ raw: ObjectRecord[];+ }> {+ return this.runWithValidationRules({+ inputRecordIds: args.records.map((record) => record.id),+ write: (repository, validateWrittenRecords) =>+ repository.performInsert({ ...args, validateWrittenRecords }),+ });+ }++ private async performInsert({records,columnsToReturn,onConflictDoNothing,+ validateWrittenRecords,}: {records: Partial<ObjectRecord>[];columnsToReturn: string[];onConflictDoNothing?: boolean;+ validateWrittenRecords?: ValidateWrittenRecords;}): Promise<{identifiers: { id: string }[];generatedMaps: ObjectRecord[];@@ -1021,6 +1076,8 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {const rawRows = await this.executeRaw<ObjectRecord>(sql, parameters);+ await validateWrittenRecords?.(rawRows);+await this.acquireRecordStock(rawRows.length);if (isDefined(filesFieldFileIds)) {@@ -1039,12 +1096,29 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {};}- async runBatchUpdate({+ async runBatchUpdate(args: {+ inputs: { id: string; data: Partial<ObjectRecord> }[];+ columnsToReturn: string[];+ }): Promise<{+ identifiers: { id: string }[];+ generatedMaps: ObjectRecord[];+ raw: ObjectRecord[];+ }> {+ return this.runWithValidationRules({+ inputRecordIds: args.inputs.map((input) => input.id),+ write: (repository, validateWrittenRecords) =>+ repository.performBatchUpdate({ ...args, validateWrittenRecords }),+ });+ }++ private async performBatchUpdate({inputs,columnsToReturn,+ validateWrittenRecords,}: {inputs: { id: string; data: Partial<ObjectRecord> }[];columnsToReturn: string[];+ validateWrittenRecords?: ValidateWrittenRecords;}): Promise<{identifiers: { id: string }[];generatedMaps: ObjectRecord[];@@ -1184,6 +1258,8 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {);}+ await validateWrittenRecords?.(generatedMaps);+if (isDefined(filesFieldFileIds)) {await this.filesFieldSync.updateFileEntityRecords(filesFieldFileIds);}@@ -1326,6 +1402,40 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {}}+ async findRecordSnapshotsBypassingPermissions({+ ids,+ fieldNames,+ }: {+ ids: string[];+ fieldNames?: string[];+ }): Promise<ObjectRecord[]> {+ const queryBuilder = this.buildIdsEventSnapshotQueryBuilder(ids);++ if (!isDefined(fieldNames)) {+ return queryBuilder.getMany<ObjectRecord>({ noFormatting: true });+ }++ const { columnNames, columnShapeByColumnName } = this.options.tableShape;++ return queryBuilder+ .select(+ columnNames.filter((columnName) => {+ const columnShape = columnShapeByColumnName[columnName];++ return (+ columnName === 'id' ||+ columnName === 'deletedAt' ||+ (isDefined(columnShape) &&+ (fieldNames.includes(columnShape.fieldName) ||+ fieldNames.includes(+ columnShape.compositeParentFieldName ?? '',+ )))+ );+ }),+ )+ .getMany<ObjectRecord>({ noFormatting: true });+ }+private buildBypassingEventSelectQueryBuilder(alias: string,): WorkspaceSelectQueryBuilder {@@ -1479,18 +1589,44 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {return new Set(rows.map((row) => String(row.id)));}- async runMutation({+ async runMutation(args: {+ selectQueryBuilder: WorkspaceSelectQueryBuilder;+ rowLevelPermissionsApplied: boolean;+ kind: MutationKind;+ columnsToReturn: string[];+ data?: Partial<ObjectRecord>;+ }): Promise<ObjectRecord[]> {+ if (args.kind !== 'update') {+ return this.performMutation(args);+ }++ return this.runWithValidationRules({+ write: (repository, validateWrittenRecords) =>+ repository.performMutation({+ ...args,+ selectQueryBuilder:+ repository === this+ ? args.selectQueryBuilder+ : args.selectQueryBuilder.clone(repository.options.executor),+ validateWrittenRecords,+ }),+ });+ }++ private async performMutation({selectQueryBuilder,rowLevelPermissionsApplied,kind,columnsToReturn,data,+ validateWrittenRecords,}: {selectQueryBuilder: WorkspaceSelectQueryBuilder;rowLevelPermissionsApplied: boolean;kind: MutationKind;columnsToReturn: string[];data?: Partial<ObjectRecord>;+ validateWrittenRecords?: ValidateWrittenRecords;}): Promise<ObjectRecord[]> {this.validateWriteIsPermitted({operationType: kind,@@ -1597,6 +1733,8 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {await this.releaseRecordStock(mutationResult.generatedMaps.length);}+ await validateWrittenRecords?.(mutationResult.generatedMaps);+if (isDefined(filesFieldFileIds)) {await this.filesFieldSync.updateFileEntityRecords(filesFieldFileIds);}diff --git a/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts b/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.tsindex 180a071ef48..3c91d69d169 100644--- a/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts+++ b/packages/twenty-server/src/engine/twenty-orm/storage/orm-workspace-context.storage.ts@@ -11,6 +11,7 @@ import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/typimport { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type FlatValidationRuleMaps } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule-maps.type';import { type UserWorkspaceRoleMap } from 'src/engine/metadata-modules/role-target/types/user-workspace-role-map.type';import { type FlatRowLevelPermissionPredicateGroupMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-group-maps.type';import { type FlatRowLevelPermissionPredicateMaps } from 'src/engine/metadata-modules/row-level-permission-predicate/types/flat-row-level-permission-predicate-maps.type';@@ -28,6 +29,7 @@ export type ORMWorkspaceContext = {apiKeyRoleMap: Record<string, string>;flatRowLevelPermissionPredicateMaps: FlatRowLevelPermissionPredicateMaps;flatRowLevelPermissionPredicateGroupMaps: FlatRowLevelPermissionPredicateGroupMaps;+ flatValidationRuleMaps?: FlatValidationRuleMaps;};export const workspaceContextStorage =diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/get-active-validation-rules.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/get-active-validation-rules.util.spec.tsnew file mode 100644index 00000000000..96b61f8bd03--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/get-active-validation-rules.util.spec.ts@@ -0,0 +1,78 @@+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';+import { type FlatValidationRuleMaps } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule-maps.type';+import { type FlatValidationRule } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule.type';+import { getActiveValidationRules } from 'src/engine/twenty-orm/utils/get-active-validation-rules.util';++const RULE: FlatValidationRule = {+ id: 'rule-id',+ universalIdentifier: 'rule-universal-identifier',+ applicationId: 'application-id',+ applicationUniversalIdentifier: 'application-universal-identifier',+ workspaceId: 'workspace-id',+ objectMetadataId: 'company-id',+ objectMetadataUniversalIdentifier: 'company-universal-identifier',+ errorFieldMetadataId: null,+ errorFieldMetadataUniversalIdentifier: null,+ name: 'Minimum employees',+ description: null,+ icon: null,+ expression: 'employees >= 10',+ bindings: { employees: 'employees-universal-identifier' },+ message: 'At least ten employees are required',+ isActive: true,+ createdAt: '2026-01-01T00:00:00.000Z',+ updatedAt: '2026-01-01T00:00:00.000Z',+};++describe('getActiveValidationRules', () => {+ it('should isolate objects and omit disabled rules', () => {+ const flatValidationRuleMaps: FlatValidationRuleMaps =+ createEmptyFlatEntityMaps();++ flatValidationRuleMaps.byUniversalIdentifier = {+ active: RULE,+ disabled: { ...RULE, id: 'disabled-rule', isActive: false },+ other: { ...RULE, id: 'other-rule', objectMetadataId: 'person-id' },+ };++ expect(+ getActiveValidationRules({+ flatValidationRuleMaps,+ objectMetadataId: 'company-id',+ }),+ ).toEqual([RULE]);+ expect(+ getActiveValidationRules({+ flatValidationRuleMaps,+ objectMetadataId: 'opportunity-id',+ }),+ ).toEqual([]);+ expect(+ getActiveValidationRules({ objectMetadataId: 'company-id' }),+ ).toEqual([]);+ });++ it('should observe rule deactivation after the metadata cache is replaced', () => {+ const previousMaps: FlatValidationRuleMaps = createEmptyFlatEntityMaps();+ previousMaps.byUniversalIdentifier = { rule: RULE };++ expect(+ getActiveValidationRules({+ flatValidationRuleMaps: previousMaps,+ objectMetadataId: 'company-id',+ }),+ ).toEqual([RULE]);++ const refreshedMaps = {+ ...previousMaps,+ byUniversalIdentifier: { rule: { ...RULE, isActive: false } },+ };++ expect(+ getActiveValidationRules({+ flatValidationRuleMaps: refreshedMaps,+ objectMetadataId: 'company-id',+ }),+ ).toEqual([]);+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/get-active-validation-rules.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/get-active-validation-rules.util.tsnew file mode 100644index 00000000000..2dfa07a587a--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/get-active-validation-rules.util.ts@@ -0,0 +1,50 @@+import { isDefined } from 'twenty-shared/utils';++import { type FlatValidationRule } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule.type';+import { type FlatValidationRuleMaps } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule-maps.type';++const activeRulesByObjectIdCache = new WeakMap<+ FlatValidationRuleMaps,+ Map<string, FlatValidationRule[]>+>();++export const getActiveValidationRules = ({+ flatValidationRuleMaps,+ objectMetadataId,+}: {+ flatValidationRuleMaps?: FlatValidationRuleMaps;+ objectMetadataId: string;+}): FlatValidationRule[] => {+ if (!isDefined(flatValidationRuleMaps)) {+ return [];+ }++ let activeRulesByObjectId = activeRulesByObjectIdCache.get(+ flatValidationRuleMaps,+ );++ if (!isDefined(activeRulesByObjectId)) {+ activeRulesByObjectId = new Map<string, FlatValidationRule[]>();++ for (const rule of Object.values(+ flatValidationRuleMaps.byUniversalIdentifier,+ )) {+ if (!isDefined(rule) || !rule.isActive) {+ continue;+ }++ const objectRules =+ activeRulesByObjectId.get(rule.objectMetadataId) ?? [];++ objectRules.push(rule);+ activeRulesByObjectId.set(rule.objectMetadataId, objectRules);+ }++ activeRulesByObjectIdCache.set(+ flatValidationRuleMaps,+ activeRulesByObjectId,+ );+ }++ return activeRulesByObjectId.get(objectMetadataId) ?? [];+};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/validate-records-against-validation-rules.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/validate-records-against-validation-rules.util.tsnew file mode 100644index 00000000000..85b3cf35c94--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/validate-records-against-validation-rules.util.ts@@ -0,0 +1,245 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type ObjectRecord } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';+import { type ObjectLiteral } from 'typeorm';++import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';+import { type FlatValidationRule } from 'src/engine/metadata-modules/flat-validation-rule/types/flat-validation-rule.type';+import { VALIDATION_RULE_MAX_REPORTED_VIOLATIONS } from 'src/engine/metadata-modules/validation-rule/constants/validation-rule-max-reported-violations.constant';+import { VALIDATION_RULE_RECORD_CHUNK_SIZE } from 'src/engine/metadata-modules/validation-rule/constants/validation-rule-record-chunk-size.constant';+import {+ RecordValidationRuleException,+ RecordValidationRuleExceptionCode,+} from 'src/engine/metadata-modules/validation-rule/exceptions/record-validation-rule.exception';+import { type RecordValidationRuleViolation } from 'src/engine/metadata-modules/validation-rule/types/record-validation-rule-violation.type';+import { buildValidationRuleFieldDescriptors } from 'src/engine/metadata-modules/validation-rule/utils/build-validation-rule-field-descriptors.util';+import { computeRecordValidationRuleViolations } from 'src/engine/metadata-modules/validation-rule/utils/compute-record-validation-rule-violations.util';+import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';+import { type WorkspaceTableShape } from 'src/engine/twenty-orm/table-shape/types/workspace-table-shape.type';++type ValidateRecordsAgainstValidationRulesArgs<TEntity extends ObjectLiteral> =+ {+ repository: WorkspaceRepository<TEntity>;+ tableShape: WorkspaceTableShape;+ validationRules: FlatValidationRule[];+ writtenRecords: ObjectRecord[];+ inputRecordIds?: (string | undefined)[];+ };++const findLiveRelatedRecords = async <TEntity extends ObjectLiteral>({+ repository,+ targetObjectMetadataId,+ ids,+ fieldNames,+}: {+ repository: WorkspaceRepository<TEntity>;+ targetObjectMetadataId: string;+ ids: string[];+ fieldNames: string[];+}): Promise<ObjectRecord[]> => {+ if (ids.length === 0) {+ return [];+ }++ const relatedRepository = repository.getRepositoryForObjectMetadataId(+ targetObjectMetadataId,+ );++ const rawRelatedRecords =+ await relatedRepository.findRecordSnapshotsBypassingPermissions({+ ids,+ fieldNames,+ });++ return relatedRepository.formatResult<ObjectRecord[]>(+ rawRelatedRecords.filter(+ (rawRelatedRecord) => !isDefined(rawRelatedRecord.deletedAt),+ ),+ );+};++const attachRelatedRecords = async <TEntity extends ObjectLiteral>({+ repository,+ tableShape,+ validationRules,+ rawWrittenRecords,+}: {+ repository: WorkspaceRepository<TEntity>;+ tableShape: WorkspaceTableShape;+ validationRules: FlatValidationRule[];+ rawWrittenRecords: ObjectRecord[];+}): Promise<ObjectRecord[]> => {+ const bindingPaths = [+ ...new Set(+ validationRules.flatMap((validationRule) =>+ Object.keys(validationRule.bindings),+ ),+ ),+ ];++ const referencedRelationShapes = bindingPaths+ .map((bindingPath) => tableShape.relationShapeByFieldName[bindingPath])+ .filter(isDefined)+ .filter(+ (relationShape) =>+ relationShape.relationType === RelationType.MANY_TO_ONE &&+ isNonEmptyString(relationShape.joinColumnName),+ );++ let records = repository.formatResult<ObjectRecord[]>(rawWrittenRecords);++ for (const relationShape of referencedRelationShapes) {+ const joinColumnName = relationShape.joinColumnName ?? '';++ const relatedRecords = await findLiveRelatedRecords({+ repository,+ targetObjectMetadataId: relationShape.targetObjectMetadataId,+ ids: [+ ...new Set(+ rawWrittenRecords+ .map((rawWrittenRecord) => rawWrittenRecord[joinColumnName])+ .filter(isNonEmptyString),+ ),+ ],+ fieldNames: bindingPaths+ .filter((bindingPath) =>+ bindingPath.startsWith(`${relationShape.fieldName}.`),+ )+ .map((bindingPath) =>+ bindingPath.slice(relationShape.fieldName.length + 1),+ ),+ });++ const relatedRecordById = new Map(+ relatedRecords.map((relatedRecord) => [+ String(relatedRecord.id),+ relatedRecord,+ ]),+ );++ records = records.map((record, recordIndex) => ({+ ...record,+ [relationShape.fieldName]:+ relatedRecordById.get(+ String(rawWrittenRecords[recordIndex]?.[joinColumnName]),+ ) ?? null,+ }));+ }++ return records;+};++const buildInputIndexByRecordId = ({+ inputRecordIds,+ recordIds,+}: {+ inputRecordIds?: (string | undefined)[];+ recordIds: string[];+}): Map<string, number> => {+ if (!isDefined(inputRecordIds)) {+ return new Map();+ }++ const indexedRecordIds = inputRecordIds.every(isNonEmptyString)+ ? inputRecordIds+ : recordIds;++ return new Map(+ indexedRecordIds.map((recordId, inputIndex) => [recordId, inputIndex]),+ );+};++export const validateRecordsAgainstValidationRulesOrThrow = async <+ TEntity extends ObjectLiteral,+>({+ repository,+ tableShape,+ validationRules,+ writtenRecords,+ inputRecordIds,+}: ValidateRecordsAgainstValidationRulesArgs<TEntity>): Promise<void> => {+ const recordIds = writtenRecords+ .map((writtenRecord) => writtenRecord.id)+ .filter(isNonEmptyString);++ if (recordIds.length === 0) {+ return;+ }++ const inputIndexByRecordId = buildInputIndexByRecordId({+ inputRecordIds,+ recordIds,+ });++ const fields = buildValidationRuleFieldDescriptors({+ objectMetadataId: tableShape.objectMetadataId,+ flatObjectMetadataMaps: repository.internalContext.flatObjectMetadataMaps,+ flatFieldMetadataMaps: repository.internalContext.flatFieldMetadataMaps,+ });+ const fieldNames = [+ ...new Set(+ validationRules.flatMap((validationRule) =>+ Object.keys(validationRule.bindings).filter(+ (bindingPath) => !bindingPath.includes('.'),+ ),+ ),+ ),+ ];+ const now = new Date().toISOString();++ const violations: RecordValidationRuleViolation[] = [];+ const evaluationErrors: RecordValidationRuleViolation[] = [];++ for (+ let chunkStart = 0;+ chunkStart < recordIds.length &&+ violations.length + evaluationErrors.length <+ VALIDATION_RULE_MAX_REPORTED_VIOLATIONS;+ chunkStart += VALIDATION_RULE_RECORD_CHUNK_SIZE+ ) {+ const rawWrittenRecords =+ await repository.findRecordSnapshotsBypassingPermissions({+ fieldNames,+ ids: recordIds.slice(+ chunkStart,+ chunkStart + VALIDATION_RULE_RECORD_CHUNK_SIZE,+ ),+ });++ const chunkResult = computeRecordValidationRuleViolations({+ records: await attachRelatedRecords({+ repository,+ tableShape,+ validationRules,+ rawWrittenRecords,+ }),+ validationRules,+ fields,+ now,+ inputIndexByRecordId,+ maxViolations:+ VALIDATION_RULE_MAX_REPORTED_VIOLATIONS -+ violations.length -+ evaluationErrors.length,+ });++ violations.push(...chunkResult.violations);+ evaluationErrors.push(...chunkResult.evaluationErrors);+ }++ if (evaluationErrors.length > 0) {+ throw new RecordValidationRuleException(+ 'A validation rule could not be evaluated',+ RecordValidationRuleExceptionCode.VALIDATION_RULE_EVALUATION_FAILED,+ evaluationErrors,+ );+ }++ if (violations.length > 0) {+ throw new RecordValidationRuleException(+ violations[0].message,+ RecordValidationRuleExceptionCode.VALIDATION_RULE_VIOLATION,+ violations,+ );+ }+};diff --git a/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts b/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.tsindex 2bf91249640..7287ef718d3 100644--- a/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts+++ b/packages/twenty-server/src/engine/twenty-orm/workspace-orm.manager.ts@@ -8,7 +8,7 @@ import { Injectable, type Type } from '@nestjs/common';import { type ObjectLiteral } from 'typeorm';-import { type ObjectRecord } from 'twenty-shared/types';+import { FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import { getWorkspaceAuthContext } from 'src/engine/core-modules/auth/storage/workspace-auth-context.storage';@@ -160,6 +160,16 @@ export class WorkspaceOrmManager {const { idByNameSingular: objectIdByNameSingular } =buildObjectIdByNameMaps(flatObjectMetadataMaps);+ const flatValidationRuleMaps = featureFlagsMap[+ FeatureFlagKey.IS_VALIDATION_RULES_ENABLED+ ]+ ? (+ await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatValidationRuleMaps',+ ])+ ).flatValidationRuleMaps+ : undefined;+return {authContext,flatObjectMetadataMaps,@@ -167,6 +177,7 @@ export class WorkspaceOrmManager {flatIndexMaps,flatRowLevelPermissionPredicateMaps,flatRowLevelPermissionPredicateGroupMaps,+ flatValidationRuleMaps,objectIdByNameSingular,featureFlagsMap,billingEntitlements,diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.tsindex 7d77d837a5c..09a74195c39 100644--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-feature-flags.util.ts@@ -13,7 +13,7 @@ const DEFAULT_SEEDED_FEATURE_FLAGS: Partial<Record<FeatureFlagKey, boolean>> = {[FeatureFlagKey.IS_RECORD_CREATION_FORM_ENABLED]: true,[FeatureFlagKey.IS_LOGS_SETTINGS_SECTION_ENABLED]: true,[FeatureFlagKey.IS_CONVERSATIONS_TAB_ENABLED]: false,- [FeatureFlagKey.IS_VALIDATION_RULES_ENABLED]: false,+ [FeatureFlagKey.IS_VALIDATION_RULES_ENABLED]: true,};type SeedFeatureFlagsArgs = {diff --git a/packages/twenty-server/test/integration/metadata/suites/validation-rule/validation-rule-enforcement.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/validation-rule/validation-rule-enforcement.integration-spec.tsnew file mode 100644index 00000000000..8d4199e6b80--- /dev/null+++ b/packages/twenty-server/test/integration/metadata/suites/validation-rule/validation-rule-enforcement.integration-spec.ts@@ -0,0 +1,332 @@+import gql from 'graphql-tag';+import { FeatureFlagKey } from 'twenty-shared/types';++import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';+import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';+import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';++const CUSTOMER_NEEDS_AMOUNT_EXPRESSION =+ 'stage != "CUSTOMER" or not isEmpty(amount)';+const RULE_MESSAGE = 'A customer deal needs an amount';++const createValidationRule = (input: Record<string, unknown>) =>+ makeMetadataApiRequest({+ query: gql`+ mutation CreateValidationRule($input: CreateValidationRuleInput!) {+ createValidationRule(input: $input) {+ id+ }+ }+ `,+ variables: { input },+ });++const findOpportunitiesByName = async (name: string) => {+ const response = await makeGraphqlApiRequest({+ query: gql`+ query FindOpportunities($name: String!) {+ opportunities(filter: { name: { eq: $name } }) {+ edges {+ node {+ id+ stage+ }+ }+ }+ }+ `,+ variables: { name },+ });++ return response.body.data.opportunities.edges.map(+ (edge: { node: { id: string; stage: string } }) => edge.node,+ );+};++describe('Validation rules should be enforced on record writes', () => {+ let validationRuleId: string;+ let opportunityObjectMetadataId: string;+ let amountFieldMetadataId: string;+ const createdOpportunityIds: string[] = [];++ beforeAll(async () => {+ await updateFeatureFlag({+ featureFlag: FeatureFlagKey.IS_VALIDATION_RULES_ENABLED,+ value: true,+ expectToFail: false,+ });++ const { objects } = await findManyObjectMetadata({+ expectToFail: false,+ input: { filter: {}, paging: { first: 1000 } },+ gqlFields: `+ id+ nameSingular+ fieldsList {+ id+ name+ }+ `,+ });++ const opportunityObjectMetadata = objects.find(+ (object: { nameSingular: string }) =>+ object.nameSingular === 'opportunity',+ );++ jestExpectToBeDefined(opportunityObjectMetadata);+ opportunityObjectMetadataId = opportunityObjectMetadata.id;++ const amountField = opportunityObjectMetadata.fieldsList?.find(+ (field: { name: string }) => field.name === 'amount',+ );++ jestExpectToBeDefined(amountField);+ amountFieldMetadataId = amountField.id;++ const response = await createValidationRule({+ objectMetadataId: opportunityObjectMetadataId,+ errorFieldMetadataId: amountFieldMetadataId,+ name: 'Customer needs an amount',+ expression: CUSTOMER_NEEDS_AMOUNT_EXPRESSION,+ message: RULE_MESSAGE,+ });++ validationRuleId = response.body.data.createValidationRule.id;+ jestExpectToBeDefined(validationRuleId);+ });++ afterAll(async () => {+ await makeMetadataApiRequest({+ query: gql`+ mutation DeleteValidationRule($id: UUID!) {+ deleteValidationRule(id: $id) {+ id+ }+ }+ `,+ variables: { id: validationRuleId },+ });++ if (createdOpportunityIds.length > 0) {+ await makeGraphqlApiRequest({+ query: gql`+ mutation DestroyOpportunities($ids: [UUID!]!) {+ destroyOpportunities(filter: { id: { in: $ids } }) {+ id+ }+ }+ `,+ variables: { ids: createdOpportunityIds },+ });+ }+ });++ it('should reject a rule expression that references an unknown field', async () => {+ const response = await createValidationRule({+ objectMetadataId: opportunityObjectMetadataId,+ name: 'Customer needs an amount',+ expression: 'stage != "CUSTOMER" or not isEmpty(amont)',+ message: RULE_MESSAGE,+ });++ expect(response.body.errors[0].message).toBe('Unknown field "amont"');+ });++ it('should reject a create that violates the rule and report the field and input index', async () => {+ const response = await makeGraphqlApiRequest({+ query: gql`+ mutation {+ createOpportunity(+ data: { name: "Validation rule invalid create", stage: CUSTOMER }+ ) {+ id+ }+ }+ `,+ });++ expect(response.body.errors[0].extensions.subCode).toBe(+ 'VALIDATION_RULE_VIOLATION',+ );+ expect(response.body.errors[0].extensions.validationRuleViolations).toEqual(+ [+ expect.objectContaining({+ ruleId: validationRuleId,+ message: RULE_MESSAGE,+ fieldMetadataId: amountFieldMetadataId,+ inputIndex: 0,+ }),+ ],+ );+ expect(+ await findOpportunitiesByName('Validation rule invalid create'),+ ).toEqual([]);+ });++ it('should accept a create that satisfies the rule', async () => {+ const response = await makeGraphqlApiRequest({+ query: gql`+ mutation {+ createOpportunity(+ data: {+ name: "Validation rule valid create"+ stage: CUSTOMER+ amount: { amountMicros: 1000000000, currencyCode: "USD" }+ }+ ) {+ id+ }+ }+ `,+ });++ expect(response.body.errors).toBeUndefined();+ createdOpportunityIds.push(response.body.data.createOpportunity.id);+ });++ it('should reject the whole batch when one created record violates the rule', async () => {+ const response = await makeGraphqlApiRequest({+ query: gql`+ mutation {+ createOpportunities(+ data: [+ { name: "Validation rule batch valid", stage: NEW }+ { name: "Validation rule batch invalid", stage: CUSTOMER }+ ]+ ) {+ id+ }+ }+ `,+ });++ expect(+ response.body.errors[0].extensions.validationRuleViolations[0].inputIndex,+ ).toBe(1);+ expect(+ await findOpportunitiesByName('Validation rule batch valid'),+ ).toEqual([]);+ });++ it('should reject a partial update that makes the record invalid and keep the stored row', async () => {+ const createResponse = await makeGraphqlApiRequest({+ query: gql`+ mutation {+ createOpportunity(+ data: { name: "Validation rule partial update", stage: NEW }+ ) {+ id+ }+ }+ `,+ });++ const opportunityId = createResponse.body.data.createOpportunity.id;++ createdOpportunityIds.push(opportunityId);++ const updateResponse = await makeGraphqlApiRequest({+ query: gql`+ mutation UpdateOpportunity($id: UUID!) {+ updateOpportunity(id: $id, data: { stage: CUSTOMER }) {+ id+ }+ }+ `,+ variables: { id: opportunityId },+ });++ expect(updateResponse.body.errors[0].extensions.subCode).toBe(+ 'VALIDATION_RULE_VIOLATION',+ );+ expect(+ await findOpportunitiesByName('Validation rule partial update'),+ ).toEqual([{ id: opportunityId, stage: 'NEW' }]);+ });++ it('should retain relation keys and composite fields when selecting rule dependencies', async () => {+ const companyResponse = await makeGraphqlApiRequest({+ query: gql`+ mutation {+ createCompany(+ data: { name: "Validation projection company", employees: 5 }+ ) {+ id+ }+ }+ `,+ });+ const companyId = companyResponse.body.data.createCompany.id;+ const ruleResponse = await createValidationRule({+ objectMetadataId: opportunityObjectMetadataId,+ name: 'Company employee requirement',+ expression: 'isDefined(company) and company.employees >= 10',+ message: 'The company needs ten employees',+ });+ const relationRuleId = ruleResponse.body.data.createValidationRule.id;++ try {+ const createOpportunity = () =>+ makeGraphqlApiRequest({+ query: gql`+ mutation CreateProjectionOpportunity($companyId: UUID!) {+ createOpportunity(+ data: {+ name: "Validation projection opportunity"+ companyId: $companyId+ stage: CUSTOMER+ amount: { amountMicros: 1000000, currencyCode: "USD" }+ }+ ) {+ id+ }+ }+ `,+ variables: { companyId },+ });++ const rejected = await createOpportunity();+ expect(+ rejected.body.errors[0].extensions.validationRuleViolations,+ ).toEqual([expect.objectContaining({ ruleId: relationRuleId })]);++ await makeGraphqlApiRequest({+ query: gql`+ mutation UpdateProjectionCompany($id: UUID!) {+ updateCompany(id: $id, data: { employees: 10 }) {+ id+ }+ }+ `,+ variables: { id: companyId },+ });+ const accepted = await createOpportunity();+ expect(accepted.body.errors).toBeUndefined();+ createdOpportunityIds.push(accepted.body.data.createOpportunity.id);+ } finally {+ await makeMetadataApiRequest({+ query: gql`+ mutation DeleteProjectionRule($id: UUID!) {+ deleteValidationRule(id: $id) {+ id+ }+ }+ `,+ variables: { id: relationRuleId },+ });+ await makeGraphqlApiRequest({+ query: gql`+ mutation DeleteProjectionCompany($id: UUID!) {+ deleteCompany(id: $id) {+ id+ }+ }+ `,+ variables: { id: companyId },+ });+ }+ });+});