Add schema based condition

packages/core/src/models/uischema.ts

@@ -22,6 +22,8 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
 */
+import {JsonSchema} from './jsonSchema';
+
 /**
  * Interface for describing an UI schema element that is referencing
  * a subschema. The value of the scope must be a JSON Pointer.
@@ -78,7 +80,7 @@ export interface Condition {
   /**
    * The type of condition.
    */
-  type: string;
+  type?: string;
 }
 
 /**
@@ -94,6 +96,10 @@ export interface LeafCondition extends Condition, Scopable {
   expectedValue: any;
 }
 
+export interface SchemaBasedCondition extends Condition, Scopable {
+  schema: JsonSchema;
+}
+
 /**
  * Common base interface for any UI schema element.
  */

packages/core/src/util/runtime.ts

@@ -25,51 +25,68 @@
 import * as _ from 'lodash';
 // TODO: pass in uischema and data instead of props and state
 import { getData } from '../reducers';
-import { LeafCondition, RuleEffect, UISchemaElement } from '../models/uischema';
+import {
+  Condition,
+  LeafCondition,
+  RuleEffect,
+  SchemaBasedCondition,
+  UISchemaElement
+} from '../models/uischema';
 import { resolveData } from './resolvers';
 import { toDataPath } from './path';
+import { createAjv } from './validator';
 
-const isRuleDefined = (uischema: UISchemaElement): boolean =>
-  !_.has(uischema, 'rule.condition') || !_.has(uischema, 'rule.condition.type') ||
+const ajv = createAjv();
+
+const ruleIsMissingProperties = (uischema: UISchemaElement): boolean =>
+  !_.has(uischema, 'rule.condition') ||
   !_.has(uischema, 'rule.condition.scope') ||
-  !_.has(uischema, 'rule.condition.expectedValue');
+  (!_.has(uischema, 'rule.condition.expectedValue') && !_.has(uischema, 'rule.condition.schema'));
 
-export const evalVisibility = (uischema: UISchemaElement, data: any) => {
-  // TODO condition evaluation should be done somewhere else
-  if (isRuleDefined(uischema)) {
+const isLeafCondition = (condition: Condition): condition is LeafCondition =>
+  condition.type === 'LEAF';
 
+const isSchemaCondition = (condition: Condition): condition is SchemaBasedCondition =>
+  _.has(condition, 'schema');
+
+const isConditionFulfilled = (uischema: UISchemaElement, data: any) => {
+  if (ruleIsMissingProperties(uischema)) {
     return true;
   }
-  const condition = uischema.rule.condition as LeafCondition;
-  const value = resolveData(data, toDataPath(condition.scope));
-  const equals = value === condition.expectedValue;
 
-  switch (uischema.rule.effect) {
-    case RuleEffect.HIDE: return !equals;
-    case RuleEffect.SHOW: return equals;
-    default:
-    // visible by default
+  const condition = uischema.rule.condition;
+
+  if (isLeafCondition(condition)) {
+    const value = resolveData(data, toDataPath(condition.scope));
+    return value === condition.expectedValue;
+  } else if (isSchemaCondition(condition)) {
+    const value = resolveData(data, toDataPath(condition.scope));
+    return  ajv.validate(condition.schema, value);
+  } else {
+    // unknown condition
     return true;
   }
 };
 
-export const evalEnablement = (uischema: UISchemaElement, data: any) => {
-
-  if (isRuleDefined(uischema)) {
+export const evalVisibility = (uischema: UISchemaElement, data: any) => {
+  const fulfilled = isConditionFulfilled(uischema, data);
 
-    return true;
+  switch (uischema.rule.effect) {
+    case RuleEffect.HIDE: return !fulfilled;
+    case RuleEffect.SHOW: return fulfilled;
+    // visible by default
+    default: return true;
   }
+};
 
-  const condition = uischema.rule.condition as LeafCondition;
-  const value = resolveData(data, toDataPath(condition.scope));
-  const equals = value === condition.expectedValue;
+export const evalEnablement = (uischema: UISchemaElement, data: any) => {
+  const fulfilled = isConditionFulfilled(uischema, data);
 
   switch (uischema.rule.effect) {
-    case RuleEffect.DISABLE: return !equals;
-    case RuleEffect.ENABLE: return equals;
-    default:
+    case RuleEffect.DISABLE: return !fulfilled;
+    case RuleEffect.ENABLE: return fulfilled;
     // enabled by default
-    return true;
+    default: return true;
   }
 };
 

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

@@ -23,7 +23,7 @@
   THE SOFTWARE.
 */
 import test from 'ava';
-import { ControlElement, LeafCondition, RuleEffect } from '../../src';
+import { ControlElement, LeafCondition, RuleEffect, SchemaBasedCondition } from '../../src';
 import { evalEnablement, evalVisibility } from '../../src/util/runtime';
 
 test('evalVisibility show valid case', t => {
@@ -47,6 +47,52 @@ test('evalVisibility show valid case', t => {
     t.is(evalVisibility(uischema, data), true);
 });
 
+test('evalVisibility show valid case based on schema condition', t => {
+  const condition: SchemaBasedCondition = {
+    scope: '#/properties/ruleValue',
+    schema: {
+        const: 'bar'
+    }
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.SHOW,
+      condition
+    }
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'bar'
+  };
+  t.is(evalVisibility(uischema, data), true);
+});
+
+test.only('evalVisibility show valid case based on schema condition and enum', t => {
+  const condition: SchemaBasedCondition = {
+    scope: '#/properties/ruleValue',
+    schema: {
+      enum: ['bar', 'baz']
+    }
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.SHOW,
+      condition
+    }
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'bar'
+  };
+  t.is(evalVisibility(uischema, data), true);
+  t.is(evalVisibility(uischema, { ...data, ruleValue: 'baz', }), true);
+  t.is(evalVisibility(uischema, { ...data, ruleValue: 'foo'}), false);
+});
+
 test('evalVisibility show invalid case', t => {
     const leafCondition: LeafCondition = {
         type: 'LEAF' ,
@@ -191,3 +237,27 @@ test('evalEnablement disable invalid case', t => {
     };
     t.is(evalEnablement(uischema, data), true);
 });
+
+test('evalEnablement disable invalid case based on schema condition', t => {
+  const condition: SchemaBasedCondition = {
+    scope: '#/properties/ruleValue',
+    schema: {
+      enum: ['bar', 'baz']
+    }
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/value',
+    rule: {
+      effect: RuleEffect.DISABLE,
+      condition
+    }
+  };
+  const data = {
+    value: 'foo',
+    ruleValue: 'bar'
+  };
+  t.is(evalEnablement(uischema, data), true);
+  t.is(evalEnablement(uischema, {...data, ruleValue: 'baz'}), true);
+  t.is(evalEnablement(uischema, {...data, ruleValue: 'foo'}), false);
+});