Intersection cannot be assigned to `Schema` type

Since v3.3 it is not possible anymore to give an explicit type definition for schemas of intersection types.The following code fails to type check.

import * as zod from "zod"

interface Foo {
  foo: string;
}

const fooSchema = zod.object({
  foo: zod.string(),
});

interface Bar {
  bar: string;
}

const barSchema = zod.object({
  bar: zod.string(),
});

const interSchema: zod.Schema<Foo & Bar> = fooSchema.and(barSchema);

Typescript produces the following error

index.ts:19:14 - error TS2322: Type 'ZodIntersection<ZodObject<{ foo: ZodString; }, "strip", ZodTypeAny, { foo: string; }, { foo: string; }>, ZodObject<{ bar: ZodString; }, "strip", ZodTypeAny, { ...; }, { ...; }>>' is not assignable to type 'ZodType<Foo & Bar, ZodTypeDef, Foo & Bar>'.
  The types returned by '_parse(...)' are incompatible between these types.
    Type 'ParseReturnType<ZodObject<{ foo: ZodString; }, "strip", ZodTypeAny, { foo: string; }, { foo: string; }> & ZodObject<{ bar: ZodString; }, "strip", ZodTypeAny, { ...; }, { ...; }>>' is not assignable to type 'ParseReturnType<Foo & Bar>'.
      Type 'OK<ZodObject<{ foo: ZodString; }, "strip", ZodTypeAny, { foo: string; }, { foo: string; }> & ZodObject<{ bar: ZodString; }, "strip", ZodTypeAny, { ...; }, { ...; }>>' is not assignable to type 'ParseReturnType<Foo & Bar>'.
        Type 'OK<ZodObject<{ foo: ZodString; }, "strip", ZodTypeAny, { foo: string; }, { foo: string; }> & ZodObject<{ bar: ZodString; }, "strip", ZodTypeAny, { ...; }, { ...; }>>' is not assignable to type 'OK<Foo & Bar>'.
          Type 'ZodObject<{ foo: ZodString; }, "strip", ZodTypeAny, { foo: string; }, { foo: string; }> & ZodObject<{ bar: ZodString; }, "strip", ZodTypeAny, { ...; }, { ...; }>' is not assignable to type 'Foo & Bar'.
            Property 'foo' is missing in type 'ZodObject<{ foo: ZodString; }, "strip", ZodTypeAny, { foo: string; }, { foo: string; }> & ZodObject<{ bar: ZodString; }, "strip", ZodTypeAny, { ...; }, { ...; }>' but required in type 'Foo'.

19 const interSchema: zod.Schema<Foo & Bar> = fooSchema.and(barSchema);
                ~~~~~~~~~~~

A workaround is to use .merge.

export const interSchema2: zod.Schema<Foo & Bar> = fooSchema.merge(barSchema);

However, this requires fooSchema to be an object and is not possible if fooSchema itself is annotated with Schema<Foo>.

[colinhacks]

Everything is easier when you don’t support chainable methods (a la https://github.com/mojotech/json-type-validation) but the fluent approach is one of Zod’s main selling points. It’s all tradeoffs.

Updated:

function parse<T extends z.ZodTypeAny>(schema: T): z.infer<T> { ... }

[geigerzaehler]

It should work for this use case.

The signature you proposed doesn’t seem to match what we need. (I also noticed that I had a typo in the signature. I’ve fixed now). The idea of the generic parse function was to ensure that the type parsed by the schema matches the output type.

Everything that involves writing schemas the conform to pre-defined TS types is doing to be messy. It’s just not what Zod was really designed for.

Thanks for clarifying this. We would love to see this becoming easier though 🙂. @mojotech/json-type-validation does this well.