creating the ZodValidatorFromConvex in zod.ts file and using it in convexToZod function output

Author: Firephoenix25

packages/convex-helpers/server/zod.ts

@@ -1314,14 +1314,65 @@ export function zBrand<
 /** Simple type conversion from a Convex validator to a Zod validator. */
 export type ConvexToZod<V extends GenericValidator> = z.ZodType<Infer<V>>;
 
+/** Better type conversion from a Convex validator to a Zod validator where the output is not a generetic ZodType but it's more specific.
+ *
+ * ES: z.ZodString instead of z.ZodType<string, z.ZodTypeDef, string>
+ * so you can use methods of z.ZodString like .min() or .email()
+ */
+
+type ZodFromValidatorBase<V extends GenericValidator> =
+  V extends VId<GenericId<infer TableName extends string>>
+    ? Zid<TableName>
+    : V extends VString<any, any>
+      ? z.ZodString
+      : V extends VFloat64<any, any>
+        ? z.ZodNumber
+        : V extends VInt64<any, any>
+          ? z.ZodBigInt
+          : V extends VBoolean<any, any>
+            ? z.ZodBoolean
+            : V extends VNull<any, any>
+              ? z.ZodNull
+              : V extends VLiteral<any, any>
+                ? z.ZodLiteral<V["value"]>
+                : V extends VObject<any, any, any, any>
+                  ? z.ZodObject<{
+                      [K in keyof V["fields"]]: ZodValidatorFromConvex<
+                        V["fields"][K]
+                      >;
+                    }>
+                  : V extends VRecord<any, infer Key, any, any, any>
+                    ? Key extends VId<GenericId<infer TableName>>
+                      ? z.ZodRecord<
+                          Zid<TableName>,
+                          ZodValidatorFromConvex<V["value"]>
+                        >
+                      : z.ZodRecord<
+                          z.ZodString,
+                          ZodValidatorFromConvex<V["value"]>
+                        >
+                    : V extends VArray<any, any>
+                      ? z.ZodArray<ZodValidatorFromConvex<V["element"]>>
+                      : V extends VUnion<any, any, any, any>
+                        ? z.ZodUnion<
+                            [ZodValidatorFromConvex<V["members"][number]>]
+                          >
+                        : z.ZodTypeAny; // fallback for unknown validators
+
+/** Main type with optional handling. */
+export type ZodValidatorFromConvex<V extends GenericValidator> =
+  V extends Validator<any, "optional", any>
+    ? z.ZodOptional<ZodFromValidatorBase<V>>
+    : ZodFromValidatorBase<V>;
+
 /**
  * Turn a Convex validator into a Zod validator.
  * @param convexValidator Convex validator can be any validator from "convex/values" e.g. `v.string()`
  * @returns Zod validator (e.g. `z.string()`) with inferred type matching the Convex validator
  */
 export function convexToZod<V extends GenericValidator>(
   convexValidator: V,
-): z.ZodType<Infer<V>> {
+): ZodValidatorFromConvex<V> {
   const isOptional = (convexValidator as any).isOptional === "optional";
 
   let zodValidator: z.ZodTypeAny;
@@ -1393,7 +1444,9 @@ export function convexToZod<V extends GenericValidator>(
       throw new Error(`Unknown convex validator type: ${convexValidator.kind}`);
   }
 
-  return isOptional ? z.optional(zodValidator) : zodValidator;
+  return isOptional
+    ? (z.optional(zodValidator) as ZodValidatorFromConvex<V>)
+    : (zodValidator as ZodValidatorFromConvex<V>);
 }
 
 /**
@@ -1408,5 +1461,5 @@ export function convexToZodFields<C extends PropertyValidators>(
 ) {
   return Object.fromEntries(
     Object.entries(convexValidators).map(([k, v]) => [k, convexToZod(v)]),
-  ) as { [k in keyof C]: z.ZodType<Infer<C[k]>> };
+  ) as { [k in keyof C]: ZodValidatorFromConvex<C[k]> };
 }