fix: issue#44 merging unresolved allOf statements

Author: Sascha Goldhofer

lib/features/allOf.ts

@@ -38,6 +38,7 @@ export function resolveAllOf(
 }
 
 /**
+ * @attention: subschemas have to be resolved upfront (e.g. if-else that do not apply)
  * Merge all allOf sub schema into a single schema. Returns undefined for
  * missing allOf definition.
  *

lib/features/if.ts

@@ -16,9 +16,13 @@ export function resolveIfSchema(
     schema: JsonSchema,
     data: unknown
 ): JsonSchema | undefined {
+    if (schema.if == null) {
+        return undefined;
+    }
     if (schema.if === false) {
         return schema.else;
     }
+
     if (schema.if && (schema.then || schema.else)) {
         const ifErrors = draft.validate(data, draft.resolveRef(schema.if));
         if (ifErrors.length === 0 && schema.then) {

lib/resolveDynamicSchema.ts

@@ -54,9 +54,25 @@ export function resolveDynamicSchema(
     }
 
     // @feature allOf
-    const allOfSchema = mergeAllOfSchema(draft, schema);
-    if (allOfSchema) {
-        resolvedSchema = mergeSchema(resolvedSchema ?? {}, allOfSchema);
+    if (Array.isArray(schema.allOf)) {
+        const allOf = schema.allOf.map((s) => {
+            // before merging allOf schema we need to resolve all subschemas
+            // if not, we would wrongly merge oneOf, if-then statements, etc
+            if (isDynamicSchema(s)) {
+                // copy of reduceSchema
+                let result = resolveDynamicSchema(draft, s, data, pointer);
+                if (result) {
+                    result = mergeSchema(s, result);
+                    return omit(result, ...toOmit);
+                }
+                return undefined;
+            }
+            return s;
+        });
+        if (allOf.length > 0) {
+            const allOfSchema = mergeAllOfSchema(draft, { allOf });
+            resolvedSchema = mergeSchema(resolvedSchema ?? {}, allOfSchema);
+        }
     }
 
     // @feature anyOf

test/unit/issues/issue44.chainedNegLogic.test.ts

@@ -0,0 +1,63 @@
+import { expect } from "chai";
+import { Draft07 as Draft } from "../../../lib/draft07";
+
+describe("issue#44 - chained negative logic", () => {
+    let draft: Draft;
+    beforeEach(() => {
+        draft = new Draft({
+            type: "object",
+            properties: {
+                animal_species: {
+                    enum: ["cat", "eagle"]
+                },
+                diet_type: {
+                    enum: ["carnivore", "omnivore"]
+                },
+                habitat_type: {
+                    enum: ["forest", "mountain"]
+                }
+            },
+            allOf: [
+                {
+                    if: {
+                        not: {
+                            properties: {
+                                animal_species: { const: "cat" }
+                            }
+                        }
+                    },
+                    then: {
+                        properties: {
+                            diet_type: { const: "carnivore" }
+                        }
+                    }
+                },
+                {
+                    if: {
+                        not: {
+                            properties: {
+                                diet_type: { const: "carnivore" },
+                                animal_species: { const: "cat" }
+                            }
+                        }
+                    },
+                    then: {
+                        properties: {
+                            habitat_type: { const: "mountain" }
+                        }
+                    }
+                }
+            ]
+        });
+    });
+
+    it("should validate input data", () => {
+        const errors = draft.validate({
+            animal_species: "cat",
+            diet_type: "omnivore",
+            habitat_type: "mountain"
+        });
+
+        expect(errors).to.have.length(0);
+    });
+});

test/unit/reduceSchema.test.ts

@@ -6,6 +6,54 @@ describe("reduceSchema", () => {
     let draft: Draft;
     beforeEach(() => (draft = new Draft()));
 
+    describe("allOf", () => {
+        it("should iteratively resolve allOf before merging (issue#44)", () => {
+            const staticSchema = reduceSchema(
+                draft,
+                {
+                    type: "object",
+                    properties: {
+                        trigger: { type: "boolean" }
+                    },
+                    allOf: [
+                        {
+                            if: {
+                                not: {
+                                    properties: {
+                                        trigger: { type: "boolean", const: true }
+                                    }
+                                }
+                            },
+                            then: {
+                                properties: {
+                                    trigger: { type: "boolean", const: false }
+                                }
+                            }
+                        },
+                        {
+                            if: {
+                                not: {
+                                    properties: {
+                                        trigger: { type: "boolean", const: false }
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                },
+                { trigger: true },
+                "#"
+            );
+
+            assert.deepEqual(staticSchema, {
+                type: "object",
+                properties: {
+                    trigger: { type: "boolean" }
+                }
+            });
+        });
+    });
+
     describe("oneOf", () => {
         it("should return oneOf source schema for resolved oneOf object", () => {
             const staticSchema = reduceSchema(

test/unit/resolveAllOf.test.ts

@@ -165,6 +165,7 @@ describe("resolveAllOf", () => {
                 }
             });
         });
+
         it("should return 'then'-schema when 'if' does match", () => {
             const schema = resolveAllOf(
                 draft,
@@ -200,6 +201,7 @@ describe("resolveAllOf", () => {
                 }
             });
         });
+
         it("should merge multiple 'then'-schema", () => {
             const schema = resolveAllOf(
                 draft,