Add handling for multiple intersected schemas and set unevaluatedProp…

…erties only if all allOf schemas have additionalProperties set to false

src/parsers/intersection.ts

@@ -1,12 +1,18 @@
 import { ZodIntersectionDef } from "zod";
 import { JsonSchema7Type, parseDef } from "../parseDef";
 import { Refs } from "../Refs";
+import { JsonSchema7StringType } from "./string";
 
 export type JsonSchema7AllOfType = {
   allOf: JsonSchema7Type[];
-  unevaluatedProperties: boolean;
+  unevaluatedProperties?: boolean;
 };
 
+const isJsonSchema7AllOfType = (type: JsonSchema7Type | JsonSchema7StringType): type is JsonSchema7AllOfType => {
+  if ("type" in type && type.type === "string") return false;
+  return 'allOf' in type;
+}
+
 export function parseIntersectionDef(
   def: ZodIntersectionDef,
   refs: Refs
@@ -20,16 +26,38 @@ export function parseIntersectionDef(
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "1"],
     }),
-  ].filter((x): x is JsonSchema7Type => !!x)
-    .map((schema) => {
+  ].filter((x): x is JsonSchema7Type => !!x);
+
+
+  let unevaluatedProperties: { unevaluatedProperties: boolean } | undefined = {unevaluatedProperties: false};
+  const mergedAllOf: JsonSchema7Type[] = []
+  // If either of the schemas is an allOf, merge them into a single allOf
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === undefined) {
+        // If on of the schemas has no unevaluatedProperties set,
+        // the merged schema should also have no unevaluatedProperties set
+        unevaluatedProperties = undefined;
+      }
+
+    } else {
+
+      let nestedSchema: JsonSchema7Type = schema
       if ('additionalProperties' in schema && schema.additionalProperties === false) {
         const {additionalProperties, ...rest} = schema;
-        return {
-          ...rest
-        };
+        nestedSchema = rest;
+      } else {
+        // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
+        unevaluatedProperties = undefined;
       }
-      return schema
-    });
+      mergedAllOf.push(nestedSchema);
 
-  return allOf.length ? {allOf, unevaluatedProperties: false} : undefined;
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : undefined;
 }

test/allParsers.test.ts

@@ -66,7 +66,6 @@ describe("All Parsers tests", () => {
               maxLength: 4,
             },
           ],
-          unevaluatedProperties: false,
         },
         literal: {
           type: "string",
@@ -391,7 +390,6 @@ describe("All Parsers tests", () => {
               maxLength: 4,
             },
           ],
-          unevaluatedProperties: false,
         },
         literal: {
           type: "string",

test/parsers/intersection.test.ts

@@ -19,7 +19,6 @@ describe("intersections", () => {
           maxLength: 3,
         },
       ],
-      unevaluatedProperties: false,
     });
   });
 
@@ -37,7 +36,6 @@ describe("intersections", () => {
           $ref: "#/allOf/0",
         },
       ],
-      unevaluatedProperties: false,
     });
   });
 
@@ -56,23 +54,152 @@ describe("intersections", () => {
         {
           properties: {
             foo: {
-              type: "string"
+              type: "string",
             }
           },
           required: ["foo"],
-          type: "object"
+          type: "object",
         },
         {
           properties: {
             bar: {
-              type: "string"
+              type: "string",
             }
           },
           required: ["bar"],
-          type: "object"
+          type: "object",
         }
       ],
       unevaluatedProperties: false,
     });
   });
+
+  it("should return `unevaluatedProperties` only if all sub-schemas has additionalProperties set to false", () => {
+    const schema1 = z.object({
+      foo: z.string()
+    });
+    const schema2 = z.object({
+      bar: z.string()
+    }).passthrough();
+    const intersection = z.intersection(schema1, schema2);
+    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      allOf: [
+        {
+          properties: {
+            foo: {
+              type: "string",
+            }
+          },
+          required: ["foo"],
+          type: "object",
+        },
+        {
+          properties: {
+            bar: {
+              type: "string",
+            }
+          },
+          required: ["bar"],
+          type: "object",
+          additionalProperties: true,
+        }
+      ],
+    });
+  });
+
+  it("should intersect multiple complex objects correctly", () => {
+    const schema1 = z.object({
+      foo: z.string()
+    });
+    const schema2 = z.object({
+      bar: z.string()
+    });
+    const schema3 = z.object({
+      baz: z.string()
+    });
+    const intersection = schema1.and(schema2).and(schema3);
+    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      allOf: [
+        {
+          properties: {
+            foo: {
+              type: "string",
+            }
+          },
+          required: ["foo"],
+          type: "object",
+        },
+        {
+          properties: {
+            bar: {
+              type: "string",
+            }
+          },
+          required: ["bar"],
+          type: "object",
+        },
+        {
+          properties: {
+            baz: {
+              type: "string",
+            }
+          },
+          required: ["baz"],
+          type: "object",
+        },
+      ],
+      unevaluatedProperties: false,
+    });
+  });
+
+  it("should return `unevaluatedProperties` only if all of the multiple sub-schemas has additionalProperties set to false", () => {
+    const schema1 = z.object({
+      foo: z.string()
+    });
+    const schema2 = z.object({
+      bar: z.string()
+    });
+    const schema3 = z.object({
+      baz: z.string()
+    }).passthrough();
+    const intersection = schema1.and(schema2).and(schema3);
+    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      allOf: [
+        {
+          properties: {
+            foo: {
+              type: "string",
+            }
+          },
+          required: ["foo"],
+          type: "object",
+        },
+        {
+          properties: {
+            bar: {
+              type: "string",
+            }
+          },
+          required: ["bar"],
+          type: "object",
+        },
+        {
+          additionalProperties: true,
+          properties: {
+            baz: {
+              type: "string",
+            }
+          },
+          required: ["baz"],
+          type: "object",
+        },
+      ]
+    });
+  });
 });