zod 4.1.3 → 4.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.1.3",
+  "version": "4.1.5",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -2059,11 +2059,11 @@ export const ZodFunction: core.$constructor<ZodFunction> = /*@__PURE__*/ core.$c
 );
 
 export function _function(): ZodFunction;
-export function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>>(params: {
+export function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
   input: In;
 }): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
 export function _function<
-  const In extends Array<core.$ZodType> = Array<core.$ZodType>,
+  const In extends ReadonlyArray<core.$ZodType>,
   const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut,
 >(params: {
   input: In;

package/src/v4/classic/tests/function.test.ts

@@ -130,6 +130,46 @@ test("valid function run", () => {
   });
 });
 
+const args3 = [
+  z.object({
+    f1: z.number(),
+    f2: z.string().nullable(),
+    f3: z.array(z.boolean().optional()).optional(),
+  }),
+] as const;
+const returns3 = z.union([z.string(), z.number()]);
+
+const func3 = z.function({
+  input: args3,
+  output: returns3,
+});
+
+test("function inference 3", () => {
+  type func3 = (typeof func3)["_input"];
+
+  expectTypeOf<func3>().toEqualTypeOf<
+    (arg: {
+      f3?: (boolean | undefined)[] | undefined;
+      f1: number;
+      f2: string | null;
+    }) => string | number
+  >();
+});
+
+test("valid function run", () => {
+  const validFunc3Instance = func3.implement((_x) => {
+    _x.f2;
+    _x.f3![0];
+    return "adf" as any;
+  });
+
+  validFunc3Instance({
+    f1: 21,
+    f2: "asdf",
+    f3: [true, false],
+  });
+});
+
 test("input validation error", () => {
   const schema = z.function({
     input: z.tuple([z.string()]),

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -1,7 +1,34 @@
+import { Validator } from "@seriousme/openapi-schema-validator";
 import { describe, expect, test } from "vitest";
 import * as z from "zod/v4";
 // import * as zCore from "zod/v4/core";
 
+const openAPI30Validator = new Validator();
+/** @see https://github.com/colinhacks/zod/issues/5147 */
+const validateOpenAPI30Schema = async (zodJSONSchema: Record<string, unknown>): Promise<true> => {
+  const res = await openAPI30Validator.validate({
+    openapi: "3.0.0",
+    info: {
+      title: "SampleApi",
+      description: "Sample backend service",
+      version: "1.0.0",
+    },
+    components: { schemas: { test: zodJSONSchema } },
+    paths: {},
+  });
+
+  if (!res.valid) {
+    // `console.error` should make `vitest` trow an unhandled error
+    // printing the validation messages in consoles
+    console.error(
+      `OpenAPI schema is not valid against ${openAPI30Validator.version}`,
+      JSON.stringify(res.errors, null, 2)
+    );
+  }
+
+  return true;
+};
+
 describe("toJSONSchema", () => {
   test("primitive types", () => {
     expect(z.toJSONSchema(z.string())).toMatchInlineSnapshot(`
@@ -552,8 +579,11 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("nullable openapi", () => {
-    expect(z.toJSONSchema(z.string().nullable(), { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+  test("nullable openapi-3.0", () => {
+    const schema = z.string().nullable();
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "nullable": true,
         "type": "string",
@@ -561,19 +591,33 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("union with null openapi", () => {
+  test("union with null openapi-3.0", () => {
     const schema = z.union([z.string(), z.null()]);
-    expect(z.toJSONSchema(schema, { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
       {
-        "nullable": true,
-        "type": "string",
+        "anyOf": [
+          {
+            "type": "string",
+          },
+          {
+            "enum": [
+              null,
+            ],
+            "nullable": true,
+            "type": "string",
+          },
+        ],
       }
     `);
   });
 
-  test("number with exclusive min-max openapi", () => {
+  test("number with exclusive min-max openapi-3.0", () => {
     const schema = z.number().lt(100).gt(1);
-    expect(z.toJSONSchema(schema, { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "exclusiveMaximum": true,
         "exclusiveMinimum": true,
@@ -665,9 +709,11 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("record openapi", () => {
+  test("record openapi-3.0", () => {
     const schema = z.record(z.string(), z.boolean());
-    expect(z.toJSONSchema(schema, { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "additionalProperties": {
           "type": "boolean",
@@ -716,9 +762,11 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("tuple openapi", () => {
+  test("tuple openapi-3.0", () => {
     const schema = z.tuple([z.string(), z.number()]);
-    expect(z.toJSONSchema(schema, { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "items": {
           "anyOf": [
@@ -737,9 +785,11 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("tuple with rest openapi", () => {
+  test("tuple with rest openapi-3.0", () => {
     const schema = z.tuple([z.string(), z.number()]).rest(z.boolean());
-    expect(z.toJSONSchema(schema, { target: "openapi-3.0" })).toMatchInlineSnapshot(`
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "items": {
           "anyOf": [
@@ -754,7 +804,37 @@ describe("toJSONSchema", () => {
             },
           ],
         },
-        "minItems": 2,
+        "minItems": 3,
+        "type": "array",
+      }
+    `);
+  });
+
+  test("tuple with null openapi-3.0", () => {
+    const schema = z.tuple([z.string(), z.number(), z.null()]);
+    const jsonSchema = z.toJSONSchema(schema, { target: "openapi-3.0" });
+    validateOpenAPI30Schema(jsonSchema);
+    expect(jsonSchema).toMatchInlineSnapshot(`
+      {
+        "items": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "number",
+            },
+            {
+              "enum": [
+                null,
+              ],
+              "nullable": true,
+              "type": "string",
+            },
+          ],
+        },
+        "maxItems": 3,
+        "minItems": 3,
         "type": "array",
       }
     `);

package/src/v4/core/to-json-schema.ts

@@ -236,7 +236,11 @@ export class JSONSchemaGenerator {
             break;
           }
           case "null": {
-            _json.type = "null";
+            if (this.target === "openapi-3.0") {
+              _json.type = "string";
+              _json.nullable = true;
+              _json.enum = [null];
+            } else _json.type = "null";
             break;
           }
           case "any": {
@@ -332,18 +336,7 @@ export class JSONSchemaGenerator {
                 path: [...params.path, "anyOf", i],
               })
             );
-            if (this.target === "openapi-3.0") {
-              const nonNull = options.filter((x) => (x as any).type !== "null");
-              const hasNull = nonNull.length !== options.length;
-              if (nonNull.length === 1) {
-                Object.assign(json, nonNull[0]!);
-              } else {
-                json.anyOf = nonNull;
-              }
-              if (hasNull) (json as any).nullable = true;
-            } else {
-              json.anyOf = options;
-            }
+            json.anyOf = options;
             break;
           }
           case "intersection": {
@@ -393,8 +386,9 @@ export class JSONSchemaGenerator {
               }
             } else if (this.target === "openapi-3.0") {
               json.items = {
-                anyOf: [...prefixItems],
+                anyOf: prefixItems,
               };
+
               if (rest) {
                 json.items.anyOf!.push(rest);
               }
@@ -534,9 +528,8 @@ export class JSONSchemaGenerator {
           case "nullable": {
             const inner = this.process(def.innerType, params);
             if (this.target === "openapi-3.0") {
-              Object.assign(_json, inner);
-              (_json as any).nullable = true;
               result.ref = def.innerType;
+              _json.nullable = true;
             } else {
               _json.anyOf = [inner, { type: "null" }];
             }

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 1,
-  patch: 3 as number,
+  patch: 5 as number,
 } as const;

package/v4/classic/schemas.d.cts

@@ -624,10 +624,10 @@ export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctio
 }
 export declare const ZodFunction: core.$constructor<ZodFunction>;
 export declare function _function(): ZodFunction;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
     input: In;
 }): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
     input: In;
     output: Out;
 }): ZodFunction<ZodTuple<In, null>, Out>;

package/v4/classic/schemas.d.ts

@@ -624,10 +624,10 @@ export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctio
 }
 export declare const ZodFunction: core.$constructor<ZodFunction>;
 export declare function _function(): ZodFunction;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
     input: In;
 }): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
     input: In;
     output: Out;
 }): ZodFunction<ZodTuple<In, null>, Out>;

package/v4/core/to-json-schema.cjs

@@ -158,7 +158,13 @@ class JSONSchemaGenerator {
                         break;
                     }
                     case "null": {
-                        _json.type = "null";
+                        if (this.target === "openapi-3.0") {
+                            _json.type = "string";
+                            _json.nullable = true;
+                            _json.enum = [null];
+                        }
+                        else
+                            _json.type = "null";
                         break;
                     }
                     case "any": {
@@ -250,21 +256,7 @@ class JSONSchemaGenerator {
                             ...params,
                             path: [...params.path, "anyOf", i],
                         }));
-                        if (this.target === "openapi-3.0") {
-                            const nonNull = options.filter((x) => x.type !== "null");
-                            const hasNull = nonNull.length !== options.length;
-                            if (nonNull.length === 1) {
-                                Object.assign(json, nonNull[0]);
-                            }
-                            else {
-                                json.anyOf = nonNull;
-                            }
-                            if (hasNull)
-                                json.nullable = true;
-                        }
-                        else {
-                            json.anyOf = options;
-                        }
+                        json.anyOf = options;
                         break;
                     }
                     case "intersection": {
@@ -308,7 +300,7 @@ class JSONSchemaGenerator {
                         }
                         else if (this.target === "openapi-3.0") {
                             json.items = {
-                                anyOf: [...prefixItems],
+                                anyOf: prefixItems,
                             };
                             if (rest) {
                                 json.items.anyOf.push(rest);
@@ -461,9 +453,8 @@ class JSONSchemaGenerator {
                     case "nullable": {
                         const inner = this.process(def.innerType, params);
                         if (this.target === "openapi-3.0") {
-                            Object.assign(_json, inner);
-                            _json.nullable = true;
                             result.ref = def.innerType;
+                            _json.nullable = true;
                         }
                         else {
                             _json.anyOf = [inner, { type: "null" }];

package/v4/core/to-json-schema.js

@@ -154,7 +154,13 @@ export class JSONSchemaGenerator {
                         break;
                     }
                     case "null": {
-                        _json.type = "null";
+                        if (this.target === "openapi-3.0") {
+                            _json.type = "string";
+                            _json.nullable = true;
+                            _json.enum = [null];
+                        }
+                        else
+                            _json.type = "null";
                         break;
                     }
                     case "any": {
@@ -246,21 +252,7 @@ export class JSONSchemaGenerator {
                             ...params,
                             path: [...params.path, "anyOf", i],
                         }));
-                        if (this.target === "openapi-3.0") {
-                            const nonNull = options.filter((x) => x.type !== "null");
-                            const hasNull = nonNull.length !== options.length;
-                            if (nonNull.length === 1) {
-                                Object.assign(json, nonNull[0]);
-                            }
-                            else {
-                                json.anyOf = nonNull;
-                            }
-                            if (hasNull)
-                                json.nullable = true;
-                        }
-                        else {
-                            json.anyOf = options;
-                        }
+                        json.anyOf = options;
                         break;
                     }
                     case "intersection": {
@@ -304,7 +296,7 @@ export class JSONSchemaGenerator {
                         }
                         else if (this.target === "openapi-3.0") {
                             json.items = {
-                                anyOf: [...prefixItems],
+                                anyOf: prefixItems,
                             };
                             if (rest) {
                                 json.items.anyOf.push(rest);
@@ -457,9 +449,8 @@ export class JSONSchemaGenerator {
                     case "nullable": {
                         const inner = this.process(def.innerType, params);
                         if (this.target === "openapi-3.0") {
-                            Object.assign(_json, inner);
-                            _json.nullable = true;
                             result.ref = def.innerType;
+                            _json.nullable = true;
                         }
                         else {
                             _json.anyOf = [inner, { type: "null" }];

package/v4/core/versions.cjs

@@ -4,5 +4,5 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 1,
-    patch: 3,
+    patch: 5,
 };

package/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 1,
-    patch: 3,
+    patch: 5,
 };