Unions in intersections still generate with `"additionalProperties": false`

[rijenkii]

See also: #64, #65.

Reproduction:

const left = z.union([
  z.object({ field1: z.number() }),
  z.object({ field3: z.string() }),
]);
const right = z.object({ field2: z.boolean() });
const intersection = z.intersection(left, right);
const schema = zodToJsonSchema(intersection);

Generates the following schema:

{
  "allOf": [
    {
      "anyOf": [
        {
          "type": "object",
          "properties": { "field1": { "type": "number" } },
          "required": ["field1"],
          "additionalProperties": false
        },
        {
          "type": "object",
          "properties": { "field3": { "type": "string" } },
          "required": ["field3"],
          "additionalProperties": false
        }
      ]
    },
    {
      "type": "object",
      "properties": { "field2": { "type": "boolean" } },
      "required": ["field2"]
    }
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Because of "additionalProperties": false, no object can be successfully validated against this schema:
https://www.jsonschemavalidator.net/s/ddO3vtM2

Compared to schema with removed additionalProperties:
https://www.jsonschemavalidator.net/s/UO8HV6Lz

[ilyabo]

We are experiencing the same issue. Is there a known workaround?

[rijenkii]

Currently I'm just removing additionalProperties: false from generated schemas:

function deepRemoveKeys(obj, exclude) {
  if (obj instanceof Array) {
    return obj.map((i) => deepRemoveKeys(i, exclude));
  }
  if (typeof obj === "object") {
    return Object.fromEntries(
      Object.entries(obj)
        .filter(
          ([k, v]) => !(k in exclude && (exclude[k] === undefined || exclude[k] === v))
        )
        .map(([k, v]) => [k, deepRemoveKeys(v, exclude)])
    );
  }
  return obj;
}

const schema = deepRemoveKeys(zodToJsonSchema(obj), { additionalProperties: false });

[felixgaschi]

I'm just adding a comment because the proposed workaround did not work for my specific case (but seems to be accurate for most cases though).

The zod union only parses the first of provided clauses, so if you provide both field1 and field3 to the zod schema provided by OP or add any random field (e.g. {"field1": 1, "field3": "A", "field2": true, "random_field": "hello world"}) only one of those fields will be parsed ({"field1": 1, "field2": true}).

So if you don't want to throw an error when both field1 and field3 or any other additional random field are provided, you can use the already provided workaround. However, if you need to throw an error in those cases, one option is to use oneOf like this:

{
  "type": "object",
  "properties": {
    "field1": {"type": "number"},
    "field2": {"type": "boolean"},
    "field3": {"type": "string"}
  },
  "required": ["field2"],
  "oneOf": [
    {"required": ["field1"]},
    {"required": ["field3"]}
  ]
  "additionalProperties": false
}

This will only allow objects with "field2" and either "field1" and "field3", disallowing any other random field.

To allow both "field1" and "field3" (while still disallowing random fields), one simply needs to replace "oneOf" with "anyOf".

Sadly this is specific to translating intersection of union. I don't know if there is some general solution if you want to be strict and disallow with JSON Schema any field that wouldn't be returned by zod.

[rijenkii]

fwif zod 4 has its own toJSONSchema function now, and it does not have this problem with my reproduction anymore:

{
  "allOf": [
    {
      "oneOf": [
        {
          "type": "object",
          "properties": { "field1": { "type": "number" } },
          "required": ["field1"]
        },
        {
          "type": "object",
          "properties": { "field3": { "type": "string" } },
          "required": ["field3"]
        }
      ]
    },
    {
      "type": "object",
      "properties": { "field2": { "type": "boolean" } },
      "required": ["field2"]
    }
  ]
}

[rijenkii]

Also,

However, if you need to throw an error [if you provide both field1 and field3 to the zod schema provided by OP]

This is just how zod works, if you want field1 OR field3, but explicitly NOT field1 AND field3, then do this:

const left = z.union([
  z.object({ field1: z.number(), field3: z.never().optional() }),
  z.object({ field3: z.string(), field1: z.never().optional() }),
]);