json-schema-library 11.0.0 → 11.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.0.0",
+  "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,8 +1,9 @@
 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";
 const DECLARATOR_ONEOF = settings.DECLARATOR_ONEOF;
 
 describe("keyword : oneof : validate", () => {
@@ -38,7 +39,7 @@ describe("keyword : oneOf : reduce", () => {
             ]
         }).reduceNode(111);
 
-        assert.deepEqual(node.schema, { type: "number", title: "A Number" });
+        assert.deepEqual(node?.schema, { type: "number", title: "A Number" });
         assert.equal(node.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
@@ -72,7 +73,7 @@ describe("keyword : oneOf : reduce", () => {
             oneOf: [{ required: ["a"], properties: { a: { type: "string" } } }, { $ref: "#/$defs/withData" }]
         }).reduceNode({ b: 111 });
 
-        assert.deepEqual(node.schema, { required: ["b"], properties: { b: { type: "number" } } });
+        assert.deepEqual(node?.schema, { required: ["b"], properties: { b: { type: "number" } } });
         // @note that we override nested oneOfIndex
         assert.equal(node.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
@@ -83,7 +84,7 @@ describe("keyword : oneOf : reduce", () => {
             oneOf: [{ required: ["a"], properties: { a: false } }, { $ref: "#/$defs/withData" }]
         }).reduceNode({ b: 111 });
 
-        assert.deepEqual(node.schema, { required: ["b"], properties: { b: true } });
+        assert.deepEqual(node?.schema, { required: ["b"], properties: { b: true } });
         assert.equal(node.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
@@ -101,7 +102,7 @@ describe("keyword : oneOf : reduce", () => {
             ]
         }).reduceNode({ title: 4 });
 
-        assert.deepEqual(node.schema, { type: "object", properties: { title: { type: "number" } } });
+        assert.deepEqual(node?.schema, { type: "object", properties: { title: { type: "number" } } });
         assert.equal(node.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
@@ -119,7 +120,7 @@ describe("keyword : oneOf : reduce", () => {
             ]
         }).reduceNode({ title: 4, test: 2 });
 
-        assert.deepEqual(node.schema, { type: "object", additionalProperties: { type: "number" } });
+        assert.deepEqual(node?.schema, { type: "object", additionalProperties: { type: "number" } });
         assert.equal(node.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 });
@@ -130,7 +131,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
             oneOf: [{ type: "string" }, { type: "number" }, { type: "object" }]
         });
         const res = reduceOneOfFuzzy({ node, data: 4, pointer: "#", path: [] });
-        assert.deepEqual(res.schema, { type: "number" });
+        assert.deepEqual(res?.schema, { type: "number" });
         assert.equal(res.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
@@ -142,7 +143,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
             ]
         });
         const res = reduceOneOfFuzzy({ node, data: "anasterixcame", pointer: "#", path: [] });
-        assert.deepEqual(res.schema, { type: "string", pattern: "asterix" });
+        assert.deepEqual(res?.schema, { type: "string", pattern: "asterix" });
         assert.equal(res.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
@@ -155,7 +156,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
             oneOf: [{ $ref: "#/definitions/a" }, { $ref: "#/definitions/b" }]
         });
         const res = reduceOneOfFuzzy({ node, data: "anasterixcame", pointer: "#", path: [] });
-        assert.deepEqual(res.schema, { type: "string", pattern: "asterix" });
+        assert.deepEqual(res?.schema, { type: "string", pattern: "asterix" });
         assert.equal(res.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
@@ -169,7 +170,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
                 ]
             });
             const res = reduceOneOfFuzzy({ node, data: { description: "..." }, pointer: "#", path: [] });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: { description: { type: "string" } }
             });
@@ -183,7 +184,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
                 ]
             });
             const res = reduceOneOfFuzzy({ node, data: { title: "asterix" }, pointer: "#", path: [] });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: { title: { type: "string" } }
             });
@@ -199,7 +200,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
                 ]
             });
             const res = reduceOneOfFuzzy({ node, data: { a: 0, b: 1 }, pointer: "#", path: [] });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: { a: t, b: t, c: t }
             });
@@ -216,7 +217,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
                 ]
             });
             const res = reduceOneOfFuzzy({ node, data: { a: true, b: 1 }, pointer: "#", path: [] });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: { a: { type: "boolean" }, b: t, d: t }
             });
@@ -252,7 +253,7 @@ describe("keyword : oneof-fuzzy : reduce", () => {
                 node,
                 data: { type: "teaser", redirectUrl: "http://example.com/test/pay/article.html" }
             });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: {
                     redirectUrl: { format: "url", type: "string" },
@@ -284,7 +285,7 @@ describe("keyword : oneof-property : reduce", () => {
                 ]
             });
             const res = reduceOneOfDeclarator({ node, data: { name: "2", title: 123 }, pointer: "#", path: [] });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: {
                     name: { type: "string", pattern: "^2$" },
@@ -318,7 +319,7 @@ describe("keyword : oneof-property : reduce", () => {
                 pointer: "#",
                 path: []
             });
-            assert.deepEqual(res.schema, {
+            assert.deepEqual(res?.schema, {
                 type: "object",
                 properties: {
                     name: { type: "string", pattern: "^2$" },
@@ -349,31 +350,188 @@ 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", () => {
+    it("should return one-of-error oneOfProperty does not match", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    oneOfProperty: "id",
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["id"],
+                            properties: { id: { const: "one" } }
+                        },
+                        {
+                            type: "object",
+                            required: ["id"],
+                            properties: { id: { const: "two" } }
+                        }
+                    ]
+                }
+            },
+            { drafts: [draftEditor] }
+        );
+
+        const { errors } = node.validate([{ id: "unknown" }]);
+
+        assert.equal(errors.length, 1);
+        assert.deepEqual(errors[0].code, "one-of-error");
+    });
+
+    it("should return validation errors of object identified by oneOfProperty", () => {
+        const node = compileSchema(
+            {
+                type: "array",
+                items: {
+                    oneOfProperty: "id",
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["id"],
+                            properties: {
+                                id: { const: "one" },
+                                title: { type: "string" }
+                            }
+                        }
+                    ]
+                }
+            },
+            { drafts: [draftEditor] }
+        );
+
+        const { errors } = node.validate([{ id: "one", title: 123 }]);
+
+        assert.equal(errors.length, 1);
+        assert.deepEqual(errors[0].code, "type-error");
+    });
+
+    // issue json-editor
+    it("should return unique-items error for failed oneOf item", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                required: ["main"],
+                properties: {
+                    main: {
+                        type: "array",
+                        items: {
+                            oneOfProperty: "type",
+                            oneOf: [{ $ref: "#/$defs/parent" }]
+                        }
+                    }
+                },
+                $defs: {
+                    parent: {
+                        type: "object",
+                        title: "Parent",
+                        description:
+                            "Adding a duplicate item to this list fails as uniqueItems=true in children. @todo correct error message",
+                        required: ["type", "children"],
+                        properties: {
+                            type: {
+                                options: { hidden: true },
+                                type: "string",
+                                const: "parent"
+                            },
+                            children: {
+                                type: "array",
+                                title: "Children",
+                                uniqueItems: true,
+                                items: {
+                                    oneOfProperty: "type",
+                                    oneOf: [
+                                        {
+                                            type: "object",
+                                            title: "Child: First",
+                                            required: ["type"],
+                                            properties: {
+                                                type: {
+                                                    options: { hidden: true },
+                                                    type: "string",
+                                                    const: "one"
+                                                }
+                                            }
+                                        },
+                                        {
+                                            type: "object",
+                                            title: "Child: Second",
+                                            required: ["type"],
+                                            properties: {
+                                                type: {
+                                                    options: { hidden: true },
+                                                    type: "string",
+                                                    const: "two"
+                                                }
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            { drafts: [draftEditor] }
+        );
+        const { errors } = node.validate({
+            main: [{ type: "parent", children: [{ type: "one" }, { type: "one" }] }]
+        });
+        assert.equal(errors.length, 1);
+        assert.deepEqual(errors[0].data.pointer, "#/main/0/children/1");
+        assert.deepEqual(errors[0].code, "unique-items-error");
+    });
 });