Let deriveType return an array

* Rename deriveType to deriveTypes
* schemaTypeIs is working for array types
* Update AllOfRenderer rank to 3
* Update AnyOfRenderer rank to 3

Fixes eclipsesource#1355

Author: eneufeld

packages/core/src/generators/uischema.ts

@@ -34,7 +34,7 @@ import {
   UISchemaElement
 } from '../models/uischema';
 import { resolveSchema } from '../util/resolvers';
-import { deriveType } from '../util';
+import { deriveTypes } from '../util';
 
 /**
  * Creates a new ILayout.
@@ -140,9 +140,18 @@ const generateUISchema = (
     return controlObject;
   }
 
-  const type = deriveType(jsonSchema);
+  const types = deriveTypes(jsonSchema);
+  if (types.length === 0) {
+    return null;
+  }
+
+  if (types.length > 1) {
+    const controlObject: ControlElement = createControlElement(currentRef);
+    schemaElements.push(controlObject);
+    return controlObject;
+  }
 
-  switch (type) {
+  switch (types[0]) {
     case 'object':
       const layout: Layout = createLayout(layoutType);
       schemaElements.push(layout);
@@ -186,8 +195,6 @@ const generateUISchema = (
       schemaElements.push(controlObject);
 
       return controlObject;
-    case 'null':
-      return null;
     default:
       throw new Error('Unknown type: ' + JSON.stringify(jsonSchema));
   }

packages/core/src/testers/index.ts

@@ -38,7 +38,7 @@ import {
   UISchemaElement
 } from '../models/uischema';
 import { resolveSchema } from '../util/resolvers';
-import { deriveType } from '../util';
+import { deriveTypes, isValidType } from '../util';
 
 /**
  * Constant that indicates that a tester is not capable of handling
@@ -86,7 +86,7 @@ export const schemaMatches = (
     return false;
   }
   let currentDataSchema = schema;
-  if (deriveType(schema) === 'object') {
+  if (isValidType(schema, 'object')) {
     currentDataSchema = resolveSchema(schema, schemaPath);
   }
   if (currentDataSchema === undefined) {
@@ -127,7 +127,9 @@ export const schemaSubPathMatches = (
  * @param {string} expectedType the expected type of the resolved sub-schema
  */
 export const schemaTypeIs = (expectedType: string): Tester =>
-  schemaMatches(schema => !isEmpty(schema) && schema.type === expectedType);
+  schemaMatches(
+    schema => !isEmpty(schema) && isValidType(schema, expectedType)
+  );
 
 /**
  * Only applicable for Controls.
@@ -359,9 +361,9 @@ export const isDateTimeControl = and(
  */
 export const isObjectArray = and(
   schemaMatches(
-    schema => deriveType(schema) === 'array' && !Array.isArray(schema.items) // we don't care about tuples
+    schema => isValidType(schema, 'array') && !Array.isArray(schema.items) // we don't care about tuples
   ),
-  schemaSubPathMatches('items', schema => deriveType(schema) === 'object')
+  schemaSubPathMatches('items', schema => isValidType(schema, 'object'))
 );
 
 /**
@@ -457,17 +459,16 @@ export const isArrayObjectControl = isObjectArrayControl;
  */
 export const isPrimitiveArrayControl = and(
   uiTypeIs('Control'),
-  schemaMatches(schema => {
+  schemaMatches(
+    schema => deriveTypes(schema).length !== 0 && !Array.isArray(schema.items) // we don't care about tuples
+  ),
+  schemaSubPathMatches('items', schema => {
+    const types = deriveTypes(schema);
     return (
-      !isEmpty(schema) &&
-      schema.type === 'array' &&
-      !isEmpty(schema.items) &&
-      !Array.isArray(schema.items)
-    ); // we don't care about tuples
-  }),
-  schemaSubPathMatches('items', schema =>
-    includes(['integer', 'number', 'boolean', 'string'], schema.type)
-  )
+      types.length === 1 &&
+      includes(['integer', 'number', 'boolean', 'string'], types[0])
+    );
+  })
 );
 
 /**

packages/core/src/util/index.ts

@@ -24,7 +24,7 @@
 */
 import isEmpty from 'lodash/isEmpty';
 import isArray from 'lodash/isArray';
-import head from 'lodash/head';
+import includes from 'lodash/includes';
 import find from 'lodash/find';
 import { JsonSchema, Scopable, UISchemaElement } from '../';
 import { resolveData, resolveSchema } from './resolvers';
@@ -56,52 +56,45 @@ export const formatErrorMessage = (errors: string[]) => {
   return errors.join('\n');
 };
 
-/**
- * Checks if the type of jsonSchema is a union of multiple types
- *
- * @param {JsonSchema} jsonSchema
- * @returns {boolean}
- */
-const isUnionType = (jsonSchema: JsonSchema): boolean =>
-  !isEmpty(jsonSchema) && !isEmpty(jsonSchema.type) && isArray(jsonSchema.type);
+const isValidType = (jsonSchema: JsonSchema, expected: string): boolean => {
+  return includes(deriveTypes(jsonSchema), expected);
+};
 
 /**
  * Derives the type of the jsonSchema element
  */
-const deriveType = (jsonSchema: JsonSchema): string => {
-  if (
-    !isEmpty(jsonSchema) &&
-    !isEmpty(jsonSchema.type) &&
-    typeof jsonSchema.type === 'string'
-  ) {
-    return jsonSchema.type;
+const deriveTypes = (jsonSchema: JsonSchema): string[] => {
+  if (isEmpty(jsonSchema)) {
+    return [];
   }
-  if (isUnionType(jsonSchema)) {
-    return head(jsonSchema.type);
+  if (!isEmpty(jsonSchema.type) && typeof jsonSchema.type === 'string') {
+    return [jsonSchema.type];
+  }
+  if (isArray(jsonSchema.type)) {
+    return jsonSchema.type;
   }
   if (
-    !isEmpty(jsonSchema) &&
-    (!isEmpty(jsonSchema.properties) ||
-      !isEmpty(jsonSchema.additionalProperties))
+    !isEmpty(jsonSchema.properties) ||
+    !isEmpty(jsonSchema.additionalProperties)
   ) {
-    return 'object';
+    return ['object'];
   }
-  if (!isEmpty(jsonSchema) && !isEmpty(jsonSchema.items)) {
-    return 'array';
+  if (!isEmpty(jsonSchema.items)) {
+    return ['array'];
   }
 
-  if (!isEmpty(jsonSchema) && !isEmpty(jsonSchema.allOf)) {
+  if (!isEmpty(jsonSchema.allOf)) {
     const allOfType = find(
       jsonSchema.allOf,
-      (schema: JsonSchema) => deriveType(schema) !== 'null'
+      (schema: JsonSchema) => deriveTypes(schema).length !== 0
     );
 
     if (allOfType) {
-      return deriveType(allOfType);
+      return deriveTypes(allOfType);
     }
   }
   // ignore all remaining cases
-  return 'null';
+  return [];
 };
 
 /**
@@ -140,7 +133,7 @@ const Runtime = {
     return isVisible(uischema, data);
   }
 };
-export { isEnabled, isVisible, Runtime, deriveType };
+export { isEnabled, isVisible, Runtime, deriveTypes, isValidType };
 
 export * from './renderer';
 export * from './cell';

packages/core/test/testers.test.ts

@@ -104,6 +104,21 @@ test('schemaTypeIs should return false for control pointing to invalid sub-schem
   t.false(schemaTypeIs('string')(uischema, schema));
 });
 
+test('schemaTypeIs should return true for array type', t => {
+  const schema: JsonSchema = {
+    type: 'object',
+    properties: {
+      foo: { type: ['string', 'integer'] }
+    }
+  };
+  const uischema: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/foo'
+  };
+  t.true(schemaTypeIs('string')(uischema, schema));
+  t.true(schemaTypeIs('integer')(uischema, schema));
+});
+
 test('formatIs should check the format of a resolved sub-schema', t => {
   const uischema: ControlElement = {
     type: 'Control',

packages/core/test/util/derivetype.test.ts

@@ -25,13 +25,14 @@
 import test from 'ava';
 
 import { JsonSchema } from '../../src/models/jsonSchema';
-import { deriveType } from '../../src/util/index';
+import { deriveTypes } from '../../src/util/index';
 
 test('derive type with type', t => {
   const schema: JsonSchema = {
     type: 'string'
   };
-  t.is(deriveType(schema), 'string');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'string');
 });
 
 test('derive type w/o type - properties object', t => {
@@ -40,7 +41,8 @@ test('derive type w/o type - properties object', t => {
       foo: { type: 'string' }
     }
   };
-  t.is(deriveType(schema), 'object');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'object');
 });
 
 test('derive type w/o type - additionalProperties object', t => {
@@ -49,7 +51,8 @@ test('derive type w/o type - additionalProperties object', t => {
       type: 'string'
     }
   };
-  t.is(deriveType(schema), 'object');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'object');
 });
 
 test('derive type w/o type - items array', t => {
@@ -58,29 +61,33 @@ test('derive type w/o type - items array', t => {
       type: 'string'
     }
   };
-  t.is(deriveType(schema), 'array');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'array');
 });
 
 test('derive type with type - union', t => {
   const schema: JsonSchema = {
     type: ['string', 'number']
   };
+  t.is(deriveTypes(schema).length, 2);
   // we just take the first, as derive type returns exactly one value
-  t.is(deriveType(schema), 'string');
+  t.is(deriveTypes(schema), schema.type);
 });
 
 test('derive type with type - allOf first has type', t => {
   const schema: JsonSchema = {
     allOf: [{ type: 'string' }, { enum: ['foo', 'bar'] }]
   };
-  t.is(deriveType(schema), 'string');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'string');
 });
 
 test('derive type with type - allOf other has type', t => {
   const schema: JsonSchema = {
     allOf: [{ enum: ['foo', 'bar'] }, { type: 'string' }]
   };
-  t.is(deriveType(schema), 'string');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'string');
 });
 
 test('derive type w/o type - allOf other has type', t => {
@@ -90,5 +97,6 @@ test('derive type w/o type - allOf other has type', t => {
       { properties: { bar: { type: 'string' } } }
     ]
   };
-  t.is(deriveType(schema), 'object');
+  t.is(deriveTypes(schema).length, 1);
+  t.is(deriveTypes(schema)[0], 'object');
 });

packages/material/src/complex/MaterialAllOfRenderer.tsx

@@ -38,40 +38,41 @@ import {
 } from '@jsonforms/core';
 import { ResolvedJsonForms } from '@jsonforms/react';
 
-class MaterialAllOfRenderer extends React.Component<StatePropsOfCombinator, any> {
-
+class MaterialAllOfRenderer extends React.Component<
+  StatePropsOfCombinator,
+  any
+> {
   render() {
-
-    const {
-      schema,
-      rootSchema,
-      path,
-      visible
-    } = this.props;
+    const { schema, rootSchema, path, visible } = this.props;
 
     const _schema = resolveSubSchemas(schema, rootSchema, 'allOf');
-    const allOfRenderInfos = createCombinatorRenderInfos((_schema as JsonSchema).allOf, rootSchema, 'allOf');
+    const allOfRenderInfos = createCombinatorRenderInfos(
+      (_schema as JsonSchema).allOf,
+      rootSchema,
+      'allOf'
+    );
 
     return (
       <Hidden xsUp={!visible}>
-        {
-          allOfRenderInfos.map((allOfRenderInfo, allOfIndex) => (
-            <ResolvedJsonForms
-              key={allOfIndex}
-              schema={allOfRenderInfo.schema}
-              uischema={allOfRenderInfo.uischema}
-              path={path}
-            />
-          ))
-        }
+        {allOfRenderInfos.map((allOfRenderInfo, allOfIndex) => (
+          <ResolvedJsonForms
+            key={allOfIndex}
+            schema={allOfRenderInfo.schema}
+            uischema={allOfRenderInfo.uischema}
+            path={path}
+          />
+        ))}
       </Hidden>
     );
   }
 }
 
-const ConnectedMaterialAllOfRenderer = connect(
-  mapStateToAllOfProps
-)(MaterialAllOfRenderer);
+const ConnectedMaterialAllOfRenderer = connect(mapStateToAllOfProps)(
+  MaterialAllOfRenderer
+);
 
-export const materialAllOfControlTester: RankedTester = rankWith(2, isAllOfControl);
+export const materialAllOfControlTester: RankedTester = rankWith(
+  3,
+  isAllOfControl
+);
 export default ConnectedMaterialAllOfRenderer;