feat(@angular-devkit/core): add not/anyOf/allOf/oneOf support to undefined defaults

Author: clydin

packages/angular_devkit/core/src/json/interface.ts

@@ -109,3 +109,9 @@ export interface JsonAstComment extends JsonAstNodeBase {
 
 
 export type JsonValue = JsonAstNode['value'];
+
+export const JsonValue = {
+  isJsonObject(value: JsonValue): value is JsonObject {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+  },
+};

packages/angular_devkit/core/src/json/schema/registry_spec.ts

@@ -366,4 +366,62 @@ describe('CoreSchemaRegistry', () => {
       )
       .toPromise().then(done, done.fail);
   });
+
+  it('adds undefined properties', done => {
+    const registry = new CoreSchemaRegistry();
+    const data: any = {};  // tslint:disable-line:no-any
+
+    registry
+      .compile({
+        properties: {
+          bool: { type: 'boolean' },
+          str: { type: 'string', default: 'someString' },
+          obj: {
+            properties: {
+              num: { type: 'number' },
+              other: { type: 'number', default: 0 },
+            },
+          },
+          objAllOk: {
+            allOf: [
+              { type: 'object' },
+            ],
+          },
+          objAllBad: {
+            allOf: [
+              { type: 'object' },
+              { type: 'number' },
+            ],
+          },
+          objOne: {
+            oneOf: [
+              { type: 'object' },
+            ],
+          },
+          objNotOk: {
+            not: { not: { type: 'object' } },
+          },
+          objNotBad: {
+            type: 'object',
+            not: { type: 'object' },
+          },
+        },
+      })
+      .pipe(
+        mergeMap(validator => validator(data)),
+        map(result => {
+          expect(result.success).toBe(true);
+          expect(data.bool).toBeUndefined();
+          expect(data.str).toBe('someString');
+          expect(data.obj.num).toBeUndefined();
+          expect(data.obj.other).toBe(0);
+          expect(data.objAllOk).toEqual({});
+          expect(data.objOne).toEqual({});
+          expect(data.objAllBad).toBeUndefined();
+          expect(data.objNotOk).toEqual({});
+          expect(data.objNotBad).toBeUndefined();
+        }),
+      )
+      .toPromise().then(done, done.fail);
+  });
 });

packages/angular_devkit/core/src/json/schema/transforms.ts

@@ -5,38 +5,121 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { JsonArray, JsonObject, JsonValue } from '../interface';
+import { JsonObject, JsonValue } from '../interface';
 import { JsonPointer } from './interface';
 
+const allTypes = ['string', 'integer', 'number', 'object', 'array', 'boolean', 'null'];
+
+function findTypes(schema: JsonObject): Set<string> {
+  if (!schema) {
+    return new Set();
+  }
+
+  let potentials: Set<string>;
+  if (typeof schema.type === 'string') {
+    potentials = new Set([schema.type]);
+  } else if (Array.isArray(schema.type)) {
+    potentials = new Set(schema.type as string[]);
+  } else {
+    potentials = new Set(allTypes);
+  }
+
+  if (JsonValue.isJsonObject(schema.not)) {
+    const notTypes = findTypes(schema.not);
+    potentials = new Set([...potentials].filter(p => !notTypes.has(p)));
+  }
+
+  if (Array.isArray(schema.allOf)) {
+    for (const sub of schema.allOf) {
+      const types = findTypes(sub as JsonObject);
+      potentials = new Set([...potentials].filter(p => types.has(p)));
+    }
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    let options = new Set<string>();
+    for (const sub of schema.oneOf) {
+      const types = findTypes(sub as JsonObject);
+      options = new Set([...options, ...types]);
+    }
+    potentials = new Set([...potentials].filter(p => options.has(p)));
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    let options = new Set<string>();
+    for (const sub of schema.anyOf) {
+      const types = findTypes(sub as JsonObject);
+      options = new Set([...options, ...types]);
+    }
+    potentials = new Set([...potentials].filter(p => options.has(p)));
+  }
+
+  return potentials;
+}
 
 export function addUndefinedDefaults(
-  value: JsonValue | undefined,
+  value: JsonValue,
   _pointer: JsonPointer,
   schema?: JsonObject,
-  _root?: JsonObject | JsonArray,
 ): JsonValue {
-  if (value === undefined && schema) {
-    if (schema.items || schema.type == 'array') {
-      return [];
+  if (!schema) {
+    return value;
+  }
+
+  const types = findTypes(schema);
+  if (types.size === 0) {
+    return value;
+  }
+
+  let type;
+  if (types.size === 1) {
+    // only one potential type
+    type = Array.from(types)[0];
+  } else if (types.size === 2 && types.has('array') && types.has('object')) {
+    // need to create one of them and array is simpler
+    type = 'array';
+  } else if (schema.properties && types.has('object')) {
+    // assume object
+    type = 'object';
+  } else if (schema.items && types.has('array')) {
+    // assume array
+    type = 'array';
+  } else {
+    // anything else needs to be checked by the consumer anyway
+    return value;
+  }
+
+  if (type === 'array') {
+    return value == undefined ? [] : value;
+  }
+
+  if (type === 'object') {
+    let newValue;
+    if (value == undefined) {
+      newValue = {} as JsonObject;
+    } else if (JsonValue.isJsonObject(value)) {
+      newValue = value;
+    } else {
+      return value;
     }
-    if (schema.properties || schema.type == 'object') {
-      const newValue: JsonObject = {};
-      for (const propName of Object.getOwnPropertyNames(schema.properties || {})) {
-        newValue[propName] = undefined as any;  // tslint:disable-line:no-any
-      }
 
+    if (!JsonValue.isJsonObject(schema.properties)) {
       return newValue;
     }
-  } else if (schema
-             && typeof value == 'object' && value
-             && (schema.properties || schema.type == 'object')
-  ) {
-    for (const propName of Object.getOwnPropertyNames(schema.properties || {})) {
-      (value as JsonObject)[propName] = (propName in value)
-        ? (value as JsonObject)[propName]
-        : undefined as any;  // tslint:disable-line:no-any
+
+    for (const propName of Object.getOwnPropertyNames(schema.properties)) {
+      if (propName in newValue) {
+        continue;
+      }
+
+      // TODO: Does not currently handle more complex schemas (oneOf/anyOf/etc.)
+      const defaultValue = (schema.properties[propName] as JsonObject).default;
+
+      newValue[propName] = defaultValue;
     }
+
+    return newValue;
   }
 
-  return value as JsonValue;
+  return value;
 }