Skip to content

The open alternative to Salesforce, designed for AI.

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.tsx
index 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>
+ )}
<SidePanelFooter
actions={[
<Button
diff --git a/packages/twenty-front/src/modules/validation-rules/types/DraftValidationRuleViolation.ts b/packages/twenty-front/src/modules/validation-rules/types/DraftValidationRuleViolation.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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/pe
import { 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.ts
index 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/reco
import { 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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 WorkspaceDataSourceService
workspaceContext.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.ts
index 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/typ
import { 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.ts
index 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.ts
index 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/r
import { 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.ts
index 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/typ
import { 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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 },
+ });
+ }
+ });
+});