json-schema-library 5.3.0 → 7.0.0

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

@@ -5,7 +5,7 @@
  * 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 {
+const typeValidators = {
     array: (core, schema, value, pointer) => core.typeKeywords.array
         .filter(key => schema && schema[key] != null)
         .map(key => core.validateKeyword[key](core, schema, value, pointer)),
@@ -28,3 +28,4 @@ export default {
         .filter(key => schema && schema[key] != null)
         .map(key => core.validateKeyword[key](core, schema, value, pointer))
 };
+export default typeValidators;

package/index.ts

@@ -1,49 +1,63 @@
-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 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 isValid from "./lib/isValid";
+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 step from "./lib/step";
-import validate from "./lib/validate";
-import validateAsync from "./lib/validateAsync";
 import settings from "./lib/config/settings";
+import strings from "./lib/config/strings";
+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,
+    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,
+    draftJsonEditorConfig, // adjusted config of draft04 to better support the json-editor
+    createError,
     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
+    isJSONError,
+    render,
+    resolveRef,
+    resolveRefMerge,
+    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
 };
 
-export type { JSONSchema, JSONPointer, JSONError, JSONValidator } from "./lib/types";
+import { DraftConfig } from "./lib/draft";
+import { EachCallback } from "./lib/each";
+import { EachSchemaCallback } from "./lib/eachSchema";
+import { ErrorData, CreateError } from "./lib/utils/createCustomError";
+import { JSONSchema, JSONPointer, JSONError, JSONValidator, JSONTypeValidator } from "./lib/types";
+
+export type {
+    CreateError,
+    DraftConfig,
+    EachCallback,
+    EachSchemaCallback,
+    ErrorData,
+    JSONError,
+    JSONPointer,
+    JSONSchema,
+    JSONTypeValidator,
+    JSONValidator
+};

package/lib/SchemaService.ts

@@ -1,24 +1,23 @@
 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";
 import { JSONSchema, JSONPointer } from "./types";
 
-
 export default class SchemaService {
     core: Core;
     schema: JSONSchema;
-    data: any;
-    cache: { [p: string]: JSONSchema };
+    data: unknown;
+    cache: Record<string, JSONSchema>;
 
-    constructor(schema: JSONSchema, data) {
+    constructor(schema: JSONSchema, data: unknown) {
         this.core = new Core(schema);
         this.schema = schema;
         this.data = data;
         this.cache = {};
     }
 
-    updateData(data: any) {
+    updateData(data: unknown) {
         this.data = data;
         this.cache = {};
     }
@@ -29,17 +28,20 @@ export default class SchemaService {
         this.cache = {};
     }
 
-    get(pointer: JSONPointer, data: any): JSONSchema {
-        if (data) { // possibly separate entry point
+    get(pointer: JSONPointer, data: unknown): JSONSchema {
+        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];
         }
 
@@ -55,7 +57,12 @@ export default class SchemaService {
 
         // step from parent to child
         const key = gp.split(pointer).pop();
-        let schema = getSchema(this.core, key, gp.get(this.data, parentPointer), this.cache[parentPointer]);
+        let schema = getSchema(
+            this.core,
+            key,
+            gp.get(this.data, parentPointer),
+            this.cache[parentPointer]
+        );
         schema = copy(schema);
         if (schema.variableSchema !== true) {
             this.cache[pointer] = schema;

package/lib/{addSchema.ts → addRemoteSchema.ts}

@@ -1,14 +1,12 @@
-import remotes from "../remotes";
-import compileSchema from "./compileSchema";
+import { Draft } from "./draft";
 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 {
+export default function addRemoteSchema(draft: Draft, url: string, schema: JSONSchema): void {
     schema.id = schema.id || url;
-    remotes[url] = compileSchema(schema);
+    draft.remotes[url] = draft.compileSchema(schema);
 }

package/lib/addValidator.ts

@@ -1,6 +1,6 @@
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 import { JSONValidator } from "./types";
-
+import { CreateError } from "./utils/createCustomError";
 
 /**
  * @throws Error
@@ -10,14 +10,15 @@ 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}'`);
+        throw new Error(
+            `Error callback 'errorCreator' must be of type function. Received '${typeof errorCreator}'`
+        );
     }
     core.errors[errorId] = errorCreator;
 }
 
-
 /**
  * Adds a custom format validator. Existing format may not be overriden (may still be modified manually)
  * @param core
@@ -28,14 +29,12 @@ 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;
 }
 
-
 /**
  * Adds a custom keyword validation to a specific type. May not override existing keywords.
  *
@@ -44,7 +43,12 @@ function addFormat(core: Core, formatType: string, validationFunction: JSONValid
  * @param keyword - The keyword to add, i.e. `minWidth: ...`
  * @param validationFunction - called with (core, schema, value, pointer)
  */
-function addKeyword(core: Core, datatype: string, keyword: string, validationFunction: JSONValidator) {
+function addKeyword(
+    core: Core,
+    datatype: string,
+    keyword: string,
+    validationFunction: JSONValidator
+) {
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
@@ -57,7 +61,6 @@ function addKeyword(core: Core, datatype: string, keyword: string, validationFun
     core.validateKeyword[keyword] = validationFunction;
 }
 
-
 export default {
     error: addError,
     format: addFormat,

package/lib/compile/getRef.ts

@@ -2,16 +2,15 @@ import { get } from "gson-pointer";
 import splitRef from "./splitRef";
 import getTypeOf from "../getTypeOf";
 import { JSONSchema } from "../types";
-
+import { Context } 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
 // 2. base or pointer is known
 // 3. base + pointer is known
-export default function getRef(context, rootSchema: JSONSchema, $ref) {
+export default function getRef(context: Context, rootSchema: JSONSchema, $ref: string): JSONSchema {
     if (isObject($ref)) {
         $ref = $ref.__ref || $ref.$ref;
     }

package/lib/compile/index.ts

@@ -1,9 +1,10 @@
 /* eslint max-statements-per-line: ["error", { "max": 2 }] */
-import eachSchema from "../eachSchema";
-import remotes from "../../remotes";
+import { eachSchema } from "../eachSchema";
+import { Draft } from "../draft";
 import joinScope from "./joinScope";
 import getRef from "./getRef";
 import { JSONSchema } from "../types";
+import { Context } from "./types";
 
 const COMPILED = "__compiled";
 const COMPILED_REF = "__ref";
@@ -11,24 +12,64 @@ 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 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 compileSchema(
+    draft: Draft,
+    schemaToCompile: JSONSchema,
+    rootSchema: JSONSchema = schemaToCompile,
+    force = false
+): JSONSchema {
+    if (!schemaToCompile || schemaToCompile[COMPILED] !== undefined) {
+        return schemaToCompile;
+    }
+
+    const context: Context = { ids: {}, remotes: draft.remotes };
+    const rootSchemaAsString = JSON.stringify(schemaToCompile);
+    const compiledSchema: JSONSchema = JSON.parse(rootSchemaAsString);
 
-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) };
-    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) });
+    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;
     }
 
-    const scopes = {};
-    const getRoot = () => rootSchema;
-    eachSchema(rootSchema, (schema, pointer) => {
-        if (schema.id) { context.ids[schema.id.replace(suffixes, "")] = pointer; }
+    // 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: Record<string, string> = {};
+    const getRoot = () => compiledSchema;
+    eachSchema(compiledSchema, (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(/##+/, "#");
@@ -37,10 +78,15 @@ export default function compile(rootSchema: JSONSchema, force = false): JSONSche
         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 (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));
@@ -48,5 +94,5 @@ export default function compile(rootSchema: JSONSchema, force = false): JSONSche
     });
 
     // console.log(JSON.stringify(context.ids, null, 2));
-    return rootSchema;
+    return compiledSchema;
 }

package/lib/compile/types.ts

@@ -0,0 +1,6 @@
+import { JSONSchema, JSONPointer } from "../types";
+
+export type Context = {
+    ids: Record<string, JSONPointer>;
+    remotes: Record<string, JSONSchema>;
+};

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/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);
     }