json-schema-library 11.0.5 → 11.2.0

package/src/keywords/maxProperties.ts

@@ -1,25 +1,46 @@
 import { isObject } from "../utils/isObject";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+import { isNumber } from "../types";
 
-export const maxPropertiesKeyword: Keyword = {
-    id: "maxProperties",
-    keyword: "maxProperties",
-    addValidate: ({ schema }) => !isNaN(schema.maxProperties),
+const KEYWORD = "maxProperties";
+
+export const maxPropertiesKeyword: Keyword<typeof KEYWORD> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMaxProperties,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMaxProperties
 };
 
-function validateMaxProperties({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
+function parseMaxProperties(node: SchemaNode) {
+    const max = node.schema[KEYWORD];
+    if (max == null) {
+        return;
+    }
+    if (!isNumber(max)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: max,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof max}'`
+        });
+    }
+    node[KEYWORD] = max;
+}
+
+function validateMaxProperties({ node, data, pointer = "#" }: JsonSchemaValidatorParams<typeof KEYWORD>) {
     if (!isObject(data)) {
         return;
     }
-    const { schema } = node;
+    const maxProperties = node[KEYWORD];
     const propertyCount = Object.keys(data).length;
-    if (isNaN(schema.maxProperties) === false && schema.maxProperties < propertyCount) {
+    if (maxProperties < propertyCount) {
         return node.createError("max-properties-error", {
-            maxProperties: schema.maxProperties,
+            maxProperties: maxProperties,
             length: propertyCount,
             pointer,
-            schema,
+            schema: node.schema,
             value: data
         });
     }

package/src/keywords/maximum.ts

@@ -1,31 +1,51 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
-import { isNumber } from "../types";
+import { isNumber, SchemaNode } from "../types";
+
+const KEYWORD = "maximum";
 
 export const maximumKeyword: Keyword = {
-    id: "maximum",
-    keyword: "maximum",
-    addValidate: ({ schema }) => !isNaN(schema.maximum),
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMaximum,
+    addValidate: (node) => node.maximum != null,
     validate: validateMaximum
 };
 
+function parseMaximum(node: SchemaNode) {
+    const max = node.schema[KEYWORD];
+    if (max == null) {
+        return;
+    }
+    if (!isNumber(max)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: max,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof max}'`
+        });
+    }
+    node[KEYWORD] = max;
+}
+
 function validateMaximum({ node, data, pointer }: JsonSchemaValidatorParams) {
     if (!isNumber(data)) {
         return undefined;
     }
 
+    const max = node[KEYWORD];
     const { schema } = node;
-    if (schema.maximum && schema.maximum < data) {
+    if (max && max < data) {
         return node.createError("maximum-error", {
-            maximum: schema.maximum,
+            maximum: max,
             length: data,
             value: data,
             pointer,
             schema
         });
     }
-    if (schema.maximum && schema.exclusiveMaximum === true && schema.maximum === data) {
+    if (max && schema.exclusiveMaximum === true && max === data) {
         return node.createError("maximum-error", {
-            maximum: schema.maximum,
+            maximum: max,
             length: data,
             pointer,
             schema,

package/src/keywords/minItems.ts

@@ -1,23 +1,44 @@
 import { JsonSchemaValidatorParams, Keyword } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+import { isNumber } from "../types";
 
-export const minItemsKeyword: Keyword = {
-    id: "minItems",
-    keyword: "minItems",
-    addValidate: ({ schema }) => !isNaN(schema.minItems),
+const KEYWORD = "minItems";
+
+export const minItemsKeyword: Keyword<"minItems"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMinItems,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMinItems
 };
 
-function validateMinItems({ node, data, pointer }: JsonSchemaValidatorParams) {
+function parseMinItems(node: SchemaNode) {
+    const min = node.schema[KEYWORD];
+    if (min == null) {
+        return;
+    }
+    if (!isNumber(min)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: min,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof min}'`
+        });
+    }
+    node[KEYWORD] = min;
+}
+
+function validateMinItems({ node, data, pointer }: JsonSchemaValidatorParams<"minItems">) {
     if (!Array.isArray(data)) {
         return;
     }
-    const { schema } = node;
-    if (schema.minItems > data.length) {
+    const minItems = node[KEYWORD];
+    if (minItems > data.length) {
         return node.createError("min-items-error", {
-            minItems: schema.minItems,
+            minItems: minItems,
             length: data.length,
             pointer,
-            schema,
+            schema: node.schema,
             value: data
         });
     }

package/src/keywords/minLength.ts

@@ -1,27 +1,48 @@
 import ucs2decode from "../utils/punycode.ucs2decode";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+import { isNumber } from "../types";
 
-export const minLengthKeyword: Keyword = {
-    id: "minLength",
-    keyword: "minLength",
-    addValidate: ({ schema }) => !isNaN(schema.minLength),
+const KEYWORD = "minLength";
+
+export const minLengthKeyword: Keyword<"minLength"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMinLength,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMinLength
 };
 
-function validateMinLength({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
+function parseMinLength(node: SchemaNode) {
+    const min = node.schema[KEYWORD];
+    if (min == null) {
+        return;
+    }
+    if (!isNumber(min)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: min,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof min}'`
+        });
+    }
+    node[KEYWORD] = min;
+}
+
+function validateMinLength({ node, data, pointer = "#" }: JsonSchemaValidatorParams<"minLength">) {
     if (typeof data !== "string") {
         return;
     }
-    const { schema } = node;
     const length = ucs2decode(data).length;
-    if (schema.minLength <= length) {
+    const minLength = node[KEYWORD];
+    if (minLength <= length) {
         return;
     }
     return node.createError("min-length-error", {
-        minLength: schema.minLength,
+        minLength,
         length,
         pointer,
-        schema,
+        schema: node.schema,
         value: data
     });
 }

package/src/keywords/minProperties.ts

@@ -1,14 +1,35 @@
 import { isObject } from "../utils/isObject";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+import { isNumber } from "../types";
 
-export const minPropertiesKeyword: Keyword = {
-    id: "minProperties",
-    keyword: "minProperties",
-    addValidate: ({ schema }) => !isNaN(schema.minProperties),
+const KEYWORD = "minProperties";
+
+export const minPropertiesKeyword: Keyword<"minProperties"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMinItems,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMinProperties
 };
 
-function validateMinProperties({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
+function parseMinItems(node: SchemaNode) {
+    const min = node.schema[KEYWORD];
+    if (min == null) {
+        return;
+    }
+    if (!isNumber(min)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: min,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof min}'`
+        });
+    }
+    node[KEYWORD] = min;
+}
+
+function validateMinProperties({ node, data, pointer = "#" }: JsonSchemaValidatorParams<"minProperties">) {
     if (!isObject(data)) {
         return;
     }

package/src/keywords/minimum.ts

@@ -1,33 +1,52 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
-import { isNumber } from "../types";
+import { isNumber, SchemaNode } from "../types";
 
-export const minimumKeyword: Keyword = {
-    id: "minimum",
-    keyword: "minimum",
-    addValidate: ({ schema }) => !isNaN(schema.minimum),
+const KEYWORD = "minimum";
+
+export const minimumKeyword: Keyword<"minimum"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMinimum,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMinimum
 };
 
-function validateMinimum({ node, data, pointer }: JsonSchemaValidatorParams) {
+function parseMinimum(node: SchemaNode) {
+    const min = node.schema[KEYWORD];
+    if (min == null) {
+        return;
+    }
+    if (!isNumber(min)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: min,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof min}'`
+        });
+    }
+    node[KEYWORD] = min;
+}
+
+function validateMinimum({ node, data, pointer }: JsonSchemaValidatorParams<"minimum">) {
     if (!isNumber(data)) {
         return undefined;
     }
-    const { schema } = node;
-    if (schema.minimum > data) {
+    const min = node[KEYWORD];
+    if (min > data) {
         return node.createError("minimum-error", {
-            minimum: schema.minimum,
+            minimum: min,
             length: data,
             pointer,
-            schema,
+            schema: node.schema,
             value: data
         });
     }
-    if (schema.exclusiveMinimum === true && schema.minimum === data) {
+    if (node.schema.exclusiveMinimum === true && node.schema.minimum === data) {
         return node.createError("minimum-error", {
-            minimum: schema.minimum,
+            minimum: min,
             length: data,
             pointer,
-            schema,
+            schema: node.schema,
             value: data
         });
     }

package/src/keywords/multipleOf.ts

@@ -1,39 +1,60 @@
 import { getPrecision } from "../utils/getPrecision";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+import { isNumber } from "../types";
 
-export const multipleOfKeyword: Keyword = {
-    id: "multipleOf",
-    keyword: "multipleOf",
-    addValidate: ({ schema }) => !isNaN(schema.multipleOf),
+const KEYWORD = "multipleOf";
+
+export const multipleOfKeyword: Keyword<"multipleOf"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMultipleOf,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMultipleOf
 };
 
-function validateMultipleOf({ node, data, pointer }: JsonSchemaValidatorParams) {
+function parseMultipleOf(node: SchemaNode) {
+    const multipleOf = node.schema[KEYWORD];
+    if (multipleOf == null) {
+        return;
+    }
+    if (!isNumber(multipleOf)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: multipleOf,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof multipleOf}'`
+        });
+    }
+    node[KEYWORD] = multipleOf;
+}
+
+function validateMultipleOf({ node, data, pointer }: JsonSchemaValidatorParams<"multipleOf">) {
     if (typeof data !== "number") {
         return undefined;
     }
-    const { schema } = node;
+    const multipleOf = node[KEYWORD];
     const valuePrecision = getPrecision(data);
-    const multiplePrecision = getPrecision(schema.multipleOf);
+    const multiplePrecision = getPrecision(multipleOf);
     if (valuePrecision > multiplePrecision) {
         // value with higher precision then multipleOf-precision can never be multiple
         return node.createError("multiple-of-error", {
-            multipleOf: schema.multipleOf,
+            multipleOf,
             value: data,
             pointer,
-            schema
+            schema: node.schema
         });
     }
 
     const precision = Math.pow(10, multiplePrecision);
     const val = Math.round(data * precision);
-    const multiple = Math.round(schema.multipleOf * precision);
+    const multiple = Math.round(multipleOf * precision);
     if ((val % multiple) / precision !== 0) {
         return node.createError("multiple-of-error", {
-            multipleOf: schema.multipleOf,
+            multipleOf: multipleOf,
             value: data,
             pointer,
-            schema
+            schema: node.schema
         });
     }
 

package/src/keywords/not.ts

@@ -1,26 +1,39 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
-import { SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 
-export const notKeyword: Keyword = {
-    id: "not",
-    keyword: "not",
+const KEYWORD = "not";
+
+export const notKeyword: Keyword<"not"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseNot,
-    addValidate: (node) => node.not != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateNot
 };
 
 export function parseNot(node: SchemaNode) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if (schema.not != null) {
-        node.not = node.compileSchema(schema.not, `${evaluationPath}/not`, `${schemaLocation}/not`);
+    const not = schema[KEYWORD];
+    if (not == null) {
+        return;
+    }
+    if (!isJsonSchema(not) && !isBooleanSchema(not)) {
+        return node.createError("schema-error", {
+            pointer: `${schemaLocation}/${KEYWORD}`,
+            schema,
+            value: not,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof not}'`
+        });
     }
+    node[KEYWORD] = node.compileSchema(schema[KEYWORD], `${evaluationPath}/not`, `${schemaLocation}/not`);
+    return node[KEYWORD].schemaValidation;
 }
 
-function validateNot({ node, data, pointer, path }: JsonSchemaValidatorParams) {
+function validateNot({ node, data, pointer, path }: JsonSchemaValidatorParams<"not">) {
     const { schema } = node;
     // not has been tested in addValidate
-    if (validateNode(node.not!, data, pointer, path).length === 0) {
-        return node.createError("not-error", { value: data, not: schema.not, pointer, schema });
+    if (validateNode(node[KEYWORD]!, data, pointer, path).length === 0) {
+        return node.createError("not-error", { value: data, not: schema[KEYWORD], pointer, schema });
     }
 }

package/src/keywords/oneOf.ts

@@ -3,7 +3,8 @@ import {
     JsonSchemaReducerParams,
     JsonSchemaValidatorParams,
     ValidationPath,
-    ValidationReturnType
+    ValidationReturnType,
+    ValidationAnnotation
 } from "../Keyword";
 import { isSchemaNode, SchemaNode } from "../types";
 import settings from "../settings";
@@ -13,15 +14,16 @@ import { isObject } from "../utils/isObject";
 import { validateNode } from "../validateNode";
 import { joinDynamicId } from "../SchemaNode";
 
+const KEYWORD = "oneOf";
 const { DECLARATOR_ONEOF } = settings;
 
 export const oneOfKeyword: Keyword = {
-    id: "oneOf",
-    keyword: "oneOf",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseOneOf,
-    addReduce: (node) => node.oneOf != null,
+    addReduce: (node) => node[KEYWORD] != null,
     reduce: reduceOneOf,
-    addValidate: (node) => node.oneOf != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: oneOfValidator
 };
 
@@ -37,11 +39,29 @@ export const oneOfFuzzyKeyword: Keyword = {
 
 export function parseOneOf(node: SchemaNode) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if (Array.isArray(schema.oneOf) && schema.oneOf.length) {
-        node.oneOf = schema.oneOf.map((s, index) =>
-            node.compileSchema(s, `${evaluationPath}/oneOf/${index}`, `${schemaLocation}/oneOf/${index}`)
-        );
+    if (schema[KEYWORD] == null) {
+        return;
+    }
+    if (!Array.isArray(schema[KEYWORD])) {
+        return node.createError("schema-error", {
+            pointer: schemaLocation,
+            schema,
+            value: schema[KEYWORD],
+            message: `Keyword '${KEYWORD}' must be an array - received '${typeof schema[KEYWORD]}'`
+        });
+    }
+    if (schema[KEYWORD].length === 0) {
+        return;
     }
+
+    node[KEYWORD] = schema[KEYWORD].map((s, index) =>
+        node.compileSchema(s, `${evaluationPath}/${KEYWORD}/${index}`, `${schemaLocation}/${KEYWORD}/${index}`)
+    );
+
+    return node[KEYWORD].reduce((errors, node) => {
+        if (node.schemaValidation) errors.push(...node.schemaValidation);
+        return errors;
+    }, [] as ValidationAnnotation[]);
 }
 
 function reduceOneOf({ node, data, pointer, path }: Omit<JsonSchemaReducerParams, "key">) {

package/src/keywords/pattern.ts

@@ -1,22 +1,49 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
 import settings from "../settings";
 
+const KEYWORD = "pattern";
 const { REGEX_FLAGS } = settings;
 
-export const patternKeyword: Keyword = {
-    id: "pattern",
-    keyword: "pattern",
-    addValidate: ({ schema }) => typeof schema.pattern === "string",
+export const patternKeyword: Keyword<"pattern"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parsePattern,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validatePattern
 };
 
-function validatePattern({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
-    const { schema } = node;
+function parsePattern(node: SchemaNode) {
+    const pattern = node.schema[KEYWORD];
+    if (pattern == null) {
+        return;
+    }
+    if (typeof pattern !== "string") {
+        return node.createError("schema-error", {
+            pointer: node.schemaLocation,
+            schema: node.schema,
+            value: pattern,
+            message: `Keyword 'pattern' must be a string - received '${typeof pattern}'`
+        });
+    }
+    try {
+        node[KEYWORD] = new RegExp(pattern, node.schema.regexFlags ?? REGEX_FLAGS);
+    } catch (e) {
+        return node.createError("schema-error", {
+            pointer: node.schemaLocation,
+            schema: node.schema,
+            value: pattern,
+            message: (e as Error).message
+        });
+    }
+}
+
+function validatePattern({ node, data, pointer = "#" }: JsonSchemaValidatorParams<"pattern">) {
     if (typeof data !== "string") {
         return;
     }
-    const pattern = new RegExp(schema.pattern, schema.regexFlags ?? REGEX_FLAGS);
-    if (pattern.test(data) === false) {
+    if (node.pattern.test(data) === false) {
+        const { schema } = node;
         return node.createError("pattern-error", {
             pattern: schema.pattern,
             description: schema.patternExample || schema.pattern,
@@ -26,5 +53,4 @@ function validatePattern({ node, data, pointer = "#" }: JsonSchemaValidatorParam
             pointer
         });
     }
-    return undefined;
 }

package/src/keywords/properties.ts

@@ -1,6 +1,12 @@
 import { getValue } from "../utils/getValue";
 import { SchemaNode } from "../types";
-import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
+import {
+    Keyword,
+    JsonSchemaResolverParams,
+    JsonSchemaValidatorParams,
+    ValidationReturnType,
+    ValidationAnnotation
+} from "../Keyword";
 import { isObject } from "../utils/isObject";
 import { validateNode } from "../validateNode";
 
@@ -20,18 +26,35 @@ function propertyResolver({ node, key }: JsonSchemaResolverParams) {
 
 export function parseProperties(node: SchemaNode) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if (schema.properties) {
-        const parsedProperties: Record<string, SchemaNode> = {};
-        Object.keys(schema.properties).forEach((propertyName) => {
-            const propertyNode = node.compileSchema(
-                schema.properties[propertyName],
-                `${evaluationPath}/properties/${propertyName}`,
-                `${schemaLocation}/properties/${propertyName}`
-            );
-            parsedProperties[propertyName] = propertyNode;
+    if (schema.properties == null) {
+        return;
+    }
+
+    if (schema.properties && !isObject(schema.properties)) {
+        return node.createError("schema-error", {
+            pointer: schemaLocation,
+            schema,
+            value: undefined,
+            message: "keyword `properties` must be of type `object`"
         });
-        node.properties = parsedProperties;
     }
+
+    const errors: ValidationAnnotation[] = [];
+    const parsedProperties: Record<string, SchemaNode> = {};
+    Object.keys(schema.properties).forEach((propertyName) => {
+        const propertyNode = node.compileSchema(
+            schema.properties[propertyName],
+            `${evaluationPath}/properties/${propertyName}`,
+            `${schemaLocation}/properties/${propertyName}`
+        );
+        parsedProperties[propertyName] = propertyNode;
+        if (parsedProperties[propertyName].schemaValidation) {
+            errors.push(...parsedProperties[propertyName].schemaValidation);
+        }
+    });
+    node.properties = parsedProperties;
+
+    return errors;
 }
 
 function validateProperties({ node, data, pointer, path }: JsonSchemaValidatorParams) {