json-schema-library 11.1.0 → 11.2.0

package/src/draft04/keywords/$ref.ts

@@ -4,7 +4,7 @@ import { isObject } from "../../utils/isObject";
 import { omit } from "../../utils/omit";
 import splitRef from "../../utils/splitRef";
 import { $refKeyword as draft06Keyword } from "../../draft06/keywords/$ref";
-import { SchemaNode } from "../../types";
+import { isSchemaNode, JsonError, SchemaNode } from "../../types";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
@@ -63,14 +63,9 @@ function resolveRef(this: SchemaNode, { pointer, path }: { pointer?: string; pat
         return this;
     }
     const resolvedNode = getRef(this);
-    // console.log("RESOLVE REF", node.schema, "resolved ref", node.$ref, "=>", resolvedNode.schema);
-    if (resolvedNode != null) {
+    if (isSchemaNode(resolvedNode)) {
         path?.push({ pointer: pointer!, node: resolvedNode });
-        // console.log("resolve ref", node.$ref, "=>", resolvedNode.schema, Object.keys(node.context.refs));
-    } else {
-        console.log("failed resolving", this.$ref, "from", Object.keys(this.context.refs));
     }
-
     return resolvedNode;
 }
 
@@ -81,7 +76,7 @@ function compileNext(referencedNode: SchemaNode, evaluationPath = referencedNode
     return referencedNode.compileSchema(referencedSchema, `${evaluationPath}/$ref`, referencedSchema.schemaLocation);
 }
 
-function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
+function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | JsonError | undefined {
     if ($ref == null) {
         return node;
     }
@@ -100,8 +95,12 @@ function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
     // check for remote-host + pointer pair to switch rootSchema
     const fragments = splitRef($ref);
     if (fragments.length === 0) {
-        // console.error("REF: INVALID", $ref);
-        return undefined;
+        return node.createError("ref-error", {
+            ref: $ref,
+            pointer: node.evaluationPath,
+            schema: node.schema,
+            value: undefined
+        });
     }
 
     // resolve $ref as remote-host
@@ -111,8 +110,12 @@ function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
         if (node.context.remotes[$ref]) {
             return compileNext(node.context.remotes[$ref], node.evaluationPath);
         }
-        // console.error("REF: UNFOUND 1", $ref, Object.keys(node.context.remotes));
-        return undefined;
+        return node.createError("ref-error", {
+            ref: $ref,
+            pointer: node.evaluationPath,
+            schema: node.schema,
+            value: undefined
+        });
     }
 
     if (fragments.length === 2) {
@@ -142,9 +145,14 @@ function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
             }
         }
 
-        // console.error("REF: UNFOUND 2", $ref);
+        // @todo returning error here breaks specs
         return undefined;
     }
 
-    console.error("REF: INVALID", $ref);
+    return node.createError("ref-error", {
+        ref: $ref,
+        pointer: node.evaluationPath,
+        schema: node.schema,
+        value: undefined
+    });
 }

package/src/draft04/keywords/exclusiveMaximum.ts

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

package/src/draft04/keywords/exclusiveMinimum.ts

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

package/src/draft04/validateSchema.test.ts

@@ -0,0 +1,20 @@
+import { compileSchema as _compileSchema, type CompileOptions } from "../compileSchema";
+import { strict as assert } from "assert";
+import { draft04 } from "../draft04";
+import { JsonSchema } from "../types";
+
+const drafts = [draft04];
+function compileSchema(schema: JsonSchema, options: CompileOptions = {}) {
+    return _compileSchema(schema, { ...options, drafts });
+}
+
+describe("validateSchema (4)", () => {
+    it("should error if `exclusiveMinimum` is not a number or boolean", () => {
+        const { schemaErrors } = compileSchema({ exclusiveMinimum: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `exclusiveMaximum` is not a number or boolean", () => {
+        const { schemaErrors } = compileSchema({ exclusiveMaximum: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+});

package/src/draft06/keywords/$ref.ts

@@ -1,6 +1,6 @@
 import { Keyword, JsonSchemaValidatorParams, ValidationPath } from "../../Keyword";
 import { resolveRef } from "../../keywords/$ref";
-import { SchemaNode } from "../../types";
+import { isSchemaNode, SchemaNode } from "../../types";
 import { resolveUri } from "../../utils/resolveUri";
 import { validateNode } from "../../validateNode";
 
@@ -51,16 +51,26 @@ function parseRef(node: SchemaNode) {
 
 function validateRef({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {
     const nextNode = resolveAllRefs(node, pointer, path);
-    if (nextNode == null) {
-        return undefined;
+    if (!isSchemaNode(nextNode)) {
+        return node.createError("ref-error", {
+            ref: node.schema.$ref,
+            pointer,
+            schema: node.schema,
+            value: data
+        });
     }
     return validateNode(nextNode, data, pointer, path);
 }
 
 function resolveAllRefs(node: SchemaNode, pointer: string, path: ValidationPath) {
     const nextNode = node.resolveRef({ pointer, path });
-    if (nextNode == null) {
-        return undefined;
+    if (!isSchemaNode(nextNode)) {
+        return node.createError("ref-error", {
+            ref: node.schema.$ref,
+            pointer,
+            schema: node.schema,
+            value: undefined
+        });
     }
     if (nextNode !== node && nextNode) {
         return resolveAllRefs(nextNode, pointer, path);

package/src/draft2019-09/keywords/$ref.test.ts

@@ -1,5 +1,6 @@
 import { strict as assert } from "assert";
 import { compileSchema } from "../../compileSchema";
+import { isJsonError } from "../../types";
 
 describe("keyword : $ref : resolve", () => {
     it("should return undefined for missing reference", () => {
@@ -8,7 +9,8 @@ describe("keyword : $ref : resolve", () => {
             minLength: 1
         }).resolveRef();
 
-        assert.deepEqual(node, undefined);
+        assert(isJsonError(node));
+        assert.deepEqual(node.code, "ref-error");
     });
 
     it("should resolve $ref from definitions", () => {

package/src/draft2019-09/keywords/$ref.ts

@@ -4,7 +4,7 @@ import splitRef from "../../utils/splitRef";
 import { omit } from "../../utils/omit";
 import { isObject } from "../../utils/isObject";
 import { validateNode } from "../../validateNode";
-import { SchemaNode } from "../../types";
+import { isSchemaNode, JsonError, SchemaNode } from "../../types";
 import { get, split } from "@sagold/json-pointer";
 import { reduceRef } from "../../keywords/$ref";
 
@@ -73,7 +73,9 @@ export function parseRef(node: SchemaNode) {
 export function resolveRef(this: SchemaNode, { pointer, path }: { pointer?: string; path?: ValidationPath } = {}) {
     if (this.schema.$recursiveRef) {
         const nextNode = resolveRecursiveRef(this, path ?? []);
-        path?.push({ pointer: pointer!, node: nextNode! });
+        if (isSchemaNode(nextNode)) {
+            path?.push({ pointer: pointer!, node: nextNode! });
+        }
         return nextNode;
     }
 
@@ -82,10 +84,8 @@ export function resolveRef(this: SchemaNode, { pointer, path }: { pointer?: stri
     }
 
     const resolvedNode = getRef(this);
-    if (resolvedNode != null) {
+    if (isSchemaNode(resolvedNode)) {
         path?.push({ pointer: pointer!, node: resolvedNode });
-    } else {
-        // console.log("failed resolving", node.$ref, "from", Object.keys(node.context.refs));
     }
     return resolvedNode;
 }
@@ -93,13 +93,18 @@ export function resolveRef(this: SchemaNode, { pointer, path }: { pointer?: stri
 function validateRef({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {
     const nextNode = node.resolveRef({ pointer, path });
     if (nextNode != null) {
-        // recursively resolveRef and validate
         return validateNode(nextNode, data, pointer, path);
     }
+    return node.createError("ref-error", {
+        ref: node.schema.$ref ?? node.schema.$recursiveRef,
+        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;
 
     // RESTRICT BY CHANGE IN BASE-URL
@@ -135,7 +140,7 @@ function compileNext(referencedNode: SchemaNode, evaluationPath = referencedNode
     return referencedNode.compileSchema(referencedSchema, `${evaluationPath}/$ref`, referencedNode.schemaLocation);
 }
 
-export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | undefined {
+export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | JsonError {
     if ($ref == null) {
         return node;
     }
@@ -153,7 +158,12 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
     const fragments = splitRef($ref);
     if (fragments.length === 0) {
         // console.error("REF: INVALID", $ref);
-        return undefined;
+        return node.createError("ref-error", {
+            ref: $ref,
+            pointer: node.evaluationPath,
+            schema: node.schema,
+            value: undefined
+        });
     }
 
     // resolve $ref as remote-host
@@ -175,7 +185,12 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
             }
         }
         // 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) {
@@ -206,16 +221,25 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
                 // @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/draft2019-09/keywords/additionalItems.ts

@@ -4,28 +4,51 @@ import { SchemaNode } from "../../types";
 import { getValue } from "../../utils/getValue";
 import { validateNode } from "../../validateNode";
 
+const KEYWORD = "additionalItems";
+
 export const additionalItemsKeyword: Keyword = {
-    id: "additionalItems",
-    keyword: "additionalItems",
+    id: KEYWORD,
+    keyword: KEYWORD,
     order: -10,
     parse: parseAdditionalItems,
     addResolve: (node: SchemaNode) => node.items != null,
     resolve: additionalItemsResolver,
-    addValidate: ({ schema }) =>
-        schema.additionalItems != null && schema.additionalItems !== true && Array.isArray(schema.items),
+    addValidate: ({ schema }) => schema[KEYWORD] != null && schema[KEYWORD] !== true && Array.isArray(schema.items),
     validate: validateAdditionalItems
 };
 
 // must come as last resolver
 export function parseAdditionalItems(node: SchemaNode) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if ((isObject(schema.additionalItems) || schema.additionalItems === true) && Array.isArray(schema.items)) {
-        node.items = node.compileSchema(
-            schema.additionalItems,
-            `${evaluationPath}/additionalItems`,
-            `${schemaLocation}/additionalItems`
-        );
+    if (schema.additionalItems == null || schema.additionalItems === false) {
+        return;
+    }
+
+    const additionalItems = schema[KEYWORD];
+
+    if (!(isObject(additionalItems) || additionalItems === true)) {
+        return node.createError("schema-error", {
+            pointer: evaluationPath,
+            schema,
+            value: undefined,
+            message: `Keyword '${KEYWORD}' must be an object or a boolean - received '${typeof additionalItems}'`
+        });
+    }
+
+    if (!Array.isArray(schema.items)) {
+        return node.createAnnotation("schema-error", {
+            pointer: evaluationPath,
+            schema,
+            value: undefined,
+            message: `Keyword '${KEYWORD}' is only evaluated with a given items-array`
+        });
     }
+
+    node.items = node.compileSchema(
+        schema.additionalItems,
+        `${evaluationPath}/additionalItems`,
+        `${schemaLocation}/additionalItems`
+    );
 }
 
 function additionalItemsResolver({ node, key, data }: JsonSchemaResolverParams) {

package/src/draft2019-09/keywords/items.ts

@@ -3,11 +3,13 @@ import { SchemaNode } from "../../types";
 import { isObject } from "../../utils/isObject";
 import { validateNode } from "../../validateNode";
 
+const KEYWORD = "items";
+
 export const itemsKeyword: Keyword = {
-    id: "items",
-    keyword: "items",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseItems,
-    addResolve: (node) => (node.prefixItems || node.items) != null,
+    addResolve: (node) => (node.prefixItems || node[KEYWORD]) != null,
     resolve: itemsResolver,
     addValidate: ({ schema }) => schema.items != null,
     validate: validateItems
@@ -24,18 +26,38 @@ function itemsResolver({ node, key }: JsonSchemaResolverParams) {
 
 export function parseItems(node: SchemaNode) {
     const { schema, evaluationPath } = node;
-    if (isObject(schema.items)) {
+    const items = schema[KEYWORD];
+    if (items == null || typeof items === "boolean") {
+        return;
+    }
+
+    if (isObject(items)) {
         const propertyNode = node.compileSchema(
-            schema.items,
-            `${evaluationPath}/items`,
-            `${node.schemaLocation}/items`
+            items,
+            `${evaluationPath}/${KEYWORD}`,
+            `${node.schemaLocation}/${KEYWORD}`
         );
         node.items = propertyNode;
-    } else if (Array.isArray(schema.items)) {
-        node.prefixItems = schema.items.map((itemSchema, index) =>
-            node.compileSchema(itemSchema, `${evaluationPath}/items/${index}`, `${node.schemaLocation}/items/${index}`)
+        return;
+    }
+
+    if (Array.isArray(items)) {
+        node.prefixItems = items.map((itemSchema, index) =>
+            node.compileSchema(
+                itemSchema,
+                `${evaluationPath}/${KEYWORD}/${index}`,
+                `${node.schemaLocation}/${KEYWORD}/${index}`
+            )
         );
+        return;
     }
+
+    return node.createError("schema-error", {
+        pointer: evaluationPath,
+        schema,
+        value: undefined,
+        message: `Keyword '${KEYWORD}' must be an object or array - received '${typeof items}'`
+    });
 }
 
 function validateItems({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {

package/src/draft2019-09/keywords/unevaluatedItems.ts

@@ -3,27 +3,40 @@ import { SchemaNode } from "../../types";
 import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../../Keyword";
 import { validateNode } from "../../validateNode";
 
+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[KEYWORD] != null,
     validate: validateUnevaluatedItems
 };
 
 export function parseUnevaluatedItems(node: SchemaNode) {
-    if (!isObject(node.schema.unevaluatedItems)) {
+    const { unevaluatedItems } = node.schema;
+    if (unevaluatedItems == null || typeof unevaluatedItems === "boolean") {
         return;
     }
+
+    if (!isObject(unevaluatedItems)) {
+        return node.createError("schema-error", {
+            pointer: node.evaluationPath,
+            schema: node.schema,
+            value: undefined,
+            message: `Keyword '${KEYWORD}' must be an object - received '${typeof unevaluatedItems}'`
+        });
+    }
+
     node.unevaluatedItems = node.compileSchema(
         node.schema.unevaluatedItems,
-        `${node.evaluationPath}/unevaluatedItems`,
-        `${node.schemaLocation}/unevaluatedItems`
+        `${node.evaluationPath}/${KEYWORD}`,
+        `${node.schemaLocation}/${KEYWORD}`
     );
 }
 

package/src/draft2019-09/methods/getData.ts

@@ -160,7 +160,7 @@ export function getData(node: SchemaNode, data?: unknown, opts?: TemplateOptions
         return defaultData;
     }
 
-    if (resolvedNode && resolvedNode !== currentNode) {
+    if (isSchemaNode(resolvedNode)) {
         defaultData = resolvedNode.getData(defaultData, opts) ?? defaultData;
         currentNode = resolvedNode;
     }

package/src/draft2019-09/validateSchema.test.ts

@@ -0,0 +1,28 @@
+import { compileSchema as _compileSchema, type CompileOptions } from "../compileSchema";
+import { strict as assert } from "assert";
+import { draft2019 } from "../draft2019";
+import { JsonSchema } from "../types";
+
+const drafts = [draft2019];
+function compileSchema(schema: JsonSchema, options: CompileOptions = {}) {
+    return _compileSchema(schema, { ...options, drafts });
+}
+
+describe("validateSchema (2019-09)", () => {
+    it("should error if `additionalItems` is of an invalid type", () => {
+        const { schemaErrors } = compileSchema({ additionalItems: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should create annotation for `additionalItems` where items-array is missing", () => {
+        const { schemaAnnotations } = compileSchema({ additionalItems: true });
+        assert.equal(schemaAnnotations?.length, 1);
+    });
+    it("should error if `items` is of an invalid type", () => {
+        const { schemaErrors } = compileSchema({ items: 999 });
+        assert.equal(schemaErrors?.length, 1);
+    });
+    it("should error if `unevaluatedItems` is not an object or boolean", () => {
+        const { schemaErrors } = compileSchema({ unevaluatedItems: [] });
+        assert.equal(schemaErrors?.length, 1);
+    });
+});

package/src/errors/errors.ts

@@ -19,12 +19,15 @@ export const errors = {
     "format-duration-error": "Value `{{value}}` at `{{pointer}}` is not a valid duration",
     "format-email-error": "Value `{{value}}` at `{{pointer}}` is not a valid email",
     "format-hostname-error": "Value `{{value}}` at `{{pointer}}` is not a valid hostname",
+    "format-idn-hostname-error": "Value `{{value}}` at `{{pointer}}` is not a valid idn hostname",
     "format-ipv4-error": "Value `{{value}}` at `{{pointer}}` is not a valid IPv4 address",
     "format-ipv4-leading-zero-error":
         "IPv4 addresses starting with zero are invalid, since they are interpreted as octals",
     "format-ipv6-error": "Value `{{value}}` at `{{pointer}}` is not a valid IPv6 address",
     "format-ipv6-leading-zero-error":
         "IPv6 addresses starting with zero are invalid, since they are interpreted as octals",
+    "format-iri-error": "Value `{{value}}` at `{{pointer}}` is not a valid iri",
+    "format-iri-reference-error": "Value `{{value}}` at `{{pointer}}` is not a valid iri-reference",
     "format-json-pointer-error": "Value `{{value}}` at `{{pointer}}` is not a valid json-pointer",
     "format-regex-error": "Value `{{value}}` at `{{pointer}}` is not a valid regular expression",
     "format-time-error": "Value `{{value}}` at `{{pointer}}` is not a valid time",
@@ -62,6 +65,7 @@ export const errors = {
     "pattern-error": "Value in `{{pointer}}` should match `{{description}}`, but received `{{received}}`",
     "pattern-properties-error":
         "Property `{{key}}` does not match any patterns in `{{pointer}}`. Valid patterns are: {{patterns}}",
+    "ref-error": "Could not resolve $ref '{{ref}}' from '{{pointer}}'",
     "required-property-error": "The required property `{{key}}` is missing at `{{pointer}}`",
     /** return schema-warning with createSchemaWarning:true when a valid, but undefined  property was found */
     "schema-warning": "Failed retrieving a schema from '{{pointer}}' to key '{{key}}'",