json-schema-library 5.3.0 → 7.0.0

package/lib/draft06/validation/type.ts

@@ -0,0 +1,47 @@
+import { JSONTypeValidator } from "../../types";
+
+/**
+ * @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: Record<string, JSONTypeValidator> = {
+    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/lib/draft06/validation/typeKeywordMapping.ts

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

package/lib/each.ts

@@ -1,7 +1,8 @@
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 import getTypeOf from "./getTypeOf";
 import { JSONSchema, JSONPointer } from "./types";
 
+export type EachCallback = (schema: JSONSchema, data: unknown, pointer: JSONPointer) => void;
 
 /**
  * Iterates over data, retrieving its schema
@@ -12,18 +13,24 @@ import { JSONSchema, JSONPointer } from "./types";
  * @param [schema] - the schema matching the data. Defaults to rootSchema
  * @param [pointer] - pointer to current data. Default to rootPointer
  */
-export default function each(core: Core, data: any, callback, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#") {
+export function each(
+    core: Core,
+    data: any,
+    callback: EachCallback,
+    schema: JSONSchema = core.rootSchema,
+    pointer: JSONPointer = "#"
+) {
     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}`);
         });
     } else if (dataType === "array") {
-        data.forEach((next, key) => {
+        data.forEach((next: unknown, key: number) => {
             const nextSchema = core.step(key, schema, data, pointer);
             core.each(next, callback, nextSchema, `${pointer}/${key}`);
         });

package/lib/eachSchema.ts

@@ -2,57 +2,70 @@ import gp from "gson-pointer";
 import getTypeDefs from "./schema/getTypeDefs";
 import { JSONSchema, JSONPointer } from "./types";
 
-
-export interface OnSchema {
-    (schema: JSONSchema, pointer: JSONPointer): void;
-}
+export type EachSchemaCallback = (schema: JSONSchema, pointer: JSONPointer) => void;
 
 type Walker = {
     nextTypeDefs: typeof nextTypeDefs;
-    callback: OnSchema;
-}
-
-
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
+    callback: EachSchemaCallback;
+};
 
+const isObject = (value: unknown): value is Record<string, unknown> =>
+    Object.prototype.toString.call(value) === "[object Object]";
 
 function nextTypeDefs(schema: JSONSchema, pointer: JSONPointer) {
-    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: Walker, schema: JSONSchema, pointer: JSONPointer) {
-    Object.keys(schema.definitions)
-        .forEach(defId => {
-            if (!isObject(schema.definitions[defId])) {
-                console.log(`Invalid schema in ${pointer}/definitions/${defId}`);
-                return;
-            }
-            walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
-        });
+function eachDefinition(
+    walk: Walker,
+    schema: JSONSchema,
+    pointer: JSONPointer,
+    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;
+        }
+        console.log(`Invalid schema in ${pointer}/${key}/${defId}`);
+    });
 }
 
-
-export default function eachSchema(schema: JSONSchema, callback: OnSchema, pointer: JSONPointer = "#") {
+export function eachSchema(
+    schema: JSONSchema,
+    callback: EachSchemaCallback,
+    pointer: JSONPointer = "#"
+) {
     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);
     }
 
-    walk.callback = (defschema, schemaPointer) => {
-        callback(defschema, schemaPointer);
-        if (defschema.definitions != null) {
-            eachDefinition(walk, defschema, schemaPointer);
-        }
-    };
+    if (schema.$defs != null) {
+        walk.callback = (defschema, schemaPointer) => {
+            callback(defschema, schemaPointer);
+            if (defschema.definitions != null) {
+                eachDefinition(walk, defschema, schemaPointer);
+            }
+        };
 
-    eachDefinition(walk, schema, pointer);
+        eachDefinition(walk, schema, pointer, "$defs");
+    }
 }

package/lib/getChildSchemaSelection.ts

@@ -1,19 +1,26 @@
+import { Draft } from "./draft";
+import { isJSONError, JSONError, JSONSchema } 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) {
+export default function getChildSchemaSelection(
+    core: Draft,
+    property: string | number,
+    schema: JSONSchema = core.rootSchema
+): JSONSchema[] | JSONError {
     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: JSONSchema) => core.resolveRef(item));
         }
         return result;
     }

package/lib/getSchema.ts

@@ -1,11 +1,9 @@
 import gp from "gson-pointer";
-import { JSONSchema, JSONPointer } from "./types";
-import Core from "./cores/CoreInterface";
-
+import { JSONSchema, JSONPointer, isJSONError } from "./types";
+import { Draft as Core } from "./draft";
 
 const emptyObject = {};
 
-
 /**
  * Returns the json-schema of a data-json-pointer.
  *
@@ -19,22 +17,33 @@ const emptyObject = {};
  * @param [schema] - the json schema to iterate. Defaults to core.rootSchema
  * @return json schema object of the json-pointer or an error
  */
-export default function getSchema(core: Core, pointer: JSONPointer, data?: any, schema: JSONSchema = core.rootSchema): JSONSchema {
+export default function getSchema(
+    core: Core,
+    pointer: JSONPointer,
+    data?: unknown,
+    schema: JSONSchema = core.rootSchema
+): JSONSchema {
     const frags = gp.split(pointer);
     return _get(core, schema, frags, pointer, data);
 }
 
-
-function _get(core: Core, schema: JSONSchema, frags: Array<string>, pointer: JSONPointer, data: any = emptyObject): JSONSchema {
+function _get(
+    core: Core,
+    schema: JSONSchema,
+    frags: Array<string>,
+    pointer: JSONPointer,
+    data: unknown = emptyObject
+): JSONSchema {
     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);
 }