json-schema-library 6.1.0 → 7.0.0

package/dist/module/index.js

@@ -1,45 +1,29 @@
-import addSchema from "./lib/addSchema";
-import addValidator from "./lib/addValidator";
-import compileSchema from "./lib/compileSchema";
-import createCustomError from "./lib/utils/createCustomError";
-import createSchemaOf from "./lib/createSchemaOf";
-import Draft04 from "./lib/cores/Draft04";
-import Draft06 from "./lib/cores/Draft06";
-import Draft07 from "./lib/cores/Draft07";
-import each from "./lib/each";
-import eachSchema from "./lib/eachSchema";
-import getChildSchemaSelection from "./lib/getChildSchemaSelection";
-import getSchema from "./lib/getSchema";
-import getTemplate from "./lib/getTemplate";
+import { createError, createCustomError } from "./lib/utils/createCustomError";
 import getTypeOf from "./lib/getTypeOf";
-import Interface from "./lib/cores/CoreInterface";
-import isValid from "./lib/isValid";
-import JsonEditor from "./lib/cores/JsonEditor";
 import resolveOneOf from "./lib/resolveOneOf.strict";
 import resolveOneOfFuzzy from "./lib/resolveOneOf.fuzzy";
+import resolveRef from "./lib/resolveRef.strict";
+import resolveRefMerge from "./lib/resolveRef.merge";
 import SchemaService from "./lib/SchemaService";
 import settings from "./lib/config/settings";
-import step from "./lib/step";
 import strings from "./lib/config/strings";
-import validate from "./lib/validate";
 import validateAsync from "./lib/validateAsync";
+import render from "./lib/utils/render";
+import { Draft } from "./lib/draft";
+import { Draft04, draft04Config } from "./lib/draft04";
+import { Draft06, draft06Config } from "./lib/draft06";
+import { Draft07, draft07Config } from "./lib/draft07";
+import { JsonEditor, draftJsonEditorConfig } from "./lib/jsoneditor";
+import { isJSONError } from "./lib/types";
 const config = { strings };
-export { config, Interface, Draft04, // core implementing draft04 specs
+export { config, Draft, Draft04, // core implementing draft04 specs
+draft04Config, // config implementing draft04 specs
 Draft06, // core implementing draft06 specs
+draft06Config, // config implementing draft06 specs
 Draft07, // core implementing draft07 specs
+draft07Config, // config implementing draft07 specs
 JsonEditor, // adjusted core of draft04 to better support the json-editor
-addSchema, // add a schema to be references via $ref
-addValidator, // add validation for keyword, format, datatype and customize errors
-compileSchema, createCustomError, createSchemaOf, // creates a simple schema based on the given data
-each, // iterate over data, receiving each data-entry with its schema
-eachSchema, // iterates over a json-schemas type definitions
-getChildSchemaSelection, // get available child schemas
-getSchema, // get schema of datapointer
-getTemplate, // create data which is valid to the given schema
-getTypeOf, // returns the javascript datatype
-isValid, // returns a boolean if the schema is valid
-resolveOneOf, resolveOneOfFuzzy, settings, SchemaService, step, // steps into a json-schema, returning the matching child-schema
-validate, // validates data by a schema
-validateAsync // async validation of data by a schema
+draftJsonEditorConfig, // adjusted config of draft04 to better support the json-editor
+createError, createCustomError, getTypeOf, // returns the javascript datatype
+isJSONError, render, resolveRef, resolveRefMerge, resolveOneOf, resolveOneOfFuzzy, settings, SchemaService, validateAsync // async validation of data by a schema
  };
-export { isJSONError } from "./lib/types";

package/dist/module/lib/SchemaService.js

@@ -1,5 +1,5 @@
 import getSchema from "./getSchema";
-import Core from "./cores/JsonEditor";
+import { JsonEditor as Core } from "./jsoneditor";
 import gp from "gson-pointer";
 import copy from "./utils/copy";
 export default class SchemaService {
@@ -19,14 +19,17 @@ export default class SchemaService {
         this.cache = {};
     }
     get(pointer, data) {
-        if (data) { // possibly separate entry point
+        if (data) {
+            // possibly separate entry point
             const schema = getSchema(this.core, pointer, data, this.schema);
             return copy(schema);
         }
-        if (pointer === "#") { // root
+        if (pointer === "#") {
+            // root
             return this.schema;
         }
-        if (this.cache[pointer]) { // return cached result
+        if (this.cache[pointer]) {
+            // return cached result
             return this.cache[pointer];
         }
         const parentPointer = gp.join(pointer, "..");

package/dist/module/lib/{draft06/addSchema.js → addRemoteSchema.js}

@@ -1,11 +1,9 @@
-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) {
+export default function addRemoteSchema(draft, url, schema) {
     schema.id = schema.id || url;
-    remotes[url] = compileSchema(schema);
+    draft.remotes[url] = draft.compileSchema(schema);
 }

package/dist/module/lib/compile/getRef.js

@@ -2,7 +2,7 @@ import { get } from "gson-pointer";
 import splitRef from "./splitRef";
 import getTypeOf from "../getTypeOf";
 const suffixes = /(#|\/)+$/g;
-const isObject = (val) => (getTypeOf(val) === "object");
+const isObject = (val) => getTypeOf(val) === "object";
 // 1. combined is known
 // 2. base or pointer is known
 // 3. base + pointer is known

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

@@ -1,6 +1,5 @@
 /* eslint max-statements-per-line: ["error", { "max": 2 }] */
-import eachSchema from "../eachSchema";
-import remotes from "../../remotes";
+import { eachSchema } from "../eachSchema";
 import joinScope from "./joinScope";
 import getRef from "./getRef";
 const COMPILED = "__compiled";
@@ -9,32 +8,44 @@ const GET_REF = "getRef";
 const GET_ROOT = "getRoot";
 const suffixes = /(#|\/)+$/g;
 /**
- * compiles the input root schema for $ref resolution and returns it again
+ * 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
+ * @param draft
+ * @param schemaToCompile - json-schema to compile
+ * @param [rootSchema] - compiled root json-schema to use for definitions resolution
+ * @param [force] = false - force compile json-schema
+ * @return compiled copy of input json-schema
  */
-export default function compile(rootSchema, force = false) {
-    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) });
+export default function compileSchema(draft, schemaToCompile, rootSchema = schemaToCompile, force = false) {
+    if (!schemaToCompile || schemaToCompile[COMPILED] !== undefined) {
+        return schemaToCompile;
+    }
+    const context = { ids: {}, remotes: draft.remotes };
+    const rootSchemaAsString = JSON.stringify(schemaToCompile);
+    const compiledSchema = JSON.parse(rootSchemaAsString);
+    Object.defineProperty(compiledSchema, COMPILED, { enumerable: false, value: true });
+    Object.defineProperty(compiledSchema, GET_REF, {
+        enumerable: false,
+        value: getRef.bind(null, context, compiledSchema)
+    });
+    // bail early, when no $refs are defined
     if (force === false && rootSchemaAsString.includes("$ref") === false) {
-        // bail early, when no $refs are defined
-        return rootSchema;
+        return compiledSchema;
+    }
+    // compile this schema under rootSchema, making definitions available to $ref-resolution
+    if (schemaToCompile !== rootSchema) {
+        Object.defineProperty(compiledSchema, "definitions", {
+            enumerable: false,
+            value: Object.assign({}, rootSchema.definitions, rootSchema.$defs, schemaToCompile.definitions, schemaToCompile.$defs)
+        });
     }
     const scopes = {};
-    const getRoot = () => rootSchema;
-    eachSchema(rootSchema, (schema, pointer) => {
+    const getRoot = () => compiledSchema;
+    eachSchema(compiledSchema, (schema, pointer) => {
         if (schema.id) {
             context.ids[schema.id.replace(suffixes, "")] = pointer;
         }
@@ -48,13 +59,16 @@ export default function compile(rootSchema, force = false) {
         if (context.ids[scope] == null) {
             context.ids[scope] = pointer;
         }
-        if (schema.$ref) {
-            Object.defineProperty(schema, COMPILED_REF, { enumerable: false, value: joinScope(scope, schema.$ref) });
+        if (schema.$ref && !schema[COMPILED_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));
         }
     });
     // console.log(JSON.stringify(context.ids, null, 2));
-    return rootSchema;
+    return compiledSchema;
 }

package/dist/module/lib/compile/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/lib/draft/index.js

@@ -0,0 +1,133 @@
+export class Draft {
+    constructor(config, schema) {
+        /** cache for remote schemas */
+        this.remotes = {};
+        /** error creators by id */
+        this.errors = {};
+        /** map for valid keywords of a type  */
+        this.typeKeywords = {};
+        /** keyword validators  */
+        this.validateKeyword = {};
+        /** type validators  */
+        this.validateType = {};
+        /** format validators  */
+        this.validateFormat = {};
+        this.config = config;
+        this.typeKeywords = JSON.parse(JSON.stringify(config.typeKeywords));
+        this.validateKeyword = Object.assign({}, config.validateKeyword);
+        this.validateType = Object.assign({}, config.validateType);
+        this.validateFormat = Object.assign({}, config.validateFormat);
+        this.errors = Object.assign({}, config.errors);
+        this.setSchema(schema);
+    }
+    get rootSchema() {
+        return this.__rootSchema;
+    }
+    set rootSchema(rootSchema) {
+        if (rootSchema == null) {
+            return;
+        }
+        this.__rootSchema = this.config.compileSchema(this, rootSchema);
+    }
+    /**
+     * register a json-schema to be referenced from another json-schema
+     * @param url - base-url of json-schema (aka id)
+     * @param schema - json-schema root
+     */
+    addRemoteSchema(url, schema) {
+        this.config.addRemoteSchema(this, url, schema);
+    }
+    compileSchema(schema) {
+        var _a;
+        return this.config.compileSchema(this, schema, (_a = this.rootSchema) !== null && _a !== void 0 ? _a : schema);
+    }
+    createSchemaOf(data) {
+        return this.config.createSchemaOf(data);
+    }
+    /**
+     * Iterates over data, retrieving its schema
+     *
+     * @param data - the data to iterate
+     * @param callback - will be called with (schema, data, pointer) on each item
+     * @param [schema] - the schema matching the data. Defaults to rootSchema
+     * @param [pointer] - pointer to current data. Default to rootPointer
+     */
+    each(data, callback, schema, pointer) {
+        return this.config.each(this, data, callback, schema, pointer);
+    }
+    eachSchema(callback, schema = this.rootSchema) {
+        return this.config.eachSchema(schema, callback);
+    }
+    getChildSchemaSelection(property, schema) {
+        return this.config.getChildSchemaSelection(this, property, schema);
+    }
+    /**
+     * Returns the json-schema of a data-json-pointer.
+     * Notes
+     *   - Uses core.step to walk through data and schema
+     *
+     * @param pointer - json pointer in data to get the json schema for
+     * @param [data] - the data object, which includes the json pointers value. This is optional, as
+     *    long as no oneOf, anyOf, etc statement is part of the pointers schema
+     * @param [schema] - the json schema to iterate. Defaults to core.rootSchema
+     * @return json schema object of the json-pointer or an error
+     */
+    getSchema(pointer = "#", data, schema) {
+        return this.config.getSchema(this, pointer, data, schema);
+    }
+    /**
+     * Create data object matching the given schema
+     *
+     * @param [data] - optional template data
+     * @param [schema] - json schema, defaults to rootSchema
+     * @return created template data
+     */
+    getTemplate(data, schema) {
+        return this.config.getTemplate(this, data, schema);
+    }
+    isValid(data, schema, pointer) {
+        return this.config.isValid(this, data, schema, pointer);
+    }
+    resolveAnyOf(data, schema, pointer) {
+        return this.config.resolveAnyOf(this, data, schema, pointer);
+    }
+    resolveAllOf(data, schema, pointer) {
+        return this.config.resolveAllOf(this, data, schema, pointer);
+    }
+    resolveRef(schema) {
+        return this.config.resolveRef(schema, this.rootSchema);
+    }
+    resolveOneOf(data, schema, pointer) {
+        return this.config.resolveOneOf(this, data, schema, pointer);
+    }
+    setSchema(schema) {
+        this.rootSchema = schema;
+    }
+    /**
+     * Returns the json-schema of the given object property or array item.
+     * e.g. it steps by one key into the data
+     *
+     *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
+     *  returns the correct schema.
+     *
+     * @param  key       - property-name or array-index
+     * @param  schema    - json schema of current data
+     * @param  data      - parent of key
+     * @param  [pointer] - pointer to schema and data (parent of key)
+     * @return Schema or Error if failed resolving key
+     */
+    step(key, schema, data, pointer) {
+        return this.config.step(this, key, schema, data, pointer);
+    }
+    /**
+     * Validate data by a json schema
+     *
+     * @param value - value to validate
+     * @param [schema] - json schema, defaults to rootSchema
+     * @param [pointer] - json pointer pointing to value (used for error-messages only)
+     * @return list of errors or empty
+     */
+    validate(data, schema, pointer) {
+        return this.config.validate(this, data, schema, pointer);
+    }
+}

package/dist/module/lib/draft04/index.js

@@ -0,0 +1,90 @@
+import addRemoteSchema from "../addRemoteSchema";
+import compileSchema from "../compileSchema";
+import { each } from "../each";
+import { eachSchema } from "../eachSchema";
+import ERRORS from "../validation/errors";
+import FORMATS from "../validation/format";
+import getSchema from "../getSchema";
+import getTemplate from "../getTemplate";
+import isValid from "../isValid";
+import KEYWORDS from "../validation/keyword";
+import merge from "../utils/merge";
+import resolveAllOf from "../resolveAllOf";
+import resolveAnyOf from "../resolveAnyOf";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import step from "../step";
+import createSchemaOf from "../createSchemaOf";
+import getChildSchemaSelection from "../getChildSchemaSelection";
+import TYPES from "../validation/type";
+import validate from "../validate";
+import { Draft } from "../draft";
+const draft04Config = {
+    typeKeywords: {
+        array: ["enum", "items", "minItems", "maxItems", "uniqueItems", "not"],
+        boolean: ["enum", "not"],
+        object: [
+            "additionalProperties",
+            "dependencies",
+            "enum",
+            "format",
+            "minProperties",
+            "maxProperties",
+            "patternProperties",
+            "properties",
+            "required",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf"
+        ],
+        string: [
+            "enum",
+            "format",
+            "maxLength",
+            "minLength",
+            "pattern",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf"
+        ],
+        number: [
+            "enum",
+            "format",
+            "maximum",
+            "minimum",
+            "multipleOf",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf"
+        ],
+        null: ["enum", "format", "not", "oneOf", "allOf", "anyOf"]
+    },
+    validateKeyword: KEYWORDS,
+    validateType: TYPES,
+    validateFormat: FORMATS,
+    errors: ERRORS,
+    addRemoteSchema,
+    compileSchema,
+    createSchemaOf,
+    each,
+    eachSchema,
+    getChildSchemaSelection,
+    getSchema,
+    getTemplate,
+    isValid,
+    resolveAllOf,
+    resolveAnyOf,
+    resolveOneOf,
+    resolveRef,
+    step,
+    validate
+};
+class Draft04 extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draft04Config, config), schema);
+    }
+}
+export { Draft04, draft04Config };

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

@@ -1,6 +1,5 @@
-/* eslint max-statements-per-line: ["error", { "max": 2 }] */
-import eachSchema from "../../eachSchema";
-import remotes from "../../../remotes";
+import { eachSchema } from "../../eachSchema";
+// import remotes from "../../../remotes";
 import joinScope from "../../compile/joinScope";
 import getRef from "../../compile/getRef";
 const COMPILED = "__compiled";
@@ -21,26 +20,36 @@ const suffixes = /(#|\/)+$/g;
  * @param [force] = false force compile json-schema
  * @return compiled json-schema
  */
-export default function compile(rootSchema, force = false) {
+export default function compileSchema(draft, schemaToCompile, rootSchema = schemaToCompile, force = false) {
     // @ts-ignore
-    if (rootSchema === true || rootSchema === false) {
-        return rootSchema;
+    if (schemaToCompile === true || schemaToCompile === false || schemaToCompile === undefined) {
+        return schemaToCompile;
     }
-    if (rootSchema[COMPILED] !== undefined) {
-        return rootSchema;
+    if (schemaToCompile[COMPILED] !== undefined) {
+        return schemaToCompile;
     } // 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) });
+    const context = { ids: {}, remotes: draft.remotes };
+    const rootSchemaAsString = JSON.stringify(schemaToCompile);
+    const compiledSchema = JSON.parse(rootSchemaAsString);
+    Object.defineProperty(compiledSchema, COMPILED, { enumerable: false, value: true });
+    Object.defineProperty(compiledSchema, GET_REF, {
+        enumerable: false,
+        value: getRef.bind(null, context, compiledSchema)
+    });
+    // bail early, when no $refs are defined
     if (force === false && rootSchemaAsString.includes("$ref") === false) {
-        // bail early, when no $refs are defined
-        return rootSchema;
+        return compiledSchema;
+    }
+    // compile this schema under rootSchema, making definitions available to $ref-resolution
+    if (compiledSchema !== rootSchema) {
+        Object.defineProperty(compiledSchema, "$defs", {
+            enumerable: true,
+            value: Object.assign({}, rootSchema.definitions, rootSchema.$defs, compiledSchema.definitions, compiledSchema.$defs)
+        });
     }
     const scopes = {};
-    const getRoot = () => rootSchema;
-    eachSchema(rootSchema, (schema, pointer) => {
+    const getRoot = () => compiledSchema;
+    eachSchema(compiledSchema, (schema, pointer) => {
         if (schema.$id) {
             context.ids[schema.$id.replace(suffixes, "")] = pointer;
         }
@@ -54,12 +63,15 @@ export default function compile(rootSchema, force = false) {
         if (context.ids[scope] == null) {
             context.ids[scope] = pointer;
         }
-        if (schema.$ref) {
-            Object.defineProperty(schema, COMPILED_REF, { enumerable: false, value: joinScope(scope, schema.$ref) });
+        if (schema.$ref && !schema[COMPILED_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;
+    return compiledSchema;
 }

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

@@ -0,0 +1,96 @@
+import addRemoteSchema from "../addRemoteSchema";
+import compileSchema from "../draft06/compile";
+import { each } from "../each";
+import { eachSchema } from "../eachSchema";
+import ERRORS from "../validation/errors";
+import FORMATS from "../validation/format";
+import getSchema from "../getSchema";
+import getTemplate from "../getTemplate";
+import isValid from "../isValid";
+import KEYWORDS from "../draft06/validation/keyword";
+import merge from "../utils/merge";
+import resolveAllOf from "../resolveAllOf";
+import resolveAnyOf from "../resolveAnyOf";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import createSchemaOf from "../createSchemaOf";
+import getChildSchemaSelection from "../getChildSchemaSelection";
+import step from "../step";
+import TYPES from "../draft06/validation/type";
+import validate from "../validate";
+import { Draft } from "../draft";
+const draft06Config = {
+    typeKeywords: {
+        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"]
+    },
+    validateKeyword: KEYWORDS,
+    validateType: TYPES,
+    validateFormat: FORMATS,
+    errors: ERRORS,
+    addRemoteSchema,
+    compileSchema,
+    createSchemaOf,
+    each,
+    eachSchema,
+    getChildSchemaSelection,
+    getSchema,
+    getTemplate,
+    isValid,
+    resolveAllOf,
+    resolveAnyOf,
+    resolveOneOf,
+    resolveRef,
+    step,
+    validate
+};
+class Draft06 extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draft06Config, config), schema);
+    }
+}
+export { Draft06, draft06Config };