json-schema-library 11.0.4 → 11.1.0

package/src/keywords/anyOf.ts

@@ -1,45 +1,64 @@
 import { mergeSchema } from "../utils/mergeSchema";
-import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams } from "../Keyword";
+import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 
+const KEYWORD = "anyOf";
+
 export const anyOfKeyword: Keyword = {
-    id: "anyOf",
-    keyword: "anyOf",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseAnyOf,
-    addReduce: (node) => node.anyOf != null,
+    addReduce: (node) => node[KEYWORD] != null,
     reduce: reduceAnyOf,
-    addValidate: (node) => node.anyOf != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateAnyOf
 };
 
 export function parseAnyOf(node: SchemaNode) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if (Array.isArray(schema.anyOf) && schema.anyOf.length) {
-        node.anyOf = schema.anyOf.map((s, index) =>
-            node.compileSchema(s, `${evaluationPath}/anyOf/${index}`, `${schemaLocation}/anyOf/${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 reduceAnyOf({ node, data, pointer, path }: JsonSchemaReducerParams) {
-    if (node.anyOf == null) {
+    if (node[KEYWORD] == null) {
         return;
     }
 
     let mergedSchema = {};
     let dynamicId = "";
-    for (let i = 0; i < node.anyOf.length; i += 1) {
-        if (validateNode(node.anyOf[i], data, pointer, path).length === 0) {
-            const { node: schemaNode } = node.anyOf[i].reduceNode(data);
+    for (let i = 0; i < node[KEYWORD].length; i += 1) {
+        if (validateNode(node[KEYWORD][i], data, pointer, path).length === 0) {
+            const { node: schemaNode } = node[KEYWORD][i].reduceNode(data);
 
             if (schemaNode) {
                 const nestedDynamicId = schemaNode.dynamicId?.replace(node.dynamicId, "") ?? "";
-                const localDynamicId = nestedDynamicId === "" ? `anyOf/${i}` : nestedDynamicId;
+                const localDynamicId = nestedDynamicId === "" ? `${KEYWORD}/${i}` : nestedDynamicId;
                 dynamicId += `${dynamicId === "" ? "" : ","}${localDynamicId}`;
 
-                const schema = mergeSchema(node.anyOf[i].schema, schemaNode.schema);
-                mergedSchema = mergeSchema(mergedSchema, schema, "anyOf");
+                const schema = mergeSchema(node[KEYWORD][i].schema, schemaNode.schema);
+                mergedSchema = mergeSchema(mergedSchema, schema, KEYWORD);
             }
         }
     }
@@ -52,13 +71,13 @@ function reduceAnyOf({ node, data, pointer, path }: JsonSchemaReducerParams) {
 }
 
 function validateAnyOf({ node, data, pointer, path }: JsonSchemaValidatorParams) {
-    if (node.anyOf == null) {
+    if (node[KEYWORD] == null) {
         return;
     }
-    for (const anyOf of node.anyOf) {
+    for (const anyOf of node[KEYWORD]) {
         if (validateNode(anyOf, data, pointer, path).length === 0) {
             return undefined;
         }
     }
-    return node.createError("any-of-error", { pointer, schema: node.schema, value: data, anyOf: node.schema.anyOf });
+    return node.createError("any-of-error", { pointer, schema: node.schema, value: data, anyOf: node.schema[KEYWORD] });
 }

package/src/keywords/contains.ts

@@ -1,20 +1,22 @@
 import { isObject } from "../utils/isObject";
-import { SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
 import { validateNode } from "../validateNode";
 
+const KEYWORD = "contains";
+
 export const containsKeyword: Keyword = {
-    id: "contains",
-    keyword: "contains",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseContains,
-    addValidate: (node) => node.contains != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateContains,
-    addReduce: (node) => node.contains != null,
+    addReduce: (node) => node[KEYWORD] != null,
     reduce: ({ node }) => {
         return node.compileSchema(
             {
                 items: {
-                    anyOf: [node.contains!.schema] // we tested for contains in addReduce
+                    anyOf: [node[KEYWORD]!.schema] // we tested for contains in addReduce
                 }
             },
             node.evaluationPath,
@@ -24,11 +26,21 @@ export const containsKeyword: Keyword = {
 };
 
 export function parseContains(node: SchemaNode) {
-    const { schema, evaluationPath } = node;
-    if (schema.contains == null) {
+    const contains = node.schema[KEYWORD];
+    if (contains == null) {
         return;
     }
-    node.contains = node.compileSchema(schema.contains, `${evaluationPath}/contains`);
+    if (!(isJsonSchema(contains) || isBooleanSchema(contains))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: contains,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof contains}'`
+        });
+    }
+
+    node[KEYWORD] = node.compileSchema(contains, `${node.evaluationPath}/${KEYWORD}`);
+    return node[KEYWORD].schemaValidation;
 }
 
 function validateContains({ node, data, pointer, path }: JsonSchemaValidatorParams) {

package/src/keywords/dependencies.ts

@@ -1,4 +1,4 @@
-import { isSchemaNode, SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, isSchemaNode, SchemaNode } from "../types";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { isObject } from "../utils/isObject";
 import { mergeNode } from "../mergeNode";
@@ -6,38 +6,58 @@ import { hasProperty } from "../utils/hasProperty";
 import { validateDependentRequired } from "./dependentRequired";
 import { validateDependentSchemas } from "./dependentSchemas";
 import sanitizeErrors from "../utils/sanitizeErrors";
+import { isListOfStrings } from "../utils/isListOfStrings";
+
+const KEYWORD = "dependencies";
 
 export const dependenciesKeyword: Keyword = {
-    id: "dependencies",
-    keyword: "dependencies",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseDependencies,
     order: -9,
-    addReduce: (node) => node.schema.dependencies != null,
+    addReduce: (node) => node.schema[KEYWORD] != null, // because we remap this has to be tested on schema
     reduce: reduceDependencies,
-    addValidate: (node) => node.schema.dependencies != null,
+    addValidate: (node) => node.schema[KEYWORD] != null, // because we remap this has to be tested on schema
     validate: validateDependencies
 };
 
 export function parseDependencies(node: SchemaNode) {
     const { dependencies } = node.schema;
     if (!isObject(dependencies)) {
-        return;
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: dependencies,
+            message: `Keyword '${KEYWORD}' must be an object - received ${typeof dependencies}`
+        });
     }
-    const schemas = Object.keys(dependencies);
-    schemas.forEach((property) => {
+
+    const errors: ValidationAnnotation[] = [];
+    for (const property of Object.keys(dependencies)) {
         const schema = dependencies[property] as string[];
-        if (isObject(schema) || typeof schema === "boolean") {
+        if (isJsonSchema(schema) || isBooleanSchema(schema)) {
             node.dependentSchemas = node.dependentSchemas ?? {};
             node.dependentSchemas[property] = node.compileSchema(
                 schema,
-                `${node.evaluationPath}/dependencies/${property}`,
-                `${node.schemaLocation}/dependencies/${property}`
+                `${node.evaluationPath}/${KEYWORD}/${property}`,
+                `${node.schemaLocation}/${KEYWORD}/${property}`
             );
-        } else {
+        } else if (isListOfStrings(schema)) {
             node.dependentRequired = node.dependentRequired ?? {};
             node.dependentRequired[property] = schema;
+        } else {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/${KEYWORD}`,
+                    schema: node.schema,
+                    value: dependencies,
+                    message: `Keyword '${KEYWORD}[string]' must be JSON Schema or string[]`
+                })
+            );
         }
-    });
+    }
+
+    return errors;
 }
 
 export function reduceDependencies({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
@@ -66,7 +86,7 @@ export function reduceDependencies({ node, data, key, pointer, path }: JsonSchem
             required.push(...dependentRequired[propertyName]);
 
             // @dynamicId
-            const localDynamicId = `dependencies/${propertyName}`;
+            const localDynamicId = `${KEYWORD}/${propertyName}`;
             dynamicId += `${dynamicId === "" ? "" : ","}${localDynamicId}`;
         });
     }
@@ -90,7 +110,7 @@ export function reduceDependencies({ node, data, key, pointer, path }: JsonSchem
             // but probably not how json-schema spec defines this behaviour (resolve only within sub-schema)
             const reducedDependency = { ...dependency, schema: { ...dependency.schema, required } }.reduceNode(data, {
                 key,
-                pointer: `${pointer}/dependencies/${propertyName}`,
+                pointer: `${pointer}/${KEYWORD}/${propertyName}`,
                 path
             }).node as SchemaNode;
 
@@ -98,7 +118,7 @@ export function reduceDependencies({ node, data, key, pointer, path }: JsonSchem
 
             // @dynamicId
             const nestedDynamicId = reducedDependency.dynamicId?.replace(node.dynamicId, "") ?? "";
-            const localDynamicId = nestedDynamicId === "" ? `dependencies/${propertyName}` : nestedDynamicId;
+            const localDynamicId = nestedDynamicId === "" ? `${KEYWORD}/${propertyName}` : nestedDynamicId;
             dynamicId += `${dynamicId === "" ? "" : ","}${localDynamicId}`;
         });
     }
@@ -113,7 +133,7 @@ export function reduceDependencies({ node, data, key, pointer, path }: JsonSchem
 
     required = workingNode.schema.required ? workingNode.schema.required.concat(...required) : required;
     required = required.filter((r: string, index: number, list: string[]) => list.indexOf(r) === index);
-    workingNode = mergeNode(workingNode, workingNode, "dependencies") as SchemaNode;
+    workingNode = mergeNode(workingNode, workingNode, KEYWORD) as SchemaNode;
     return workingNode.compileSchema(
         { ...workingNode.schema, required },
         workingNode.evaluationPath,

package/src/keywords/dependentRequired.ts

@@ -1,20 +1,51 @@
-import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
+import { Keyword, JsonSchemaValidatorParams, ValidationReturnType, ValidationAnnotation } from "../Keyword";
 import { JsonError, SchemaNode } from "../types";
+import { isListOfStrings } from "../utils/isListOfStrings";
 import { isObject } from "../utils/isObject";
 
+const KEYWORD = "dependentRequired";
+
 export const dependentRequiredKeyword: Keyword = {
-    id: "dependentRequired",
-    keyword: "dependentRequired",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseDependentRequired,
-    addValidate: (node) => isObject(node.schema.dependentRequired),
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateDependentRequired
 };
 
 export function parseDependentRequired(node: SchemaNode) {
-    if (!isObject(node.schema.dependentRequired)) {
+    const { schema } = node;
+    if (schema[KEYWORD] == null) {
         return;
     }
-    node.dependentRequired = (node.schema.dependentRequired as Record<string, string[]>) ?? {};
+    if (!isObject(schema[KEYWORD])) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema,
+            value: schema[KEYWORD],
+            message: `Keyword '${KEYWORD}' must be an object - received '${typeof schema[KEYWORD]}'`
+        });
+    }
+
+    const errors: ValidationAnnotation[] = [];
+    node.dependentRequired = {};
+    for (const propertyName of Object.keys(schema[KEYWORD])) {
+        const list = schema[KEYWORD][propertyName];
+        if (isListOfStrings(list)) {
+            node.dependentRequired[propertyName] = list;
+        } else {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/${KEYWORD}/${propertyName}`,
+                    schema,
+                    value: list,
+                    message: `Keyword '${KEYWORD}[string]' must be a string[] - received '${typeof list}'`
+                })
+            );
+        }
+    }
+
+    return errors;
 }
 
 export function validateDependentRequired({
@@ -22,41 +53,28 @@ export function validateDependentRequired({
     data,
     pointer = "#"
 }: JsonSchemaValidatorParams): ValidationReturnType {
-    if (!isObject(data)) {
+    const { dependentRequired } = node;
+    if (dependentRequired == null || !isObject(data)) {
         return undefined;
     }
-    const { dependentRequired } = node;
     const errors: JsonError[] = [];
-    if (dependentRequired) {
-        Object.keys(data).forEach((property) => {
-            const dependencies = dependentRequired[property];
-            // @draft >= 6 boolean schema
-            // @ts-expect-error boolean schema
-            if (dependencies === true) {
-                return;
-            }
-            // @ts-expect-error boolean schema
-            if (dependencies === false) {
-                // @ts-expect-error boolean schema
-                errors.push(node.createError("missing-dependency-error", { pointer, schema, value: data }));
-                return;
-            }
-            if (!Array.isArray(dependencies)) {
-                return;
+    Object.keys(data).forEach((property) => {
+        const dependencies = dependentRequired[property];
+        if (!Array.isArray(dependencies)) {
+            return;
+        }
+        for (let i = 0, l = dependencies.length; i < l; i += 1) {
+            if (data[dependencies[i]] === undefined) {
+                errors.push(
+                    node.createError("missing-dependency-error", {
+                        missingProperty: dependencies[i],
+                        pointer,
+                        schema: node.schema,
+                        value: data
+                    })
+                );
             }
-            for (let i = 0, l = dependencies.length; i < l; i += 1) {
-                if (data[dependencies[i]] === undefined) {
-                    errors.push(
-                        node.createError("missing-dependency-error", {
-                            missingProperty: dependencies[i],
-                            pointer,
-                            schema: node.schema,
-                            value: data
-                        })
-                    );
-                }
-            }
-        });
-    }
+        }
+    });
     return errors;
 }

package/src/keywords/dependentSchemas.ts

@@ -1,13 +1,15 @@
 import { mergeSchema } from "../utils/mergeSchema";
 import { isObject } from "../utils/isObject";
-import { isSchemaNode, SchemaNode, JsonSchema } from "../types";
+import { isSchemaNode, SchemaNode, JsonSchema, isBooleanSchema } from "../types";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { validateNode } from "../validateNode";
 import sanitizeErrors from "../utils/sanitizeErrors";
 
+const KEYWORD = "dependentSchemas";
+
 export const dependentSchemasKeyword: Keyword = {
-    id: "dependentSchemas",
-    keyword: "dependentSchemas",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseDependentSchemas,
     addReduce: (node) => node.dependentSchemas != null,
     reduce: reduceDependentSchemas,
@@ -17,29 +19,51 @@ export const dependentSchemasKeyword: Keyword = {
 
 export function parseDependentSchemas(node: SchemaNode) {
     const { dependentSchemas } = node.schema;
-    if (!isObject(dependentSchemas)) {
+    if (dependentSchemas == null) {
         return;
     }
+    if (!isObject(dependentSchemas)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: dependentSchemas,
+            message: `Keyword '${KEYWORD}' must be an object - received '${typeof dependentSchemas}'`
+        });
+    }
 
-    const schemas = Object.keys(dependentSchemas);
-    if (schemas.length === 0) {
+    const dependentProperties = Object.keys(dependentSchemas);
+    if (dependentProperties.length === 0) {
         return;
     }
 
+    const errors: ValidationAnnotation[] = [];
     const parsedSchemas: Record<string, boolean | SchemaNode> = {};
-    schemas.forEach((property) => {
+    for (const property of Object.keys(dependentSchemas)) {
         const schema = dependentSchemas[property];
         if (isObject(schema)) {
             parsedSchemas[property] = node.compileSchema(
                 schema,
-                `${node.evaluationPath}/dependentSchemas/${property}`,
-                `${node.schemaLocation}/dependentSchemas/${property}`
+                `${node.evaluationPath}/${KEYWORD}/${property}`,
+                `${node.schemaLocation}/${KEYWORD}/${property}`
             );
-        } else if (typeof schema === "boolean") {
+            if (parsedSchemas[property].schemaValidation) {
+                errors.push(...parsedSchemas[property].schemaValidation);
+            }
+        } else if (isBooleanSchema(schema)) {
             parsedSchemas[property] = schema;
+        } else {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/${KEYWORD}/${property}`,
+                    schema: node.schema,
+                    value: schema,
+                    message: `Keyword '${KEYWORD}[string]' must be a valid JSON Schema'`
+                })
+            );
         }
-    });
+    }
     node.dependentSchemas = parsedSchemas;
+    return errors;
 }
 
 export function reduceDependentSchemas({ node, data }: JsonSchemaReducerParams) {
@@ -62,7 +86,7 @@ export function reduceDependentSchemas({ node, data }: JsonSchemaReducerParams)
         } else {
             mergedSchema.properties[propertyName] = dependentSchemas[propertyName];
         }
-        dynamicId += `${added ? "," : ""}dependentSchemas/${propertyName}`;
+        dynamicId += `${added ? "," : ""}${KEYWORD}/${propertyName}`;
         added++;
     });
 
@@ -70,7 +94,7 @@ export function reduceDependentSchemas({ node, data }: JsonSchemaReducerParams)
         return node;
     }
 
-    mergedSchema = mergeSchema(node.schema, mergedSchema, "dependentSchemas");
+    mergedSchema = mergeSchema(node.schema, mergedSchema, KEYWORD);
     return node.compileSchema(mergedSchema, node.evaluationPath, node.schemaLocation, `${dynamicId})`);
 }
 

package/src/keywords/deprecated.ts

@@ -1,18 +1,42 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+
+const KEYWORD = "deprecated";
 
 export const deprecatedKeyword: Keyword = {
-    id: "deprecated",
-    keyword: "deprecated",
-    addValidate: ({ schema }) => schema.deprecated === true,
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseDeprecated,
+    addValidate: (node) => node[KEYWORD] === true,
     validate: validateDeprecated
 };
 
+function parseDeprecated(node: SchemaNode) {
+    const deprecated = node.schema[KEYWORD];
+    if (deprecated == null) {
+        return;
+    }
+    if (typeof deprecated !== "boolean") {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: deprecated,
+            message: `Keyword '${KEYWORD}' must be a boolean - received '${typeof deprecated}'`
+        });
+    }
+    node[KEYWORD] = deprecated;
+}
+
 function validateDeprecated({ node, data, pointer }: JsonSchemaValidatorParams) {
     return [
-        node.createAnnotation("deprecated-warning", {
-            pointer,
-            schema: node.schema,
-            value: data
-        })
+        node.createAnnotation(
+            "deprecated-warning",
+            {
+                pointer,
+                schema: node.schema,
+                value: data
+            },
+            node.schema.deprecatedMessage
+        )
     ];
 }

package/src/keywords/enum.ts

@@ -1,30 +1,52 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
 import { getTypeOf } from "../utils/getTypeOf";
 
+const KEYWORD = "enum";
+
 export const enumKeyword: Keyword = {
-    id: "enum",
-    keyword: "enum",
-    addValidate: ({ schema }) => Array.isArray(schema.enum),
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseEnum,
+    addValidate: (node) => node.enum != null,
     validate: validateEnum
 };
 
-function validateEnum({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
+export function parseEnum(node: SchemaNode) {
     const { schema } = node;
+    if (schema[KEYWORD] == null) {
+        return;
+    }
+    if (!Array.isArray(schema[KEYWORD])) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema,
+            value: schema[KEYWORD],
+            message: `Keyword '${KEYWORD}' must be an array - received '${typeof schema[KEYWORD]}'`
+        });
+    }
+    node.enum = schema[KEYWORD];
+}
+
+function validateEnum({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
+    if (node.enum == null) {
+        return;
+    }
     const type = getTypeOf(data);
     if (type === "object" || type === "array") {
         const valueStr = JSON.stringify(data);
-        for (const e of schema.enum) {
+        for (const e of node.enum) {
             if (JSON.stringify(e) === valueStr) {
                 return undefined;
             }
         }
-    } else if (schema.enum.includes(data)) {
+    } else if (node.enum.includes(data)) {
         return undefined;
     }
     return node.createError("enum-error", {
         pointer,
-        schema,
+        schema: node.schema,
         value: data,
-        values: schema.enum
+        values: node.enum
     });
 }

package/src/keywords/exclusiveMaximum.ts

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

package/src/keywords/exclusiveMinimum.ts

@@ -1,12 +1,31 @@
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+import { SchemaNode } from "../SchemaNode";
+
+const KEYWORD = "exclusiveMinimum";
 
 export const exclusiveMinimumKeyword: Keyword = {
-    id: "exclusiveMinimum",
-    keyword: "exclusiveMinimum",
-    addValidate: ({ schema }) => schema.exclusiveMinimum != null && !isNaN(parseInt(schema.exclusiveMinimum)),
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseExclusiveMinimum,
+    addValidate: ({ schema }) => schema[KEYWORD] != null && !isNaN(parseInt(schema[KEYWORD])),
     validate: validateExclusiveMinimum
 };
 
+function parseExclusiveMinimum(node: SchemaNode) {
+    const min = node.schema[KEYWORD];
+    if (min == null) {
+        return;
+    }
+    if (typeof min !== "number") {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: min,
+            message: `Keyword '${KEYWORD}' must be a number - received '${typeof min}'`
+        });
+    }
+}
+
 function validateExclusiveMinimum({ node, data, pointer }: JsonSchemaValidatorParams) {
     if (typeof data !== "number") {
         return undefined;