json-schema-library 5.2.1 → 6.1.0

package/index.ts

@@ -1,24 +1,28 @@
-import strings from "./lib/config/strings";
-import Interface from "./lib/cores/CoreInterface";
-import Draft04 from "./lib/cores/Draft04";
-import JsonEditor from "./lib/cores/JsonEditor";
 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 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 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 settings from "./lib/config/settings";
 
 const config = { strings };
 
@@ -26,6 +30,8 @@ export {
     config,
     Interface,
     Draft04, // core implementing draft04 specs
+    Draft06, // core implementing draft06 specs
+    Draft07, // core 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
@@ -39,6 +45,8 @@ export {
     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
@@ -47,3 +55,4 @@ export {
 };
 
 export type { JSONSchema, JSONPointer, JSONError, JSONValidator } from "./lib/types";
+export { isJSONError } from "./lib/types";

package/lib/addValidator.ts

@@ -1,5 +1,6 @@
 import Core from "./cores/CoreInterface";
 import { JSONValidator } from "./types";
+import { CreateError } from "./utils/createCustomError";
 
 
 /**
@@ -10,7 +11,7 @@ import { JSONValidator } from "./types";
  * @param errorId id of error @see /lib/validation/errors
  * @param errorCreator - function returning an error-object @see /lib/utils/createCustomError
  */
-function addError(core: Core, errorId: string, errorCreator) {
+function addError(core: Core, errorId: string, errorCreator: CreateError) {
     if (typeof errorCreator !== "function") {
         throw new Error(`Error callback 'errorCreator' must be of type function. Received '${typeof errorCreator}'`);
     }
@@ -28,11 +29,10 @@ function addFormat(core: Core, formatType: string, validationFunction: JSONValid
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
-    if (core.validateFormat[formatType] == null) {
-        core.validateFormat[formatType] = validationFunction;
-        return;
+    if (core.validateFormat[formatType]) {
+        throw new Error(`A format '${formatType}' is already registered to validation`);
     }
-    throw new Error(`A format '${formatType}' is already registered to validation`);
+    core.validateFormat[formatType] = validationFunction;
 }
 
 

package/lib/compile/getRef.ts

@@ -5,7 +5,7 @@ import { JSONSchema } from "../types";
 
 
 const suffixes = /(#|\/)+$/g;
-const isObject = val => (getTypeOf(val) === "object");
+const isObject = (val: unknown): val is Record<string, any> => (getTypeOf(val) === "object");
 
 
 // 1. combined is known

package/lib/compile/index.ts

@@ -11,7 +11,17 @@ const GET_REF = "getRef";
 const GET_ROOT = "getRoot";
 const suffixes = /(#|\/)+$/g;
 
-
+/**
+ * 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: JSONSchema, force = false): JSONSchema {
     if (rootSchema[COMPILED] !== undefined) { return rootSchema; } // eslint-disable-line
     const context = { ids: {}, remotes: Object.assign({}, remotes) };

package/lib/config/strings.ts

@@ -5,15 +5,28 @@ export default {
     AdditionalPropertiesError: "Additional property `{{property}}` on `{{pointer}}` does not match schema `{{schema}}`",
     AnyOfError: "Value `{{value}}` at `{{pointer}}` does not match any schema of `{{anyOf}}`",
     AllOfError: "Value `{{value}}` at `{{pointer}}` does not match schema of `{{allOf}}`",
+    ConstError: "Expected value at `{{pointer}}` to be `{{expected}}`, but value given is `{{value}}`",
+    ContainsError: "The array at `{{pointer}}` must contain an element that matches `{{schema}}`",
+    ContainsArrayError: "The property at `{{pointer}}` must not be an array",
+    containsAnyError: "The array at `{{pointer}}` must contain at least one item",
     EnumError: "Expected given value `{{value}}` in `{{pointer}}` to be one of `{{values}}`",
+    FormatDateError: "Value `{{value}}` at `{{pointer}}` is not a valid date",
     FormatDateTimeError: "Value `{{value}}` at `{{pointer}}` is not a valid date-time",
     FormatEmailError: "Value `{{value}}` at `{{pointer}}` is not a valid email",
-    FormatUrlError: "Value `{{value}}` at `{{pointer}}` is not a valid url",
-    FormatUriError: "Value `{{value}}` at `{{pointer}}` is not a valid uri",
+    FormatURLError: "Value `{{value}}` at `{{pointer}}` is not a valid url",
+    FormatURIError: "Value `{{value}}` at `{{pointer}}` is not a valid uri",
+    FormatURIReferenceError: "Value `{{value}}` at `{{pointer}}` is not a valid uri-reference",
+    FormatURITemplateError: "Value `{{value}}` at `{{pointer}}` is not a valid uri-template",
     FormatHostnameError: "Value `{{value}}` at `{{pointer}}` is not a valid hostname",
     FormatIPV4Error: "Value `{{value}}` at `{{pointer}}` is not a valid IPv4 address",
+    FormatIPV4LeadingZeroError: "IPv4 addresses starting with zero are invalid, since they are interpreted as octals",
     FormatIPV6Error: "Value `{{value}}` at `{{pointer}}` is not a valid IPv6 address",
+    FormatIPV6LeadingZeroError: "IPv6 addresses starting with zero are invalid, since they are interpreted as octals",
+    FormatJSONPointerError: "Value `{{value}}` at `{{pointer}}` is not a valid json-pointer",
     FormatRegExError: "Value `{{value}}` at `{{pointer}}` is not a valid regular expression",
+    FormatTimeError: "Value `{{value}}` at `{{pointer}}` is not a valid time",
+    InvalidDataError: "No value may be specified in `{{pointer}}`",
+    InvalidPropertyNameError: "Invalid property name `{{property}}` at `{{pointer}}`",
     MaximumError: "Value in `{{pointer}}` is `{{length}}`, but should be `{{maximum}}` at maximum",
     MaxItemsError: "Too many items in `{{pointer}}`, should be `{{maximum}}` at most, but got `{{length}}`",
     MaxLengthError: "Value `{{pointer}}` should have a maximum length of `{{maxLength}}`, but got `{{length}}`.",
@@ -38,4 +51,5 @@ export default {
     UnknownPropertyError: "Could not find a valid schema for property `{{pointer}}` within object",
     UniqueItemsError: "Expected unique items in {{pointer}}: duplicate value `{{value}}` found at {{itemPointer}} and {{duplicatePointer}}",
     ValueNotEmptyError: "A value for `{{property}}` is required at `{{pointer}}`"
-};
+} as Record<string, string>;
+

package/lib/cores/CoreInterface.ts

@@ -3,17 +3,23 @@ import resolveRef from "../resolveRef.withOverwrite";
 import compileSchema from "../compileSchema";
 import resolveAnyOf from "../resolveAnyOf";
 import resolveAllOf from "../resolveAllOf";
-import { JSONSchema, JSONPointer, JSONError } from "../types";
-
+import { JSONSchema, JSONPointer, JSONValidator, JSONTypeValidator, JSONError } from "../types";
+import { CreateError } from "../utils/createCustomError";
 
 /* eslint no-unused-vars: 0 no-empty-function: 0 */
 export default class CoreInterface {
+    /** entry point of schema */
     __rootSchema: JSONSchema;
-    errors;
-    typeKeywords;
-    validateFormat;
-    validateKeyword;
-    validateType;
+    /** error creators by id */
+    errors: Record<string, CreateError> = {};
+    /** map for valid keywords of a type  */
+    typeKeywords: Record<string, string[]> = {};
+    /** keyword validators  */
+    validateKeyword: Record<string, JSONValidator> = {};
+    /** type validators  */
+    validateType: Record<string, JSONTypeValidator> = {};
+    /** format validators  */
+    validateFormat: Record<string, JSONValidator> = {};
 
     constructor(schema?: JSONSchema) {
         this.setSchema(schema);
@@ -34,7 +40,11 @@ export default class CoreInterface {
         throw new Error("function 'each' is not implemented");
     }
 
-    validate(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#"): Array<JSONError> {
+    validate(
+        data: unknown,
+        schema: JSONSchema = this.rootSchema,
+        pointer: JSONPointer = "#"
+    ): Array<JSONError> {
         throw new Error("function 'validate' is not implemented");
     }
 
@@ -62,7 +72,7 @@ export default class CoreInterface {
         throw new Error("function 'getSchema' is not implemented");
     }
 
-    getTemplate(data: any, schema: JSONSchema = this.rootSchema) {
+    getTemplate(data?: unknown, schema: JSONSchema = this.rootSchema) {
         throw new Error("function 'getTemplate' is not implemented");
     }
 
@@ -70,7 +80,24 @@ export default class CoreInterface {
         this.rootSchema = schema;
     }
 
-    step(key: string, schema: JSONSchema, data: any, pointer: JSONPointer = "#"): JSONSchema {
+    /**
+     * 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 object or array of key
+     * @param [pointer] json pointer of parent object or array
+     * @return schema or error if failed resolving key
+     */
+    step(
+        key: string | number,
+        schema: JSONSchema,
+        data: any,
+        pointer: JSONPointer = "#"
+    ): JSONSchema {
         throw new Error("function 'step' is not implemented");
     }
 }

package/lib/cores/Draft04.ts

@@ -20,9 +20,7 @@ import TYPES from "../validation/type";
 import FORMATS from "../validation/format";
 import ERRORS from "../validation/errors";
 
-
 export default class Draft04Core extends CoreInterface {
-
     constructor(schema?: JSONSchema) {
         super(schema);
         this.typeKeywords = JSON.parse(JSON.stringify(TYPE_KEYWORD_MAPPING));
@@ -44,7 +42,7 @@ export default class Draft04Core extends CoreInterface {
         return this.validate(data, schema, pointer).length === 0;
     }
 
-    resolveOneOf(data: any, schema: JSONSchema, pointer: JSONPointer) {
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer) {
         return resolveOneOf(this, data, schema, pointer);
     }
 
@@ -56,7 +54,7 @@ export default class Draft04Core extends CoreInterface {
         return getSchema(this, pointer, data, schema);
     }
 
-    getTemplate(data: any, schema: JSONSchema = this.rootSchema) {
+    getTemplate(data?: unknown, schema: JSONSchema = this.rootSchema) {
         return getTemplate(this, data, schema);
     }
 

package/lib/cores/Draft06.ts

@@ -0,0 +1,76 @@
+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 { JSONSchema, JSONPointer } from "../types";
+
+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?: JSONSchema) {
+        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: JSONSchema) {
+        if (rootSchema == null) {
+            return;
+        }
+        this.__rootSchema = compileSchema(rootSchema);
+    }
+
+    each(data: any, callback, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+        each(this, data, callback, schema, pointer);
+    }
+
+    validate(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+        return validate(this, data, schema, pointer);
+    }
+
+    isValid(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+        return this.validate(data, schema, pointer).length === 0;
+    }
+
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer) {
+        return resolveOneOf(this, data, schema, pointer);
+    }
+
+    resolveRef(schema: JSONSchema) {
+        return resolveRef(schema, this.rootSchema);
+    }
+
+    getSchema(pointer: JSONPointer, data: any, schema: JSONSchema = this.rootSchema) {
+        return getSchema(this, pointer, data, schema);
+    }
+
+    getTemplate(data?: unknown, schema: JSONSchema = this.rootSchema) {
+        return getTemplate(this, data, schema);
+    }
+
+    step(key: string, schema: JSONSchema, data: any, pointer: JSONPointer = "#") {
+        return step(this, key, schema, data, pointer);
+    }
+}

package/lib/cores/Draft07.ts

@@ -0,0 +1,75 @@
+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 { JSONSchema, JSONPointer } from "../types";
+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?: JSONSchema) {
+        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: JSONSchema) {
+        if (rootSchema == null) {
+            return;
+        }
+        this.__rootSchema = compileSchema(rootSchema);
+    }
+
+    each(data: any, callback, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+        each(this, data, callback, schema, pointer);
+    }
+
+    validate(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+        return validate(this, data, schema, pointer);
+    }
+
+    isValid(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+        return this.validate(data, schema, pointer).length === 0;
+    }
+
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer) {
+        return resolveOneOf(this, data, schema, pointer);
+    }
+
+    resolveRef(schema: JSONSchema) {
+        return resolveRef(schema, this.rootSchema);
+    }
+
+    getSchema(pointer: JSONPointer, data: any, schema: JSONSchema = this.rootSchema) {
+        return getSchema(this, pointer, data, schema);
+    }
+
+    getTemplate(data?: unknown, schema: JSONSchema = this.rootSchema) {
+        return getTemplate(this, data, schema);
+    }
+
+    step(key: string, schema: JSONSchema, data: any, pointer: JSONPointer = "#") {
+        return step(this, key, schema, data, pointer);
+    }
+}

package/lib/cores/JsonEditor.ts

@@ -14,9 +14,7 @@ import TYPES from "../validation/type";
 import FORMATS from "../validation/format";
 import ERRORS from "../validation/errors";
 
-
 export default class JsonEditorCore extends CoreInterface {
-
     constructor(schema?: JSONSchema) {
         super(schema);
         this.typeKeywords = JSON.parse(JSON.stringify(TYPE_KEYWORD_MAPPING));
@@ -42,7 +40,7 @@ export default class JsonEditorCore extends CoreInterface {
         return this.validate(data, schema, pointer).length === 0;
     }
 
-    resolveOneOf(data, schema: JSONSchema, pointer: JSONPointer) {
+    resolveOneOf(data, schema: JSONSchema, pointer?: JSONPointer) {
         return resolveOneOf(this, data, schema, pointer);
     }
 
@@ -54,7 +52,7 @@ export default class JsonEditorCore extends CoreInterface {
         return getSchema(this, pointer, data, schema);
     }
 
-    getTemplate(data: any, schema: JSONSchema = this.rootSchema) {
+    getTemplate(data?: any, schema: JSONSchema = this.rootSchema) {
         return getTemplate(this, data, schema);
     }
 

package/lib/createSchemaOf.ts

@@ -1,7 +1,6 @@
 import getTypeOf from "./getTypeOf";
 import { JSONSchema } from "./types";
 
-
 /**
  * Create a simple json schema for the given input data
  * @param  data - data to get json schema for
@@ -14,12 +13,11 @@ export default function createSchemaOf(data: any): JSONSchema {
 
     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]);
-
     } else if (schema.type === "array") {
         schema.items = data.map(createSchemaOf);
     }

package/lib/draft06/addSchema.ts

@@ -0,0 +1,14 @@
+import remotes from "../../remotes";
+import compileSchema from "./compile";
+import { JSONSchema } from "../types";
+
+
+/**
+ * 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: string, schema: JSONSchema): void {
+    schema.id = schema.id || url;
+    remotes[url] = compileSchema(schema);
+}

package/lib/draft06/compile/index.ts

@@ -0,0 +1,68 @@
+/* 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";
+import { JSONSchema } from "../../types";
+
+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: JSONSchema, force = false): JSONSchema {
+    // @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;
+}