json-schema-library 11.0.1 → 11.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.0.1",
+  "version": "11.0.2",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -33,7 +33,7 @@
     "test:6:ci": "DISABLE_LOG=true mocha -R json 'src/tests/spec/draft06.spec.ts' > test-result-spec6.json; exit 0",
     "test:7": "mocha 'src/tests/spec/draft07.spec.ts'",
     "test:7:ci": "DISABLE_LOG=true mocha -R json 'src/tests/spec/draft07.spec.ts' > test-result-spec7.json; exit 0",
-    "test:inspect": "yarn test:unit --inspect-brk",
+    "test:inspect": "NODE_OPTIONS='--inspect-brk' mocha 'src/**/*.test.ts'",
     "test:spec": "mocha 'src/tests/spec/*.spec.ts'",
     "test:unit": "mocha 'src/**/*.test.ts'",
     "test:unit:ci": "DISABLE_LOG=true mocha -R json 'src/**/*.test.ts' -R json > test-result-unit.json; exit 0"

package/src/SchemaNode.ts

@@ -38,7 +38,7 @@ import { getNode } from "./getNode";
 import { getNodeChild } from "./getNodeChild";
 import { DataNode } from "./methods/toDataNodes";
 
-const { DYNAMIC_PROPERTIES, REGEX_FLAGS } = settings;
+const { DYNAMIC_PROPERTIES, REGEX_FLAGS, DECLARATOR_ONEOF } = settings;
 
 export function isSchemaNode(value: unknown): value is SchemaNode {
     return isObject(value) && Array.isArray(value?.reducers) && Array.isArray(value?.resolvers);
@@ -194,12 +194,34 @@ interface SchemaNodeMethodsType {
     createAnnotation<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonAnnotation;
     createSchema(data?: unknown): JsonSchema;
 
-    // getNode overloads
+    /**
+     * Returns a node matching the given location (pointer) in data
+     *
+     * - the returned node will have a **reduced schema** based on given input data
+     * - return returned node $ref is resolved
+     *
+     * To resolve dynamic schema where the type of JSON Schema is evaluated by
+     * its value, a data object has to be passed in options.
+     *
+     * Per default this function will return `undefined` schema for valid properties
+     * that do not have a defined schema. Use the option `withSchemaWarning: true` to
+     * receive an error with `code: schema-warning` containing the location of its
+     * last evaluated json-schema.
+     *
+     * @returns { node } or { error } where node can also be undefined (valid but undefined)
+     */
     getNode(pointer: string, data: unknown, options: { withSchemaWarning: true } & GetNodeOptions): NodeOrError;
     getNode(pointer: string, data: unknown, options: { createSchema: true } & GetNodeOptions): NodeOrError;
     getNode(pointer: string, data?: unknown, options?: GetNodeOptions): OptionalNodeOrError;
 
-    // getNodeChild overloads
+    /**
+     * Returns the child for the given property-name or array-index
+     *
+     * - the returned child node is **not reduced**
+     * - a child node $ref is resolved
+     *
+     * @returns { node } or { error } where node can also be undefined (valid but undefined)
+     */
     getNodeChild(
         key: string | number,
         data: unknown,
@@ -431,7 +453,7 @@ export const SchemaNodeMethods = {
         }
 
         // remove dynamic properties of node
-        workingNode.schema = omit(workingNode.schema, ...DYNAMIC_PROPERTIES);
+        workingNode.schema = omit(workingNode.schema, DECLARATOR_ONEOF, ...DYNAMIC_PROPERTIES);
         // @ts-expect-error string accessing schema props
         DYNAMIC_PROPERTIES.forEach((prop) => (workingNode[prop] = undefined));
         return { node: workingNode, error: undefined };

package/src/draftEditor.ts

@@ -1,14 +1,14 @@
 import { extendDraft } from "./Draft";
-import { draft2019 } from "./draft2019";
+import { draft2020 } from "./draft2020";
 import { oneOfFuzzyKeyword } from "./keywords/oneOf";
 import { render } from "./errors/render";
 
 /**
- * @draft-editor https://json-schema.org/draft/2019-09/release-notes
+ * @draft-editor https://json-schema.org/draft/2020-12/release-notes
  *
- * Uses Draft 2019-09 and changes resolveOneOf to be fuzzy
+ * Uses Draft 2020-12 and changes resolveOneOf to be fuzzy
  */
-export const draftEditor = extendDraft(draft2019, {
+export const draftEditor = extendDraft(draft2020, {
     $schemaRegEx: ".",
     keywords: [oneOfFuzzyKeyword],
     errors: {

package/src/errors/errors.ts

@@ -45,12 +45,13 @@ export const errors = {
     "min-items-one-error": "At least one item is required in `{{pointer}}`",
     "min-length-error": "Value `{{pointer}}` should have a minimum length of `{{minLength}}`, but got `{{length}}`.",
     "min-length-one-error": "A value is required in `{{pointer}}`",
-    "missing-one-of-declarator-error": "Missing oneOf declarator `{{declarator}}` in `{{pointer}}`",
+    "missing-one-of-declarator-error": "Missing oneOf declarator `{{declarator}}` in schema `{{schemaLocation}}`",
     "min-properties-error":
         "Too few properties in `{{pointer}}`, should be at least `{{minProperties}}`, but got `{{length}}`",
     "missing-array-item-error": "Array at '{{pointer}}' has a missing item at '{{key}}'",
     "missing-dependency-error": "The required propery '{{missingProperty}}' in `{{pointer}}` is missing",
-    "missing-one-of-property-error": "Value at `{{pointer}}` property: `{{property}}`",
+    "missing-one-of-property-error":
+        "Value at `{{pointer}}` must be object or array and have a property ${oneOfProperty}: ${value}",
     "multiple-of-error": "Expected `{{value}}` in `{{pointer}}` to be multiple of `{{multipleOf}}`",
     "multiple-one-of-error": "Value `{{value}}` should not match multiple schemas in oneOf `{{matches}}`",
     "no-additional-properties-error": "Additional property `{{property}}` in `{{pointer}}` is not allowed",

package/src/getNode.oneOfProperty.test.ts

@@ -0,0 +1,43 @@
+import { compileSchema } from "./compileSchema";
+import { strict as assert } from "assert";
+import { isSchemaNode } from "./types";
+import settings from "./settings";
+const DECLARATOR_ONEOF = settings.DECLARATOR_ONEOF;
+
+describe("getNodeChild.oneOfProperty", () => {
+    describe("", () => {
+        it("should return resolved reference (reduced oneOfNode)", () => {
+            const node = compileSchema({
+                items: {
+                    [DECLARATOR_ONEOF]: "name",
+                    oneOf: [{ $ref: "#/$defs/first" }, { $ref: "#/$defs/second" }]
+                },
+                $defs: {
+                    first: {
+                        properties: { name: { type: "string", const: "first" }, title: { type: "number" } }
+                    },
+                    second: {
+                        properties: { name: { type: "string", const: "second" }, title: { type: "number" } }
+                    }
+                }
+            });
+
+            // precondition
+            const reducedItems = node.items?.reduceNode({ name: "second" });
+            assert(reducedItems && reducedItems.node, "should have successfully resolved items schema directly");
+            assert.deepEqual(
+                reducedItems.node?.schema,
+                {
+                    properties: { name: { type: "string", const: "second" }, title: { type: "number" } }
+                },
+                "should have correctly resolved items-schema directly"
+            );
+
+            const { node: res } = node.getNode("#/0", [{ name: "second" }]);
+            assert(isSchemaNode(res), "expected result to a node");
+            assert.deepEqual(res.schema, {
+                properties: { name: { type: "string", const: "second" }, title: { type: "number" } }
+            });
+        });
+    });
+});

package/src/{compileSchema.getNode.test.ts → getNode.test.ts}

@@ -520,7 +520,7 @@ describe("compileSchema : getNode", () => {
                 assert.deepEqual(node.schema, { type: "array", minItems: 2 });
             });
 
-            it("should mrege title from local schema", () => {
+            it("should merge title from local schema", () => {
                 const { node } = compileSchema({
                     type: "array",
                     prefixItems: [{ title: "from ref", $ref: "/$defs/target" }],

package/src/getNode.ts

@@ -1,4 +1,4 @@
-import { GetNodeOptions, SchemaNode } from "./SchemaNode";
+import { GetNodeOptions, isSchemaNode, SchemaNode } from "./SchemaNode";
 import { isJsonError, NodeOrError, OptionalNodeOrError } from "./types";
 import { split } from "@sagold/json-pointer";
 import { getValue } from "./utils/getValue";
@@ -7,9 +7,13 @@ import { getValue } from "./utils/getValue";
 export function getNode(pointer: string, data: unknown, options: { withSchemaWarning: true } & GetNodeOptions): NodeOrError;
 export function getNode(pointer: string, data: unknown, options: { createSchema: true } & GetNodeOptions): NodeOrError;
 export function getNode(pointer: string, data?: unknown, options?: GetNodeOptions): OptionalNodeOrError;
+
 /**
  * Returns a node containing JSON Schema of a data JSON Pointer.
  *
+ * - the returned node will have a reduced schema based on given input data
+ * - the returned node $ref is resolved
+ *
  * To resolve dynamic schema where the type of JSON Schema is evaluated by
  * its value, a data object has to be passed in options.
  *
@@ -49,6 +53,15 @@ export function getNode(
         currentNode = result.node;
         data = getValue(data, keys[i]);
     }
-    const result = currentNode.resolveRef(options);
-    return isJsonError(result) ? { node: undefined, error: result } : { node: result, error: undefined };
+
+    const { node: reducedNode, error: reduceError } = currentNode.resolveRef(options).reduceNode(data);
+
+    if (isJsonError(reduceError)) {
+        return { node: undefined, error: reduceError };
+    }
+    if (isSchemaNode(reducedNode)) {
+        return { node: reducedNode, error: undefined };
+    }
+
+    return { error: undefined };
 }

package/src/getNodeChild.ts

@@ -2,67 +2,73 @@ import { GetNodeOptions, isSchemaNode, SchemaNode } from "./SchemaNode";
 import { isJsonError, NodeOrError, OptionalNodeOrError } from "./types";
 import { getValue } from "./utils/getValue";
 
-// prettier-ignore
-export function getNodeChild(key: string | number, data: unknown, options: { withSchemaWarning: true } & GetNodeOptions): NodeOrError;
-// prettier-ignore
-export function getNodeChild(key: string | number, data: unknown, options: { createSchema: true } & GetNodeOptions): NodeOrError;
+export function getNodeChild(key: string | number, data: unknown, options: { withSchemaWarning: true } & GetNodeOptions): NodeOrError; // prettier-ignore
+export function getNodeChild(key: string | number, data: unknown, options: { createSchema: true } & GetNodeOptions): NodeOrError; // prettier-ignore
 export function getNodeChild(key: string | number, data?: unknown, options?: GetNodeOptions): OptionalNodeOrError;
 
 /**
- * @returns child node identified by property as SchemaNode
+ * Returns the child for the given property-name or array-index
+ *
+ * - the returned child node is **not reduced**
+ * - a child node $ref is resolved
+ *
+ * @returns { node } or { error } where node can also be undefined (valid but undefined)
  */
 export function getNodeChild(
     key: string | number,
     data?: unknown,
     options: GetNodeOptions = {}
-): OptionalNodeOrError | NodeOrError | object {
+): OptionalNodeOrError | NodeOrError {
     options.path = options.path ?? [];
-
     options.withSchemaWarning = options.withSchemaWarning ?? false;
     options.pointer = options.pointer ?? "#";
     const { path, pointer } = options;
 
+    // reduce parent
     // @ts-expect-error implicitely any
-    let node = this as SchemaNode;
-    if (node.reducers.length) {
-        const result = node.reduceNode(data, { key, path, pointer });
+    let parentNode = this as SchemaNode;
+    if (parentNode.reducers.length) {
+        const result = parentNode.reduceNode(data, { key, path, pointer });
         if (result.error) {
             return result;
         }
         if (isSchemaNode(result.node)) {
-            node = result.node;
+            parentNode = result.node;
         }
     }
 
-    for (const resolver of node.resolvers) {
-        const schemaNode = resolver({ data, key, node });
-        if (isSchemaNode(schemaNode)) {
-            return { node: schemaNode.resolveRef({ pointer, path }), error: undefined };
-        }
+    // find child node
+    for (const resolver of parentNode.resolvers) {
+        const schemaNode = resolver({ data, key, node: parentNode });
+        // a matching resolver found an error, return
         if (isJsonError(schemaNode)) {
             return { node: undefined, error: schemaNode };
         }
+        // a matching resolver found a child node, return
+        if (isSchemaNode(schemaNode)) {
+            return { node: schemaNode.resolveRef({ pointer, path }), error: undefined };
+        }
     }
 
-    const referencedNode = node.resolveRef({ path });
-    if (referencedNode !== node) {
-        return referencedNode.getNodeChild(key, data, options);
-    }
-
+    // no child node was found, but the child node is valid
     if (options.createSchema === true) {
-        const newNode = node.compileSchema(
-            node.createSchema(getValue(data, key)),
-            `${node.evaluationPath}/additional`,
-            `${node.schemaLocation}/additional`
+        const newNode = parentNode.compileSchema(
+            parentNode.createSchema(getValue(data, key)),
+            `${parentNode.evaluationPath}/additional`,
+            `${parentNode.schemaLocation}/additional`
         );
         return { node: newNode, error: undefined };
     }
 
     if (options.withSchemaWarning === true) {
-        const error = node.createError("schema-warning", { pointer, value: data, schema: node.schema, key });
+        const error = parentNode.createError("schema-warning", {
+            pointer,
+            value: data,
+            schema: parentNode.schema,
+            key
+        });
         return { node: undefined, error };
     }
 
-    // throw new Error("getNodeChild failed retrieving node or error");
-    return {};
+    return { node: undefined };
 }

package/src/keywords/oneOf.test.ts

@@ -1,6 +1,6 @@
 import { strict as assert } from "assert";
 import { compileSchema } from "../compileSchema";
-import { isJsonError } from "../types";
+import { isJsonError, isSchemaNode } from "../types";
 import { reduceOneOfDeclarator, reduceOneOfFuzzy } from "./oneOf";
 import settings from "../settings";
 import { draftEditor } from "../draftEditor";
@@ -350,33 +350,56 @@ describe("keyword : oneof-property : reduce", () => {
             assert(isJsonError(res), "expected result to be an error");
             assert.deepEqual(res.code, "missing-one-of-property-error");
         });
-    });
 
-    describe("array", () => {
-        it("should return an error if no oneOfProperty could be matched", () => {
+        it("should return correct reference", () => {
             const node = compileSchema({
-                oneOf: [
-                    {
-                        type: "object",
-                        required: ["title"],
-                        properties: {
-                            title: {
-                                type: "string"
-                            }
-                        }
+                [DECLARATOR_ONEOF]: "name",
+                oneOf: [{ $ref: "#/$defs/first" }, { $ref: "#/$defs/second" }],
+                $defs: {
+                    first: {
+                        properties: { name: { type: "string", const: "first" }, title: { type: "number" } }
+                    },
+                    second: {
+                        properties: { name: { type: "string", const: "second" }, title: { type: "number" } }
                     }
-                ]
+                }
+            });
+            const res = reduceOneOfDeclarator({ node, data: { name: "second" }, pointer: "#", path: [] });
+            assert(isSchemaNode(res), "expected result to be a node");
+            assert.deepEqual(res.schema, {
+                properties: { name: { type: "string", const: "second" }, title: { type: "number" } }
+            });
+        });
+
+        it("should return correct reference even if data is not fully valid", () => {
+            const node = compileSchema({
+                [DECLARATOR_ONEOF]: "name",
+                oneOf: [{ $ref: "#/$defs/first" }, { $ref: "#/$defs/second" }],
+                $defs: {
+                    first: {
+                        properties: { name: { type: "string", const: "first" }, title: { type: "number" } }
+                    },
+                    second: {
+                        properties: { name: { type: "string", const: "second" }, title: { type: "number" } }
+                    }
+                }
             });
             const res = reduceOneOfDeclarator({
                 node,
-                data: { name: "2", title: "not a number" },
+                data: { name: "first", title: "not a number" },
                 pointer: "#",
                 path: []
             });
-            assert(isJsonError(res), "expected result to be an error");
-            assert.deepEqual(res.code, "missing-one-of-property-error");
+            assert(isSchemaNode(res), "expected result to be a node");
+            assert.deepEqual(res.schema, {
+                properties: { name: { type: "string", const: "first" }, title: { type: "number" } }
+            });
         });
     });
+
+    describe("array", () => {
+        // TODO test access on array-item as oneOfProperty id (oneOfProperty: "0")
+    });
 });
 
 describe("keyword : oneof-fuzzy : validate", () => {

package/src/keywords/oneOf.ts

@@ -101,42 +101,57 @@ function reduceOneOf({ node, data, pointer, path }: Omit<JsonSchemaReducerParams
     });
 }
 
+/**
+ * Returns matching oneOf schema identified by matching schema for oneOfProperty
+ */
 export function reduceOneOfDeclarator({ node, data, pointer, path }: Omit<JsonSchemaReducerParams, "key">) {
     if (node.oneOf == null) {
         return;
     }
 
-    const errors: ValidationReturnType = [];
     const oneOfProperty = node.schema[DECLARATOR_ONEOF];
-    const oneOfValue = getValue(data, oneOfProperty);
+    const oneOfPropertyValue = getValue(data, oneOfProperty);
 
-    if (oneOfValue === undefined) {
+    // in this case, we also fail when data undefined as this always is valid,
+    // but not in context on an expected oneOfProperty
+    if (data === undefined || oneOfPropertyValue === undefined) {
         return node.createError("missing-one-of-property-error", {
-            property: oneOfProperty,
+            oneOfProperty,
             pointer,
             schema: node.schema,
             value: data
         });
     }
 
+    // find oneOf schema that has a matching oneOfProperty to the current input data
+    // TODO throw an error if multiple matches were found
+    const errors: ValidationReturnType = [];
     for (let i = 0; i < node.oneOf.length; i += 1) {
         const { node: resultNode } = node.oneOf[i].getNodeChild(oneOfProperty, data);
         if (!isSchemaNode(resultNode)) {
+            // one of the oneOf schemas has a missing oneOfTypeProperty
+            // TODO this still might succeed
+            // TODO there is a possibility this throws an invalid error as we use input data
             return node.createError("missing-one-of-declarator-error", {
                 declarator: DECLARATOR_ONEOF,
                 oneOfProperty,
-                schemaPointer: node.oneOf[i].schemaLocation,
+                schemaLocation: node.oneOf[i].schemaLocation,
                 pointer: `${pointer}/oneOf/${i}`,
                 schema: node.schema,
                 value: data
             });
         }
 
-        const result = sanitizeErrors(validateNode(resultNode, oneOfValue, pointer, path));
-        // result = result.filter(errorOrPromise);
+        // collect errors in case we fail finding a matching schema
+        const result = sanitizeErrors(
+            validateNode(resultNode, oneOfPropertyValue, `${pointer}/${oneOfProperty}`, path)
+        );
+
         if (result.length > 0) {
             errors.push(...result);
         } else {
+            // return at once when we found a schema
+            // TODO should check all oneOf-schema
             const { node: reducedNode } = node.oneOf[i].reduceNode(data, { pointer, path });
             if (reducedNode) {
                 reducedNode.oneOfIndex = i; // @evaluation-info
@@ -147,7 +162,7 @@ export function reduceOneOfDeclarator({ node, data, pointer, path }: Omit<JsonSc
 
     return node.createError("one-of-property-error", {
         property: oneOfProperty,
-        value: oneOfValue,
+        value: data,
         pointer,
         schema: node.schema,
         errors

package/src/methods/getChildSelection.test.ts

@@ -34,6 +34,24 @@ describe("getChildSelection", () => {
         );
     });
 
+    it("should return resolved $ref", () => {
+        const result = compileSchema({
+            type: "array",
+            prefixItems: [{ $ref: "#/$defs/first" }, { $ref: "#/$defs/second" }],
+            $defs: {
+                first: { type: "string" },
+                second: { type: "number" }
+            }
+        }).getChildSelection(1);
+
+        assert(!isJsonError(result));
+        assert.deepEqual(result.length, 1);
+        assert.deepEqual(
+            result.map((n) => n.schema),
+            [{ type: "number" }]
+        );
+    });
+
     it("should return an empty array if items schema is undefined", () => {
         const result = compileSchema({
             type: "array",

package/src/methods/getChildSelection.ts

@@ -5,7 +5,7 @@ import { isSchemaNode, JsonError, SchemaNode } from "../types";
  * could be added at the given property (e.g. item-index), thus an array of options is returned. In all other cases
  * a list with a single item will be returned
  */
-export function getChildSelection(node: SchemaNode, property: string | number): SchemaNode[] | JsonError {
+export function getChildSelection(node: SchemaNode, property: string | number) {
     if (node.oneOf) {
         return node.oneOf.map((childNode: SchemaNode) => childNode.resolveRef());
     }

package/src/{compileSchema.reduceSchema.test.ts → reduceNode.test.ts}

@@ -302,7 +302,6 @@ describe("compileSchema : reduceNode", () => {
             }).reduceNode({ id: "second" });
             assert.deepEqual(node.schema, {
                 type: "object",
-                oneOfProperty: "id",
                 properties: { id: { const: "second" }, one: { type: "number" } }
             });
         });