json-schema-library 11.0.4 → 11.1.0

package/index.ts

@@ -3,7 +3,15 @@ export type { CompileOptions } from "./src/compileSchema";
 export type { Context, SchemaNode, GetNodeOptions, ValidateReturnType } from "./src/SchemaNode";
 export type { DataNode } from "./src/methods/toDataNodes";
 export type { Draft, DraftVersion } from "./src/Draft";
-export type { JsonError, JsonAnnotation, JsonPointer, JsonSchema, BooleanSchema, OptionalNodeOrError, NodeOrError } from "./src/types";
+export type {
+    JsonError,
+    JsonAnnotation,
+    JsonPointer,
+    JsonSchema,
+    BooleanSchema,
+    OptionalNodeOrError,
+    NodeOrError
+} from "./src/types";
 export type {
     Keyword,
     Maybe,
@@ -29,6 +37,7 @@ export { draftEditor } from "./src/draftEditor";
 
 // keywords
 export { oneOfFuzzyKeyword, oneOfKeyword } from "./src/keywords/oneOf";
+export { propertyDependenciesKeyword } from "./src/keywords/propertyDependencies";
 
 // errors
 export { render } from "./src/errors/render";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.0.4",
+  "version": "11.1.0",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -13,7 +13,6 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "preinstall": "npx only-allow yarn",
     "coverage": "nyc npm run test --reporter=lcov",
     "dist": "tsdown -f esm -f cjs --minify; yarn dist:iife",
     "dist:iife": "tsdown --config tsdown.iife.config.ts --no-clean --minify; mv dist/index.iife.js dist/jlib.js",
@@ -66,19 +65,19 @@
   "homepage": "https://github.com/sagold/json-schema-library",
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/glob": "^9.0.0",
+    "@types/glob": "^ 8.1.0",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^25.2.3",
+    "@types/node": "^25.3.3",
     "@types/valid-url": "^1.0.7",
     "eslint": "^9.39.2",
-    "glob": "^13.0.3",
+    "glob": "^13.0.6",
     "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite#Test-JSON-Schema-Acceptance-1.029",
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
-    "tsdown": "^0.20.3",
+    "tsdown": "^0.21.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.55.0",
+    "typescript-eslint": "^8.57.0",
     "watch": "^1.0.1"
   },
   "dependencies": {
@@ -93,14 +92,18 @@
     "valid-url": "^1.0.9"
   },
   "resolutions": {
+    "ajv": ">=6.14.0",
     "braces": ">=3.0.3",
     "cross-spawn": ">=7.0.6",
+    "diff": ">=8.0.3",
     "json5": ">=2.2.3",
     "js-yaml": ">=4.1.1",
     "lodash": ">=4",
     "merge": ">=2",
     "micromatch": ">=4.0.8",
-    "string-width": ">=4.2.3"
+    "serialize-javascript": ">=7.0.3",
+    "string-width": ">=4.2.3",
+    "minimatch": ">=9.0.7"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/Draft.ts

@@ -2,7 +2,7 @@ import type { JsonSchemaValidator, Keyword } from "./Keyword";
 import { copyDraft } from "./utils/copyDraft";
 import { createSchema } from "./methods/createSchema";
 import { toDataNodes } from "./methods/toDataNodes";
-import { ErrorConfig } from "./types";
+import { ErrorConfig, SchemaNode } from "./types";
 import { getChildSelection } from "./methods/getChildSelection";
 import { getData } from "./methods/getData";
 

package/src/Keyword.ts

@@ -37,30 +37,56 @@ export type ValidationAnnotation = JsonError | JsonAnnotation | Promise<Maybe<Va
 type ValidationResult = Maybe<ValidationAnnotation>;
 export type ValidationReturnType = ValidationResult | ValidationResult[];
 
-export type JsonSchemaValidatorParams = { pointer: string; data: unknown; node: SchemaNode; path: ValidationPath };
-export interface JsonSchemaValidator {
+export type SchemaNodeWithRequired<K extends keyof SchemaNode> = SchemaNode & Required<Pick<SchemaNode, K>>;
+export type JsonSchemaValidatorParams<Key extends keyof SchemaNode = keyof SchemaNode> = {
+    pointer: string;
+    data: unknown;
+    node: SchemaNodeWithRequired<Key>;
+    path: ValidationPath;
+};
+export interface JsonSchemaValidator<Key extends keyof SchemaNode = keyof SchemaNode> {
     toJSON?: () => string;
     order?: number;
-    (options: JsonSchemaValidatorParams): ValidationReturnType;
+    (options: JsonSchemaValidatorParams<Key>): ValidationReturnType;
 }
 
-export type Keyword = {
+export type Keyword<Key extends keyof SchemaNode = keyof SchemaNode> = {
     id: string;
     /** unique keyword corresponding to JSON Schema keywords (or custom) */
     keyword: string;
     /** sort order of keyword. Lower numbers will be processed last. Default is 0 */
     order?: number;
-    /** called with compileSchema */
-    parse?: (node: SchemaNode) => void;
+    /**
+     * Called once for each JSON Schema dduring compileSchema to evaluate keyword.
+     * Use this to skip or preprocess the Keyword for the given JSON Schema and
+     * to create any schema annotations, like input errors.
+     *
+     * - most keywords cache their evaluation directly on node, e.g. node.required
+     * - most keywords skip any other actions if their evaluation is missing on node
+     * - return any errors found in JSON schema related to this keyword
+     *      (this includes errors from created nodes)
+     */
+    parse?: (node: SchemaNode) => void | ValidationAnnotation | ValidationAnnotation[];
     addResolve?: (node: SchemaNode) => boolean;
-    /** return node corresponding to passed in key or do nothing */
+    /**
+     * If this contains child-data, resolve must return schema associated for the passed in key
+     *
+     * @example
+     * a keyword properties has has child-properties. So when a properties[key] exists,
+     * it will return the node of properties[key] or nothing at all
+     */
     resolve?: JsonSchemaResolver;
 
+    /** return true if the given node should run the validate-function on this keyword */
     addValidate?: (node: SchemaNode) => boolean;
-    /** validate data using node */
-    validate?: JsonSchemaValidator;
+    /**
+     * Perform validation for this keyword and the passed in data
+     */
+    validate?: JsonSchemaValidator<Key>;
 
     addReduce?: (node: SchemaNode) => boolean;
-    /** remove dynamic schema-keywords by merging valid sub-schemas */
+    /**
+     * Remove dynamic schema-keywords by merging valid sub-schemas
+     */
     reduce?: JsonSchemaReducer;
 };

package/src/SchemaNode.ts

@@ -24,7 +24,8 @@ import {
     OptionalNodeOrError,
     NodeOrError,
     JsonAnnotation,
-    isJsonAnnotation
+    isJsonAnnotation,
+    isBooleanSchema
 } from "./types";
 import { isObject } from "./utils/isObject";
 import { join } from "@sagold/json-pointer";
@@ -91,6 +92,8 @@ export type Context = {
     formats: Draft["formats"];
     /** [SHARED USING ADD REMOTE] getData default options */
     getDataDefaultOptions?: TemplateOptions;
+    /** [SHARED USING ADD REMOTE] collect unknown keywords in schemaAnnotations */
+    withSchemaAnnotations?: boolean;
 };
 
 export interface SchemaNode extends SchemaNodeMethodsType {
@@ -129,6 +132,7 @@ export interface SchemaNode extends SchemaNodeMethodsType {
     reducers: JsonSchemaReducer[];
     resolvers: JsonSchemaResolver[];
     validators: JsonSchemaValidator[];
+    schemaValidation?: ValidationAnnotation[];
 
     // parsed schema properties (registered by parsers)
     $id?: string;
@@ -140,7 +144,9 @@ export interface SchemaNode extends SchemaNodeMethodsType {
     contains?: SchemaNode;
     dependentRequired?: Record<string, string[]>;
     dependentSchemas?: Record<string, SchemaNode | boolean>;
+    deprecated?: boolean;
     else?: SchemaNode;
+    enum?: unknown[];
     if?: SchemaNode;
     /**
      * # Items-array schema - for all drafts
@@ -177,21 +183,40 @@ export interface SchemaNode extends SchemaNodeMethodsType {
      * | [AdditionalItems Specification](https://json-schema.org/draft/2019-09/draft-handrews-json-schema-02#additionalItems)
      */
     items?: SchemaNode;
+    maximum?: number;
+    minimum?: number;
+    maxItems?: number;
+    maxLength?: number;
+    maxProperties?: number;
+    minItems?: number;
+    minLength?: number;
+    minProperties?: number;
     not?: SchemaNode;
     oneOf?: SchemaNode[];
+    multipleOf?: number;
+    pattern?: RegExp;
     patternProperties?: { name: string; pattern: RegExp; node: SchemaNode }[];
+    propertyDependencies?: Record<string, Record<string, SchemaNode>>;
     properties?: Record<string, SchemaNode>;
     propertyNames?: SchemaNode;
+    required?: string[];
     then?: SchemaNode;
+    type?: string | string[];
     unevaluatedItems?: SchemaNode;
     unevaluatedProperties?: SchemaNode;
+    uniqueItems?: true;
 }
 
 /**
  * Fixed SchemaNode mixin methods
  */
 interface SchemaNodeMethodsType {
-    compileSchema(schema: JsonSchema | BooleanSchema, evaluationPath?: string, schemaLocation?: string, dynamicId?: string): SchemaNode;
+    compileSchema(
+        schema: JsonSchema | BooleanSchema,
+        evaluationPath?: string,
+        schemaLocation?: string,
+        dynamicId?: string
+    ): SchemaNode;
     createError<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonError;
     createAnnotation<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonAnnotation;
     createSchema(data?: unknown): JsonSchema;
@@ -325,7 +350,20 @@ export const SchemaNodeMethods = {
             ...SchemaNodeMethods
         };
 
-        addKeywords(node);
+        if (!isJsonSchema(schema) && !isBooleanSchema(schema)) {
+            node.schemaValidation = [
+                node.createError("schema-error", {
+                    pointer: schemaLocation ?? evaluationPath,
+                    schema,
+                    value: undefined,
+                    message: `JSON schema must be object or boolean - reveived: '${schema}'`
+                })
+            ];
+            return node;
+        }
+        const schemaValidation = addKeywords(node).filter((err) => err != null);
+        node.schemaValidation = sanitizeErrors(schemaValidation);
+
         return node;
     },
 
@@ -497,15 +535,15 @@ export const SchemaNodeMethods = {
      * @returns the current node (not the remote schema-node)
      */
     addRemoteSchema(url: string, schema: JsonSchema | BooleanSchema): SchemaNode {
-    // @draft >= 6
-    if (isJsonSchema(schema)) {
-        schema.$id = resolveUri(schema.$id || url);
-    }
-        
+        // @draft >= 6
+        if (isJsonSchema(schema)) {
+            schema.$id = resolveUri(schema.$id || url);
+        }
+
         const node = this as SchemaNode;
         const { context } = node;
         const schemaId = isJsonSchema(schema) ? schema.$schema : undefined;
-const draft = getDraft(context.drafts, schemaId ?? context.rootNode.schema?.$schema);
+        const draft = getDraft(context.drafts, schemaId ?? context.rootNode.schema?.$schema);
 
         const remoteNode: SchemaNode = {
             evaluationPath: "#",
@@ -565,20 +603,40 @@ const noRefMergeDrafts = ["draft-04", "draft-06", "draft-07"];
 export function addKeywords(node: SchemaNode) {
     if (node.schema.$ref && noRefMergeDrafts.includes(node.context.version)) {
         // for these draft versions only ref is validated
-        node.context.keywords
+        return node.context.keywords
             .filter(({ keyword }) => whitelist.includes(keyword))
-            .forEach((keyword) => execKeyword(keyword, node));
-        return;
+            .map((keyword) => execKeyword(keyword, node));
     }
     const keys = Object.keys(node.schema);
-    node.context.keywords
-        .filter(({ keyword }) => keys.includes(keyword) || whitelist.includes(keyword))
-        .forEach((keyword) => execKeyword(keyword, node));
+    const errors = node.context.keywords
+        .filter(({ keyword }) => whitelist.includes(keyword) || keys.includes(keyword))
+        .map((keyword) => execKeyword(keyword, node));
+
+    // find unused keywords
+    if (node.context.withSchemaAnnotations) {
+        Object.keys(node.schema)
+            .filter(
+                (key) =>
+                    !key.startsWith("x-") && node.context.keywords.find((keyword) => keyword.keyword === key) == null
+            )
+            .forEach((keyword) => {
+                errors.push(
+                    node.createAnnotation("unknown-keyword-warning", {
+                        pointer: `${node.schemaLocation}/${keyword}`,
+                        schema: node.schema,
+                        value: keyword,
+                        draft: node.getDraftVersion()
+                    })
+                );
+            });
+    }
+
+    return errors;
 }
 
 export function execKeyword(keyword: Keyword, node: SchemaNode) {
     // @todo consider first parsing all nodes
-    keyword.parse?.(node);
+    const errors = keyword.parse?.(node);
     if (keyword.reduce && keyword.addReduce?.(node)) {
         node.reducers.push(keyword.reduce);
     }
@@ -588,4 +646,5 @@ export function execKeyword(keyword: Keyword, node: SchemaNode) {
     if (keyword.validate && keyword.addValidate?.(node)) {
         node.validators.push(keyword.validate);
     }
+    return errors;
 }

package/src/compileSchema.ts

@@ -6,10 +6,21 @@ import { draft07 } from "./draft07";
 import { draft2019 } from "./draft2019";
 import { draft2020 } from "./draft2020";
 import { pick } from "./utils/pick";
-import { JsonSchema, BooleanSchema, Draft, isJsonSchema } from "./types";
+import {
+    JsonSchema,
+    BooleanSchema,
+    Draft,
+    isJsonSchema,
+    JsonAnnotation,
+    JsonError,
+    isJsonError,
+    isJsonAnnotation,
+    isBooleanSchema
+} from "./types";
 import { TemplateOptions } from "./methods/getData";
 import { SchemaNode, SchemaNodeMethods, addKeywords, isSchemaNode } from "./SchemaNode";
 import settings from "./settings";
+import sanitizeErrors from "./utils/sanitizeErrors";
 
 const { REGEX_FLAGS } = settings;
 
@@ -18,6 +29,10 @@ export type CompileOptions = {
     remote?: SchemaNode;
     formatAssertion?: boolean | "meta-schema" | undefined;
     getDataDefaultOptions?: TemplateOptions;
+    /** set to true to throw an Errors 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 */
+    withSchemaAnnotations?: boolean;
 };
 
 const defaultDrafts: Draft[] = [draft04, draft06, draft07, draft2019, draft2020];
@@ -35,8 +50,7 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;
     const draft = getDraft(drafts, isJsonSchema(schema) ? schema.$schema : undefined);
-
-    const node: SchemaNode = {
+    const node: SchemaNode & { schemaErrors?: JsonError[]; schemaAnnotations: JsonAnnotation[] } = {
         evaluationPath: "#",
         lastIdPointer: "#",
         schemaLocation: "#",
@@ -54,6 +68,7 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
             refs: {},
             ...copy(pick(draft, "methods", "keywords", "version", "formats", "errors")),
             getDataDefaultOptions: options.getDataDefaultOptions,
+            withSchemaAnnotations: options.withSchemaAnnotations ?? false,
             drafts
         },
         ...SchemaNodeMethods
@@ -82,6 +97,40 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
         node.context.keywords = node.context.keywords.filter((f) => f.keyword !== "format");
     }
 
-    addKeywords(node);
+    if (!isJsonSchema(schema) && !isBooleanSchema(schema)) {
+        node.schemaErrors = [
+            node.createError("schema-error", {
+                pointer: "#",
+                schema,
+                value: undefined,
+                message: `JSON schema must be object or boolean - reveived: '${schema}'`
+            })
+        ];
+        return node;
+    }
+
+    // parse and validate schema
+    let schemaValidation = addKeywords(node).filter((err) => err != null);
+    schemaValidation = sanitizeErrors(schemaValidation);
+    const schemaErrors: JsonError[] = [];
+    const schemaAnnotations: JsonAnnotation[] = [];
+    schemaValidation.forEach((error) => {
+        if (isJsonError(error)) {
+            schemaErrors.push(error);
+        } else if (isJsonAnnotation(error)) {
+            schemaAnnotations.push(error);
+        }
+    });
+
+    if (options.throwOnInvalidSchema && schemaErrors.length > 0) {
+        const error = new Error("Invalid schema passed to compileSchema");
+        // @ts-expect-error unknown error-property
+        error.data = schemaErrors;
+        throw error;
+    }
+
+    node.schemaErrors = schemaErrors;
+    node.schemaAnnotations = schemaAnnotations;
+
     return node;
 }

package/src/errors/errors.ts

@@ -74,5 +74,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/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) {

package/src/keywords/$ref.ts

@@ -72,6 +72,18 @@ export function parseRef(node: SchemaNode) {
             node.$ref = `#${node.$ref}`;
         }
     }
+
+    // validate simple ref to definitions
+    if (node.$ref?.startsWith("#/$defs/")) {
+        if (get(node.getNodeRoot().schema, node.$ref) == null) {
+            return node.createError("schema-error", {
+                pointer: `${node.schemaLocation}/$ref`,
+                schema: node.schema,
+                value: node.schema.$ref,
+                message: `Invalid $ref to missing target '${node.schema.ref}'`
+            });
+        }
+    }
 }
 
 export function reduceRef({ node, data, key, pointer, path }: JsonSchemaReducerParams) {

package/src/keywords/additionalProperties.ts

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

package/src/keywords/allOf.ts

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