json-schema-library 11.0.5 → 11.2.0

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,10 @@ 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;
+    /** [SHARED USING ADD REMOTE] throw error on validation when ref cannot be resolved */
+    throwOnInvalidRef?: boolean;
 };
 
 export interface SchemaNode extends SchemaNodeMethodsType {
@@ -129,6 +134,7 @@ export interface SchemaNode extends SchemaNodeMethodsType {
     reducers: JsonSchemaReducer[];
     resolvers: JsonSchemaResolver[];
     validators: JsonSchemaValidator[];
+    schemaValidation?: ValidationAnnotation[];
 
     // parsed schema properties (registered by parsers)
     $id?: string;
@@ -140,7 +146,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 +185,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 +352,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;
     },
 
@@ -474,6 +514,13 @@ export const SchemaNodeMethods = {
         const errorsAsync: Promise<Maybe<ValidationAnnotation>[]>[] = [];
         sanitizeErrors(Array.isArray(errors) ? errors : [errors]).forEach((error) => {
             if (isJsonError(error)) {
+                if (node.context.throwOnInvalidRef && error.code === "ref-error") {
+                    const refError = new Error("Invalid $ref: " + error.message);
+                    // @ts-expect-error unknown error-property
+                    refError.data = syncErrors;
+                    throw refError;
+                }
+
                 syncErrors.push(error);
             } else if (error instanceof Promise) {
                 errorsAsync.push(error.then(sanitizeErrors));
@@ -497,15 +544,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 +612,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 +655,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,12 @@ export type CompileOptions = {
     remote?: SchemaNode;
     formatAssertion?: boolean | "meta-schema" | undefined;
     getDataDefaultOptions?: TemplateOptions;
+    /** 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 */
+    withSchemaAnnotations?: boolean;
+    /** set to true to throw an Error when encountering an unresolvable ref  */
+    throwOnInvalidRef?: boolean;
 };
 
 const defaultDrafts: Draft[] = [draft04, draft06, draft07, draft2019, draft2020];
@@ -35,8 +52,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 +70,8 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
             refs: {},
             ...copy(pick(draft, "methods", "keywords", "version", "formats", "errors")),
             getDataDefaultOptions: options.getDataDefaultOptions,
+            withSchemaAnnotations: options.withSchemaAnnotations ?? false,
+            throwOnInvalidRef: options.throwOnInvalidRef ?? false,
             drafts
         },
         ...SchemaNodeMethods
@@ -82,6 +100,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/draft04/keywords/$ref.ts

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

package/src/draft04/keywords/exclusiveMaximum.ts

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

package/src/draft04/keywords/exclusiveMinimum.ts

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

package/src/draft04/validateSchema.test.ts

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

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

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

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

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

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

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