Improve z.function typing. Add .def

Author: colinhacks

packages/zod/src/v4/classic/tests/function.test.ts

@@ -68,7 +68,7 @@ test("function inference 1", () => {
 test("args method", () => {
   const t1 = z.function();
   type t1 = (typeof t1)["_input"];
-  expectTypeOf<t1>().toEqualTypeOf<(...args_1: unknown[]) => unknown>();
+  expectTypeOf<t1>().toEqualTypeOf<(...args_1: never[]) => unknown>();
 
   const t2args = z.tuple([z.string()], z.unknown());
 
@@ -81,6 +81,14 @@ test("args method", () => {
   expectTypeOf<t3>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => boolean>();
 });
 
+test("contravariance", () => {
+  const fn = z.function().implement((_a: string, _b: number) => {
+    return new Date();
+  });
+
+  expectTypeOf(fn).toEqualTypeOf<(a: string, b: number) => Date>();
+});
+
 const args2 = z.tuple([
   z.object({
     f1: z.number(),

packages/zod/src/v4/core/function.ts

@@ -12,40 +12,47 @@ import type * as util from "./util.js";
 //////////                      //////////
 //////////////////////////////////////////
 //////////////////////////////////////////
-export interface $ZodFunctionDef /* extends schemas.$ZodTypeDef */ {
+export interface $ZodFunctionDef<
+  In extends $ZodFunctionIn = $ZodFunctionIn,
+  Out extends $ZodFunctionOut = $ZodFunctionOut,
+> {
   type: "function";
-  input: $ZodFunctionArgs | null;
-  output: schemas.$ZodType | null;
+  input: In;
+  output: Out;
 }
 
 export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
+export type $ZodFunctionIn = $ZodFunctionArgs | null;
+export type $ZodFunctionOut = schemas.$ZodType | null;
 
-export type $InferInnerFunctionType<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (
-  ...args: Args["_zod"]["output"]
-) => Returns["_zod"]["input"];
+export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["output"]
+) => null extends Returns ? unknown : NonNullable<Returns>["_zod"]["input"];
 
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (
-  ...args: Args["_zod"]["output"]
-) => util.MaybeAsync<Returns["_zod"]["input"]>;
+export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["output"]
+) => null extends Returns ? unknown : util.MaybeAsync<NonNullable<Returns>["_zod"]["input"]>;
 
-export type $InferOuterFunctionType<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (
-  ...args: Args["_zod"]["input"]
-) => Returns["_zod"]["output"];
+export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["input"]
+) => null extends Returns ? unknown : NonNullable<Returns>["_zod"]["output"];
 
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (
-  ...args: Args["_zod"]["input"]
-) => util.MaybeAsync<Returns["_zod"]["output"]>;
+export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: null extends Args ? never[] : NonNullable<Args>["_zod"]["input"]
+) => null extends Returns ? unknown : util.MaybeAsync<NonNullable<Returns>["_zod"]["output"]>;
 
 export class $ZodFunction<
-  Args extends $ZodFunctionArgs = $ZodFunctionArgs,
-  Returns extends schemas.$ZodType = schemas.$ZodType,
+  Args extends $ZodFunctionIn = $ZodFunctionIn,
+  Returns extends $ZodFunctionOut = $ZodFunctionOut,
 > {
-  _def: $ZodFunctionDef;
+  _def: $ZodFunctionDef<Args, Returns>;
+  def: $ZodFunctionDef<Args, Returns>;
   _input!: $InferInnerFunctionType<Args, Returns>;
   _output!: $InferOuterFunctionType<Args, Returns>;
 
-  constructor(def: $ZodFunctionDef) {
+  constructor(def: $ZodFunctionDef<Args, Returns>) {
     this._def = def;
+    this.def = def;
   }
 
   implement<F extends $InferInnerFunctionType<Args, Returns>>(
@@ -59,7 +66,7 @@ export class $ZodFunction<
       if (!Array.isArray(parsedArgs)) {
         throw new Error("Invalid arguments schema: not an array or tuple schema.");
       }
-      const output = func(...parsedArgs);
+      const output = func(...(parsedArgs as any));
       return this._def.output ? parse(this._def.output, output, undefined, { callee: impl }) : output;
     }) as any;
     return impl;
@@ -77,17 +84,17 @@ export class $ZodFunction<
       if (!Array.isArray(parsedArgs)) {
         throw new Error("Invalid arguments schema: not an array or tuple schema.");
       }
-      const output = await func(...parsedArgs);
+      const output = await func(...(parsedArgs as any));
       return this._def.output ? parseAsync(this._def.output, output, undefined, { callee: impl }) : output;
     }) as any;
     return impl;
   }
 
-  input<const Items extends util.TupleItems, const Rest extends schemas.$ZodType | null = null>(
+  input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = null>(
     args: Items,
     rest?: Rest
   ): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
-  input<NewArgs extends $ZodFunctionArgs>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
   input(...args: any[]): $ZodFunction<any, Returns> {
     if (Array.isArray(args[0])) {
       return new $ZodFunction({
@@ -116,19 +123,28 @@ export class $ZodFunction<
   }
 }
 
-export interface $ZodFunctionParams<I extends $ZodFunctionArgs, O extends schemas.$ZodType> {
+export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
   input?: I;
   output?: O;
 }
 
 function _function(): $ZodFunction;
+function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
+  input: In;
+}): $ZodFunction<$ZodTuple<In, null>, null>;
+function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
+  input: In;
+}): $ZodFunction<In, null>;
+function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+  output: Out;
+}): $ZodFunction<null, Out>;
 function _function<
-  const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>,
+  In extends $ZodFunctionIn = $ZodFunctionIn,
   Out extends schemas.$ZodType = schemas.$ZodType,
->(params?: { input?: In; output?: Out }): $ZodFunction<$ZodTuple<In, null>, Out>;
-function _function<In extends $ZodFunctionArgs = $ZodFunctionArgs, Out extends schemas.$ZodType = schemas.$ZodType>(
-  params?: $ZodFunctionParams<In, Out>
-): $ZodFunction<In, Out>;
+>(params?: {
+  input: In;
+  output: Out;
+}): $ZodFunction<In, Out>;
 function _function(params?: {
   output?: schemas.$ZodType;
   input?: $ZodFunctionArgs | Array<schemas.$ZodType>;

play.ts

@@ -1,20 +1,13 @@
 import * as z from "zod/v4";
 
-z;
+export const a = z.object({
+  asdf: z.iso.datetime(),
+});
 
-const result = z.toJSONSchema(z.date(), {
-  unrepresentable: "any",
-  override: (ctx) => {
-    const def = ctx.zodSchema._zod.def;
-    if (def.type === "date") {
-      ctx.jsonSchema.type = "string";
-      ctx.jsonSchema.format = "date-time";
-    }
-  },
+const fn = z.function({
+  // input: z.tuple([z.string()], z.number()),
+  output: z.string(),
 });
-/* => {
-  type: 'string',
-  format: 'date-time',
-  '$schema': 'https://json-schema.org/draft/2020-12/schema'
-} */
-console.dir(result, { depth: null });
+
+fn.def.output;
+fn.def.input;

tsconfig.json

@@ -2,7 +2,7 @@
   "extends": "./.configs/tsconfig.base.json",
   "compilerOptions": {
     "rootDir": ".",
-    "noEmit": true
+    "declaration": true
   },
   "exclude": ["packages/docs"]
 }