Incompatibility between literals helper and zod

[tyb51]

Example

when generating a zod schema

import { convexToZod } from "convex-helpers/server/zod4";
export const PersonSchema = convexToZod(Person.table.validator);

We get a proper ZodValidator when we define the table as followed

export const Person= Table("persons", {
  firstName: v.string(),
  lastName: v.string(),
  gender: v.union(v.literal("male"), v.literal("female"), v.literal("other")),
});

But when we define it as

export const Person= Table("persons", {
  firstName: v.string(),
  lastName: v.string(),
   gender: literals("male", "female", "other"),
});

The zod PersonSchema gives a never type to the gender field

[ianmacartney]

Does it work on the latest alpha? npm i convex-helpers@alpha?

[tyb51]

Yes latest Alpha does work. Type is now ZodUnion<readonly [ZodLiteral<"male">, ZodLiteral<"female">, ZodLiteral<"other">]>

[widavies]

I'm having an issue with this when:

gender: v.union(v.literal("male"), v.literal("female"), v.literal("other"))

is instead defined using enums:

enum Gender = {
  Male = 'male',
  Female = 'female',
  Other = 'other',
}

gender: v.union(...Object.values(Gender).map(v.literal)),

convexToZod will infer the gender type as never instead of Gender

Not working on 0.1.106-alpha.2

[widavies]

This might just be incorrect type inference (via ZodValidatorFromConvex) not the actual conversion output from convexToZod

Edit: Double checked this, the actual covnexToZod output is correct. This is only an issue with type inference via ZodValidatorFromConvex

[ianmacartney]

@widavies Note that literals was designed in part to get around the inference challenges of spreading into v.union - can you confirm if the issue is with literals or spreading into v.union?

[ianmacartney]

I cut a Devin branch - if that validates your concern go ahead and check that box on the page

[widavies]

I'll test it tonight, thanks!

[widavies]

@ianmacartney Looks like the issue is present regardless of whether literals or spreading into v.union is used:

Versions:

• Convex-helpers: 0.1.106-alpha.2
• Typescript 5.9.3

[ianmacartney]

This works for me, so I think it might be some inference limitation on Object.values happening:

  convexToZod(v.object({
    A: literals(...["value1", "value2", "value3"] as const),
  }))

but I get ZodTypeAny when it's ...Object.values.

[Nicolapps]

Thanks for reporting the issue! I added tests that repro it here:

• Zod 4 support: fix VUnion<… …[]> handling in convexToZod #872

The problem is that in both your code examples, the source type is a VUnion<…, VLiteral<Generic>[]>>, while usually union types use a tuple type (e.g. VUnion<…, [VString, VNull]>>). The current implementation assumes that we use a tuple type to avoid some TypeScript infinite recursion issues:

https://github.com/get-convex/convex-helpers/blob/main/packages/convex-helpers/server/zod4.ts#L1800-L1834

We should find a way to your cases too.