json-schema-library 11.0.4 → 11.1.0

package/src/keywords/format.ts

@@ -1,12 +1,31 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+
+const KEYWORD = "format";
 
 export const formatKeyword: Keyword = {
-    id: "format",
-    keyword: "format",
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseFormat,
     addValidate: ({ schema }) => schema?.format != null,
     validate: validateFormat
 };
 
+function parseFormat(node: SchemaNode) {
+    const format = node.schema[KEYWORD];
+    if (format == null) {
+        return;
+    }
+    if (typeof format !== "string") {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: format,
+            message: `Keyword '${KEYWORD}' must be a string - received '${typeof format}'`
+        });
+    }
+}
+
 function validateFormat(options: JsonSchemaValidatorParams) {
     const { node } = options;
     const formatValidator = node.context.formats[node.schema.format];

package/src/keywords/ifthenelse.ts

@@ -1,6 +1,6 @@
 import { mergeSchema } from "../utils/mergeSchema";
-import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams } from "../Keyword";
-import { SchemaNode } from "../types";
+import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 
 export const ifKeyword: Keyword = {
@@ -15,15 +15,59 @@ export const ifKeyword: Keyword = {
 
 export function parseIfThenElse(node: SchemaNode) {
     const { schema, evaluationPath } = node;
+    const errors: ValidationAnnotation[] = [];
     if (schema.if != null) {
-        node.if = node.compileSchema(schema.if, `${evaluationPath}/if`);
+        if (isJsonSchema(schema.if) || isBooleanSchema(schema.if)) {
+            node.if = node.compileSchema(schema.if, `${evaluationPath}/if`);
+            if (node.if.schemaValidation) {
+                errors.push(...node.if.schemaValidation);
+            }
+        } else {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/if`,
+                    schema: node.schema,
+                    value: schema.if,
+                    message: `Keyword 'if' must be valid JSON Schema - received '${typeof schema.if}'`
+                })
+            );
+        }
     }
     if (schema.then != null) {
-        node.then = node.compileSchema(schema.then, `${evaluationPath}/then`);
+        if (isJsonSchema(schema.then) || isBooleanSchema(schema.then)) {
+            node.then = node.compileSchema(schema.then, `${evaluationPath}/then`);
+            if (node.then.schemaValidation) {
+                errors.push(...node.then.schemaValidation);
+            }
+        } else {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/then`,
+                    schema: node.schema,
+                    value: schema.then,
+                    message: `Keyword 'then' must be valid JSON Schema - received '${typeof schema.then}'`
+                })
+            );
+        }
     }
     if (schema.else != null) {
-        node.else = node.compileSchema(schema.else, `${evaluationPath}/else`);
+        if (isJsonSchema(schema.else) || isBooleanSchema(schema.else)) {
+            node.else = node.compileSchema(schema.else, `${evaluationPath}/else`);
+            if (node.else.schemaValidation) {
+                errors.push(...node.else.schemaValidation);
+            }
+        } else {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/else`,
+                    schema: node.schema,
+                    value: schema.else,
+                    message: `Keyword 'else' must be valid JSON Schema - received '${typeof schema.else}'`
+                })
+            );
+        }
     }
+    return errors;
 }
 
 function reduceIf({ node, data, pointer, path }: JsonSchemaReducerParams) {

package/src/keywords/items.ts

@@ -1,15 +1,16 @@
 import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
-import { SchemaNode } from "../types";
-import { isObject } from "../utils/isObject";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 
+const KEYWORD = "items";
+
 export const itemsKeyword: Keyword = {
-    id: "items",
-    keyword: "items",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseItems,
-    addResolve: (node) => node.items != null,
+    addResolve: (node) => node[KEYWORD] != null,
     resolve: itemsResolver,
-    addValidate: ({ schema }) => schema.items != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateItems
 };
 
@@ -23,14 +24,27 @@ function itemsResolver({ node, key }: JsonSchemaResolverParams) {
 }
 
 export function parseItems(node: SchemaNode) {
-    const { schema, evaluationPath } = node;
-    if (isObject(schema.items)) {
-        const propertyNode = node.compileSchema(
-            schema.items,
-            `${evaluationPath}/items`,
-            `${node.schemaLocation}/items`
+    const items = node.schema[KEYWORD];
+    if (items == null) {
+        return;
+    }
+    if (!(isJsonSchema(items) || isBooleanSchema(items))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: items,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof items}'`
+        });
+    }
+
+    if (items !== true) {
+        // @todo remove skipping boolean schema
+        node[KEYWORD] = node.compileSchema(
+            items,
+            `${node.evaluationPath}/${KEYWORD}`,
+            `${node.schemaLocation}/${KEYWORD}`
         );
-        node.items = propertyNode;
+        return node[KEYWORD].schemaValidation;
     }
 }
 

package/src/keywords/maxItems.ts

@@ -1,12 +1,32 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { isNumber, SchemaNode } from "../types";
+
+const KEYWORD = "maxItems";
 
 export const maxItemsKeyword: Keyword = {
-    id: "maxItems",
-    keyword: "maxItems",
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMaxItems,
     addValidate: ({ schema }) => !isNaN(schema.maxItems),
     validate: validateMaxItems
 };
 
+function parseMaxItems(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 validateMaxItems({ node, data, pointer }: JsonSchemaValidatorParams) {
     const { schema } = node;
     if (Array.isArray(data) && schema.maxItems < data.length) {

package/src/keywords/maxLength.ts

@@ -1,25 +1,46 @@
 import ucs2decode from "../utils/punycode.ucs2decode";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+import { isNumber } from "../types";
 
-export const maxLengthKeyword: Keyword = {
-    id: "maxLength",
-    keyword: "maxLength",
-    addValidate: ({ schema }) => !isNaN(schema.maxLength),
+const KEYWORD = "maxLength";
+
+export const maxLengthKeyword: Keyword<"maxLength"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseMaxLength,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateMaxLength
 };
 
-function validateMaxLength({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
+function parseMaxLength(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 validateMaxLength({ node, data, pointer = "#" }: JsonSchemaValidatorParams<"maxLength">) {
     if (typeof data !== "string") {
         return;
     }
-    const { schema } = node;
+    const maxLength = node[KEYWORD];
     const length = ucs2decode(data).length;
-    if (schema.maxLength < length) {
+    if (maxLength < length) {
         return node.createError("max-length-error", {
-            maxLength: schema.maxLength,
+            maxLength: maxLength,
             length,
             pointer,
-            schema,
+            schema: node.schema,
             value: data
         });
     }

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
         });
     }