json-schema-library 11.0.5 → 11.2.0

package/src/keywords/propertyDependencies.test.ts

@@ -0,0 +1,180 @@
+import { strict as assert } from "assert";
+import { compileSchema } from "../compileSchema";
+import { draft2020 } from "../draft2020";
+import { extendDraft } from "../Draft";
+import { propertyDependenciesKeyword } from "./propertyDependencies";
+import { isSchemaNode } from "../SchemaNode";
+
+const drafts = [
+    extendDraft(draft2020, {
+        keywords: [propertyDependenciesKeyword]
+    })
+];
+
+describe("keyword : propertyDependencies : validate", () => {
+    it("should return error if schema at matching property+value is invalid", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    propertyDependencies: {
+                        propertyName: {
+                            propertyValue: {
+                                $ref: "#/$defs/object"
+                            }
+                        }
+                    }
+                },
+                $defs: {
+                    object: {
+                        type: "object",
+                        required: ["propertyName", "test"],
+                        properties: {
+                            propertyName: { type: "string" },
+                            test: { type: "string" }
+                        }
+                    }
+                }
+            },
+            { drafts }
+        );
+        const { errors } = node.validate([{ propertyName: "propertyValue", test: 123 }]);
+        assert.equal(errors.length, 1);
+    });
+
+    it("should return all errors for schemata at matching property+value", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    propertyDependencies: {
+                        propertyName: {
+                            propertyValue: {
+                                $ref: "#/$defs/object"
+                            }
+                        },
+                        type: {
+                            headline: {
+                                $ref: "#/$defs/object"
+                            }
+                        }
+                    }
+                },
+                $defs: {
+                    object: {
+                        type: "object",
+                        required: ["propertyName", "type", "test"],
+                        properties: {
+                            propertyName: { type: "string" },
+                            type: { type: "string" },
+                            test: { type: "number" }
+                        }
+                    }
+                }
+            },
+            { drafts }
+        );
+        const { errors } = node.validate([{ propertyName: "propertyValue", type: "headline", test: "123" }]);
+        assert.equal(errors.length, 2);
+    });
+
+    it("should be valid for valid schema matching property+value", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    propertyDependencies: {
+                        propertyName: {
+                            propertyValue: {
+                                $ref: "#/$defs/object"
+                            }
+                        }
+                    }
+                },
+                $defs: {
+                    object: {
+                        type: "object",
+                        required: ["propertyName", "type", "test"],
+                        properties: {
+                            propertyName: { type: "string" },
+                            type: { type: "string" },
+                            test: { type: "number" }
+                        }
+                    }
+                }
+            },
+            { drafts }
+        );
+        const { errors } = node.validate([{ propertyName: "propertyValue", type: "headline", test: 123 }]);
+        assert.equal(errors.length, 0);
+    });
+
+    it("should be valid for valid schema matching property+number", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    propertyDependencies: {
+                        test: {
+                            "123": {
+                                $ref: "#/$defs/object"
+                            }
+                        }
+                    }
+                },
+                $defs: {
+                    object: {
+                        type: "object",
+                        required: ["propertyName", "type", "test"],
+                        properties: {
+                            propertyName: { type: "string" },
+                            type: { type: "string" },
+                            test: { type: "number" }
+                        }
+                    }
+                }
+            },
+            { drafts }
+        );
+        const { errors } = node.validate([{ propertyName: "propertyValue", type: "headline", test: 123 }]);
+        assert.equal(errors.length, 0);
+    });
+});
+
+describe("keyword : propertyDependencies : validate", () => {
+    it("should return reduced schema of matching property+value", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    properties: {
+                        id: { type: "string" }
+                    },
+                    propertyDependencies: {
+                        propertyName: {
+                            propertyValue: {
+                                $ref: "#/$defs/object"
+                            }
+                        }
+                    }
+                },
+                $defs: {
+                    object: {
+                        type: "object",
+                        required: ["propertyName", "test"],
+                        properties: {
+                            propertyName: { type: "string" },
+                            test: { type: "string" }
+                        }
+                    }
+                }
+            },
+            { drafts }
+        );
+        const reducedNode = node.getNode("#/0", [{ propertyName: "propertyValue", test: 123 }])?.node;
+        assert(isSchemaNode(reducedNode));
+        assert(reducedNode.schema.propertyDependencies == null);
+        assert(reducedNode.schema.properties.id);
+        assert(reducedNode.schema.properties.propertyName);
+    });
+});

package/src/keywords/propertyDependencies.ts

@@ -0,0 +1,173 @@
+import {
+    Keyword,
+    JsonSchemaValidatorParams,
+    JsonSchemaReducerParams,
+    ValidationReturnType,
+    ValidationAnnotation
+} from "../Keyword";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
+import { hasProperty } from "../utils/hasProperty";
+import { isObject } from "../utils/isObject";
+import { mergeSchema } from "../utils/mergeSchema";
+import sanitizeErrors from "../utils/sanitizeErrors";
+import { validateNode } from "../validateNode";
+
+const KEYWORD = "propertyDependencies";
+
+function findMatchingSchemata(node: SchemaNode, data: Record<string, unknown>) {
+    const dependentProperties = node[KEYWORD];
+    if (dependentProperties == null) {
+        return undefined;
+    }
+    const dependentPropertyNames = Object.keys(dependentProperties);
+    const matchingSchemata: { property: string; value: string; node: SchemaNode }[] = [];
+    for (const propertyName of dependentPropertyNames) {
+        if (hasProperty(data, propertyName)) {
+            const value = data[propertyName];
+            if (dependentProperties[propertyName][value as string]) {
+                matchingSchemata.push({
+                    property: propertyName,
+                    value: `${value}`,
+                    node: dependentProperties[propertyName][value as string]
+                });
+            }
+        }
+    }
+    return matchingSchemata;
+}
+
+/**
+ * @experimental `propertyDependencies` to resolve schema by nested name and value
+ * @reference https://docs.google.com/presentation/d/1ajXlCQcsjjiMLsluFIILR7sN5aDRBnfqQ9DLbcFbqjI/mobilepresent?slide=id.p
+ *
+ * - matching schemas are resolved and validiated
+ * - multiple matching schemas are resolved and validiated
+ * - ignores keyword if no schema is matched
+ *
+ * @example
+ * {
+ *   type: "object",
+ *   propertyDependencies: {
+ *      propertyName: {
+ *          propertyValue: { $ref: "#/$defs/schema" }
+ *      }
+ *   }
+ * }
+ *
+ * matches
+ *
+ * {
+ *   "propertyName": "propertyValue",
+ *   "otherData": 123
+ * } with "#/$defs/schema"
+ */
+export const propertyDependenciesKeyword: Keyword = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parsePropertyDependencies,
+    addValidate: (node) => node[KEYWORD] != null,
+    validate: validatePropertyDependencies,
+    addReduce: (node) => node[KEYWORD] != null,
+    reduce: reducePropertyDependencies
+};
+
+function parsePropertyDependencies(node: SchemaNode) {
+    const propertyDependencies = node.schema[KEYWORD];
+    if (!isObject(propertyDependencies)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: propertyDependencies,
+            message: `Keyword '${KEYWORD}' must be an object - received '${typeof propertyDependencies}'`
+        });
+    }
+    const parsed: Record<string, Record<string, SchemaNode>> = {};
+    const errors: ValidationAnnotation[] = [];
+    Object.keys(propertyDependencies).map((propertyName) => {
+        const values = propertyDependencies[propertyName];
+        if (!isObject(values)) {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: `${node.schemaLocation}/${KEYWORD}/${propertyName}`,
+                    schema: node.schema,
+                    value: propertyDependencies,
+                    message: `Keyword '${KEYWORD}[string]' must be an object - received '${typeof propertyDependencies}'`
+                })
+            );
+            return;
+        }
+        Object.keys(values).forEach((value) => {
+            const schema = values[value];
+            if (!(isJsonSchema(schema) || isBooleanSchema(schema))) {
+                errors.push(
+                    node.createError("schema-error", {
+                        pointer: `${node.schemaLocation}/${KEYWORD}/${propertyName}/${value}`,
+                        schema: node.schema,
+                        value: schema,
+                        message: `Keyword '${KEYWORD}[string][string]' must be a valid JSON Schema - received '${typeof schema}'`
+                    })
+                );
+                return;
+            }
+            parsed[propertyName] = parsed[propertyName] ?? {};
+            parsed[propertyName][value] = node.compileSchema(
+                schema,
+                `${node.evaluationPath}/${KEYWORD}/${propertyName}/${value}`,
+                `${node.schemaLocation}/${KEYWORD}/${propertyName}/${value}`
+            );
+            if (parsed[propertyName][value].schemaValidation) {
+                errors.push(...parsed[propertyName][value].schemaValidation);
+            }
+        });
+    });
+    node[KEYWORD] = parsed;
+    return errors;
+}
+
+function validatePropertyDependencies({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {
+    if (!isObject(data)) {
+        return undefined;
+    }
+    const matchingSchemata = findMatchingSchemata(node, data);
+    if (matchingSchemata == null || matchingSchemata.length === 0) {
+        return undefined;
+    }
+    const errors: ValidationReturnType[] = [];
+    for (const match of matchingSchemata) {
+        const result = validateNode(match.node, data, pointer, path);
+        errors.push(result);
+    }
+    return sanitizeErrors(errors);
+}
+
+function reducePropertyDependencies({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
+    if (!isObject(data)) {
+        return undefined;
+    }
+    const matchingSchemata = findMatchingSchemata(node, data);
+    if (matchingSchemata == null || matchingSchemata.length === 0) {
+        return undefined;
+    }
+
+    let mergedSchema = {};
+    let dynamicId = "";
+    for (const match of matchingSchemata) {
+        const { node: schemaNode } = match.node.reduceNode(data, { key, pointer, path });
+        if (schemaNode) {
+            const nestedDynamicId = schemaNode.dynamicId?.replace(node.dynamicId, "") ?? "";
+            const localDynamicId =
+                nestedDynamicId === "" ? `propertyDependencies/${match.property}/${match.value}` : nestedDynamicId;
+            dynamicId += `${dynamicId === "" ? "" : ","}${localDynamicId}`;
+
+            const schema = mergeSchema(match.node.schema, schemaNode.schema);
+            mergedSchema = mergeSchema(mergedSchema, schema, "propertyDependencies");
+        }
+    }
+
+    return node.compileSchema(
+        mergedSchema,
+        `${node.evaluationPath}/${dynamicId}`,
+        node.schemaLocation,
+        `${node.schemaLocation}(${dynamicId})`
+    );
+}

package/src/keywords/propertyNames.ts

@@ -1,29 +1,41 @@
-import { JsonError } from "../types";
+import { isBooleanSchema, isJsonSchema, JsonError } from "../types";
 import { isObject } from "../utils/isObject";
 import { SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
 import { validateNode } from "../validateNode";
 
+const KEYWORD = "propertyNames";
+
 export const propertyNamesKeyword: Keyword = {
-    id: "propertyNames",
-    keyword: "propertyNames",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parsePropertyNames,
-    addValidate: ({ schema }) => schema.propertyNames != null,
+    addValidate: (node) => node.schema[KEYWORD] != null,
     validate: validatePropertyNames
 };
 
 export function parsePropertyNames(node: SchemaNode) {
-    const { propertyNames } = node.schema;
+    const propertyNames = node.schema[KEYWORD];
     if (propertyNames == null) {
         return;
     }
-    if (isObject(propertyNames)) {
-        node.propertyNames = node.compileSchema(
-            propertyNames,
-            `${node.evaluationPath}/propertyNames`,
-            `${node.schemaLocation}/propertyNames`
-        );
+    if (!(isJsonSchema(propertyNames) || isBooleanSchema(propertyNames))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: propertyNames,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof propertyNames}'`
+        });
+    }
+    if (isBooleanSchema(propertyNames)) {
+        return;
     }
+    node.propertyNames = node.compileSchema(
+        propertyNames,
+        `${node.evaluationPath}/propertyNames`,
+        `${node.schemaLocation}/propertyNames`
+    );
+    return node.schemaValidation;
 }
 
 function validatePropertyNames({ node, data, pointer, path }: JsonSchemaValidatorParams) {
@@ -46,11 +58,11 @@ function validatePropertyNames({ node, data, pointer, path }: JsonSchemaValidato
         });
     }
 
-    if (schema.propertyNames === true) {
+    if (schema[KEYWORD] === true) {
         return undefined;
     }
 
-    const propertyNames = node.propertyNames;
+    const propertyNames = node[KEYWORD];
     if (!isObject(propertyNames)) {
         // ignore invalid schema
         return undefined;
@@ -59,7 +71,7 @@ function validatePropertyNames({ node, data, pointer, path }: JsonSchemaValidato
     const errors: JsonError[] = [];
     const properties = Object.keys(data);
     properties.forEach((prop) => {
-        const validationResult = validateNode(propertyNames, prop, `${pointer}/prop`, path);
+        const validationResult = validateNode(propertyNames, prop, `${pointer}/${prop}`, path);
         if (validationResult.length > 0) {
             errors.push(
                 node.createError("invalid-property-name-error", {

package/src/keywords/required.ts

@@ -1,25 +1,48 @@
 import { isObject } from "../utils/isObject";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
 import { hasProperty } from "../utils/hasProperty";
+import { SchemaNode } from "../SchemaNode";
+import { isListOfStrings } from "../utils/isListOfStrings";
 
-export const requiredKeyword: Keyword = {
-    id: "required",
-    keyword: "required",
-    addValidate: ({ schema }) => Array.isArray(schema.required),
+const KEYWORD = "required";
+
+export const requiredKeyword: Keyword<"required"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseRequired,
+    addValidate: (node) => node.required != null,
     validate: validateRequired
 };
 
-function validateRequired({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
-    const { schema } = node;
+function parseRequired(node: SchemaNode) {
+    const required = node.schema[KEYWORD];
+    if (required == null) {
+        return;
+    }
+
+    if (!isListOfStrings(required)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: required,
+            message: `Keyword '${KEYWORD}' must be a string[]`
+        });
+    }
+
+    node.required = required;
+}
+
+function validateRequired({ node, data, pointer = "#" }: JsonSchemaValidatorParams<"required">) {
+    const { required } = node;
     if (!isObject(data)) {
         return undefined;
     }
-    return schema.required.map((property: string) => {
+    return required.map((property: string) => {
         if (!hasProperty(data, property)) {
             return node.createError("required-property-error", {
                 key: property,
                 pointer,
-                schema,
+                schema: node.schema,
                 value: data
             });
         }

package/src/keywords/type.ts

@@ -2,17 +2,58 @@ import { getTypeOf, JSType } from "../utils/getTypeOf";
 import { SchemaNode } from "../types";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams } from "../Keyword";
 
-export const typeKeyword: Keyword = {
-    id: "type",
-    keyword: "type",
-    addReduce: (node) => Array.isArray(node.schema.type),
+const KEYWORD = "type";
+const validTyes = ["null", "boolean", "number", "integer", "string", "object", "array"];
+
+export const typeKeyword: Keyword<"type"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseType,
+    addReduce: (node) => Array.isArray(node.type),
     reduce: reduceType,
-    addValidate: ({ schema }) => schema.type != null,
+    addValidate: (node) => node.type != null,
     validate: validateType
 };
 
+function parseType(node: SchemaNode) {
+    const type = node.schema[KEYWORD];
+    if (type == null) {
+        return;
+    }
+    if (typeof type !== "string" && !Array.isArray(type)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: type,
+            message: `Keyword '${KEYWORD}' must be a string or a string[] - received ${typeof type}`
+        });
+    }
+    if (typeof type === "string" && !validTyes.includes(type)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: type,
+            message: `Keyword '${KEYWORD}' is not a valid JSON Schema type - received '${type}'. Expected one of ${validTyes.join(", ")}`
+        });
+    }
+
+    if (Array.isArray(type)) {
+        const invalidTypeIndex = type.findIndex((t) => !validTyes.includes(t));
+        if (invalidTypeIndex !== -1) {
+            return node.createError("schema-error", {
+                pointer: `${node.schemaLocation}/${KEYWORD}/${invalidTypeIndex}`,
+                schema: node.schema,
+                value: type[invalidTypeIndex],
+                message: `Keyword '${KEYWORD}' contains an invalid JSON Schema type: '${type[invalidTypeIndex]}'`
+            });
+        }
+    }
+
+    node[KEYWORD] = type;
+}
+
 function reduceType({ node, pointer, data }: JsonSchemaReducerParams): undefined | SchemaNode {
-    const dataType = getJsonSchemaType(data, node.schema.type);
+    const dataType = getJsonSchemaType(data, node.type!);
     if (dataType !== "undefined" && Array.isArray(node.schema.type) && node.schema.type.includes(dataType)) {
         return node.compileSchema({ ...node.schema, pointer, type: dataType }, node.evaluationPath);
     }
@@ -30,22 +71,18 @@ function getJsonSchemaType(value: unknown, expectedType: string | string[]): JST
     return jsType;
 }
 
-function validateType({ node, data, pointer }: JsonSchemaValidatorParams) {
-    const schema = node.schema;
-    const dataType = getJsonSchemaType(data, schema.type);
-    if (
-        data === undefined ||
-        schema.type === dataType ||
-        (Array.isArray(schema.type) && schema.type.includes(dataType))
-    ) {
+function validateType({ node, data, pointer }: JsonSchemaValidatorParams<"type">) {
+    const type = node[KEYWORD];
+    const dataType = getJsonSchemaType(data, type);
+    if (data === undefined || type === dataType || (Array.isArray(type) && type.includes(dataType))) {
         return;
     }
 
     return node.createError("type-error", {
         value: data,
         received: dataType,
-        expected: schema.type,
-        schema,
+        expected: type,
+        schema: node.schema,
         pointer
     });
 }

package/src/keywords/unevaluatedItems.ts

@@ -1,31 +1,47 @@
-import { isObject } from "../utils/isObject";
-import { SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { validateNode } from "../validateNode";
 import { isItemEvaluated } from "../isItemEvaluated";
 
+const KEYWORD = "unevaluatedItems";
+
 /**
  * @draft >= 2019-09
  * Similar to additionalItems, but can "see" into subschemas and across references
  * https://json-schema.org/draft/2019-09/json-schema-core#rfc.section.9.3.1.3
  */
 export const unevaluatedItemsKeyword: Keyword = {
-    id: "unevaluatedItems",
-    keyword: "unevaluatedItems",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseUnevaluatedItems,
-    addValidate: ({ schema }) => schema.unevaluatedItems != null,
+    addValidate: ({ schema }) => schema.unevaluatedItems != null, // currently we do not store boolean schema
     validate: validateUnevaluatedItems
 };
 
 export function parseUnevaluatedItems(node: SchemaNode) {
-    if (!isObject(node.schema.unevaluatedItems)) {
+    const unevaluatedItems = node.schema[KEYWORD];
+    if (unevaluatedItems == null) {
+        return;
+    }
+    if (!(isJsonSchema(unevaluatedItems) || isBooleanSchema(unevaluatedItems))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: unevaluatedItems,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof unevaluatedItems}'`
+        });
+    }
+
+    if (isBooleanSchema(unevaluatedItems)) {
         return;
     }
+
     node.unevaluatedItems = node.compileSchema(
         node.schema.unevaluatedItems,
-        `${node.evaluationPath}/unevaluatedItems`,
-        `${node.schemaLocation}/unevaluatedItems`
+        `${node.evaluationPath}/${KEYWORD}`,
+        `${node.schemaLocation}/${KEYWORD}`
     );
+    return node.unevaluatedItems.schemaValidation;
 }
 
 function validateUnevaluatedItems({ node, data, pointer, path }: JsonSchemaValidatorParams) {