Add support for 'then/else' paths

packages/core/src/util/path.ts

@@ -57,9 +57,9 @@ export { compose as composePaths };
  */
 export const toDataPathSegments = (schemaPath: string): string[] => {
   const s = schemaPath
-    .replace(/anyOf\/[\d]\//g, '')
-    .replace(/allOf\/[\d]\//g, '')
-    .replace(/oneOf\/[\d]\//g, '');
+    .replace(/anyOf\/[\d]\/((then|else)\/)?/g, '')
+    .replace(/allOf\/[\d]\/((then|else)\/)?/g, '')
+    .replace(/oneOf\/[\d]\/((then|else)\/)?/g, '');
   const segments = s.split('/');
 
   const decodedSegments = segments.map(decode);

packages/core/src/util/resolvers.ts

@@ -134,13 +134,29 @@ export const resolveSchema = (
       const schemas = [].concat(
         resultSchema?.oneOf ?? [],
         resultSchema?.allOf ?? [],
-        resultSchema?.anyOf ?? []
+        resultSchema?.anyOf ?? [],
+        // also add root level schema composition entries
+        schema?.oneOf ?? [],
+        schema?.allOf ?? [],
+        schema?.anyOf ?? []
       );
-      for (let item of schemas) {
+      for (const item of schemas) {
         curSchema = resolveSchema(item, validPathSegments.slice(i).map(encode).join('/'));
         if (curSchema) {
           break;
         }
+        if (!curSchema) {
+          const conditionalSchemas = [].concat(
+              item.then ?? [],
+              item.else ?? [],
+          );
+          for (const condiItem of conditionalSchemas) {
+            curSchema = resolveSchema(condiItem, schemaPath);
+            if (curSchema) {
+              break;
+            }
+          }
+        }
       }
       if (curSchema) {
         // already resolved rest of the path

packages/core/test/util/path.test.ts

@@ -46,12 +46,39 @@ test('toDataPath ', t => {
 test('toDataPath replace anyOf', t => {
   t.is(toDataPath('/anyOf/1/properties/foo/anyOf/1/properties/bar'), 'foo.bar');
 });
+test('toDataPath replace anyOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/anyOf/1/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple directly nested anyOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/anyOf/1/then/anyOf/0/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple nested properties with anyOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/anyOf/1/properties/foo/anyOf/0/then/properties/bar'), 'foo.bar');
+});
 test('toDataPath replace allOf', t => {
   t.is(toDataPath('/allOf/1/properties/foo/allOf/1/properties/bar'), 'foo.bar');
 });
+test('toDataPath replace allOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/allOf/1/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple directly nested allOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/allOf/1/then/allOf/0/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple nested properties with allOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/allOf/1/properties/foo/allOf/0/then/properties/bar'), 'foo.bar');
+});
 test('toDataPath replace oneOf', t => {
   t.is(toDataPath('/oneOf/1/properties/foo/oneOf/1/properties/bar'), 'foo.bar');
 });
+test('toDataPath replace oneOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/oneOf/1/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple directly nested oneOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/oneOf/1/then/oneOf/0/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple nested properties with oneOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/oneOf/1/properties/foo/oneOf/0/then/properties/bar'), 'foo.bar');
+});
 test('toDataPath replace all combinators', t => {
   t.is(
     toDataPath(

packages/core/test/util/resolvers.test.ts

@@ -53,15 +53,58 @@ test('resolveSchema - resolves schema with any ', t => {
           }
         }]
       }
-    }
+    },
+    anyOf: [
+      {
+        if: {
+          properties: {
+            exist: {
+              const: true
+            }
+          }
+        },
+        then: {
+          properties: {
+            lastname: {
+              type: 'string'
+            }
+          }
+        },
+        else: {
+          properties: {
+            firstname: {
+              type: 'string'
+            },
+            address: {
+              type: 'object',
+              anyOf: [
+                {
+                  properties: {
+                    street: {
+                      type: 'string'
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      }
+    ]
   };
   // test backward compatibility
   t.deepEqual(resolveSchema(schema, '#/properties/description/oneOf/0/properties/name'), {type: 'string'});
   t.deepEqual(resolveSchema(schema, '#/properties/description/oneOf/1/properties/index'), {type: 'number'});
+  t.deepEqual(resolveSchema(schema, '#/anyOf/0/then/properties/lastname'), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/anyOf/0/else/properties/firstname'), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/anyOf/0/else/properties/address/anyOf/0/properties/street'), {type: 'string'});
   // new simple approach
   t.deepEqual(resolveSchema(schema, '#/properties/description/properties/name'), {type: 'string'});
   t.deepEqual(resolveSchema(schema, '#/properties/description/properties/index'), {type: 'number'});
   t.deepEqual(resolveSchema(schema, '#/properties/description/properties/exist'), {type: 'boolean'});
+  t.deepEqual(resolveSchema(schema, '#/properties/lastname'), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/firstname'), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/address/properties/street'), {type: 'string'});
   t.is(resolveSchema(schema, '#/properties/description/properties/notfound'), undefined);
 });
 

packages/examples/src/examples/conditional-schema-compositions.ts

@@ -0,0 +1,118 @@
+/*
+  The MIT License
+
+  Copyright (c) 2017-2019 EclipseSource Munich
+  https://github.com/eclipsesource/jsonforms
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+import { registerExamples } from '../register';
+
+export const schema = {
+  type: 'object',
+  properties: {
+    name: {
+      type: 'string',
+      minLength: 1,
+      description: 'The task\'s name',
+    },
+    recurrence: {
+      type: 'string',
+      enum: ['Never', 'Daily', 'Weekly', 'Monthly'],
+    },
+  },
+  anyOf: [
+    {
+      if: {
+        properties: {
+          recurrence: {
+            const: 'Never'
+          }
+        }
+      },
+      then: {
+        properties: {
+          lastname: {
+            type: 'string'
+          },
+          age: {
+            type: 'number'
+          }
+        }
+      }
+    },
+  ]
+};
+
+export const uischema = {
+  type: 'HorizontalLayout',
+  elements: [
+    {
+      type: 'VerticalLayout',
+      elements: [
+        {
+          type: 'Control',
+          scope: '#/properties/name',
+        },
+        {
+          type: 'Control',
+          scope: '#/properties/recurrence',
+        },
+        {
+          type: 'Control',
+          scope: '#/anyOf/0/then/properties/lastname',
+          rule: {
+            effect: 'SHOW',
+            condition: {
+              scope: '#/properties/recurrence',
+              schema: {
+                const: 'Never'
+              }
+            }
+          }
+        },
+        {
+          type: 'Control',
+          scope: '#/properties/age',
+          rule: {
+            effect: 'SHOW',
+            condition: {
+              scope: '#/properties/recurrence',
+              schema: {
+                const: 'Never'
+              }
+            }
+          }
+        },
+      ],
+    },
+  ],
+};
+
+const data = {};
+
+registerExamples([
+  {
+    name: 'conditional-schema-compositions',
+    label: 'Conditional Schema Compositions',
+    data,
+    schema,
+    uischema
+  }
+]);

packages/examples/src/index.ts

@@ -76,6 +76,7 @@ import * as enumInArray from './examples/enumInArray';
 import * as readonly from './examples/readonly';
 import * as bug_1779 from './examples/1779';
 import * as bug_1645 from './examples/1645';
+import * as conditionalSchemaComposition from './examples/conditional-schema-compositions';
 export * from './register';
 export * from './example';
 
@@ -136,5 +137,6 @@ export {
   enumInArray,
   readonly,
   bug_1779,
-  bug_1645
+  bug_1645,
+  conditionalSchemaComposition
 };