Generic type for any schema that preserves output type?

[mwisnicki]

I'm trying to write a generic wrapper for parse functions:

function parseWrapper<T>(o: any, schema: z.Schema<T>): T {
  return schema.parse(o);
}

This unfortunately returns Partial on any schema or subschema that has a default. ZodType behaves the same way.

The closest I got based on #1310 is this:

function parseWrapper<S extends z.ZodType, T = z.infer<S>>(o: any, schema: S): T {
  return schema.parse(o);
}

However this introduces unwanted parameter for schema. I'm not returning a schema so I feel like this should be unnecessary.

I think the problem can be reduced to:

const Foo = z.string().default("foo");
type IFoo = z.infer<typeof Foo>;
const fooCopy: z.Schema<IFoo> = Foo; // fails because `string|undefined` can't be assigned to `string`

What would be the correct generic type for any kind of parseable schema that preserves output type?

[scotttrinh]

The third generic is the Input type which defaults to the value of the output type (the first generic), so if you don't specify it, it requires that the input and output match, which is not the case for ZodDefault or ZodEffect.

TypeScript Playground

import { z } from "zod";

const Foo = z.string().default("foo");
type InputFoo = z.input<typeof Foo>;
type OutputFoo = z.infer<typeof Foo>;
const fooCopy: z.Schema<OutputFoo, z.ZodTypeDef, InputFoo> = Foo;

I don't have a quick answer to the actual question here, but wanted to provide that quick bit of context. Hopefully that's helpful, but I'll try to take a swing at helping the broader question soon too.