json-schema-library 5.3.0 → 7.0.0

package/lib/draft/index.ts

@@ -0,0 +1,201 @@
+import step from "../step";
+import validate from "../validate";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import resolveAllOf from "../resolveAllOf";
+import resolveAnyOf from "../resolveAnyOf";
+import getTemplate from "../getTemplate";
+import getChildSchemaSelection from "../getChildSchemaSelection";
+import getSchema from "../getSchema";
+import { each, EachCallback } from "../each";
+import isValid from "../isValid";
+import { eachSchema, EachSchemaCallback } from "../eachSchema";
+import createSchemaOf from "../createSchemaOf";
+import compileSchema from "../compileSchema";
+import { CreateError } from "../utils/createCustomError";
+import addRemoteSchema from "../addRemoteSchema";
+import { JSONSchema, JSONPointer, JSONValidator, JSONTypeValidator, JSONError } from "../types";
+
+export type DraftConfig = {
+    /** 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>;
+
+    addRemoteSchema: typeof addRemoteSchema;
+    compileSchema: typeof compileSchema;
+    createSchemaOf: typeof createSchemaOf;
+    each: typeof each;
+    eachSchema: typeof eachSchema;
+    getChildSchemaSelection: typeof getChildSchemaSelection;
+    getSchema: typeof getSchema;
+    getTemplate: typeof getTemplate;
+    isValid: typeof isValid;
+    resolveAllOf: typeof resolveAllOf;
+    resolveAnyOf: typeof resolveAnyOf;
+    resolveOneOf: typeof resolveOneOf;
+    resolveRef: typeof resolveRef;
+    step: typeof step;
+    validate: typeof validate;
+};
+
+export class Draft {
+    readonly config: DraftConfig;
+    /** entry point of schema */
+    private __rootSchema: JSONSchema;
+    /** cache for remote schemas */
+    remotes: Record<string, JSONSchema> = {};
+    /** error creators by id */
+    readonly errors: Record<string, CreateError> = {};
+    /** map for valid keywords of a type  */
+    readonly typeKeywords: Record<string, string[]> = {};
+    /** keyword validators  */
+    readonly validateKeyword: Record<string, JSONValidator> = {};
+    /** type validators  */
+    readonly validateType: Record<string, JSONTypeValidator> = {};
+    /** format validators  */
+    readonly validateFormat: Record<string, JSONValidator> = {};
+
+    constructor(config: DraftConfig, schema?: JSONSchema) {
+        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: JSONSchema) {
+        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: string, schema: JSONSchema): void {
+        this.config.addRemoteSchema(this, url, schema);
+    }
+
+    compileSchema(schema: JSONSchema): JSONSchema {
+        return this.config.compileSchema(this, schema, this.rootSchema ?? schema);
+    }
+
+    createSchemaOf(data: unknown) {
+        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: any, callback: EachCallback, schema?: JSONSchema, pointer?: JSONPointer) {
+        return this.config.each(this, data, callback, schema, pointer);
+    }
+
+    eachSchema(callback: EachSchemaCallback, schema = this.rootSchema) {
+        return this.config.eachSchema(schema, callback);
+    }
+
+    getChildSchemaSelection(property: string | number, schema?: JSONSchema) {
+        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: JSONPointer = "#", data?: any, schema?: JSONSchema): JSONSchema | JSONError {
+        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?: unknown, schema?: JSONSchema) {
+        return this.config.getTemplate(this, data, schema);
+    }
+
+    isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): boolean {
+        return this.config.isValid(this, data, schema, pointer);
+    }
+
+    resolveAnyOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema {
+        return this.config.resolveAnyOf(this, data, schema, pointer);
+    }
+
+    resolveAllOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema {
+        return this.config.resolveAllOf(this, data, schema, pointer);
+    }
+
+    resolveRef(schema: JSONSchema): JSONSchema {
+        return this.config.resolveRef(schema, this.rootSchema);
+    }
+
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema {
+        return this.config.resolveOneOf(this, data, schema, pointer);
+    }
+
+    setSchema(schema: JSONSchema) {
+        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: string | number, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema {
+        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: unknown, schema?: JSONSchema, pointer?: JSONPointer): JSONError[] {
+        return this.config.validate(this, data, schema, pointer);
+    }
+}

package/lib/draft04/index.ts

@@ -0,0 +1,95 @@
+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 { DraftConfig, Draft } from "../draft";
+import { JSONSchema } from "../types";
+
+const draft04Config: DraftConfig = {
+    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?: JSONSchema, config: Partial<DraftConfig> = {}) {
+        super(merge(draft04Config, config), schema);
+    }
+}
+
+export { Draft04, draft04Config };

package/lib/draft06/compile/index.ts

@@ -0,0 +1,104 @@
+/* eslint max-statements-per-line: ["error", { "max": 2 }] */
+import { Draft } from "../../draft";
+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;
+
+type Context = {
+    ids: Record<string, unknown>;
+    remotes: Record<string, JSONSchema>;
+};
+
+/**
+ * @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: Draft,
+    schemaToCompile: JSONSchema,
+    rootSchema = schemaToCompile,
+    force = false
+): JSONSchema {
+    // @ts-ignore
+    if (schemaToCompile === true || schemaToCompile === false || schemaToCompile === undefined) {
+        return schemaToCompile;
+    }
+    if (schemaToCompile[COMPILED] !== undefined) {
+        return schemaToCompile;
+    } // eslint-disable-line
+    const context: 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: 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(/##+/, "#");
+        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/lib/draft06/index.ts

@@ -0,0 +1,101 @@
+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 { DraftConfig, Draft } from "../draft";
+import { JSONSchema } from "../types";
+
+const draft06Config: DraftConfig = {
+    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?: JSONSchema, config: Partial<DraftConfig> = {}) {
+        super(merge(draft06Config, config), schema);
+    }
+}
+
+export { Draft06, draft06Config };

package/lib/draft06/validation/keyword.ts

@@ -0,0 +1,199 @@
+import Keywords from "../../validation/keyword";
+import getTypeOf from "../../getTypeOf";
+import { JSONValidator, JSONError } from "../../types";
+
+const KeywordValidation: Record<string, JSONValidator> = {
+    ...Keywords,
+    // @draft >= 6
+    contains: (core, schema, value: unknown[], 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: Record<string, unknown>, pointer) => {
+        const properties = schema.properties || {};
+        const pp = schema.patternProperties;
+        if (getTypeOf(pp) !== "object") {
+            return undefined;
+        }
+
+        const errors: JSONError[] = [];
+        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: Record<string, unknown>, 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: JSONError[] = [];
+        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;