json-schema-library 11.0.5 → 11.2.0

package/src/keywords/$ref.ts

@@ -1,4 +1,4 @@
-import { SchemaNode } from "../types";
+import { isJsonError, isSchemaNode, JsonError, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams, ValidationPath, JsonSchemaReducerParams } from "../Keyword";
 import { resolveUri } from "../utils/resolveUri";
 import splitRef from "../utils/splitRef";
@@ -72,6 +72,18 @@ export function parseRef(node: SchemaNode) {
             node.$ref = `#${node.$ref}`;
         }
     }
+
+    // validate simple ref to definitions
+    if (node.$ref?.startsWith("#/$defs/")) {
+        if (get(node.getNodeRoot().schema, node.$ref) == null) {
+            return node.createError("schema-error", {
+                pointer: `${node.schemaLocation}/$ref`,
+                schema: node.schema,
+                value: node.schema.$ref,
+                message: `Invalid $ref to missing target '${node.schema.ref}'`
+            });
+        }
+    }
 }
 
 export function reduceRef({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
@@ -81,7 +93,12 @@ export function reduceRef({ node, data, key, pointer, path }: JsonSchemaReducerP
 
     const resolvedNode = node.resolveRef({ pointer, path });
     if (resolvedNode == null) {
-        return;
+        return node.createError("ref-error", {
+            ref: node.schema.$ref ?? node.schema.$dynamicRef,
+            pointer,
+            schema: node.schema,
+            value: data
+        });
     }
 
     if (resolvedNode.schemaLocation === node.schemaLocation) {
@@ -95,6 +112,9 @@ export function reduceRef({ node, data, key, pointer, path }: JsonSchemaReducerP
 export function resolveRef(this: SchemaNode, { pointer, path = [] }: { pointer?: string; path?: ValidationPath } = {}) {
     if (this.schema.$dynamicRef) {
         const nextNode = resolveRecursiveRef(this, path);
+        if (isJsonError(nextNode)) {
+            return nextNode;
+        }
         path.push({ pointer: pointer!, node: nextNode! });
         return nextNode;
     }
@@ -104,7 +124,7 @@ export function resolveRef(this: SchemaNode, { pointer, path = [] }: { pointer?:
     }
 
     const resolvedNode = getRef(this);
-    if (resolvedNode != null) {
+    if (isSchemaNode(resolvedNode)) {
         path.push({ pointer: pointer!, node: resolvedNode });
     }
 
@@ -117,10 +137,16 @@ function validateRef({ node, data, pointer = "#", path }: JsonSchemaValidatorPar
         // recursively resolveRef and validate
         return validateNode(nextNode, data, pointer, path);
     }
+    return node.createError("ref-error", {
+        ref: node.schema.$ref ?? node.schema.$dynamicRef,
+        pointer,
+        schema: node.schema,
+        value: data
+    });
 }
 
 // 1. https://json-schema.org/draft/2019-09/json-schema-core#scopes
-function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode | undefined {
+function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode | JsonError {
     const history = path;
     const refInCurrentScope = resolveUri(node.$id, node.schema.$dynamicRef);
 
@@ -168,7 +194,7 @@ function compileNext(referencedNode: SchemaNode, sourceNode: SchemaNode) {
     );
 }
 
-export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
+export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | JsonError {
     if ($ref == null) {
         return node;
     }
@@ -190,7 +216,12 @@ export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefi
     // check for remote-host + pointer pair to switch rootSchema
     const fragments = splitRef($ref);
     if (fragments.length === 0) {
-        return undefined;
+        return node.createError("ref-error", {
+            ref: $ref,
+            pointer: node.evaluationPath,
+            schema: node.schema,
+            value: undefined
+        });
     }
 
     // resolve $ref as remote-host
@@ -200,6 +231,7 @@ export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefi
         if (node.context.remotes[$ref]) {
             return compileNext(node.context.remotes[$ref], node);
         }
+
         if ($ref[0] === "#") {
             // support refOfUnknownKeyword
             const rootSchema = node.context.rootNode.schema;
@@ -209,7 +241,12 @@ export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefi
             }
         }
         // console.error("REF: UNFOUND 1", $ref);
-        return undefined;
+        return node.createError("ref-error", {
+            ref: $ref,
+            pointer: node.evaluationPath,
+            schema: node.schema,
+            value: undefined
+        });
     }
 
     if (fragments.length === 2) {
@@ -240,16 +277,25 @@ export function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefi
                 // @ts-expect-error random path
                 currentNode = currentNode[property];
                 if (currentNode == null) {
-                    console.error("REF: FAILED RESOLVING ref json-pointer", fragments[1]);
-                    return undefined;
+                    // console.error("REF: FAILED RESOLVING ref json-pointer", fragments[1]);
+                    return node.createError("ref-error", {
+                        ref: $ref,
+                        pointer: node.evaluationPath,
+                        schema: node.schema,
+                        value: undefined,
+                        host: fragments[0],
+                        local: fragments[1]
+                    });
                 }
             }
             return currentNode;
         }
-
-        console.error("REF: UNFOUND 2", $ref);
-        return undefined;
     }
 
-    console.error("REF: UNHANDLED", $ref);
+    return node.createError("ref-error", {
+        ref: $ref,
+        pointer: node.evaluationPath,
+        schema: node.schema,
+        value: undefined
+    });
 }

package/src/keywords/additionalProperties.ts

@@ -1,7 +1,7 @@
 import settings from "../settings";
 import { isObject } from "../utils/isObject";
-import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType} from "../Keyword";
-import { SchemaNode } from "../types";
+import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
+import { isBooleanSchema, SchemaNode } from "../types";
 import { getValue } from "../utils/getValue";
 import { validateNode } from "../validateNode";
 
@@ -24,13 +24,24 @@ export const additionalPropertiesKeyword: Keyword = {
 // must come as last resolver
 export function parseAdditionalProperties(node: SchemaNode) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if (isObject(schema.additionalProperties)) {
-        node.additionalProperties = node.compileSchema(
-            schema.additionalProperties,
-            `${evaluationPath}/additionalProperties`,
-            `${schemaLocation}/additionalProperties`
-        );
+    if (schema.additionalProperties == null || isBooleanSchema(schema.additionalProperties)) {
+        return;
     }
+
+    if (!isObject(schema.additionalProperties)) {
+        return node.createError("schema-error", {
+            pointer: node.schemaLocation,
+            schema,
+            value: schema.additionalProperties,
+            message: `keyword 'additionalProperties' must be a valid JSON Schema - receoved: ${typeof schema.additionalProperties}`
+        });
+    }
+
+    node.additionalProperties = node.compileSchema(
+        schema.additionalProperties,
+        `${evaluationPath}/additionalProperties`,
+        `${schemaLocation}/additionalProperties`
+    );
 }
 
 function additionalPropertyResolver({ node, data, key }: JsonSchemaResolverParams) {

package/src/keywords/allOf.ts

@@ -1,29 +1,55 @@
 import { mergeSchema } from "../utils/mergeSchema";
-import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
+import {
+    Keyword,
+    JsonSchemaReducerParams,
+    JsonSchemaValidatorParams,
+    ValidationReturnType,
+    ValidationAnnotation
+} from "../Keyword";
 import { SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 
+const KEYWORD = "allOf";
+
 export const allOfKeyword: Keyword = {
-    id: "allOf",
-    keyword: "allOf",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseAllOf,
-    addReduce: (node: SchemaNode) => node.allOf != null,
+    addReduce: (node: SchemaNode) => node[KEYWORD] != null,
     reduce: reduceAllOf,
-    addValidate: (node) => node.allOf != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validateAllOf
 };
 
 export function parseAllOf(node: SchemaNode) {
-    const { schema, evaluationPath } = node;
-    if (Array.isArray(schema.allOf) && schema.allOf.length) {
-        node.allOf = schema.allOf.map((s, index) =>
-            node.compileSchema(s, `${evaluationPath}/allOf/${index}`, `${node.schemaLocation}/allOf/${index}`)
-        );
+    const { schema, evaluationPath, schemaLocation } = node;
+    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 reduceAllOf({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
-    if (node.allOf == null) {
+    if (node[KEYWORD] == null) {
         return;
     }
 
@@ -31,15 +57,15 @@ function reduceAllOf({ node, data, key, pointer, path }: JsonSchemaReducerParams
     // dynamic schema parts
     let mergedSchema = {};
     let dynamicId = "";
-    for (let i = 0; i < node.allOf.length; i += 1) {
-        const { node: schemaNode } = node.allOf[i].reduceNode(data, { key, pointer, path });
+    for (let i = 0; i < node[KEYWORD].length; i += 1) {
+        const { node: schemaNode } = node[KEYWORD][i].reduceNode(data, { key, pointer, path });
         if (schemaNode) {
             const nestedDynamicId = schemaNode.dynamicId?.replace(node.dynamicId, "") ?? "";
-            const localDynamicId = nestedDynamicId === "" ? `allOf/${i}` : nestedDynamicId;
+            const localDynamicId = nestedDynamicId === "" ? `${KEYWORD}/${i}` : nestedDynamicId;
             dynamicId += `${dynamicId === "" ? "" : ","}${localDynamicId}`;
 
-            const schema = mergeSchema(node.allOf[i].schema, schemaNode.schema);
-            mergedSchema = mergeSchema(mergedSchema, schema, "allOf", "contains");
+            const schema = mergeSchema(node[KEYWORD][i].schema, schemaNode.schema);
+            mergedSchema = mergeSchema(mergedSchema, schema, KEYWORD, "contains");
         }
     }
 
@@ -52,11 +78,11 @@ function reduceAllOf({ node, data, key, pointer, path }: JsonSchemaReducerParams
 }
 
 function validateAllOf({ node, data, pointer, path }: JsonSchemaValidatorParams) {
-    if (!Array.isArray(node.allOf) || node.allOf.length === 0) {
+    if (!Array.isArray(node[KEYWORD]) || node[KEYWORD].length === 0) {
         return;
     }
     const errors: ValidationReturnType = [];
-    node.allOf.forEach((allOfNode) => {
+    node[KEYWORD].forEach((allOfNode) => {
         errors.push(...validateNode(allOfNode, data, pointer, path));
     });
     return errors;

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,