Add overloads for zod resolver to handle schemaOptions.raw

Author: controversial

zod/src/__tests__/zod.ts

@@ -154,4 +154,31 @@ describe('zodResolver', () => {
       }>
     >();
   });
+
+  it('should correctly infer the output type from a zod schema using a transform with schemaOptions.raw', () => {
+    const resolver1 = zodResolver(
+      z.object({ id: z.number().transform((val) => String(val)) }),
+      undefined,
+      { raw: true },
+    );
+    expectTypeOf(resolver1).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+
+    const resolver2 = zodResolver(
+      z.object({ id: z.number().transform((val) => String(val)) }),
+      {},
+      { raw: false },
+    );
+    expectTypeOf(resolver2).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+
+    const resolver3 = zodResolver(
+      z.object({ id: z.number().transform((val) => String(val)) }),
+    );
+    expectTypeOf(resolver3).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+  });
 });

zod/src/zod.ts

@@ -81,6 +81,28 @@ function parseErrorSchema(
  *   resolver: zodResolver(schema)
  * });
  */
+// passing raw: false or omitting resolverOptions.raw you get the transformed output type
+export function zodResolver<Input extends FieldValues, Context, Output>(
+  schema: z.ZodSchema<Output, any, Input>,
+  schemaOptions?: Partial<z.ParseParams>,
+  resolverOptions?: {
+    mode?: 'async' | 'sync';
+    raw?: false;
+  },
+): Resolver<
+  Input,
+  Context,
+  Output
+>
+// passing raw: true you get back the input type
+export function zodResolver<Input extends FieldValues, Context, Output>(
+  schema: z.ZodSchema<Output, any, Input>,
+  schemaOptions: Partial<z.ParseParams> | undefined,
+  resolverOptions: {
+    mode?: 'async' | 'sync';
+    raw: true;
+  },
+): Resolver<Input, Context, Input>
 export function zodResolver<
   Input extends FieldValues,
   Context,
@@ -95,7 +117,7 @@ export function zodResolver<
 ): Resolver<
   Input,
   Context,
-  Output
+  Output | Input // implementation signature might return either; this is hidden from consumers
 > {
   return async (values: Input, _, options) => {
     try {
@@ -107,8 +129,8 @@ export function zodResolver<
 
       return {
         errors: {},
-        values: data,
-      } satisfies ResolverSuccess<Output>;
+        values: resolverOptions.raw ? Object.assign({}, values) : data,
+      } satisfies ResolverSuccess<Input | Output>;
     } catch (error) {
       if (isZodError(error)) {
         return {