json-schema-library 5.2.1 → 6.1.0

package/dist/module/lib/cores/Draft06.js

@@ -0,0 +1,61 @@
+import CoreInterface from "./CoreInterface";
+import step from "../step";
+import validate from "../validate";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import getTemplate from "../getTemplate";
+import getSchema from "../getSchema";
+import each from "../each";
+import compileSchema from "../draft06/compile";
+import remotes from "../../remotes";
+import draft06 from "../../remotes/draft06.json";
+// @ts-ignore
+remotes["http://json-schema.org/draft-06/schema"] = compileSchema(draft06);
+import TYPE_KEYWORD_MAPPING from "../draft06/validation/typeKeywordMapping";
+import KEYWORDS from "../draft06/validation/keyword";
+import TYPES from "../draft06/validation/type";
+import FORMATS from "../validation/format";
+import ERRORS from "../validation/errors";
+export default class Draft06Core extends CoreInterface {
+    constructor(schema) {
+        super(schema);
+        this.typeKeywords = JSON.parse(JSON.stringify(TYPE_KEYWORD_MAPPING));
+        this.validateKeyword = Object.assign({}, KEYWORDS);
+        this.validateType = Object.assign({}, TYPES);
+        this.validateFormat = Object.assign({}, FORMATS);
+        this.errors = Object.assign({}, ERRORS);
+    }
+    get rootSchema() {
+        return this.__rootSchema;
+    }
+    set rootSchema(rootSchema) {
+        if (rootSchema == null) {
+            return;
+        }
+        this.__rootSchema = compileSchema(rootSchema);
+    }
+    each(data, callback, schema = this.rootSchema, pointer = "#") {
+        each(this, data, callback, schema, pointer);
+    }
+    validate(data, schema = this.rootSchema, pointer = "#") {
+        return validate(this, data, schema, pointer);
+    }
+    isValid(data, schema = this.rootSchema, pointer = "#") {
+        return this.validate(data, schema, pointer).length === 0;
+    }
+    resolveOneOf(data, schema, pointer) {
+        return resolveOneOf(this, data, schema, pointer);
+    }
+    resolveRef(schema) {
+        return resolveRef(schema, this.rootSchema);
+    }
+    getSchema(pointer, data, schema = this.rootSchema) {
+        return getSchema(this, pointer, data, schema);
+    }
+    getTemplate(data, schema = this.rootSchema) {
+        return getTemplate(this, data, schema);
+    }
+    step(key, schema, data, pointer = "#") {
+        return step(this, key, schema, data, pointer);
+    }
+}

package/dist/module/lib/cores/Draft07.js

@@ -0,0 +1,61 @@
+import CoreInterface from "./CoreInterface";
+import step from "../step";
+import validate from "../validate";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import getTemplate from "../getTemplate";
+import getSchema from "../getSchema";
+import addSchema from "../addSchema";
+import each from "../each";
+import compileSchema from "../draft06/compile";
+import draft07 from "../../remotes/draft07.json";
+import TYPE_KEYWORD_MAPPING from "../draft06/validation/typeKeywordMapping";
+import KEYWORDS from "../draft06/validation/keyword";
+import TYPES from "../draft06/validation/type";
+import FORMATS from "../validation/format";
+import ERRORS from "../validation/errors";
+import addValidator from "../addValidator";
+addSchema("http://json-schema.org/draft-07/schema", draft07);
+export default class Draft07Core extends CoreInterface {
+    constructor(schema) {
+        super(schema);
+        this.typeKeywords = JSON.parse(JSON.stringify(TYPE_KEYWORD_MAPPING));
+        Object.assign(this.validateKeyword, KEYWORDS);
+        Object.assign(this.validateType, TYPES);
+        Object.keys(FORMATS).forEach((id) => addValidator.format(this, id, FORMATS[id]));
+        Object.keys(ERRORS).forEach((id) => addValidator.error(this, id, ERRORS[id]));
+    }
+    get rootSchema() {
+        return this.__rootSchema;
+    }
+    set rootSchema(rootSchema) {
+        if (rootSchema == null) {
+            return;
+        }
+        this.__rootSchema = compileSchema(rootSchema);
+    }
+    each(data, callback, schema = this.rootSchema, pointer = "#") {
+        each(this, data, callback, schema, pointer);
+    }
+    validate(data, schema = this.rootSchema, pointer = "#") {
+        return validate(this, data, schema, pointer);
+    }
+    isValid(data, schema = this.rootSchema, pointer = "#") {
+        return this.validate(data, schema, pointer).length === 0;
+    }
+    resolveOneOf(data, schema, pointer) {
+        return resolveOneOf(this, data, schema, pointer);
+    }
+    resolveRef(schema) {
+        return resolveRef(schema, this.rootSchema);
+    }
+    getSchema(pointer, data, schema = this.rootSchema) {
+        return getSchema(this, pointer, data, schema);
+    }
+    getTemplate(data, schema = this.rootSchema) {
+        return getTemplate(this, data, schema);
+    }
+    step(key, schema, data, pointer = "#") {
+        return step(this, key, schema, data, pointer);
+    }
+}

package/dist/module/lib/createSchemaOf.js

@@ -10,7 +10,7 @@ export default function createSchemaOf(data) {
     };
     if (schema.type === "object") {
         schema.properties = {};
-        Object.keys(data).forEach(key => (schema.properties[key] = createSchemaOf(data[key])));
+        Object.keys(data).forEach((key) => (schema.properties[key] = createSchemaOf(data[key])));
     }
     if (schema.type === "array" && data.length === 1) {
         schema.items = createSchemaOf(data[0]);

package/dist/module/lib/draft06/addSchema.js

@@ -0,0 +1,11 @@
+import remotes from "../../remotes";
+import compileSchema from "./compile";
+/**
+ * register a json-schema to be referenced from another json-schema
+ * @param url    base-url of json-schema (aka id)
+ * @param schema
+ */
+export default function addSchema(url, schema) {
+    schema.id = schema.id || url;
+    remotes[url] = compileSchema(schema);
+}

package/dist/module/lib/draft06/compile/index.js

@@ -0,0 +1,65 @@
+/* eslint max-statements-per-line: ["error", { "max": 2 }] */
+import eachSchema from "../../eachSchema";
+import remotes from "../../../remotes";
+import joinScope from "../../compile/joinScope";
+import getRef from "../../compile/getRef";
+const COMPILED = "__compiled";
+const COMPILED_REF = "__ref";
+const GET_REF = "getRef";
+const GET_ROOT = "getRoot";
+const suffixes = /(#|\/)+$/g;
+/**
+ * @draft starting with _draft 06_ keyword `id` has been renamed to `$id`
+ *
+ * compiles the input root schema for $ref resolution and returns it again
+ * @attention this modifies input schema but maintains object-structure
+ *
+ * for a compiled json-schema you can call getRef on any contained schema (location of type).
+ * this resolves a $ref target to a valid schema (for a valid $ref)
+ *
+ * @param rootSchema root json-schema ($id, defs, ... ) to compile
+ * @param [force] = false force compile json-schema
+ * @return compiled json-schema
+ */
+export default function compile(rootSchema, force = false) {
+    // @ts-ignore
+    if (rootSchema === true || rootSchema === false) {
+        return rootSchema;
+    }
+    if (rootSchema[COMPILED] !== undefined) {
+        return rootSchema;
+    } // eslint-disable-line
+    const context = { ids: {}, remotes: Object.assign({}, remotes) };
+    const rootSchemaAsString = JSON.stringify(rootSchema);
+    rootSchema = JSON.parse(rootSchemaAsString);
+    Object.defineProperty(rootSchema, COMPILED, { enumerable: false, value: true });
+    Object.defineProperty(rootSchema, GET_REF, { enumerable: false, value: getRef.bind(null, context, rootSchema) });
+    if (force === false && rootSchemaAsString.includes("$ref") === false) {
+        // bail early, when no $refs are defined
+        return rootSchema;
+    }
+    const scopes = {};
+    const getRoot = () => rootSchema;
+    eachSchema(rootSchema, (schema, pointer) => {
+        if (schema.$id) {
+            context.ids[schema.$id.replace(suffixes, "")] = pointer;
+        }
+        // build up scopes and add them to $ref-resolution map
+        pointer = `#${pointer}`.replace(/##+/, "#");
+        const previousPointer = pointer.replace(/\/[^/]+$/, "");
+        const parentPointer = pointer.replace(/\/[^/]+\/[^/]+$/, "");
+        const previousScope = scopes[previousPointer] || scopes[parentPointer];
+        const scope = joinScope(previousScope, schema.$id);
+        scopes[pointer] = scope;
+        if (context.ids[scope] == null) {
+            context.ids[scope] = pointer;
+        }
+        if (schema.$ref) {
+            Object.defineProperty(schema, COMPILED_REF, { enumerable: false, value: joinScope(scope, schema.$ref) });
+            // @todo currently not used:
+            Object.defineProperty(schema, GET_ROOT, { enumerable: false, value: getRoot });
+            // console.log("compiled ref", scope, schema.$ref, "=>", joinScope(scope, schema.$ref));
+        }
+    });
+    return rootSchema;
+}

package/dist/module/lib/draft06/validation/keyword.js

@@ -0,0 +1,156 @@
+import Keywords from "../../validation/keyword";
+import getTypeOf from "../../getTypeOf";
+const KeywordValidation = {
+    ...Keywords,
+    // @draft >= 6
+    contains: (core, schema, value, pointer) => {
+        if (schema.contains === false) {
+            return core.errors.containsArrayError({ pointer, value });
+        }
+        if (schema.contains === true) {
+            if (Array.isArray(value) && value.length === 0) {
+                return core.errors.containsAnyError({ pointer });
+            }
+            return undefined;
+        }
+        if (getTypeOf(schema.contains) !== "object") {
+            // ignore invalid schema
+            return undefined;
+        }
+        for (let i = 0; i < value.length; i += 1) {
+            if (core.isValid(value[i], schema.contains)) {
+                return undefined;
+            }
+        }
+        return core.errors.containsError({ pointer, schema: JSON.stringify(schema.contains) });
+    },
+    exclusiveMaximum: (core, schema, value, pointer) => {
+        if (isNaN(schema.exclusiveMaximum)) {
+            return undefined;
+        }
+        if (schema.exclusiveMaximum <= value) {
+            return core.errors.maximumError({ maximum: schema.exclusiveMaximum, length: value, pointer });
+        }
+        return undefined;
+    },
+    exclusiveMinimum: (core, schema, value, pointer) => {
+        if (isNaN(schema.exclusiveMinimum)) {
+            return undefined;
+        }
+        if (schema.exclusiveMinimum >= value) {
+            return core.errors.minimumError({ minimum: schema.exclusiveMinimum, length: value, pointer });
+        }
+        return undefined;
+    },
+    if: (core, schema, value, pointer) => {
+        if (schema.if == null) {
+            return undefined;
+        }
+        const ifErrors = core.validate(value, schema.if, pointer);
+        // console.log("if Errors", value, ifErrors);
+        if (ifErrors.length === 0 && schema.then) {
+            return core.validate(value, schema.then, pointer);
+        }
+        if (ifErrors.length !== 0 && schema.else) {
+            return core.validate(value, schema.else, pointer);
+        }
+    },
+    maximum: (core, schema, value, pointer) => {
+        if (isNaN(schema.maximum)) {
+            return undefined;
+        }
+        if (schema.maximum && schema.maximum < value) {
+            return core.errors.maximumError({ maximum: schema.maximum, length: value, pointer });
+        }
+        return undefined;
+    },
+    minimum: (core, schema, value, pointer) => {
+        if (isNaN(schema.minimum)) {
+            return undefined;
+        }
+        if (schema.minimum > value) {
+            return core.errors.minimumError({ minimum: schema.minimum, length: value, pointer });
+        }
+        return undefined;
+    },
+    patternProperties: (core, schema, value, pointer) => {
+        const properties = schema.properties || {};
+        const pp = schema.patternProperties;
+        if (getTypeOf(pp) !== "object") {
+            return undefined;
+        }
+        const errors = [];
+        const keys = Object.keys(value);
+        const patterns = Object.keys(pp).map(expr => ({
+            regex: new RegExp(expr),
+            patternSchema: pp[expr]
+        }));
+        keys.forEach(key => {
+            let patternFound = false;
+            for (let i = 0, l = patterns.length; i < l; i += 1) {
+                if (patterns[i].regex.test(key)) {
+                    patternFound = true;
+                    // for a boolean schema `false`, always invalidate
+                    if (patterns[i].patternSchema === false) {
+                        errors.push(core.errors.patternPropertiesError({
+                            key, pointer, patterns: Object.keys(pp).join(",")
+                        }));
+                        return;
+                    }
+                    const valErrors = core.validate(value[key], patterns[i].patternSchema, `${pointer}/${key}`);
+                    if (valErrors && valErrors.length > 0) {
+                        errors.push(...valErrors);
+                    }
+                }
+            }
+            if (properties[key]) {
+                return;
+            }
+            if (patternFound === false && schema.additionalProperties === false) {
+                // this is an arrangement with additionalProperties
+                errors.push(core.errors.patternPropertiesError({
+                    key, pointer, patterns: Object.keys(pp).join(",")
+                }));
+            }
+        });
+        return errors;
+    },
+    // @draft >= 6
+    propertyNames: (core, schema, value, pointer) => {
+        // bool schema
+        if (schema.propertyNames === false) {
+            // empty objects are valid
+            if (Object.keys(value).length === 0) {
+                return undefined;
+            }
+            return core.errors.invalidPropertyNameError({
+                property: Object.keys(value),
+                pointer,
+                value
+            });
+        }
+        if (schema.propertyNames === true) {
+            return undefined;
+        }
+        if (getTypeOf(schema.propertyNames) !== "object") {
+            // ignore invalid schema
+            return undefined;
+        }
+        const errors = [];
+        const properties = Object.keys(value);
+        const propertySchema = { ...schema.propertyNames, type: "string" };
+        properties.forEach(prop => {
+            const validationResult = core.validate(prop, propertySchema, `${pointer}/${prop}`);
+            if (validationResult.length > 0) {
+                errors.push(core.errors.invalidPropertyNameError({
+                    property: prop,
+                    pointer,
+                    validationError: validationResult[0],
+                    value: value[prop]
+                }));
+            }
+        });
+        return errors;
+    }
+};
+export default KeywordValidation;

package/dist/module/lib/draft06/validation/type.js

@@ -0,0 +1,30 @@
+/**
+ * @todo: type is also a keyword, as is properties, items, etc
+ *
+ * An instance has one of six primitive types (http://json-schema.org/latest/json-schema-core.html#rfc.section.4.2)
+ * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
+ * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
+ */
+export default {
+    array: (core, schema, value, pointer) => core.typeKeywords.array
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+    object: (core, schema, value, pointer) => core.typeKeywords.object
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+    string: (core, schema, value, pointer) => core.typeKeywords.string
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+    integer: (core, schema, value, pointer) => core.typeKeywords.number
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+    number: (core, schema, value, pointer) => core.typeKeywords.number
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+    "boolean": (core, schema, value, pointer) => core.typeKeywords.boolean
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+    "null": (core, schema, value, pointer) => core.typeKeywords.null
+        .filter(key => schema && schema[key] != null)
+        .map(key => core.validateKeyword[key](core, schema, value, pointer))
+};

package/dist/module/lib/draft06/validation/typeKeywordMapping.js

@@ -0,0 +1,15 @@
+/**
+ * Mapping, used in type validation to iterate over type-specific keywords to validate
+ *  - overview https://epoberezkin.github.io/ajv/keywords.html
+ */
+export default {
+    array: ["enum", "contains", "items", "minItems", "maxItems", "uniqueItems", "not", "if"],
+    boolean: ["enum", "not"],
+    object: [
+        "additionalProperties", "dependencies", "enum", "format", "minProperties", "maxProperties",
+        "patternProperties", "properties", "propertyNames", "required", "not", "oneOf", "allOf", "anyOf", "if"
+    ],
+    string: ["enum", "format", "maxLength", "minLength", "pattern", "not", "oneOf", "allOf", "anyOf", "if"],
+    number: ["enum", "exclusiveMaximum", "exclusiveMinimum", "format", "maximum", "minimum", "multipleOf", "not", "oneOf", "allOf", "anyOf", "if"],
+    null: ["enum", "format", "not", "oneOf", "allOf", "anyOf"]
+};

package/dist/module/lib/each.js

@@ -12,7 +12,7 @@ export default function each(core, data, callback, schema = core.rootSchema, poi
     callback(schema, data, pointer);
     const dataType = getTypeOf(data);
     if (dataType === "object") {
-        Object.keys(data).forEach(key => {
+        Object.keys(data).forEach((key) => {
             const nextSchema = core.step(key, schema, data, pointer); // not save
             const next = data[key]; // save
             core.each(next, callback, nextSchema, `${pointer}/${key}`);

package/dist/module/lib/eachSchema.js

@@ -12,11 +12,11 @@ function nextTypeDefs(schema, pointer) {
 function eachDefinition(walk, schema, pointer) {
     Object.keys(schema.definitions)
         .forEach(defId => {
-        if (!isObject(schema.definitions[defId])) {
-            console.log(`Invalid schema in ${pointer}/definitions/${defId}`);
+        if (schema.definitions[defId] === false || isObject(schema.definitions[defId])) {
+            walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
             return;
         }
-        walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
+        console.log(`Invalid schema in ${pointer}/definitions/${defId}`);
     });
 }
 export default function eachSchema(schema, callback, pointer = "#") {

package/dist/module/lib/getChildSchemaSelection.js

@@ -1,18 +1,19 @@
+import { isJSONError } from "./types";
 /**
  * Returns a list of possible child-schemas for the given property key. In case of a oneOf selection, multiple schemas
  * could be added at the given property (e.g. item-index), thus an array of options is returned. In all other cases
  * a list with a single item will be returned
  *
- * @param  {Core} core          - core to use
- * @param  {String} property    - parent schema of following property
- * @param  {Object} [schema]    - parent schema of following property
- * @return {Object}
+ * @param core          - core to use
+ * @param property    - parent schema of following property
+ * @param [schema]    - parent schema of following property
+ * @return
  */
 export default function getChildSchemaSelection(core, property, schema = core.rootSchema) {
     const result = core.step(property, schema, {}, "#");
-    if (result.type === "error") {
+    if (isJSONError(result)) {
         if (result.code === "one-of-error") {
-            return result.data.oneOf.map(item => core.resolveRef(item));
+            return result.data.oneOf.map((item) => core.resolveRef(item));
         }
         return result;
     }

package/dist/module/lib/getSchema.js

@@ -1,4 +1,5 @@
 import gp from "gson-pointer";
+import { isJSONError } from "./types";
 const emptyObject = {};
 /**
  * Returns the json-schema of a data-json-pointer.
@@ -23,7 +24,7 @@ function _get(core, schema, frags, pointer, data = emptyObject) {
     }
     const key = frags.shift(); // step key
     schema = core.step(key, schema, data, pointer); // step schema
-    if (schema && schema.type === "error") {
+    if (isJSONError(schema)) {
         return schema;
     }
     data = data[key]; // step data

package/dist/module/lib/getTemplate.js

@@ -4,6 +4,10 @@ import getTypeOf from "./getTypeOf";
 import merge from "./utils/merge";
 import copy from "./utils/copy";
 import settings from "./config/settings";
+import { isJSONError } from "./types";
+const defaultOptions = {
+    addOptionalProps: true
+};
 let cache;
 function shouldResolveRef(schema, pointer) {
     // ensure we refactored consistently
@@ -14,7 +18,7 @@ function shouldResolveRef(schema, pointer) {
     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, schema, pointer) {
@@ -102,7 +106,7 @@ const isJSONSchema = (template) => template && typeof template === "object";
  * @param [schema] - json schema, defaults to rootSchema
  * @return created template data
  */
-function getTemplate(core, data, _schema, pointer) {
+function getTemplate(core, data, _schema, pointer, opts) {
     if (_schema == null) {
         throw new Error(`getTemplate: missing schema for data: ${JSON.stringify(data)}`);
     }
@@ -115,13 +119,16 @@ function getTemplate(core, data, _schema, pointer) {
         return undefined;
     }
     pointer = schema.pointer;
+    if (schema === null || schema === void 0 ? void 0 : 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;
         }
@@ -129,6 +136,9 @@ function getTemplate(core, data, _schema, pointer) {
             schema = resolvedSchema;
         }
     }
+    // @todo Array.isArray(schema.type)
+    // -> hasDefault? return
+    // if not -> pick first type
     if (!isJSONSchema(schema) || schema.type == null) {
         return undefined;
     }
@@ -136,35 +146,56 @@ function getTemplate(core, data, _schema, pointer) {
     if (data != null && getTypeOf(data) !== schema.type) {
         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, schema, data) => getDefault(schema, data, ""),
-    "number": (core, schema, data) => getDefault(schema, data, 0),
-    "integer": (core, schema, data) => getDefault(schema, data, 0),
-    "boolean": (core, schema, data) => getDefault(schema, data, false),
-    "object": (core, schema, data, pointer) => {
+    null: (core, schema, data) => getDefault(schema, data, null),
+    string: (core, schema, data) => getDefault(schema, data, ""),
+    number: (core, schema, data) => getDefault(schema, data, 0),
+    integer: (core, schema, data) => getDefault(schema, data, 0),
+    boolean: (core, schema, data) => getDefault(schema, data, false),
+    object: (core, schema, data, pointer, opts) => {
         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, schema, data, pointer) => {
+    array: (core, schema, data, pointer, opts) => {
         const template = schema.default === undefined ? [] : schema.default;
         const d = data || [];
         schema.minItems = schema.minItems || 0;
@@ -175,7 +206,7 @@ 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;
         }
@@ -193,7 +224,7 @@ 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;
         }
@@ -203,7 +234,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;
@@ -214,7 +245,7 @@ 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;
         }
@@ -225,6 +256,9 @@ function getDefault(schema, templateValue, initValue) {
     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];
     }
@@ -233,7 +267,7 @@ function getDefault(schema, templateValue, initValue) {
     }
     return schema.default;
 }
-export default (core, data, schema = core.rootSchema) => {
-    cache = { "mi": ".." };
-    return getTemplate(core, data, schema, "#");
+export default (core, data, schema = core.rootSchema, opts = defaultOptions) => {
+    cache = { mi: ".." };
+    return getTemplate(core, data, schema, "#", opts);
 };