feat(core): Add validate function based rule condition

packages/core/src/models/uischema.ts

@@ -150,6 +150,16 @@ export interface SchemaBasedCondition extends BaseCondition, Scoped {
   failWhenUndefined?: boolean;
 }
 
+/** A condition using a validation function to determine its fulfillment. */
+export interface ValidateFunctionCondition extends BaseCondition, Scoped {
+  /**
+   * Validates whether the condition is fulfilled.
+   *
+   * @param data The data as resolved via the scope.
+   * @returns `true` if the condition is fulfilled */
+  validate: (data: unknown) => boolean;
+}
+
 /**
  * A composable condition.
  */
@@ -179,7 +189,8 @@ export type Condition =
   | LeafCondition
   | OrCondition
   | AndCondition
-  | SchemaBasedCondition;
+  | SchemaBasedCondition
+  | ValidateFunctionCondition;
 
 /**
  * Common base interface for any UI schema element.

packages/core/src/util/runtime.ts

@@ -33,6 +33,7 @@ import {
   SchemaBasedCondition,
   Scopable,
   UISchemaElement,
+  ValidateFunctionCondition,
 } from '../models';
 import { resolveData } from './resolvers';
 import type Ajv from 'ajv';
@@ -51,6 +52,12 @@ const isSchemaCondition = (
   condition: Condition
 ): condition is SchemaBasedCondition => has(condition, 'schema');
 
+const isValidateFunctionCondition = (
+  condition: Condition
+): condition is ValidateFunctionCondition =>
+  has(condition, 'validate') &&
+  typeof (condition as ValidateFunctionCondition).validate === 'function';
+
 const getConditionScope = (condition: Scopable, path: string): string => {
   return composeWithUi(condition, path);
 };
@@ -80,6 +87,9 @@ const evaluateCondition = (
       return false;
     }
     return ajv.validate(condition.schema, value) as boolean;
+  } else if (isValidateFunctionCondition(condition)) {
+    const value = resolveData(data, getConditionScope(condition, path));
+    return condition.validate(value);
   } else {
     // unknown condition
     return true;

packages/core/test/util/runtime.test.ts

@@ -33,6 +33,7 @@ import {
   OrCondition,
   RuleEffect,
   SchemaBasedCondition,
+  ValidateFunctionCondition,
 } from '../../src';
 import { evalEnablement, evalVisibility } from '../../src/util/runtime';
 
@@ -491,6 +492,90 @@ test('evalEnablement disable valid case', (t) => {
   t.is(evalEnablement(uischema, data, undefined, createAjv()), false);
 });
 
+// Add test case for ValidateFunctionCondition with evalEnablement (valid enable case)
+test('evalEnablement enable valid case based on ValidateFunctionCondition', (t) => {
+  const condition: ValidateFunctionCondition = {
+    scope: '#/properties/ruleValue',
+    validate: (data) => data === 'bar',
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.ENABLE,
+      condition: condition,
+    },
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'bar',
+  };
+  t.is(evalEnablement(uischema, data, undefined, createAjv()), true);
+});
+
+// Add test case for ValidateFunctionCondition with evalEnablement (invalid enable case)
+test('evalEnablement enable invalid case based on ValidateFunctionCondition', (t) => {
+  const condition: ValidateFunctionCondition = {
+    scope: '#/properties/ruleValue',
+    validate: (data) => data === 'bar',
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.ENABLE,
+      condition: condition,
+    },
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'foobar',
+  };
+  t.is(evalEnablement(uischema, data, undefined, createAjv()), false);
+});
+
+// Add test case for ValidateFunctionCondition with evalEnablement (valid disable case)
+test('evalEnablement disable valid case based on ValidateFunctionCondition', (t) => {
+  const condition: ValidateFunctionCondition = {
+    scope: '#/properties/ruleValue',
+    validate: (data) => data === 'bar',
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.DISABLE,
+      condition: condition,
+    },
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'bar',
+  };
+  t.is(evalEnablement(uischema, data, undefined, createAjv()), false);
+});
+
+// Add test case for ValidateFunctionCondition with evalEnablement (invalid disable case)
+test('evalEnablement disable invalid case based on ValidateFunctionCondition', (t) => {
+  const condition: ValidateFunctionCondition = {
+    scope: '#/properties/ruleValue',
+    validate: (data) => data === 'bar',
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.DISABLE,
+      condition: condition,
+    },
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'foobar',
+  };
+  t.is(evalEnablement(uischema, data, undefined, createAjv()), true);
+});
+
 test('evalEnablement disable invalid case', (t) => {
   const leafCondition: LeafCondition = {
     type: 'LEAF',

packages/examples/src/examples/rule.ts

@@ -44,6 +44,10 @@ export const schema = {
       type: 'string',
       enum: ['All', 'Some', 'Only potatoes'],
     },
+    vitaminDeficiency: {
+      type: 'string',
+      enum: ['None', 'Vitamin A', 'Vitamin B', 'Vitamin C'],
+    },
   },
 };
 
@@ -101,6 +105,20 @@ export const uischema = {
             },
           },
         },
+        {
+          type: 'Control',
+          label: 'Vitamin deficiency?',
+          scope: '#/properties/vitaminDeficiency',
+          rule: {
+            effect: 'SHOW',
+            condition: {
+              scope: '#',
+              validate: (data: any) => {
+                return !data.dead && data.kindOfVegetables !== 'All';
+              },
+            },
+          },
+        },
       ],
     },
   ],