json-schema-library 5.2.1 → 6.1.0

package/lib/draft06/validation/keyword.ts

@@ -0,0 +1,177 @@
+import Keywords from "../../validation/keyword";
+import getTypeOf from "../../getTypeOf";
+import { JSONValidator } from "../../types";
+
+const KeywordValidation: Record<string, JSONValidator> = {
+    ...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/lib/draft06/validation/type.ts

@@ -0,0 +1,43 @@
+/**
+ * @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)
+ */
+export default {
+
+    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))
+};

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/each.ts

@@ -2,7 +2,6 @@ import Core from "./cores/CoreInterface";
 import getTypeOf from "./getTypeOf";
 import { JSONSchema, JSONPointer } from "./types";
 
-
 /**
  * Iterates over data, retrieving its schema
  *
@@ -12,12 +11,18 @@ 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 default function each(
+    core: Core,
+    data: any,
+    callback,
+    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}`);

package/lib/eachSchema.ts

@@ -30,11 +30,11 @@ function nextTypeDefs(schema: JSONSchema, pointer: JSONPointer) {
 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}`);
+            if (schema.definitions[defId] === false || isObject(schema.definitions[defId])) {
+                walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
                 return;
             }
-            walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
+            console.log(`Invalid schema in ${pointer}/definitions/${defId}`);
         });
 }
 

package/lib/getChildSchemaSelection.ts

@@ -1,19 +1,26 @@
+import CoreInterface from "./cores/CoreInterface";
+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: CoreInterface,
+    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) => core.resolveRef(item));
         }
         return result;
     }

package/lib/getSchema.ts

@@ -1,11 +1,9 @@
 import gp from "gson-pointer";
-import { JSONSchema, JSONPointer } from "./types";
+import { JSONSchema, JSONPointer, isJSONError } from "./types";
 import Core from "./cores/CoreInterface";
 
-
 const emptyObject = {};
 
-
 /**
  * Returns the json-schema of a data-json-pointer.
  *
@@ -19,20 +17,30 @@ 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;
     }
 
     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;
     }
     data = data[key]; // step data