json-schema-library 11.1.0 → 11.3.0

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/draft2019.ts

@@ -60,7 +60,7 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft2019 = sanitizeKeywords({
     version: "draft-2019-09",
-    $schemaRegEx: "draft[/-]2019-09",
+    $schemaRegEx: "draft[/-]2019-?(09)?",
     $schema: "https://json-schema.org/draft/2019-09/schema",
     errors,
     formats,

package/src/draft2020.ts

@@ -70,7 +70,7 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft2020 = sanitizeKeywords({
     version: "draft-2020-12",
-    $schemaRegEx: "draft[/-]2020-12",
+    $schemaRegEx: "draft[/-]2020-?(12)?",
     $schema: "https://json-schema.org/draft/2020-12/schema",
     errors,
     formats,

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}}'",

package/src/formats/formats.ts

@@ -1,16 +1,14 @@
 /* eslint-disable no-control-regex */
-import { getTypeOf } from "../utils/getTypeOf";
+import { isAsciiIdn, isUri, isIdnEmail, isIri, isIriReference, isIdn } from "@hyperjump/json-schema-formats";
 import validUrl from "valid-url";
+import { getTypeOf } from "../utils/getTypeOf";
 import { JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
-import { parse as parseIdnEmail } from "smtp-address-parser";
 import settings from "../settings";
 
 const { REGEX_FLAGS } = settings;
 const isValidIPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
 const isValidIPV6 =
     /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
-const isValidHostname =
-    /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/;
 const matchDate = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
 const matchTime =
     /^(?<time>(?:([0-1]\d|2[0-3]):[0-5]\d:(?<second>[0-5]\d|60)))(?:\.\d+)?(?<offset>(?:z|[+-]([0-1]\d|2[0-3])(?::?[0-5]\d)?))$/i;
@@ -129,33 +127,30 @@ export const formats: Record<string, (options: JsonSchemaValidatorParams) => Val
         return undefined;
     },
 
-    /**
-     * @draft 7
-     * [RFC6531] https://json-schema.org/draft-07/json-schema-validation.html#RFC6531
-     */
-    "idn-email": ({ node, pointer, data }) => {
+    hostname: ({ node, pointer, data }) => {
         const { schema } = node;
-        if (typeof data !== "string" || data === "") {
+        if (typeof data !== "string" || isAsciiIdn(data)) {
             return undefined;
         }
-        try {
-            parseIdnEmail(data);
-            return undefined;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (e) {
-            return node.createError("format-email-error", { value: data, pointer, schema });
-        }
+        return node.createError("format-hostname-error", { value: data, pointer, schema });
     },
 
-    hostname: ({ node, pointer, data }) => {
-        const { schema } = node;
-        if (typeof data !== "string") {
+    "idn-hostname": ({ node, pointer, data }) => {
+        if (typeof data !== "string" || isIdn(data)) {
             return undefined;
         }
-        if (isValidHostname.test(data)) {
+        return node.createError("format-idn-hostname-error", { value: data, pointer, schema: node.schema });
+    },
+
+    /**
+     * @draft 7
+     * [RFC6531] https://json-schema.org/draft-07/json-schema-validation.html#RFC6531
+     */
+    "idn-email": ({ node, pointer, data }) => {
+        if (typeof data !== "string" || data === "" || isIdnEmail(data)) {
             return undefined;
         }
-        return node.createError("format-hostname-error", { value: data, pointer, schema });
+        return node.createError("format-email-error", { value: data, pointer, schema: node.schema });
     },
 
     ipv4: ({ node, pointer, data }) => {
@@ -188,6 +183,22 @@ export const formats: Record<string, (options: JsonSchemaValidatorParams) => Val
         return node.createError("format-ipv6-error", { value: data, pointer, schema });
     },
 
+    iri: ({ node, pointer, data }) => {
+        const { schema } = node;
+        if (typeof data !== "string" || data === "" || isIri(data)) {
+            return undefined;
+        }
+        return node.createError("format-iri-error", { value: data, pointer, schema });
+    },
+
+    "iri-reference": ({ node, pointer, data }) => {
+        const { schema } = node;
+        if (typeof data !== "string" || data === "" || isIriReference(data)) {
+            return undefined;
+        }
+        return node.createError("format-iri-reference-error", { value: data, pointer, schema });
+    },
+
     "json-pointer": ({ node, pointer, data }) => {
         const { schema } = node;
         if (typeof data !== "string" || data === "") {
@@ -281,14 +292,10 @@ export const formats: Record<string, (options: JsonSchemaValidatorParams) => Val
     },
 
     uri: ({ node, pointer, data }) => {
-        const { schema } = node;
-        if (typeof data !== "string" || data === "") {
-            return undefined;
-        }
-        if (validUrl.isUri(data)) {
+        if (typeof data !== "string" || data === "" || isUri(data)) {
             return undefined;
         }
-        return node.createError("format-uri-error", { value: data, pointer, schema });
+        return node.createError("format-uri-error", { value: data, pointer, schema: node.schema });
     },
 
     "uri-reference": ({ node, pointer, data }) => {

package/src/formats/hyperjump.d.ts

@@ -0,0 +1,172 @@
+declare module "@hyperjump/json-schema-formats" {
+    /**
+     * The 'date' format. Validates that a string represents a date according to
+     * [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339.html#section-5.6).
+     *
+     * @see [JSON Schema Core, section 7.3.1](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.1)
+     */
+    export const isDate: (date: string) => boolean;
+
+    /**
+     * The 'time' format. Validates that a string represents a time according to
+     * [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339.html#section-5.6).
+     *
+     * **NOTE**: Leap seconds are only allowed on specific dates. Since there is no date
+     * in this context, leap seconds are never allowed.
+     *
+     * @see [JSON Schema Core, section 7.3.1](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.1)
+     */
+    export const isTime: (time: string) => boolean;
+
+    /**
+     * The 'date-time' format. Validates that a string represents a date-time
+     * according to [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339.html#section-5.6).
+     *
+     * @see [JSON Schema Core, section 7.3.1](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.1)
+     */
+    export const isDateTime: (dateTime: string) => boolean;
+
+    /**
+     * The 'duration' format. Validates that a string represents a duration
+     * according to [RFC 3339, Appendix A](https://www.rfc-editor.org/rfc/rfc3339.html#appendix-A).
+     *
+     * @see [JSON Schema Core, section 7.3.1](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.1)
+     */
+    export const isDuration: (duration: string) => boolean;
+
+    /**
+     * The 'email' format. Validates that a string represents an email as defined by
+     * the "Mailbox" ABNF rule in [RFC 5321, section 4.1.2](https://www.rfc-editor.org/rfc/rfc5321.html#section-4.1.2).
+     *
+     * @see [JSON Schema Core, section 7.3.2](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.2)
+     */
+    export const isEmail: (email: string) => boolean;
+
+    /**
+     * The 'idn-email' format. Validates that a string represents an email as
+     * defined by the "Mailbox" ABNF rule in [RFC 6531, section 3.3](https://www.rfc-editor.org/rfc/rfc6531.html#section-3.3).
+     *
+     * @see [JSON Schema Core, section 7.3.2](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.2)
+     */
+    export const isIdnEmail: (email: string) => boolean;
+
+    /**
+     * The 'hostname' format in draft-04 - draft-06. Validates that a string
+     * represents a hostname as defined by [RFC 1123, section 2.1](https://www.rfc-editor.org/rfc/rfc1123.html#section-2.1).
+     *
+     * **NOTE**: The 'hostname' format changed in draft-07. Use {@link isAsciiIdn} for
+     * draft-07 and later.
+     *
+     * @see [JSON Schema Core, section 7.3.3](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.3)
+     */
+    export const isHostname: (hostname: string) => boolean;
+
+    /**
+     * The 'hostname' format since draft-07. Validates that a string represents an
+     * IDNA2008 internationalized domain name consiting of only A-labels and NR-LDH
+     * labels as defined by [RFC 5890, section 2.3.2.1](https://www.rfc-editor.org/rfc/rfc5890.html#section-2.3.2.3).
+     *
+     * **NOTE**: The 'hostname' format changed in draft-07. Use {@link isHostname}
+     * for draft-06 and earlier.
+     *
+     * @see [JSON Schema Core, section 7.3.3](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.3)
+     */
+    export const isAsciiIdn: (hostname: string) => boolean;
+
+    /**
+     * The 'idn-hostname' format. Validates that a string represents an IDNA2008
+     * internationalized domain name as defined by [RFC 5890, section 2.3.2.1](https://www.rfc-editor.org/rfc/rfc5890.html#section-2.3.2.1).
+     *
+     * @see [JSON Schema Core, section 7.3.3](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.3)
+     */
+    export const isIdn: (hostname: string) => boolean;
+
+    /**
+     * The 'ipv4' format. Validates that a string represents an IPv4 address
+     * according to the "dotted-quad" ABNF syntax as defined in
+     * [RFC 2673, section 3.2](https://www.rfc-editor.org/rfc/rfc2673.html#section-3.2).
+     *
+     * @see [JSON Schema Core, section 7.3.4](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.4)
+     */
+    export const isIPv4: (ip: string) => boolean;
+
+    /**
+     * The 'ipv6' format. Validates that a string represents an IPv6 address as
+     * defined in [RFC 4291, section 2.2](https://www.rfc-editor.org/rfc/rfc4291.html#section-2.2).
+     *
+     * @see [JSON Schema Core, section 7.3.4](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.4)
+     */
+    export const isIPv6: (ip: string) => boolean;
+
+    /**
+     * The 'uri' format. Validates that a string represents a URI as defined by [RFC
+     * 3986](https://www.rfc-editor.org/rfc/rfc3986.html).
+     *
+     * @see [JSON Schema Core, section 7.3.5](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.5)
+     */
+    export const isUri: (uri: string) => boolean;
+
+    /**
+     * The 'uri-reference' format. Validates that a string represents a URI
+     * Reference as defined by [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986.html).
+     *
+     * @see [JSON Schema Core, section 7.3.5](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.5)
+     */
+    export const isUriReference: (uri: string) => boolean;
+
+    /**
+     * The 'iri' format. Validates that a string represents an IRI as defined by
+     * [RFC 3987](https://www.rfc-editor.org/rfc/rfc3987.html).
+     *
+     * @see [JSON Schema Core, section 7.3.5](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.5)
+     */
+    export const isIri: (iri: string) => boolean;
+
+    /**
+     * The 'iri-reference' format. Validates that a string represents an IRI
+     * Reference as defined by [RFC 3987](https://www.rfc-editor.org/rfc/rfc3987.html).
+     *
+     * @see [JSON Schema Core, section 7.3.5](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.5)
+     */
+    export const isIriReference: (iri: string) => boolean;
+
+    /**
+     * The 'uuid' format. Validates that a string represents a UUID address as
+     * defined by [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.html).
+     *
+     * @see [JSON Schema Core, section 7.3.5](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.5)
+     */
+    export const isUuid: (uuid: string) => boolean;
+
+    /**
+     * The 'uri-template' format. Validates that a string represents a URI Template
+     * as defined by [RFC 6570](https://www.rfc-editor.org/rfc/rfc6570.html).
+     *
+     * @see [JSON Schema Core, section 7.3.6](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.6)
+     */
+    export const isUriTemplate: (uriTemplate: string) => boolean;
+
+    /**
+     * The 'json-pointer' format. Validates that a string represents a JSON Pointer
+     * as defined by [RFC 6901](https://www.rfc-editor.org/rfc/rfc6901.html).
+     *
+     * @see [JSON Schema Core, section 7.3.7](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.7)
+     */
+    export const isJsonPointer: (pointer: string) => boolean;
+
+    /**
+     * The 'relative-json-pointer' format. Validates that a string represents an IRI
+     * Reference as defined by [draft-bhutton-relative-json-pointer-00](https://datatracker.ietf.org/doc/html/draft-bhutton-relative-json-pointer-00).
+     *
+     * @see [JSON Schema Core, section 7.3.5](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.5)
+     */
+    export const isRelativeJsonPointer: (pointer: string) => boolean;
+
+    /**
+     * The 'regex' format. Validates that a string represents a regular expression
+     * as defined by [ECMA-262](https://262.ecma-international.org/5.1/).
+     *
+     * @see [JSON Schema Core, section 7.3.8](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-7.3.8)
+     */
+    export const isRegex: (regex: string) => boolean;
+}

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";
@@ -8,6 +8,7 @@ import { validateNode } from "../validateNode";
 import { get, split } from "@sagold/json-pointer";
 import { mergeNode } from "../mergeNode";
 import { pick } from "../utils/pick";
+import settings from "src/settings";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
@@ -93,7 +94,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) {
@@ -107,6 +113,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;
     }
@@ -116,7 +125,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 });
     }
 
@@ -129,10 +138,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);
 
@@ -163,14 +178,12 @@ function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode
     return getRef(node, refInCurrentScope);
 }
 
-const PROPERTIES_TO_MERGE = ["title", "description", "options", "readOnly", "writeOnly"];
-
-function compileNext(referencedNode: SchemaNode, sourceNode: SchemaNode) {
+export function compileNext(referencedNode: SchemaNode, sourceNode: SchemaNode) {
     let referencedSchema = referencedNode.schema;
     if (isObject(referencedNode.schema)) {
         referencedSchema = {
             ...omit(referencedNode.schema, "$id"),
-            ...pick(sourceNode.schema, ...PROPERTIES_TO_MERGE)
+            ...pick(sourceNode.schema, ...settings.PROPERTIES_TO_MERGE)
         };
     }
     return referencedNode.compileSchema(
@@ -180,7 +193,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;
     }
@@ -202,7 +215,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
@@ -212,6 +230,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;
@@ -221,7 +240,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) {
@@ -252,16 +276,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/oneOf.test.ts

@@ -483,7 +483,7 @@ describe("keyword : oneof-fuzzy : validate", () => {
                         required: ["type", "children"],
                         properties: {
                             type: {
-                                options: { hidden: true },
+                                "x-options": { hidden: true },
                                 type: "string",
                                 const: "parent"
                             },
@@ -500,7 +500,7 @@ describe("keyword : oneof-fuzzy : validate", () => {
                                             required: ["type"],
                                             properties: {
                                                 type: {
-                                                    options: { hidden: true },
+                                                    "x-options": { hidden: true },
                                                     type: "string",
                                                     const: "one"
                                                 }
@@ -512,7 +512,7 @@ describe("keyword : oneof-fuzzy : validate", () => {
                                             required: ["type"],
                                             properties: {
                                                 type: {
-                                                    options: { hidden: true },
+                                                    "x-options": { hidden: true },
                                                     type: "string",
                                                     const: "two"
                                                 }