zodvex 0.2.2 → 0.2.4

package/src/builders.ts

@@ -155,13 +155,13 @@ export function zActionBuilder<Builder extends (fn: any) => any>(builder: Builde
  *
  * @example
  * ```ts
- * import { query } from './_generated/server'
+ * import { type QueryCtx, query } from './_generated/server'
  * import { zCustomQueryBuilder, customCtx } from 'zodvex'
  *
  * // Create a builder with auth context
  * export const authQuery = zCustomQueryBuilder(
  *   query,
- *   customCtx(async (ctx) => {
+ *   customCtx(async (ctx: QueryCtx) => {
  *     const user = await getUserOrThrow(ctx)
  *     return { user }
  *   })
@@ -208,13 +208,13 @@ export function zCustomQueryBuilder<
  *
  * @example
  * ```ts
- * import { mutation } from './_generated/server'
+ * import { type MutationCtx, mutation } from './_generated/server'
  * import { zCustomMutationBuilder, customCtx } from 'zodvex'
  *
  * // Create a builder with auth context
  * export const authMutation = zCustomMutationBuilder(
  *   mutation,
- *   customCtx(async (ctx) => {
+ *   customCtx(async (ctx: MutationCtx) => {
  *     const user = await getUserOrThrow(ctx)
  *     return { user }
  *   })
@@ -261,13 +261,13 @@ export function zCustomMutationBuilder<
  *
  * @example
  * ```ts
- * import { action } from './_generated/server'
+ * import { type ActionCtx, action } from './_generated/server'
  * import { zCustomActionBuilder, customCtx } from 'zodvex'
  *
  * // Create a builder with auth context
  * export const authAction = zCustomActionBuilder(
  *   action,
- *   customCtx(async (ctx) => {
+ *   customCtx(async (ctx: ActionCtx) => {
  *     const identity = await ctx.auth.getUserIdentity()
  *     if (!identity) throw new Error('Unauthorized')
  *     return { userId: identity.subject }

package/src/custom.ts

@@ -232,7 +232,11 @@ export function customFnBuilder<
               handleZodValidationError(e, 'returns')
             }
             if (added?.onSuccess) {
-              await added.onSuccess({ ctx, args: parsed.data, result: validated })
+              await added.onSuccess({
+                ctx,
+                args: parsed.data,
+                result: validated
+              })
             }
             return toConvexJS(returns as z.ZodTypeAny, validated)
           }

package/src/mapping/handlers/union.ts

@@ -13,11 +13,12 @@ export function convertDiscriminatedUnionType(
   if (options) {
     const opts = Array.isArray(options) ? options : Array.from(options)
     if (opts.length >= 2) {
-      const convexOptions = opts.map((opt: any) => zodToConvexInternal(opt, visited)) as Validator<
-        any,
-        'required',
-        any
-      >[]
+      // IMPORTANT: Create a new visited set for each union member to prevent false circular
+      // reference detection. The same schema can legitimately appear in multiple union branches.
+      const convexOptions = opts.map((opt: any) => {
+        const branchVisited = new Set(visited)
+        return zodToConvexInternal(opt, branchVisited)
+      }) as Validator<any, 'required', any>[]
       const [first, second, ...rest] = convexOptions
       return v.union(
         first as Validator<any, 'required', any>,
@@ -44,9 +45,15 @@ export function convertUnionType(
       return zodToConvexInternal(options[0], visited)
     } else {
       // Convert each option recursively
-      const convexOptions = options.map((opt: any) =>
-        zodToConvexInternal(opt, visited)
-      ) as Validator<any, 'required', any>[]
+      // IMPORTANT: Create a new visited set for each union member to prevent false circular
+      // reference detection. The same schema can legitimately appear in multiple union branches.
+      // However, we do want to preserve the parent visited set to catch actual circular refs
+      // that involve the union itself.
+      const convexOptions = options.map((opt: any) => {
+        // Create a new Set that includes the parent's visited schemas but won't pollute it
+        const branchVisited = new Set(visited)
+        return zodToConvexInternal(opt, branchVisited)
+      }) as Validator<any, 'required', any>[]
       if (convexOptions.length >= 2) {
         const [first, second, ...rest] = convexOptions
         return v.union(

package/src/mapping/types.ts

@@ -22,6 +22,25 @@ type IsZid<T> = T extends { _tableName: infer _TableName extends string } ? true
 // Extract table name from zid type (via _tableName property)
 type ExtractTableName<T> = T extends { _tableName: infer TableName } ? TableName : never
 
+// Helper to map enum tuple to VLiteral validators tuple
+// Based on convex-helpers approach which handles different lengths explicitly
+// This avoids TypeScript recursion issues and provides better type inference
+type EnumToLiteralsTuple<T extends readonly [string, ...string[]]> = T['length'] extends 1
+  ? [VLiteral<T[0], 'required'>]
+  : T['length'] extends 2
+    ? [VLiteral<T[0], 'required'>, VLiteral<T[1], 'required'>]
+    : [
+        VLiteral<T[0], 'required'>,
+        VLiteral<T[1], 'required'>,
+        ...{
+          [K in keyof T]: K extends '0' | '1'
+            ? never
+            : K extends keyof T
+              ? VLiteral<T[K], 'required'>
+              : never
+        }[keyof T & number][]
+      ]
+
 export type ZodValidator = Record<string, z.ZodTypeAny>
 
 // Helper type to convert optional types to union with null for container elements
@@ -62,11 +81,25 @@ type ConvexValidatorFromZodBase<Z extends z.ZodTypeAny> =
                       : Z extends z.ZodLiteral<infer T>
                         ? VLiteral<T, 'required'>
                         : Z extends z.ZodEnum<infer T>
-                          ? T extends Readonly<Record<string, infer _V>>
-                            ? T[keyof T] extends infer Values
-                              ? VUnion<Values, any[], 'required'>
-                              : never
-                            : never
+                          ? T extends readonly [string, ...string[]]
+                            ? T['length'] extends 1
+                              ? VLiteral<T[0], 'required'>
+                              : T['length'] extends 2
+                                ? VUnion<
+                                    T[number],
+                                    [VLiteral<T[0], 'required'>, VLiteral<T[1], 'required'>],
+                                    'required',
+                                    never
+                                  >
+                                : VUnion<T[number], EnumToLiteralsTuple<T>, 'required', never>
+                            : T extends Record<string, string | number>
+                              ? VUnion<
+                                  T[keyof T],
+                                  Array<VLiteral<T[keyof T], 'required'>>,
+                                  'required',
+                                  never
+                                >
+                              : VUnion<string, any[], 'required', any>
                           : Z extends z.ZodRecord<z.ZodString, infer V extends z.ZodTypeAny>
                             ? VRecord<
                                 Record<string, z.infer<V>>,
@@ -148,11 +181,33 @@ export type ConvexValidatorFromZod<
                               : Z extends z.ZodLiteral<infer T>
                                 ? VLiteral<T, Constraint>
                                 : Z extends z.ZodEnum<infer T>
-                                  ? T extends Readonly<Record<string, infer _V>>
-                                    ? T[keyof T] extends infer Values
-                                      ? VUnion<Values, any[], Constraint>
-                                      : never
-                                    : never
+                                  ? T extends readonly [string, ...string[]]
+                                    ? T['length'] extends 1
+                                      ? VLiteral<T[0], Constraint>
+                                      : T['length'] extends 2
+                                        ? VUnion<
+                                            T[number],
+                                            [
+                                              VLiteral<T[0], 'required'>,
+                                              VLiteral<T[1], 'required'>
+                                            ],
+                                            Constraint,
+                                            never
+                                          >
+                                        : VUnion<
+                                            T[number],
+                                            EnumToLiteralsTuple<T>,
+                                            Constraint,
+                                            never
+                                          >
+                                    : T extends Record<string, string | number>
+                                      ? VUnion<
+                                          T[keyof T],
+                                          Array<VLiteral<T[keyof T], 'required'>>,
+                                          Constraint,
+                                          never
+                                        >
+                                      : VUnion<string, any[], Constraint, any>
                                   : Z extends z.ZodRecord<z.ZodString, infer V extends z.ZodTypeAny>
                                     ? VRecord<
                                         Record<string, z.infer<V>>,