v4: Regression in generic type inference for ZodType compared to ZodSchema

[mn-prp]

In v4, ZodSchema is deprecated and aliased to ZodType, but the type inference powers of the latter are much more limited.

The following is a pattern we use in many places in our code at my workplace:

import { z as v3 } from 'zod/v3'
import { z as v4 } from 'zod/v4'

const schemaV3 = v3.object({
  foo: v3.array(v3.string()),
  bar: v3.literal('baz')
})

const genericV3 = <In, Out>(schema: v3.ZodSchema<In,v3.ZodTypeDef, Out>): { in: In; out: Out } => {
  return undefined as any
}


/* Correctly inferred as
  {
    in: {
        foo: string[];
        bar: "baz";
    };
    out: {
        foo: string[];
        bar: "baz";
    };
  }
 */
const testV3 = genericV3(schemaV3) 

const schemaV4 = v4.object({
  foo: v4.array(v4.string()),
  bar: v4.literal('baz')
})

const genericV4 = <In, Out>(schema: v4.ZodType<In, Out>): { in: In; out: Out } => {
  return undefined as any
}

/* Incorrectly inferred as
{ in: any; out: any; }
 */
const testV4 = genericV4(schemaV4)

Is this a temporary regression? Is there an alternate typing we should be using that will accomplish the goal of writing generic functions and classes over the types implied by a zod schema?

[colinhacks]

I'm not entirely sure why this doesn't work, but ultimately this approach is flawed. Use this instead:

const inferSchema = <T extends z.core.$ZodType>(_: T): {
  in: z.input<T>;
  out: z.output<T>;
} => {
  return {} as any;
};

Also note that the generic structure is ZodType<Out, In> (for historical reasons). This isn't the problem though, just something to keep in mind.

[mn-prp]

@colinhacks

Thanks for your reply. I appreciate the suggestion, but our codebase already does utilize those input and output helpers. But I think my attempt to give a minimal reproduction of the issue obscured the details of what this change made impossible.

With that in mind, I'm sharing a fuller snippet, showing how work done inside generic functions becomes unsafe and requires as any type casts or worse.

I'm copy/pasting the whole snippet so people can open in an IDE easily, but the key errors are at the end.

import { z as v3 } from 'zod/v3'
import { z as v4 } from 'zod/v4'

const schemaV3 = v3.object({
  foo: v3.array(v3.string().transform(Number)),
  bar: v3.literal('baz')
})

const genericV3 = <In, Out>(
  schema: v3.ZodSchema<Out, v3.ZodTypeDef, In>
): { in: In; out: Out } => {
  return undefined as any
}

/* Correctly inferred as
  {
    in: {
        foo: string[];
        bar: "baz";
    };
    out: {
        foo: number[];
        bar: "baz";
    };
  }
 */
const testV3 = genericV3(schemaV3)

type Constraint<T> = { foo: T[] }

type SecondaryConstraint = { id: string }

const genericV3WithConstraint = <In extends Constraint<T>, Out, T>(
  schema: v3.ZodSchema<Out, v3.ZodTypeDef, In>
): { in: In; out: Out } => {
  return undefined as any
}

// correctly inferred
const testV3WithConstraint = genericV3WithConstraint(schemaV3)

const twiceGenericV3 = <In extends (Constraint<T> & SecondaryConstraint), Out, T>(
  schema: v3.ZodSchema<Out, v3.ZodTypeDef, In> 
): { in: In; out: Out } => {
  const intermediate = genericV3WithConstraint(schema) // typescript knows both constraints are satisfied, so we can call parsers with broader types

  // @ts-expect-error
  const number: number = schema.parse({}).id // typescript catches this error, because it knows that the parsed id is a string

  return {} as any
}

/* ----------------------------------- V4 ----------------------------------- */

const schemaV4 = v4.object({
  foo: v4.array(v4.string().transform(Number)),
  bar: v4.literal('baz')
})

const genericV4 = <In, Out>(
  schema: v4.ZodType<Out, In>
): { in: In; out: Out } => {
  return undefined as any
}

/* Incorrectly inferred as
{ in: any; out: any; }
 */
const testV4 = genericV4(schemaV4)

const genericV4WithConstraint = <Schema extends v4.ZodType, T>(
  schema: v4.output<Schema> extends Constraint<T> ? Schema : never
): { in: v4.input<Schema>; out: v4.output<Schema> } => {
  return undefined as any
}

// correctly inferred
const testV4WithConstraint = genericV4WithConstraint(schemaV4)

const twiceGenericV4 = <Schema extends v4.ZodType, T>(
  schema: v4.output<Schema> extends Constraint<T> & SecondaryConstraint
    ? Schema
    : never
): { in: v4.input<Schema>; out: v4.output<Schema> } => {
  // @ts-expect-error -- This should NOT error, but it does.
  const intermediate = genericV4WithConstraint(schema)

  // this SHOULD error, but it doesn't
  const number: number = schema.parse({}).id // wrongly inferred as any, so we can assign it to a number

  return {} as any
}

const testComposedGenericV4 = twiceGenericV4(
  schemaV4.extend({ id: v4.string() })
)

Do you have a solution for this as well? Is this just outside the scope of the intended use of the library?

PS. I just wanted to thank you for the excellent library, and the performance improvements of v4 are really welcome. The transition has mostly been very easy for us. I spent a couple days this week migrating ~375 files that were using v3 to v4. The only sticking points were react hook form resolvers (which is expected, since they haven't updated to support v4 yet) and these generics in our more complicated internal library code. Unfortunately, the internal library code has become a blocker that is probably going to make me toss out my migration branch, since we don't want to support both v3 and v4 internally at once. But truly the ease of the non-generic migration was wonderful.