json-schema-library 5.2.1 → 6.1.0

package/lib/getTemplate.ts

@@ -4,28 +4,44 @@ import getTypeOf from "./getTypeOf";
 import merge from "./utils/merge";
 import copy from "./utils/copy";
 import settings from "./config/settings";
-import { JSONSchema, JSONPointer } from "./types";
+import { JSONSchema, JSONPointer, isJSONError } from "./types";
 import Core from "./cores/CoreInterface";
 
+interface TemplateOptions {
+    /** Add all properties (required and optional) to the generated data */
+    addOptionalProps: boolean;
+}
+
+const defaultOptions: TemplateOptions = {
+    addOptionalProps: true
+};
 
 let cache;
 function shouldResolveRef(schema: JSONSchema, pointer: JSONPointer) {
     // ensure we refactored consistently
-    if (pointer == null) { throw new Error("Missing pointer"); }
+    if (pointer == null) {
+        throw new Error("Missing pointer");
+    }
 
     const { $ref } = schema;
-    if ($ref == null) { return true; }
+    if ($ref == null) {
+        return true;
+    }
 
-    const value = (cache[pointer] == null || cache[pointer][$ref] == null) ? 0 : cache[pointer][$ref];
+    const value = cache[pointer] == null || cache[pointer][$ref] == null ? 0 : cache[pointer][$ref];
     return value < settings.GET_TEMPLATE_RECURSION_LIMIT;
 }
 
 function resolveRef(core: Core, schema: JSONSchema, pointer: JSONPointer) {
     // ensure we refactored consistently
-    if (pointer == null) { throw new Error(`missing pointer ${pointer}`); }
+    if (pointer == null) {
+        throw new Error(`missing pointer ${pointer}`);
+    }
 
     const { $ref } = schema;
-    if ($ref == null) { return schema; }
+    if ($ref == null) {
+        return schema;
+    }
 
     // @todo pointer + ref is redundant?
     cache[pointer] = cache[pointer] || {};
@@ -34,7 +50,6 @@ function resolveRef(core: Core, schema: JSONSchema, pointer: JSONPointer) {
     return core.resolveRef(schema);
 }
 
-
 function convertValue(type: string, value: any) {
     if (type === "string") {
         return JSON.stringify(value);
@@ -59,13 +74,20 @@ function convertValue(type: string, value: any) {
  * @param pointer
  * @return resolved json-schema or input-schema
  */
-function createTemplateSchema(core: Core, schema: JSONSchema, data, pointer: JSONPointer): JSONSchema|false {
+function createTemplateSchema(
+    core: Core,
+    schema: JSONSchema,
+    data,
+    pointer: JSONPointer
+): JSONSchema | false {
     // invalid schema
     if (getTypeOf(schema) !== "object") {
         return Object.assign({ pointer }, schema);
     }
     // return if reached recursion limit
-    if (shouldResolveRef(schema, pointer) === false && data == null) { return false; }
+    if (shouldResolveRef(schema, pointer) === false && data == null) {
+        return false;
+    }
 
     // resolve $ref and copy schema
     let templateSchema = copy(resolveRef(core, schema, pointer));
@@ -86,7 +108,10 @@ function createTemplateSchema(core: Core, schema: JSONSchema, data, pointer: JSO
         for (let i = 0, l = schema.allOf.length; i < l; i += 1) {
             // test if we may resolve
             if (shouldResolveRef(schema.allOf[i], `${pointer}/allOf/${i}`)) {
-                templateSchema = merge(templateSchema, resolveRef(core, schema.allOf[i], `${pointer}/allOf/${i}`));
+                templateSchema = merge(
+                    templateSchema,
+                    resolveRef(core, schema.allOf[i], `${pointer}/allOf/${i}`)
+                );
                 // add pointer return-value, if any
                 templateSchema.pointer = schema.allOf[i].$ref || templateSchema.pointer;
             }
@@ -108,21 +133,37 @@ const isJSONSchema = (template): template is JSONSchema => template && typeof te
  * @param [schema] - json schema, defaults to rootSchema
  * @return created template data
  */
-function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer) {
-    if (_schema == null) { throw new Error(`getTemplate: missing schema for data: ${JSON.stringify(data)}`); }
-    if (pointer == null) { throw new Error("Missing pointer"); }
+function getTemplate(
+    core: Core,
+    data?: unknown,
+    _schema?: JSONSchema,
+    pointer?: JSONPointer,
+    opts?: TemplateOptions
+) {
+    if (_schema == null) {
+        throw new Error(`getTemplate: missing schema for data: ${JSON.stringify(data)}`);
+    }
+    if (pointer == null) {
+        throw new Error("Missing pointer");
+    }
 
     // resolve $ref references, allOf and first anyOf definitions
     let schema = createTemplateSchema(core, _schema, data, pointer);
-    if (!isJSONSchema(schema)) { return undefined; }
+    if (!isJSONSchema(schema)) {
+        return undefined;
+    }
     pointer = schema.pointer;
 
+    if (schema?.const) {
+        return schema.const;
+    }
+
     if (schema.oneOf) {
         // find correct schema for data
         const resolvedSchema = resolveOneOfFuzzy(core, data, schema);
-        if (data == null && resolvedSchema.type === "error") {
+        if (data == null && isJSONError(resolvedSchema)) {
             schema = schema.oneOf[0];
-        } else if (resolvedSchema.type === "error") {
+        } else if (isJSONError(resolvedSchema.type)) {
             // @todo - check: do not return schema, but either input-data or undefined (clearing wrong data)
             return data;
         } else {
@@ -130,6 +171,10 @@ function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer) {
         }
     }
 
+    // @todo Array.isArray(schema.type)
+    // -> hasDefault? return
+    // if not -> pick first type
+
     if (!isJSONSchema(schema) || schema.type == null) {
         return undefined;
     }
@@ -139,41 +184,83 @@ function getTemplate(core, data, _schema: JSONSchema, pointer: JSONPointer) {
         data = convertValue(schema.type, data);
     }
 
-    if (TYPE[schema.type] == null) { // eslint-disable-line no-use-before-define
+    if (TYPE[schema.type] == null) {
+        // eslint-disable-line no-use-before-define
         throw new Error(`Unsupported type '${schema.type} in ${JSON.stringify(schema)}'`);
     }
 
-    const templateData = TYPE[schema.type](core, schema, data, pointer); // eslint-disable-line no-use-before-define
+    const templateData = TYPE[schema.type](core, schema, data, pointer, opts); // eslint-disable-line no-use-before-define
     return templateData;
 }
 
-
 const TYPE = {
-    "string": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, ""),
-    "number": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, 0),
-    "integer": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, 0),
-    "boolean": (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, false),
-    "object": (core: Core, schema: JSONSchema, data: any, pointer: JSONPointer) => {
+    null: (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, null),
+    string: (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, ""),
+    number: (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, 0),
+    integer: (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, 0),
+    boolean: (core: Core, schema: JSONSchema, data: any) => getDefault(schema, data, false),
+    object: (
+        core: Core,
+        schema: JSONSchema,
+        data: any,
+        pointer: JSONPointer,
+        opts: TemplateOptions
+    ) => {
         const template = schema.default === undefined ? {} : schema.default;
         const d = {}; // do not assign data here, to keep ordering from json-schema
 
         if (schema.properties) {
-            Object.keys(schema.properties).forEach(key => {
-                const value = (data == null || data[key] == null) ? template[key] : data[key];
-                d[key] = getTemplate(core, value, schema.properties[key], `${pointer}/properties/${key}`);
+            Object.keys(schema.properties).forEach((key) => {
+                const value = data == null || data[key] == null ? template[key] : data[key];
+                const isRequired = Array.isArray(schema.required) && schema.required.includes(key);
+
+                // Omit adding a property if it is not required or optional props should be added
+                if (value != null || isRequired || opts.addOptionalProps) {
+                    d[key] = getTemplate(
+                        core,
+                        value,
+                        schema.properties[key],
+                        `${pointer}/properties/${key}`,
+                        opts
+                    );
+                }
+            });
+        }
+
+        if (schema.dependencies) {
+            Object.keys(schema.dependencies).forEach((key) => {
+                const dependency = schema.dependencies[key];
+                if (getTypeOf(dependency) !== "object") {
+                    return;
+                }
+                if (d[key] === undefined) {
+                    return;
+                }
+
+                const result = getTemplate(
+                    core,
+                    data,
+                    { ...dependency, type: "object" },
+                    `${pointer}/dependencies/${key}`,
+                    opts
+                );
+
+                if (result && !isJSONError(result)) {
+                    Object.assign(d, result);
+                }
             });
         }
 
         if (data) {
             // merge any missing data (additionals) to resulting object
-            Object.keys(data).forEach(key => (d[key] == null && (d[key] = data[key])));
+            Object.keys(data).forEach((key) => d[key] == null && (d[key] = data[key]));
         }
 
         // returns object, which is ordered by json-schema
         return d;
     },
     // build array type of items, ignores additionalItems
-    "array": (core: Core, schema: JSONSchema, data, pointer: JSONPointer) => {
+    array: (core: Core, schema: JSONSchema, data, pointer: JSONPointer, opts: TemplateOptions) => {
         const template = schema.default === undefined ? [] : schema.default;
         const d = data || [];
         schema.minItems = schema.minItems || 0;
@@ -186,7 +273,13 @@ const TYPE = {
         // build defined set of items
         if (Array.isArray(schema.items)) {
             for (let i = 0, l = Math.min(schema.minItems, schema.items.length); i < l; i += 1) {
-                d[i] = getTemplate(core, d[i] == null ? template[i] : d[i], schema.items[i], `${pointer}/items/${i}`);
+                d[i] = getTemplate(
+                    core,
+                    d[i] == null ? template[i] : d[i],
+                    schema.items[i],
+                    `${pointer}/items/${i}`,
+                    opts
+                );
             }
             return d;
         }
@@ -207,7 +300,13 @@ const TYPE = {
         if (templateSchema.oneOf && d.length === 0) {
             const oneOfSchema = templateSchema.oneOf[0];
             for (let i = 0; i < schema.minItems; i += 1) {
-                d[i] = getTemplate(core, d[i] == null ? template[i] : d[i], oneOfSchema, `${pointer}/oneOf/0`);
+                d[i] = getTemplate(
+                    core,
+                    d[i] == null ? template[i] : d[i],
+                    oneOfSchema,
+                    `${pointer}/oneOf/0`,
+                    opts
+                );
             }
             return d;
         }
@@ -218,7 +317,7 @@ const TYPE = {
                 const value = d[i] == null ? template[i] : d[i];
                 const one = resolveOneOfFuzzy(core, value, templateSchema);
                 if (one) {
-                    d[i] = getTemplate(core, value, one, `${pointer}/oneOf/${i}`);
+                    d[i] = getTemplate(core, value, one, `${pointer}/oneOf/${i}`, opts);
                 } else {
                     d[i] = value;
                 }
@@ -229,7 +328,13 @@ const TYPE = {
         // build items-definition
         if (templateSchema.type) {
             for (let i = 0, l = Math.max(schema.minItems, d.length); i < l; i += 1) {
-                d[i] = getTemplate(core, d[i] == null ? template[i] : d[i], templateSchema, `${pointer}/items`);
+                d[i] = getTemplate(
+                    core,
+                    d[i] == null ? template[i] : d[i],
+                    templateSchema,
+                    `${pointer}/items`,
+                    opts
+                );
             }
             return d;
         }
@@ -238,10 +343,11 @@ const TYPE = {
     }
 };
 
-
 function getDefault(schema: JSONSchema, templateValue: any, initValue: any) {
     if (templateValue != null) {
         return templateValue;
+    } else if (schema.const) {
+        return schema.const;
     } else if (schema.default === undefined && Array.isArray(schema.enum)) {
         return schema.enum[0];
     } else if (schema.default === undefined) {
@@ -250,8 +356,12 @@ function getDefault(schema: JSONSchema, templateValue: any, initValue: any) {
     return schema.default;
 }
 
-
-export default (core: Core, data?: any, schema: JSONSchema = core.rootSchema) => {
-    cache = { "mi": ".." };
-    return getTemplate(core, data, schema, "#");
+export default (
+    core: Core,
+    data?: any,
+    schema: JSONSchema = core.rootSchema,
+    opts: TemplateOptions = defaultOptions
+) => {
+    cache = { mi: ".." };
+    return getTemplate(core, data, schema, "#", opts);
 };

package/lib/getTypeOf.ts

@@ -1,7 +1,8 @@
 const toString = Object.prototype.toString;
 
+export type JSType = "array"|"bigint"|"boolean"|"function"|"null"|"number"|"object"|"string"|"symbol"|"undefined";
 
-export default function getTypeOf(value: any) {
+export default function getTypeOf(value: unknown) : JSType {
     // eslint-disable-next-line newline-per-chained-call
     return toString.call(value).match(/\s([^\]]+)\]/).pop().toLowerCase();
 }

package/lib/resolveAllOf.ts

@@ -4,14 +4,18 @@ import errors from "./validation/errors";
 import { JSONSchema, JSONPointer, JSONError } from "./types";
 import Core from "./cores/CoreInterface";
 
-
-export default function resolveAllOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveAllOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
     let mergedSchema = copy(schema);
     for (let i = 0; i < schema.allOf.length; i += 1) {
         const allOfSchema = core.resolveRef(schema.allOf[i]);
-        if (core.isValid(data, allOfSchema, pointer) === false) {
-            return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
-        }
+        // if (core.isValid(data, allOfSchema, pointer) === false) {
+        //     return errors.allOfError({ value: data, pointer, allOf: JSON.stringify(schema.allOf) });
+        // }
         mergedSchema = merge(mergedSchema, allOfSchema);
     }
 

package/lib/resolveOneOf.fuzzy.ts

@@ -2,10 +2,9 @@ import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
 import getTypeOf from "./getTypeOf";
 import settings from "./config/settings";
-import { JSONSchema, JSONPointer, JSONError } from "./types";
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
 import Core from "./cores/CoreInterface";
 
-
 const { DECLARATOR_ONEOF } = settings;
 
 /**
@@ -17,7 +16,12 @@ const { DECLARATOR_ONEOF } = settings;
  * @param [pointer]
  * @return ranking value (higher is better)
  */
-function fuzzyObjectValue(core: Core, one: JSONSchema, data: { [p: string]: any }, pointer?: JSONPointer) {
+function fuzzyObjectValue(
+    core: Core,
+    one: JSONSchema,
+    data: { [p: string]: any },
+    pointer?: JSONPointer
+) {
     if (data == null || one.properties == null) {
         return -1;
     }
@@ -43,7 +47,12 @@ function fuzzyObjectValue(core: Core, one: JSONSchema, data: { [p: string]: any
  * @param [pointer] - json pointer to data
  * @return oneOf schema or an error
  */
-export default function resolveOneOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveOneOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
     // !keyword: oneOfProperty
     // an additional <DECLARATOR_ONEOF> (default `oneOfProperty`) on the schema will exactly determine the
     // oneOf value (if set in data)
@@ -52,7 +61,6 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
     // abort if no data is given an DECLARATOR_ONEOF is set (used by getChildSchemaSelection)
     // this case (data != null) should not be necessary
     if (data != null && schema[DECLARATOR_ONEOF]) {
-
         const errors = [];
         const oneOfProperty = schema[DECLARATOR_ONEOF];
         const oneOfValue = data[schema[DECLARATOR_ONEOF]];
@@ -65,7 +73,7 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
             const one = core.resolveRef(schema.oneOf[i]);
             const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
 
-            if (oneOfPropertySchema && oneOfPropertySchema.type === "error") {
+            if (isJSONError(oneOfPropertySchema)) {
                 return oneOfPropertySchema;
             }
 
@@ -79,7 +87,12 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
             }
         }
 
-        return core.errors.oneOfPropertyError({ property: oneOfProperty, value: oneOfValue, pointer, errors });
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
     }
 
     // keyword: oneOf
@@ -111,7 +124,11 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
         }
 
         if (schemaOfItem === undefined) {
-            return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf });
+            return core.errors.oneOfError({
+                value: JSON.stringify(data),
+                pointer,
+                oneOf: schema.oneOf
+            });
         }
 
         return schemaOfItem;

package/lib/resolveOneOf.strict.ts

@@ -3,7 +3,6 @@ import flattenArray from "./utils/flattenArray";
 import Core from "./cores/CoreInterface";
 import { JSONSchema, JSONError, JSONPointer } from "./types";
 
-
 /**
  * Selects and returns a oneOf schema for the given data
  *
@@ -13,7 +12,12 @@ import { JSONSchema, JSONError, JSONPointer } from "./types";
  * @param pointer - json pointer to data
  * @return oneOf schema or an error
  */
-export default function resolveOneOf(core: Core, data: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): JSONSchema|JSONError {
+export default function resolveOneOf(
+    core: Core,
+    data: any,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
     const matches = [];
     const errors = [];
     for (let i = 0; i < schema.oneOf.length; i += 1) {
@@ -33,8 +37,17 @@ export default function resolveOneOf(core: Core, data: any, schema: JSONSchema =
         return matches[0];
     }
     if (matches.length > 1) {
-        return core.errors.multipleOneOfError({ value: data, pointer, matches });
+        return core.errors.multipleOneOfError({
+            value: data,
+            pointer,
+            matches,
+        });
     }
 
-    return core.errors.oneOfError({ value: JSON.stringify(data), pointer, oneOf: schema.oneOf, errors });
+    return core.errors.oneOfError({
+        value: JSON.stringify(data),
+        pointer,
+        oneOf: schema.oneOf,
+        errors,
+    });
 }

package/lib/resolveRef.strict.ts

@@ -6,6 +6,15 @@ export default function resolveRef(schema: JSONSchema, rootSchema: JSONSchema):
         return schema;
     }
 
+    if (schema.getRoot) {
+        // we actually always need to resolve the schema like this, since returned subschemas
+        // must resolve relative from their schema
+        const resolvedSchema = schema.getRoot().getRef(schema);
+        // console.log(schema.$ref, "=>", resolvedSchema);
+        return resolvedSchema;
+    }
+
+    // tryout - this should never be called, except we missed something
     const resolvedSchema = rootSchema.getRef(schema);
     return resolvedSchema;
 }

package/lib/schema/getTypeDefs.ts

@@ -19,7 +19,20 @@ export default function getTypeDefs(schema: JSONSchema): Array<{ pointer: JSONPo
     if (id == null) {
         return defs;
     }
-    const type = types[id];
+
+    let type;
+    if (Array.isArray(id)) {
+        // since types can also be declared as a set of types, merge the definitions
+        // maybe this will require a more sophisticated approach
+        type = {};
+        for (let i = 0, l = id.length; i < l; i += 1) {
+            Object.assign(type, types[id[i]]);
+        }
+
+    } else {
+        type = types[id];
+    }
+
     if (type.definitions == null) {
         return defs;
     }

package/lib/schema/getTypeId.ts

@@ -12,7 +12,7 @@ const typeKeywords = Object.keys(types).filter(id => types[id].type === false);
  * @param schema
  * @return type id, if found
  */
-export default function getTypeId(schema: JSONSchema): string|undefined {
+export default function getTypeId(schema: JSONSchema): string|string[]|undefined {
     if (isObject(schema) === false) {
         return undefined;
     }
@@ -21,7 +21,7 @@ export default function getTypeId(schema: JSONSchema): string|undefined {
         return "enum";
     }
 
-    if (types[schema.type]) {
+    if (types[schema.type] || Array.isArray(schema.type)) {
         return schema.type;
     }