json-schema-library 11.1.0 → 11.3.0

package/src/compileSchema.test.ts

@@ -2,6 +2,9 @@ import { compileSchema } from "./compileSchema";
 import { strict as assert } from "assert";
 import { draftEditor } from "./draftEditor";
 import { SchemaNode } from "./SchemaNode";
+import { draft04 } from "./draft04";
+import { draft07 } from "./draft07";
+import { draft2020 } from "./draft2020";
 
 describe("compileSchema vocabulary", () => {
     let root: SchemaNode;
@@ -33,6 +36,54 @@ describe("compileSchema vocabulary", () => {
     });
 });
 
+describe("compileSchema draft-version", () => {
+    it("should select last draft", () => {
+        const node = compileSchema({}, { drafts: [draft04, draft07, draft2020] });
+        assert(node.getDraftVersion(), "draft-2020");
+    });
+
+    it("should select draft specified by $schema", () => {
+        const node = compileSchema(
+            { $schema: "http://json-schema.org/draft-07/schema#" },
+            { drafts: [draft04, draft07, draft2020] }
+        );
+        assert(node.getDraftVersion(), "draft-07");
+    });
+
+    it("should select fallback draft specified by `draft`", () => {
+        const node = compileSchema(
+            {},
+            {
+                draft: "http://json-schema.org/draft-07/schema#",
+                drafts: [draft04, draft07, draft2020]
+            }
+        );
+        assert(node.getDraftVersion(), "draft-07");
+    });
+
+    it("should prefer `$schema` over `draft` options", () => {
+        const node = compileSchema(
+            { $schema: "http://json-schema.org/draft-04/schema#" },
+            {
+                draft: "http://json-schema.org/draft-07/schema#",
+                drafts: [draft04, draft07, draft2020]
+            }
+        );
+        assert(node.getDraftVersion(), "draft-04");
+    });
+
+    it("should always fallback to last draft if nothing matches", () => {
+        const node = compileSchema(
+            { $schema: "http://json-schema.org/draft-A/schema#" },
+            {
+                draft: "http://json-schema.org/draft-B/schema#",
+                drafts: [draft04, draft07, draft2020]
+            }
+        );
+        assert(node.getDraftVersion(), "draft-2020");
+    });
+});
+
 describe("compileSchema vocabulary", () => {
     it("should add remote schema on compile", () => {
         const remote = compileSchema({
@@ -150,6 +201,7 @@ describe("compileSchema `schemaLocation`", () => {
             $defs: { asset: { type: "string" } }
         });
 
+        assert(node.if && node.then && node.properties && node.$defs);
         assert.deepEqual(node.schemaLocation, "#");
         assert.deepEqual(node.if.schemaLocation, "#/if");
         assert.deepEqual(node.then.schemaLocation, "#/then");

package/src/compileSchema.ts

@@ -25,14 +25,63 @@ import sanitizeErrors from "./utils/sanitizeErrors";
 const { REGEX_FLAGS } = settings;
 
 export type CompileOptions = {
+    /**
+     * List of drafts to support.
+     *
+     * Drafts are selected by testing the passed `schema.$schema` for a matching id, which
+     * is tested by each draft's `Draft.$schemaRegEx`. In case no draft matches `schema.$schema`
+     * the last draft in the list will be used.
+     *
+     * @default [draft04, draft06, draft07, draft2019, draft2020]
+     *
+     * @example
+     * import { draft04, draft07, draft2020 } from "json-schema-library"
+     * compileSchema({ $schema: "draft-04" }, { drafts: [draft04, draft07, draft2020] })
+     */
     drafts?: Draft[];
+    /**
+     * Fallback _draft_ version in case no _draft_ is specified by `schema.$schema`.
+     *
+     * Drafts are selected by given `schema.$schema` or the last draft from `drafts` as a fallback.
+     * Specifying `draft` will workthe same as a specifying `schema.$schema` in case no $schema is
+     * defined. When no match can be found, the last _draft_ from `drafts` will be used.
+     *
+     * @example
+     * // uses draft-04
+     * compileSchema({ $schema: "draft-04" }, { drafts: [draft04, draft07, draft2020] })
+     *
+     * // uses draft-2020-12
+     * compileSchema({}, { drafts: [draft04, draft07, draft2020] })
+     *
+     * // uses draft-07
+     * compileSchema({}, { draft: "draft-07", drafts: [draft04, draft07, draft2020] })
+
+     * // uses draft-04
+     * compileSchema({ $schema: "draft-04" }, { draft: "draft-07", drafts: [draft04, draft07, draft2020] })
+     *
+     * // uses draft-2020
+     * compileSchema({ $schema: "draft-04" }, { draft: "draft-07", drafts: [draft2020] })
+     */
+    draft?: string;
+    /**
+     * Set node and its remote schemata as remote schemata for this node and schema to resolve $ref
+     */
     remote?: SchemaNode;
+    /**
+     * Enables `format`-keyword assertions when this is set tor `true` or sets assertion as defined by
+     * the given meta-schema. Set to `false` to deactivate format validation.
+     *
+     * @default true
+     */
     formatAssertion?: boolean | "meta-schema" | undefined;
+    /** Set default options for all `node.getData` requests */
     getDataDefaultOptions?: TemplateOptions;
-    /** set to true to throw an Errors on errors in input schema. Defaults to false */
+    /** Set to true to throw an Error on errors in input schema. Defaults to false */
     throwOnInvalidSchema?: boolean;
-    /** set to true to collect unknown keywords of input schema in `node.schemaAnnotations`. Defaults to false */
+    /** Set to true to collect unknown keywords of input schema in `node.schemaAnnotations`. Defaults to false */
     withSchemaAnnotations?: boolean;
+    /** Set to true to throw an Error when encountering an unresolvable ref  */
+    throwOnInvalidRef?: boolean;
 };
 
 const defaultDrafts: Draft[] = [draft04, draft06, draft07, draft2019, draft2020];
@@ -49,7 +98,7 @@ function getDraft(drafts: Draft[], $schema: string) {
 export function compileSchema(schema: JsonSchema | BooleanSchema, options: CompileOptions = {}) {
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;
-    const draft = getDraft(drafts, isJsonSchema(schema) ? schema.$schema : undefined);
+    const draft = getDraft(drafts, isJsonSchema(schema) ? (options.draft ?? schema.$schema) : undefined);
     const node: SchemaNode & { schemaErrors?: JsonError[]; schemaAnnotations: JsonAnnotation[] } = {
         evaluationPath: "#",
         lastIdPointer: "#",
@@ -69,6 +118,7 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
             ...copy(pick(draft, "methods", "keywords", "version", "formats", "errors")),
             getDataDefaultOptions: options.getDataDefaultOptions,
             withSchemaAnnotations: options.withSchemaAnnotations ?? false,
+            throwOnInvalidRef: options.throwOnInvalidRef ?? false,
             drafts
         },
         ...SchemaNodeMethods

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

@@ -61,8 +61,8 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft04 = sanitizeKeywords({
     version: "draft-04",
-    $schemaRegEx: "draft-04",
-    $schema: "http://json-schema.org/draft-04/schema",
+    $schemaRegEx: "draft-?0?4",
+    $schema: "http://json-schema.org/draft-04/schema#",
     errors,
     formats,
     methods: {

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

@@ -62,8 +62,8 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft06 = sanitizeKeywords({
     version: "draft-06",
-    $schemaRegEx: "draft-06",
-    $schema: "http://json-schema.org/draft-06/schema",
+    $schemaRegEx: "draft-?0?6",
+    $schema: "http://json-schema.org/draft-06/schema#",
     errors,
     formats,
     methods: {

package/src/draft07.ts

@@ -53,8 +53,8 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft07 = sanitizeKeywords({
     version: "draft-07",
-    $schemaRegEx: "draft-07",
-    $schema: "http://json-schema.org/draft-07/schema",
+    $schemaRegEx: "draft-?0?7",
+    $schema: "http://json-schema.org/draft-07/schema#",
     errors,
     formats,
     methods: {

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

@@ -1,12 +1,10 @@
 import { Keyword, JsonSchemaValidatorParams, ValidationPath } from "../../Keyword";
 import { resolveUri } from "../../utils/resolveUri";
 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";
+import { reduceRef, compileNext } from "../../keywords/$ref";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
@@ -73,7 +71,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 +82,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 +91,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
@@ -127,33 +130,30 @@ function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode
     return nextNode;
 }
 
-function compileNext(referencedNode: SchemaNode, evaluationPath = referencedNode.evaluationPath) {
-    const referencedSchema = isObject(referencedNode.schema)
-        ? omit(referencedNode.schema, "$id")
-        : referencedNode.schema;
-
-    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;
     }
 
     // resolve $ref by json-evaluationPath
     if (node.context.refs[$ref]) {
-        return compileNext(node.context.refs[$ref], node.evaluationPath);
+        return compileNext(node.context.refs[$ref], node);
     }
     // resolve $ref from $anchor
     if (node.context.anchors[$ref]) {
-        return compileNext(node.context.anchors[$ref], node.evaluationPath);
+        return compileNext(node.context.anchors[$ref], node);
     }
 
     // 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
@@ -161,7 +161,7 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
         const $ref = fragments[0];
         // this is a reference to remote-host root node
         if (node.context.remotes[$ref]) {
-            return compileNext(node.context.remotes[$ref], node.evaluationPath);
+            return compileNext(node.context.remotes[$ref], node);
         }
         if ($ref[0] === "#") {
             // @todo there is a bug joining multiple fragments to e.g. #/base#/examples/0
@@ -175,7 +175,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 +211,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) {