json-schema-library 10.5.4 → 11.0.1

package/src/draft2019.ts

@@ -1,17 +1,24 @@
+import { $defsKeyword } from "./keywords/$defs";
+import { $refKeyword } from "./draft2019-09/keywords/$ref";
 import { additionalItemsKeyword } from "./draft2019-09/keywords/additionalItems";
 import { additionalPropertiesKeyword } from "./keywords/additionalProperties";
 import { allOfKeyword } from "./keywords/allOf";
 import { anyOfKeyword } from "./keywords/anyOf";
 import { constKeyword } from "./keywords/const";
 import { containsKeyword } from "./keywords/contains";
-import { $defsKeyword } from "./keywords/$defs";
+import { createSchema } from "./methods/createSchema";
 import { dependenciesKeyword } from "./keywords/dependencies";
 import { dependentRequiredKeyword } from "./keywords/dependentRequired";
 import { dependentSchemasKeyword } from "./keywords/dependentSchemas";
+import { deprecatedKeyword } from "./keywords/deprecated";
 import { enumKeyword } from "./keywords/enum";
+import { errors } from "./errors/errors";
 import { exclusiveMaximumKeyword } from "./keywords/exclusiveMaximum";
 import { exclusiveMinimumKeyword } from "./keywords/exclusiveMinimum";
 import { formatKeyword } from "./keywords/format";
+import { formats } from "./formats/formats";
+import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
+import { getData } from "./draft2019-09/methods/getData";
 import { ifKeyword } from "./keywords/ifthenelse";
 import { itemsKeyword } from "./draft2019-09/keywords/items";
 import { maximumKeyword } from "./keywords/maximum";
@@ -29,19 +36,13 @@ import { patternKeyword } from "./keywords/pattern";
 import { patternPropertiesKeyword } from "./keywords/patternProperties";
 import { propertiesKeyword } from "./keywords/properties";
 import { propertyNamesKeyword } from "./keywords/propertyNames";
-import { $refKeyword } from "./draft2019-09/keywords/$ref";
 import { requiredKeyword } from "./keywords/required";
 import { sanitizeKeywords } from "./Draft";
+import { toDataNodes } from "./methods/toDataNodes";
 import { typeKeyword } from "./keywords/type";
 import { unevaluatedItemsKeyword } from "./draft2019-09/keywords/unevaluatedItems";
 import { unevaluatedPropertiesKeyword } from "./keywords/unevaluatedProperties";
 import { uniqueItemsKeyword } from "./keywords/uniqueItems";
-import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
-import { getData } from "./draft2019-09/methods/getData";
-import { toDataNodes } from "./methods/toDataNodes";
-import { createSchema } from "./methods/createSchema";
-import { errors } from "./errors/errors";
-import { formats } from "./formats/formats";
 
 /**
  * @draft-2019 https://json-schema.org/draft/2019-09/release-notes
@@ -79,6 +80,7 @@ export const draft2019 = sanitizeKeywords({
         dependenciesKeyword, // optional support for old draft-version
         dependentRequiredKeyword, // draft-2019: new
         dependentSchemasKeyword, // draft-2019: new
+        deprecatedKeyword,
         enumKeyword,
         exclusiveMaximumKeyword,
         exclusiveMinimumKeyword,

package/src/draft2020.ts

@@ -1,17 +1,21 @@
+import { $defsKeyword } from "./keywords/$defs";
+import { $refKeyword } from "./keywords/$ref";
 import { additionalPropertiesKeyword } from "./keywords/additionalProperties";
 import { allOfKeyword } from "./keywords/allOf";
 import { anyOfKeyword } from "./keywords/anyOf";
 import { constKeyword } from "./keywords/const";
 import { containsKeyword } from "./keywords/contains";
-import { $defsKeyword } from "./keywords/$defs";
+import { createSchema } from "./methods/createSchema";
 import { dependenciesKeyword } from "./keywords/dependencies";
 import { dependentRequiredKeyword } from "./keywords/dependentRequired";
 import { dependentSchemasKeyword } from "./keywords/dependentSchemas";
-import { toDataNodes } from "./methods/toDataNodes";
+import { deprecatedKeyword } from "./keywords/deprecated";
 import { enumKeyword } from "./keywords/enum";
+import { errors } from "./errors/errors";
 import { exclusiveMaximumKeyword } from "./keywords/exclusiveMaximum";
 import { exclusiveMinimumKeyword } from "./keywords/exclusiveMinimum";
 import { formatKeyword } from "./keywords/format";
+import { formats } from "./formats/formats";
 import { getChildSelection } from "./methods/getChildSelection";
 import { getData } from "./methods/getData";
 import { ifKeyword } from "./keywords/ifthenelse";
@@ -32,16 +36,13 @@ import { patternPropertiesKeyword } from "./keywords/patternProperties";
 import { prefixItemsKeyword } from "./keywords/prefixItems";
 import { propertiesKeyword } from "./keywords/properties";
 import { propertyNamesKeyword } from "./keywords/propertyNames";
-import { $refKeyword } from "./keywords/$ref";
 import { requiredKeyword } from "./keywords/required";
 import { sanitizeKeywords } from "./Draft";
+import { toDataNodes } from "./methods/toDataNodes";
 import { typeKeyword } from "./keywords/type";
 import { unevaluatedItemsKeyword } from "./keywords/unevaluatedItems";
 import { unevaluatedPropertiesKeyword } from "./keywords/unevaluatedProperties";
 import { uniqueItemsKeyword } from "./keywords/uniqueItems";
-import { createSchema } from "./methods/createSchema";
-import { errors } from "./errors/errors";
-import { formats } from "./formats/formats";
 
 /**
  * @draft-2020-12 https://json-schema.org/draft/2020-12/release-notes
@@ -90,6 +91,7 @@ export const draft2020 = sanitizeKeywords({
         dependenciesKeyword,
         dependentRequiredKeyword,
         dependentSchemasKeyword,
+        deprecatedKeyword,
         enumKeyword,
         exclusiveMaximumKeyword,
         exclusiveMinimumKeyword,

package/src/errors/errors.ts

@@ -71,5 +71,7 @@ export const errors = {
     "unique-items-error":
         "Items in array must be unique. Value `{{value}}` in `{{pointer}}` is a duplicate of {{duplicatePointer}}.",
     "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}}`"
+    "value-not-empty-error": "A value for `{{property}}` is required at `{{pointer}}`",
+    // annotations
+    "deprecated-warning": "Value at `{{pointer}}` is deprecated"
 };

package/src/formats/formats.ts

@@ -1,9 +1,8 @@
 /* eslint-disable no-control-regex */
 import { getTypeOf } from "../utils/getTypeOf";
 import validUrl from "valid-url";
-import { JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { parse as parseIdnEmail } from "smtp-address-parser";
-import { JsonError } from "../types";
 import settings from "../settings";
 
 const { REGEX_FLAGS } = settings;
@@ -27,10 +26,7 @@ const isValidURITemplate =
 const isValidDurationString = /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/;
 
 // Default Json-Schema formats: date-time, email, hostname, ipv4, ipv6, uri, uriref
-export const formats: Record<
-    string,
-    (options: JsonSchemaValidatorParams) => undefined | JsonError | ValidationResult[]
-> = {
+export const formats: Record<string, (options: JsonSchemaValidatorParams) => ValidationReturnType> = {
     date: ({ node, pointer, data }) => {
         const { schema } = node;
         if (typeof data !== "string" || data === "") {

package/src/keywords/additionalProperties.ts

@@ -1,6 +1,6 @@
 import settings from "../settings";
 import { isObject } from "../utils/isObject";
-import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType} from "../Keyword";
 import { SchemaNode } from "../types";
 import { getValue } from "../utils/getValue";
 import { validateNode } from "../validateNode";
@@ -65,7 +65,7 @@ function validateAdditionalProperty({ node, data, pointer = "#", path }: JsonSch
     }
 
     const { schema } = node;
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     let receivedProperties = Object.keys(data).filter((prop) => settings.propertyBlacklist.includes(prop) === false);
     const patternProperties = node.patternProperties;
     if (Array.isArray(patternProperties)) {

package/src/keywords/allOf.ts

@@ -1,5 +1,5 @@
 import { mergeSchema } from "../utils/mergeSchema";
-import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 
@@ -55,7 +55,7 @@ function validateAllOf({ node, data, pointer, path }: JsonSchemaValidatorParams)
     if (!Array.isArray(node.allOf) || node.allOf.length === 0) {
         return;
     }
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     node.allOf.forEach((allOfNode) => {
         errors.push(...validateNode(allOfNode, data, pointer, path));
     });

package/src/keywords/dependencies.ts

@@ -1,10 +1,11 @@
 import { isSchemaNode, SchemaNode } from "../types";
-import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { isObject } from "../utils/isObject";
 import { mergeNode } from "../mergeNode";
 import { hasProperty } from "../utils/hasProperty";
 import { validateDependentRequired } from "./dependentRequired";
 import { validateDependentSchemas } from "./dependentSchemas";
+import sanitizeErrors from "../utils/sanitizeErrors";
 
 export const dependenciesKeyword: Keyword = {
     id: "dependencies",
@@ -125,15 +126,13 @@ function validateDependencies({ node, data, pointer, path }: JsonSchemaValidator
     if (!isObject(data)) {
         return undefined;
     }
-    let errors: ValidationResult[] = [];
+    const errors: ValidationAnnotation[] = [];
     if (node.dependentRequired) {
-        errors = validateDependentRequired({ node, data, pointer, path }) ?? [];
+        sanitizeErrors(validateDependentRequired({ node, data, pointer, path }), errors);
     }
     if (node.dependentSchemas) {
         const schemaErrors = validateDependentSchemas({ node, data, pointer, path });
-        if (schemaErrors) {
-            errors.push(...schemaErrors);
-        }
+        sanitizeErrors(schemaErrors, errors);
     }
     return errors;
 }

package/src/keywords/dependentRequired.ts

@@ -1,4 +1,4 @@
-import { Keyword, JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { JsonError, SchemaNode } from "../types";
 import { isObject } from "../utils/isObject";
 
@@ -21,7 +21,7 @@ export function validateDependentRequired({
     node,
     data,
     pointer = "#"
-}: JsonSchemaValidatorParams): undefined | ValidationResult[] {
+}: JsonSchemaValidatorParams): ValidationReturnType {
     if (!isObject(data)) {
         return undefined;
     }

package/src/keywords/dependentSchemas.ts

@@ -1,8 +1,9 @@
 import { mergeSchema } from "../utils/mergeSchema";
 import { isObject } from "../utils/isObject";
 import { isSchemaNode, SchemaNode, JsonSchema } from "../types";
-import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { validateNode } from "../validateNode";
+import sanitizeErrors from "../utils/sanitizeErrors";
 
 export const dependentSchemasKeyword: Keyword = {
     id: "dependentSchemas",
@@ -78,7 +79,7 @@ export function validateDependentSchemas({ node, data, pointer, path }: JsonSche
     if (!isObject(data) || dependentSchemas == null) {
         return undefined;
     }
-    const errors: ValidationResult[] = [];
+    const errors: ValidationAnnotation[] = [];
     Object.keys(data).forEach((property) => {
         const dependencies = dependentSchemas[property];
         // @draft >= 6 boolean schema
@@ -90,7 +91,7 @@ export function validateDependentSchemas({ node, data, pointer, path }: JsonSche
             return;
         }
         if (isSchemaNode(dependencies)) {
-            errors.push(...validateNode(dependencies, data, pointer, path));
+            sanitizeErrors(validateNode(dependencies, data, pointer, path), errors);
             return;
         }
     });

package/src/keywords/deprecated.ts

@@ -0,0 +1,18 @@
+import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
+
+export const deprecatedKeyword: Keyword = {
+    id: "deprecated",
+    keyword: "deprecated",
+    addValidate: ({ schema }) => schema.deprecated === true,
+    validate: validateDeprecated
+};
+
+function validateDeprecated({ node, data, pointer }: JsonSchemaValidatorParams) {
+    return [
+        node.createAnnotation("deprecated-warning", {
+            pointer,
+            schema: node.schema,
+            value: data
+        })
+    ];
+}

package/src/keywords/items.ts

@@ -1,4 +1,4 @@
-import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationResult } from "../Keyword";
+import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { SchemaNode } from "../types";
 import { isObject } from "../utils/isObject";
 import { validateNode } from "../validateNode";
@@ -52,7 +52,7 @@ function validateItems({ node, data, pointer = "#", path }: JsonSchemaValidatorP
         return node.createError("invalid-data-error", { pointer, value: data, schema });
     }
 
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     if (node.items) {
         for (let i = schema.prefixItems?.length ?? 0; i < data.length; i += 1) {
             const itemData = data[i];

package/src/keywords/oneOf.test.ts

@@ -3,6 +3,7 @@ import { compileSchema } from "../compileSchema";
 import { isJsonError } 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$" },
@@ -377,3 +378,137 @@ describe("keyword : oneof-property : reduce", () => {
         });
     });
 });
+
+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");
+    });
+});

package/src/keywords/oneOf.ts

@@ -3,7 +3,7 @@ import {
     JsonSchemaReducerParams,
     JsonSchemaValidatorParams,
     ValidationPath,
-    ValidationResult
+    ValidationReturnType
 } from "../Keyword";
 import { isSchemaNode, SchemaNode } from "../types";
 import settings from "../settings";
@@ -57,7 +57,7 @@ function reduceOneOf({ node, data, pointer, path }: Omit<JsonSchemaReducerParams
     }
 
     const matches: { index: number; node: SchemaNode }[] = [];
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType[] = [];
     for (let i = 0; i < node.oneOf.length; i += 1) {
         const validationErrors = validateNode(node.oneOf[i], data, pointer, path);
         if (validationErrors.length === 0) {
@@ -106,7 +106,7 @@ export function reduceOneOfDeclarator({ node, data, pointer, path }: Omit<JsonSc
         return;
     }
 
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     const oneOfProperty = node.schema[DECLARATOR_ONEOF];
     const oneOfValue = getValue(data, oneOfProperty);
 
@@ -236,13 +236,73 @@ export function reduceOneOfFuzzy({ node, data, pointer, path }: Omit<JsonSchemaR
     return oneOfResult;
 }
 
+function validateFromDeclarator({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {
+    const { oneOf, schema } = node;
+    if (!oneOf) {
+        return;
+    }
+
+    // with a declarator we only validate by a declarator to retrieve matches.
+    // - if a single match was found, we return validation errors if any
+    // - if no match was found we return a one-of-error
+    // - if multiples matches were found we return a multiple-one-of-error
+    const oneOfProperty = schema[DECLARATOR_ONEOF];
+    const oneOfValue = getValue(data, oneOfProperty);
+    const matches: { index: number; node: SchemaNode }[] = [];
+    const errors: ValidationReturnType = [];
+    for (const oneOfNode of oneOf) {
+        const { node: oneOfPropertyNode, error } = oneOfNode.getNodeChild(oneOfProperty, oneOfValue);
+        if (oneOfPropertyNode) {
+            const validationResult = validateNode(oneOfPropertyNode, oneOfValue, `${pointer}/${oneOfProperty}`, path);
+            if (validationResult.length > 0) {
+                errors.push(...validationResult);
+            } else {
+                matches.push({ index: oneOf.indexOf(oneOfNode), node: oneOfNode });
+            }
+        } else {
+            console.log(
+                `jlib oneOf error: failed getting schema for '${oneOfProperty}' to resolve ${DECLARATOR_ONEOF} in ${pointer}/oneOf/${oneOf.indexOf(oneOfNode)}`,
+                error
+            );
+        }
+    }
+
+    if (matches.length === 1) {
+        const match = matches[0];
+        match.node.oneOfIndex = match.index; // @evaluation-info
+        return validateNode(match.node, data, pointer, path);
+    }
+
+    if (matches.length > 1) {
+        return node.createError("multiple-one-of-error", {
+            value: data,
+            pointer,
+            schema,
+            matches
+        });
+    }
+
+    return node.createError("one-of-error", {
+        value: JSON.stringify(data),
+        pointer,
+        schema,
+        oneOf: schema.oneOf,
+        errors
+    });
+}
+
 function oneOfValidator({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {
     const { oneOf, schema } = node;
     if (!oneOf) {
         return;
     }
+
+    if (schema[DECLARATOR_ONEOF]) {
+        return validateFromDeclarator({ node, data, pointer, path });
+    }
+
     const matches: { index: number; node: SchemaNode }[] = [];
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     for (let i = 0; i < oneOf.length; i += 1) {
         const validationResult = validateNode(oneOf[i], data, pointer, path);
         if (validationResult.length > 0) {