json-schema-library 11.0.4 → 11.1.0

package/src/keywords/not.ts

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

package/src/keywords/oneOf.ts

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

package/src/keywords/pattern.ts

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

package/src/keywords/properties.ts

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

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, JsonSchema, 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", {