json-schema-library 11.0.0 → 11.0.2

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
@@ -236,11 +251,71 @@ 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: ValidationReturnType = [];
     for (let i = 0; i < oneOf.length; i += 1) {

package/src/keywords/prefixItems.ts

@@ -32,19 +32,10 @@ export function parseItems(node: SchemaNode) {
 }
 
 function validatePrefixItems({ node, data, pointer = "#", path }: JsonSchemaValidatorParams) {
-    // const { schema } = node;
     if (!Array.isArray(data) || data.length === 0) {
         return;
     }
 
-    // @draft >= 7 bool schema
-    // if (schema.items === false) {
-    //     if (Array.isArray(data) && data.length === 0) {
-    //         return undefined;
-    //     }
-    //     return node.createError("InvalidDataError", { pointer, value: data, schema });
-    // }
-
     const errors: ValidationReturnType = [];
     if (node.prefixItems) {
         // note: schema is valid when data does not have enough elements as defined by array-list

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());
     }