feat: Added support for rule-agnostic and common validation rules

Author: Vojtěch Václav Porteš

README.md

@@ -209,38 +209,72 @@ const fields: IBuilderFieldProps[] = [
     type: 'TEXT',
     operators: ['EQUAL', 'CONTAINS'],
     validation: {
-      required: true,
-      minLength: 2,
-      maxLength: 50,
+      common: {
+        required: true,
+      },
+      rules: [
+        {
+          operators: ['EQUAL', 'CONTAINS'],
+          minLength: 2,
+          maxLength: 50,
+        },
+      ],
     },
   },
   {
     field: 'PRICE',
     label: 'Price',
     type: 'NUMBER',
-    operators: ['EQUAL', 'BETWEEN'],
+    operators: ['EQUAL', 'BETWEEN', 'NOT_BETWEEN'],
     validation: {
-      min: 0,
-      range: {
-        requireAscending: true,
-        allowEqual: false,
+      common: {
+        required: true,
       },
+      rules: [
+        {
+          operators: ['EQUAL'],
+          min: 0,
+          max: 100,
+        },
+        {
+          operators: ['BETWEEN', 'NOT_BETWEEN'],
+          range: {
+            common: {
+              min: 0,
+              max: 100,
+            },
+            start: {
+              max: 80,
+            },
+            end: {
+              min: 10,
+            },
+            requireAscending: true,
+            allowEqual: false,
+          },
+        },
+      ],
     },
   },
 ];
 ```
 
 Built-in validation supports:
 
+- operator-agnostic validation in `validation.common`
+- operator-aware validation in `validation.rules`
 - shared rules like `required`, `oneOf`, and `custom`
 - text rules like `minLength`, `maxLength`, and `matches`
 - number rules like `min`, `max`, `integer`, `positive`, and `negative`
 - date rules like `minDate` and `maxDate`
 - multi-list rules like `minItems` and `maxItems`
 - range validation for `BETWEEN` and `NOT_BETWEEN`
 
-If you use `range`, you can validate both the range shape and the relationship between values:
+If you use `range`, you can validate both values together and individually:
 
+- `common`
+- `start`
+- `end`
 - `requireAscending`
 - `allowEqual`
 - `validate`

src/builder.tsx

@@ -46,13 +46,13 @@ import { Text } from './text';
 import { IButtonProps } from './button';
 import { createGroupNode } from './utils/create-group-node.util';
 import { createId } from './utils/create-id.util';
-import { createBuilderValidationResult } from './utils/create-builder-validation-result.util';
 import { emitQuery } from './utils/emit-query.util';
 import { ingestQuery } from './utils/ingest-query.util';
 import { isPromiseLike } from './utils/is-promise-like.util';
 import { isSameQuery } from './utils/is-same-query.util';
 import { moveQueryNode } from './utils/move-query-node.util';
-import { validateBuilderQuery } from './utils/validate-builder-query.util';
+import { createBuilderValidationResult } from './utils/validation/create-builder-validation-result.util';
+import { validateBuilderQuery } from './utils/validation/validate-builder-query.util';
 import {
   DenormalizedQuery,
   INormalizedRuleNode,
@@ -111,16 +111,26 @@ export interface IBuilderValidationMessageContext {
   operator?: BuilderFieldOperator;
   value?: BuilderFieldValue;
   ruleId?: string;
+  rangeBoundary?: 'start' | 'end';
 }
 
 export type BuilderValidationMessage =
   | string
   | ((context: IBuilderValidationMessageContext) => string);
 
-export interface IBuilderRangeValidation<TValue = string | number> {
+export interface IBuilderRangeValidation<
+  TValueValidation = unknown,
+  TRangeValue = string | number
+> {
+  common?: Partial<TValueValidation>;
+  start?: Partial<TValueValidation>;
+  end?: Partial<TValueValidation>;
   allowEqual?: boolean;
   requireAscending?: boolean;
-  validate?: (range: [TValue, TValue]) => boolean | Promise<boolean>;
+  validate?: (
+    range: [TRangeValue, TRangeValue],
+    context: IBuilderValidationMessageContext
+  ) => boolean | Promise<boolean>;
   message?: BuilderValidationMessage;
 }
 
@@ -134,48 +144,100 @@ export interface IBuilderFieldValidationBase<TValue = unknown> {
   customMessage?: BuilderValidationMessage;
 }
 
-export interface ITextFieldValidation
+export interface ITextValueValidationRule
   extends IBuilderFieldValidationBase<string | string[]> {
   minLength?: number;
   maxLength?: number;
   matches?: RegExp;
-  range?: IBuilderRangeValidation<string>;
 }
 
-export interface INumberFieldValidation
+export interface INumberValueValidationRule
   extends IBuilderFieldValidationBase<number | number[]> {
   min?: number;
   max?: number;
   integer?: boolean;
   positive?: boolean;
   negative?: boolean;
-  range?: IBuilderRangeValidation<number>;
 }
 
-export interface IDateFieldValidation
+export interface IDateValueValidationRule
   extends IBuilderFieldValidationBase<string | string[]> {
   minDate?: string | Date;
   maxDate?: string | Date;
-  range?: IBuilderRangeValidation<string>;
 }
 
-export type IBooleanFieldValidation = IBuilderFieldValidationBase<boolean>;
+export type IBooleanValueValidationRule = IBuilderFieldValidationBase<boolean>;
 
-export type IListFieldValidation =
+export type IListValueValidationRule =
   IBuilderFieldValidationBase<string | number>;
 
-export interface IMultiListFieldValidation
+export interface IMultiListValueValidationRule
   extends IBuilderFieldValidationBase<Array<string | number>> {
   minItems?: number;
   maxItems?: number;
 }
 
-export type IStatementFieldValidation = IBuilderFieldValidationBase<string> & {
+export type IStatementValueValidationRule =
+  IBuilderFieldValidationBase<string> & {
   minLength?: number;
   maxLength?: number;
   matches?: RegExp;
 };
 
+export type IBuilderOperatorValidationRule<TRule> = Partial<TRule> & {
+  operators: BuilderFieldOperator[];
+};
+
+export interface IBuilderValidationConfig<TRule> {
+  common?: Partial<TRule>;
+  rules?: Array<IBuilderOperatorValidationRule<TRule>>;
+}
+
+export interface ITextFieldValidationRule extends ITextValueValidationRule {
+  range?: IBuilderRangeValidation<ITextValueValidationRule, string>;
+}
+
+export interface INumberFieldValidationRule extends INumberValueValidationRule {
+  range?: IBuilderRangeValidation<INumberValueValidationRule, number>;
+}
+
+export interface IDateFieldValidationRule extends IDateValueValidationRule {
+  range?: IBuilderRangeValidation<IDateValueValidationRule, string>;
+}
+
+export type IStatementFieldValidationRule = IStatementValueValidationRule;
+export type IBooleanFieldValidationRule = IBooleanValueValidationRule;
+export type IListFieldValidationRule = IListValueValidationRule;
+export type IMultiListFieldValidationRule = IMultiListValueValidationRule;
+
+export type ITextFieldValidation =
+  | Partial<ITextFieldValidationRule>
+  | IBuilderValidationConfig<ITextFieldValidationRule>;
+
+export type INumberFieldValidation =
+  | Partial<INumberFieldValidationRule>
+  | IBuilderValidationConfig<INumberFieldValidationRule>;
+
+export type IDateFieldValidation =
+  | Partial<IDateFieldValidationRule>
+  | IBuilderValidationConfig<IDateFieldValidationRule>;
+
+export type IBooleanFieldValidation =
+  | Partial<IBooleanFieldValidationRule>
+  | IBuilderValidationConfig<IBooleanFieldValidationRule>;
+
+export type IListFieldValidation =
+  | Partial<IListFieldValidationRule>
+  | IBuilderValidationConfig<IListFieldValidationRule>;
+
+export type IMultiListFieldValidation =
+  | Partial<IMultiListFieldValidationRule>
+  | IBuilderValidationConfig<IMultiListFieldValidationRule>;
+
+export type IStatementFieldValidation =
+  | Partial<IStatementFieldValidationRule>
+  | IBuilderValidationConfig<IStatementFieldValidationRule>;
+
 interface IBuilderFieldBase<
   TType extends BuilderFieldType,
   TValue extends BuilderFieldValue | undefined,

src/index.tsx

@@ -12,7 +12,9 @@ export type {
   IBuilderComponentsProps,
   IBuilderFieldProps,
   IBuilderFieldValidationBase,
+  IBuilderOperatorValidationRule,
   IBuilderStateChange,
+  IBuilderValidationConfig,
   IBuilderValidationContext,
   IBuilderValidationIssue,
   IBuilderValidationMessageContext,
@@ -23,17 +25,31 @@ export type {
   IResolvedBuilderComponentsProps,
   IDateFieldProps,
   IDateFieldValidation,
+  IDateFieldValidationRule,
+  IDateValueValidationRule,
   IGroupFieldProps,
   IListFieldProps,
   IListFieldValidation,
+  IListFieldValidationRule,
+  IListValueValidationRule,
   IMultiListFieldProps,
   IMultiListFieldValidation,
+  IMultiListFieldValidationRule,
+  IMultiListValueValidationRule,
   INumberFieldProps,
   INumberFieldValidation,
+  INumberFieldValidationRule,
+  INumberValueValidationRule,
   IStatementFieldProps,
   IStatementFieldValidation,
+  IStatementFieldValidationRule,
+  IStatementValueValidationRule,
   ITextFieldProps,
   ITextFieldValidation,
+  ITextFieldValidationRule,
+  ITextValueValidationRule,
+  IBooleanFieldValidationRule,
+  IBooleanValueValidationRule,
 } from './builder';
 export { ThemeProvider } from './theme-provider/theme-provider'
 export type { IThemeProviderProps } from './theme-provider/theme-provider'

src/utils/validate-builder-query.util.test.ts

@@ -3,7 +3,7 @@ import {
   IBuilderValidationContext,
 } from '../builder';
 import { strings } from '../constants/strings';
-import { validateBuilderQuery } from './validate-builder-query.util';
+import { validateBuilderQuery } from './validation/validate-builder-query.util';
 
 describe('validateBuilderQuery', () => {
   const context: IBuilderValidationContext = {
@@ -22,13 +22,35 @@ describe('validateBuilderQuery', () => {
         field: 'AMOUNT',
         label: 'Amount',
         type: 'NUMBER',
-        operators: ['BETWEEN'],
+        operators: ['LARGER', 'BETWEEN', 'NOT_BETWEEN'],
         validation: {
-          required: true,
-          range: {
-            requireAscending: true,
-            allowEqual: false,
+          common: {
+            required: true,
           },
+          rules: [
+            {
+              operators: ['LARGER'],
+              min: 10,
+              max: 20,
+            },
+            {
+              operators: ['BETWEEN', 'NOT_BETWEEN'],
+              range: {
+                common: {
+                  min: 10,
+                  max: 20,
+                },
+                start: {
+                  max: 15,
+                },
+                end: {
+                  min: 12,
+                },
+                requireAscending: true,
+                allowEqual: false,
+              },
+            },
+          ],
         },
       },
     ] as IBuilderFieldProps[],
@@ -93,7 +115,59 @@ describe('validateBuilderQuery', () => {
     );
 
     expect(result.isValid).toEqual(false);
-    expect(result.issuesByRuleId['rule-2'][0].code).toEqual('range_order');
+    expect(result.issuesByRuleId['rule-2'].map((issue) => issue.code)).toEqual(
+      expect.arrayContaining(['range_order'])
+    );
+  });
+
+  it('Applies operator-specific scalar validation for single-value operators', async () => {
+    const result = await validateBuilderQuery(
+      [
+        {
+          type: 'GROUP',
+          value: 'AND',
+          isNegated: false,
+          children: [
+            {
+              id: 'rule-3',
+              field: 'AMOUNT',
+              operator: 'LARGER',
+              value: 5,
+            },
+          ],
+        },
+      ],
+      context
+    );
+
+    expect(result.isValid).toEqual(false);
+    expect(result.issuesByRuleId['rule-3'][0].code).toEqual('min');
+  });
+
+  it('Applies common and boundary-specific validation for range operators', async () => {
+    const result = await validateBuilderQuery(
+      [
+        {
+          type: 'GROUP',
+          value: 'AND',
+          isNegated: false,
+          children: [
+            {
+              id: 'rule-4',
+              field: 'AMOUNT',
+              operator: 'BETWEEN',
+              value: [16, 11],
+            },
+          ],
+        },
+      ],
+      context
+    );
+
+    expect(result.isValid).toEqual(false);
+    expect(result.issuesByRuleId['rule-4'].map((issue) => issue.code)).toEqual(
+      expect.arrayContaining(['max', 'min', 'range_order'])
+    );
   });
 
   it('Uses localized validation messages from strings', async () => {