json-schema-library 5.3.0 → 7.0.0

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

@@ -0,0 +1,77 @@
+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 compileSchema(draft, schemaToCompile, rootSchema = schemaToCompile, force = false) {
+    // @ts-ignore
+    if (schemaToCompile === true || schemaToCompile === false || schemaToCompile === undefined) {
+        return schemaToCompile;
+    }
+    if (schemaToCompile[COMPILED] !== undefined) {
+        return schemaToCompile;
+    } // eslint-disable-line
+    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) {
+        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 = () => 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(/##+/, "#");
+        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 && !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 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 };

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

@@ -0,0 +1,168 @@
+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,31 @@
+/**
+ * @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)
+ */
+const validationType = {
+    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))
+};
+export default validationType;

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/draft07/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 draft07Config = {
+    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 Draft07 extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draft07Config, config), schema);
+    }
+}
+export { Draft07, draft07Config };

package/dist/module/lib/each.js

@@ -8,11 +8,11 @@ import getTypeOf from "./getTypeOf";
  * @param [schema] - the schema matching the data. Defaults to rootSchema
  * @param [pointer] - pointer to current data. Default to rootPointer
  */
-export default function each(core, data, callback, schema = core.rootSchema, pointer = "#") {
+export function each(core, data, callback, schema = core.rootSchema, pointer = "#") {
     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

@@ -1,35 +1,44 @@
 import gp from "gson-pointer";
 import getTypeDefs from "./schema/getTypeDefs";
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
 function nextTypeDefs(schema, pointer) {
-    if (this.callback(schema, pointer) === true) { // eslint-disable-line no-invalid-this
+    if (this.callback(schema, pointer) === true) {
+        // eslint-disable-line no-invalid-this
         return; // stop iteration
     }
     const defs = getTypeDefs(schema);
     // eslint-disable-next-line no-invalid-this
-    defs.forEach(next => this.nextTypeDefs(next.def, gp.join(pointer, next.pointer, false)));
+    defs.forEach((next) => this.nextTypeDefs(next.def, gp.join(pointer, next.pointer, false)));
 }
-function eachDefinition(walk, schema, pointer) {
-    Object.keys(schema.definitions)
-        .forEach(defId => {
-        if (!isObject(schema.definitions[defId])) {
-            console.log(`Invalid schema in ${pointer}/definitions/${defId}`);
+function eachDefinition(walk, schema, pointer, key = "definitions") {
+    const defs = schema[key];
+    Object.keys(defs).forEach((defId) => {
+        if (defs[defId] === false || isObject(defs[defId])) {
+            walk.nextTypeDefs(defs[defId], gp.join(pointer, key, defId, false));
             return;
         }
-        walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
+        console.log(`Invalid schema in ${pointer}/${key}/${defId}`);
     });
 }
-export default function eachSchema(schema, callback, pointer = "#") {
+export function eachSchema(schema, callback, pointer = "#") {
     const walk = { callback, nextTypeDefs };
     walk.nextTypeDefs(schema, pointer);
-    if (schema.definitions == null) {
-        return;
+    if (schema.definitions != null) {
+        walk.callback = (defschema, schemaPointer) => {
+            callback(defschema, schemaPointer);
+            if (defschema.definitions != null) {
+                eachDefinition(walk, defschema, schemaPointer);
+            }
+        };
+        eachDefinition(walk, schema, pointer);
+    }
+    if (schema.$defs != null) {
+        walk.callback = (defschema, schemaPointer) => {
+            callback(defschema, schemaPointer);
+            if (defschema.definitions != null) {
+                eachDefinition(walk, defschema, schemaPointer);
+            }
+        };
+        eachDefinition(walk, schema, pointer, "$defs");
     }
-    walk.callback = (defschema, schemaPointer) => {
-        callback(defschema, schemaPointer);
-        if (defschema.definitions != null) {
-            eachDefinition(walk, defschema, schemaPointer);
-        }
-    };
-    eachDefinition(walk, schema, 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.
@@ -19,13 +20,14 @@ export default function getSchema(core, pointer, data, schema = core.rootSchema)
 }
 function _get(core, schema, frags, pointer, data = emptyObject) {
     if (frags.length === 0) {
-        return schema;
+        return core.resolveRef(schema);
     }
     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;
     }
+    // @ts-ignore
     data = data[key]; // step data
     return _get(core, schema, frags, `${pointer}/${key}`, data);
 }