This seems like a bug to me but maybe someone knows

[kevinclarkadstech]

Hello everyone, I am trying to make a typescript type to represent a "base" Zod Schema per se, to make sure that there is a consistency and I would expect the union to correctly identify the input. If I DON'T use the TS type, it works, but with the TS type, it does not seem to recognize the union properly.

I am trying to create a Mutation type, that has a literal from an array as const export, and that works fine. Then, I am trying to have a generic input type that maps up to a Zod object.

type MutationSchema<Input extends Zod.ZodType> = z.ZodObject<{
    name: z.ZodType<AppMutationNames>,
    input: Input
}>;

const InitiatePasswordlessEmailAuthenticationMutationSchema: MutationSchema<ZodType<{ email: string}>> = z.object({
    // name: AppMutationNamesSchema,
    name: z.literal('initiatePasswordlessEmailAuthentication'),
    input: z.object({
        email: z.string(),
    }),
});

const VerifyPasswordlessEmailAuthenticationMutationSchema: MutationSchema<ZodType<{ email: string, verificationCode: number, pendingAuthToken: string}>> = z.object({
    // name: AppMutationNamesSchema,
    name: z.literal('verifyPasswordlessEmailAuthentication'),
    input: z.object({
        email: z.string(),
        verificationCode: z.number(),
        pendingAuthToken: z.string(),
    }),
});

This works fine with TypeScript, very cool, get Intellisense and makes sure the Zod object is typed correctly.

Then, I want to create a schema such as

const MutationSchema = z.union([InitiatePasswordlessEmailAuthenticationMutationSchema, VerifyPasswordlessEmailAuthenticationMutationSchema]);

When I get the api call to my mutation endpoint, I want to say

const parsedMutation = MutationSchema.parse({ name: req.params.mutationName, input: req.body });

Then be able to say switch (parsedMutation.name)
And get the input accurate based on the mutation's name. But when I say

  const testing = MutationSchema.parse({

});
if (testing.name === 'initiatePasswordlessEmailAuthentication') {
    testing.input.email;
} else if (testing.name === 'verifyPasswordlessEmailAuthentication') {
    testing.input.email;
    testing.input.verificationCode;
    testing.input.pendingAuthToken;
}

it says verificationCode does not exist on type {email: string } | {email: string, verificationCode: number, pendingAuthToken: string }

This WORKS if I remove my type, i.e. say

const InitiatePasswordlessEmailAuthenticationMutationSchema = z.object({
  // name: AppMutationNamesSchema,
  name: z.literal('initiatePasswordlessEmailAuthentication'),
  input: z.object({
      email: z.string(),
  }),
});

const VerifyPasswordlessEmailAuthenticationMutationSchema = z.object({
  // name: AppMutationNamesSchema,
  name: z.literal('verifyPasswordlessEmailAuthentication'),
  input: z.object({
      email: z.string(),
      verificationCode: z.number(),
      pendingAuthToken: z.string(),
  }),
});

And then no problem with TypeScript, it does a proper union check and input is properly typed.

Since I am the only one working on my project I could just ignore using a type, or assert to TypeScript what input is, but both of those annoy the perfectionist in me. Any ideas? Thanks!