introduce: $ref-reducer

Author: sagold

src/SchemaNode.ts

@@ -338,9 +338,8 @@ export const SchemaNodeMethods = {
         data: unknown,
         options: { key?: string | number; pointer?: string; path?: ValidationPath } = {}
     ): OptionalNodeAndError {
+        const node = this as SchemaNode;
         const { key, pointer, path } = options;
-        const resolvedNode = { ...this.resolveRef({ pointer, path }) } as SchemaNode;
-        const node = mergeNode(this, resolvedNode, "$ref");
 
         // @ts-expect-error bool schema
         if (node.schema === false) {
@@ -353,10 +352,12 @@ export const SchemaNodeMethods = {
         }
 
         let schema;
-        let workingNode = node;
+        // we need to copy node to prevent modification of source
+        // @todo does mergeNode break immutability?
+        let workingNode = node.compileSchema(node.schema, node.spointer, node.schemaId);
         const reducers = node.reducers;
         for (let i = 0; i < reducers.length; i += 1) {
-            const result = reducers[i]({ data, key, node, pointer });
+            const result = reducers[i]({ data, key, node, pointer, path });
             if (isJsonError(result)) {
                 return { node: undefined, error: result };
             }
@@ -374,7 +375,6 @@ export const SchemaNodeMethods = {
         }
 
         if (schema === false) {
-            console.log("return boolean schema `false`");
             // @ts-expect-error bool schema
             return { node: { ...node, schema: false, reducers: [] } as SchemaNode, error: undefined };
         }

src/compileSchema.getChild.test.ts

@@ -156,6 +156,7 @@ describe("compileSchema : reduceSchema", () => {
                     }
                 }
             }).reduceSchema({ one: "" });
+
             assert.deepEqual(node.schema, {
                 type: "object",
                 required: ["one", "two", "three"],
@@ -677,6 +678,49 @@ describe("compileSchema : reduceSchema", () => {
         });
     });
 
+    describe("$ref", () => {
+        it("should resolve to $ref referenced schema", () => {
+            const { node } = compileSchema({
+                $ref: "/$defs/one",
+                $defs: {
+                    one: { type: "boolean", title: "one" }
+                }
+            }).reduceSchema(3);
+
+            assert.deepEqual(node.schema, { type: "boolean", title: "one" });
+        });
+
+        it("should resolve to multiple $ref referenced schema", () => {
+            const { node } = compileSchema({
+                $ref: "/$defs/one",
+                $defs: {
+                    one: { $ref: "/$defs/two" },
+                    two: { type: "boolean", title: "two" }
+                }
+            }).reduceSchema(3);
+
+            assert.deepEqual(node.schema, { type: "boolean", title: "two" });
+        });
+
+        it("should merge nested sub-schema", () => {
+            const { node } = compileSchema({
+                $ref: "/$defs/one",
+                description: "from root",
+                $defs: {
+                    one: { default: "from one", $ref: "/$defs/two" },
+                    two: { type: "boolean", title: "from two" }
+                }
+            }).reduceSchema(3);
+
+            assert.deepEqual(node.schema, {
+                description: "from root",
+                default: "from one",
+                title: "from two",
+                type: "boolean"
+            });
+        });
+    });
+
     describe("dynamicId", () => {
         it("should add dynamicId based on merge anyOf schema", () => {
             const { node } = compileSchema({

src/compileSchema.reduceSchema.test.ts

@@ -748,6 +748,62 @@ describe("compileSchema.validate", () => {
         });
     });
 
+    describe("unavaluatedProperties", () => {
+        let node: SchemaNode;
+        beforeEach(
+            () =>
+                (node = compileSchema({
+                    $schema: "https://json-schema.org/draft/2020-12/schema",
+                    $defs: {
+                        one: {
+                            oneOf: [
+                                { $ref: "#/$defs/two" },
+                                { required: ["b"], properties: { b: true } },
+                                {
+                                    required: ["xx"],
+                                    patternProperties: {
+                                        x: true
+                                    }
+                                },
+                                {
+                                    required: ["all"],
+                                    unevaluatedProperties: true
+                                }
+                            ]
+                        },
+                        two: {
+                            oneOf: [
+                                {
+                                    required: ["c"],
+                                    properties: {
+                                        c: true
+                                    }
+                                },
+                                {
+                                    required: ["d"],
+                                    properties: {
+                                        d: true
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    oneOf: [{ $ref: "#/$defs/one" }, { required: ["a"], properties: { a: true } }],
+                    unevaluatedProperties: false
+                }))
+        );
+
+        it("`all` is valid", () => {
+            const { errors } = node.validate({ all: 1 });
+            assert(errors.length === 0);
+        });
+
+        it("`all` and `foo` is valid", () => {
+            const { errors } = node.validate({ all: 1, foo: 1 });
+            assert(errors.length === 0);
+        });
+    });
+
     describe("recursiveRef (spec)", () => {
         describe("$recursiveRef without using nesting", () => {
             it("integer does not match as a property value", () => {

src/compileSchema.validate.test.ts

@@ -6,13 +6,16 @@ import { isObject } from "../../utils/isObject";
 import { validateNode } from "../../validateNode";
 import { SchemaNode } from "../../types";
 import { get } from "@sagold/json-pointer";
+import { reduceRef } from "../../keywords/$ref";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
     keyword: "$ref",
     parse: parseRef,
     addValidate: ({ schema }) => schema.$ref != null || schema.$recursiveRef != null,
-    validate: validateRef
+    validate: validateRef,
+    addReduce: ({ schema }) => schema.$ref != null || schema.$recursiveRef != null,
+    reduce: reduceRef
 };
 
 function register(node: SchemaNode, path: string) {
@@ -54,10 +57,23 @@ export function parseRef(node: SchemaNode) {
     }
 }
 
+// export function reduceRef({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
+//     const resolvedNode = node.resolveRef({ pointer, path });
+//     if (resolvedNode.schemaId === node.schemaId) {
+//         return resolvedNode;
+//     }
+//     const result = resolvedNode.reduceSchema(data, { key, pointer, path });
+//     return result.node ?? result.error;
+//     // const merged = mergeNode({ ...node, $ref: undefined, schema: { ...node.schema, $ref: undefined } }, resolvedNode);
+//     // const { node: reducedNode, error } = merged.reduceSchema(data, { key, pointer, path });
+//     // return reducedNode ?? error;
+// }
+
 export function resolveRef({ pointer, path }: { pointer?: string; path?: ValidationPath } = {}) {
     const node = this as SchemaNode;
     if (node.schema.$recursiveRef) {
         const nextNode = resolveRecursiveRef(node, path);
+        console.log("recursive ref:", nextNode.schema);
         path?.push({ pointer, node: nextNode });
         return nextNode;
     }

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

@@ -48,6 +48,15 @@ export function isItemEvaluated({ node, data, key, pointer, path }: Options) {
             }
         }
     }
+
+    if (node.oneOf) {
+        for (let i = 0; i < node.oneOf.length; i += 1) {
+            if (isItemEvaluated({ node: node.oneOf[i], data, key, pointer, path })) {
+                return true;
+            }
+        }
+    }
+
     if (node.if) {
         if (isItemEvaluated({ node: node.if, data, key, pointer, path })) {
             return true;

src/isItemEvaluated.ts

@@ -0,0 +1,93 @@
+import { ValidationPath } from "./Keyword";
+import { SchemaNode } from "./types";
+import { hasProperty } from "./utils/hasProperty";
+// import { getValue } from "./utils/getValue";
+import { validateNode } from "./validateNode";
+
+type Options = {
+    /** array node */
+    node: SchemaNode;
+    /** array data */
+    data: Record<string, unknown>;
+    /** array index to evaluate */
+    key: string;
+    /** pointer to array */
+    pointer: string;
+
+    path: ValidationPath;
+};
+
+/**
+ * Returns true if an item is evaluated
+ *
+ * - Note that this check is partial, the remainder is done in unevaluatedItems
+ * - This function currently checks for schema that are not visible by simple validation
+ * - We could introduce this method as a new keyword-layer
+ */
+export function isPropertyEvaluated({ node, data, key, pointer, path }: Options) {
+    if (Array.isArray(node.schema.required) && !node.schema.required.find((prop) => hasProperty(data, prop))) {
+        return false;
+    }
+
+    if (node.schema.unevaluatedProperties === true || node.schema.additionalProperties === true) {
+        return true;
+    }
+
+    if (node.properties?.[key] && node.properties[key].validate(data[key], pointer, path).valid) {
+        return true;
+    }
+
+    if (node.patternProperties && node.patternProperties.find((p) => p.pattern.test(key))) {
+        return true;
+    }
+
+    if (node.allOf) {
+        for (let i = 0; i < node.allOf.length; i += 1) {
+            if (isPropertyEvaluated({ node: node.allOf[i], data, key, pointer, path })) {
+                return true;
+            }
+        }
+    }
+
+    if (node.anyOf) {
+        for (let i = 0; i < node.anyOf.length; i += 1) {
+            if (isPropertyEvaluated({ node: node.anyOf[i], data, key, pointer, path })) {
+                return true;
+            }
+        }
+    }
+
+    if (node.oneOf) {
+        for (let i = 0; i < node.oneOf.length; i += 1) {
+            if (isPropertyEvaluated({ node: node.oneOf[i], data, key, pointer, path })) {
+                return true;
+            }
+        }
+    }
+
+    if (node.if) {
+        if (isPropertyEvaluated({ node: node.if, data, key, pointer, path })) {
+            return true;
+        }
+
+        const validIf = validateNode(node.if, data, pointer, path).length === 0;
+        if (validIf && node.then) {
+            if (isPropertyEvaluated({ node: node.then, data, key, pointer, path })) {
+                return true;
+            }
+        } else if (!validIf && node.else) {
+            if (isPropertyEvaluated({ node: node.else, data, key, pointer, path })) {
+                return true;
+            }
+        }
+    }
+
+    const resolved = node.resolveRef({ pointer, path });
+    if (resolved !== node) {
+        if (isPropertyEvaluated({ node: resolved, data, key, pointer, path })) {
+            return true;
+        }
+    }
+
+    return false;
+}

src/isPropertyEvaluated.ts

@@ -1,16 +1,20 @@
 import { SchemaNode } from "../types";
-import { Keyword, JsonSchemaValidatorParams, ValidationPath } from "../Keyword";
+import { Keyword, JsonSchemaValidatorParams, ValidationPath, JsonSchemaReducerParams } from "../Keyword";
 import { joinId } from "../utils/joinId";
 import splitRef from "../utils/splitRef";
 import { omit } from "../utils/omit";
 import { isObject } from "../utils/isObject";
 import { validateNode } from "../validateNode";
 import { get, split } from "@sagold/json-pointer";
+import { mergeNode } from "../mergeNode";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
     keyword: "$ref",
+    order: 10,
     parse: parseRef,
+    addReduce: (node) => node.$ref != null || node.schema.$dynamicRef != null,
+    reduce: reduceRef,
     addValidate: ({ schema }) => schema.$ref != null || schema.$dynamicRef != null,
     validate: validateRef
 };
@@ -69,11 +73,21 @@ export function parseRef(node: SchemaNode) {
     }
 }
 
+export function reduceRef({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
+    const resolvedNode = node.resolveRef({ pointer, path });
+    if (resolvedNode.schemaId === node.schemaId) {
+        return resolvedNode;
+    }
+    const merged = mergeNode(node, resolvedNode);
+    const { node: reducedNode, error } = merged.reduceSchema(data, { key, pointer, path });
+    return reducedNode ?? error;
+}
+
 export function resolveRef({ pointer, path }: { pointer?: string; path?: ValidationPath } = {}) {
     const node = this as SchemaNode;
+
     if (node.schema.$dynamicRef) {
         const nextNode = resolveRecursiveRef(node, path);
-        // console.log("resolved node", node.schema.$dynamicRef, "=>", nextNode != null);
         path?.push({ pointer, node: nextNode });
         return nextNode;
     }
@@ -85,8 +99,6 @@ export function resolveRef({ pointer, path }: { pointer?: string; path?: Validat
     const resolvedNode = getRef(node);
     if (resolvedNode != null) {
         path?.push({ pointer, node: resolvedNode });
-    } else {
-        // console.log("failed resolving", node.$ref, "from", Object.keys(node.context.refs));
     }
     return resolvedNode;
 }
@@ -103,9 +115,6 @@ function validateRef({ node, data, pointer = "#", path }: JsonSchemaValidatorPar
 function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode {
     const history = path;
     const refInCurrentScope = joinId(node.$id, node.schema.$dynamicRef);
-    // console.log("resolve $dynamicRef:", node.schema.$dynamicRef);
-    // console.log(" -> scope:", joinId(node.$id, node.schema.$dynamicRef));
-    // console.log("dynamicAnchors", Object.keys(node.context.dynamicAnchors));
 
     // A $dynamicRef with a non-matching $dynamicAnchor in the same schema resource behaves like a normal $ref to $anchor
     const nonMatchingDynamicAnchor = node.context.dynamicAnchors[refInCurrentScope] == null;
@@ -131,7 +140,7 @@ function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode
     }
 
     // A $dynamicRef without a matching $dynamicAnchor in the same schema resource behaves like a normal $ref to $anchor
-    // console.log(" -> resolve as ref");
+
     const nextNode = getRef(node, refInCurrentScope);
     return nextNode;
 }

src/keywords/$ref.ts

@@ -22,13 +22,13 @@ export function parseAllOf(node: SchemaNode) {
     }
 }
 
-function reduceAllOf({ node, data }: JsonSchemaReducerParams) {
+function reduceAllOf({ node, data, key, pointer, path }: JsonSchemaReducerParams) {
     // note: parts of schemas could be merged, e.g. if they do not include
     // dynamic schema parts
     let mergedSchema = {};
     let dynamicId = "";
     for (let i = 0; i < node.allOf.length; i += 1) {
-        const { node: schemaNode } = node.allOf[i].reduceSchema(data);
+        const { node: schemaNode } = node.allOf[i].reduceSchema(data, { key, pointer, path });
         if (schemaNode) {
             const nestedDynamicId = schemaNode.dynamicId?.replace(node.dynamicId, "") ?? "";
             const localDynamicId = nestedDynamicId === "" ? `allOf/${i}` : nestedDynamicId;