json-schema-library 11.0.5 → 11.2.0

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}}'",
@@ -74,5 +78,8 @@ export const errors = {
     "unknown-property-error": "Could not find a valid schema for property `{{pointer}}` within object",
     "value-not-empty-error": "A value for `{{property}}` is required at `{{pointer}}`",
     // annotations
-    "deprecated-warning": "Value at `{{pointer}}` is deprecated"
+    "deprecated-warning": "Value at `{{pointer}}` is deprecated",
+    // schema validation
+    "schema-error": "Invalid schema found at {{pointer}}: {{message}}",
+    "unknown-keyword-warning": "Keyword '{{value}}' is not a valid keyword to draft '{{draft}}'"
 };

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/$defs.ts

@@ -1,5 +1,6 @@
-import { Keyword } from "../Keyword";
+import { Keyword, ValidationAnnotation } from "../Keyword";
 import { SchemaNode } from "../types";
+import { isObject } from "../utils/isObject";
 
 export const $defsKeyword: Keyword = {
     id: "$defs",
@@ -8,17 +9,40 @@ export const $defsKeyword: Keyword = {
 };
 
 export function parseDefs(node: SchemaNode) {
+    const errors: ValidationAnnotation[] = [];
+
     if (node.schema.$defs) {
-        node.$defs = node.$defs ?? {};
-        Object.keys(node.schema.$defs).forEach((property) => {
-            node.$defs![property] = node.compileSchema(
-                node.schema.$defs[property],
-                `${node.evaluationPath}/$defs/${urlEncodeJsonPointerProperty(property)}`,
-                `${node.schemaLocation}/$defs/${property}`
+        if (!isObject(node.schema.$defs)) {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: node.schemaLocation,
+                    schema: node.schema,
+                    value: node.schema.$defs,
+                    message: `$defs must be an object - received: ${typeof node.schema.$defs}`
+                })
             );
-        });
+        } else {
+            node.$defs = node.$defs ?? {};
+            Object.keys(node.schema.$defs).forEach((property) => {
+                node.$defs![property] = node.compileSchema(
+                    node.schema.$defs[property],
+                    `${node.evaluationPath}/$defs/${urlEncodeJsonPointerProperty(property)}`,
+                    `${node.schemaLocation}/$defs/${property}`
+                );
+            });
+        }
     }
     if (node.schema.definitions) {
+        if (!isObject(node.schema.definitions)) {
+            errors.push(
+                node.createError("schema-error", {
+                    pointer: node.schemaLocation,
+                    schema: node.schema,
+                    value: node.schema.$defs,
+                    message: `definitions must be an object - received: ${typeof node.schema.definitions}`
+                })
+            );
+        }
         node.$defs = node.$defs ?? {};
         Object.keys(node.schema.definitions).forEach((property) => {
             node.$defs![property] = node.compileSchema(
@@ -28,6 +52,8 @@ export function parseDefs(node: SchemaNode) {
             );
         });
     }
+
+    return errors;
 }
 
 function urlEncodeJsonPointerProperty(property: string) {