json-schema-library 11.0.5 → 11.2.0

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;

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