@hookform/resolvers 5.0.0 → 5.1.0

package/zod/src/__tests__/zod-v4-mini.ts

@@ -0,0 +1,182 @@
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
+import { z } from 'zod/v4-mini';
+import { zodResolver } from '..';
+import {
+  fields,
+  invalidData,
+  schema,
+  validData,
+} from './__fixtures__/data-v4-mini';
+
+const shouldUseNativeValidation = false;
+
+describe('zodResolver', () => {
+  it('should return values from zodResolver when validation pass & raw=true', async () => {
+    const parseAsyncSpy = vi.spyOn(schema, 'parseAsync');
+
+    const result = await zodResolver(schema, undefined, {
+      raw: true,
+    })(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+    result;
+
+    expect(parseAsyncSpy).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ errors: {}, values: validData });
+    expectTypeOf(result.values);
+  });
+
+  it('should return parsed values from zodResolver with `mode: sync` when validation pass', async () => {
+    const parseSpy = vi.spyOn(schema, 'parse');
+    const parseAsyncSpy = vi.spyOn(schema, 'parseAsync');
+
+    const result = await zodResolver(schema, undefined, {
+      mode: 'sync',
+    })(validData, undefined, { fields, shouldUseNativeValidation });
+    expect(parseSpy).toHaveBeenCalledTimes(1);
+    expect(parseAsyncSpy).not.toHaveBeenCalled();
+    expect(result.errors).toEqual({});
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return a single error from zodResolver when validation fails', async () => {
+    const result = await zodResolver(schema)(invalidData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return a single error from zodResolver with `mode: sync` when validation fails', async () => {
+    const parseSpy = vi.spyOn(schema, 'parse');
+    const parseAsyncSpy = vi.spyOn(schema, 'parseAsync');
+
+    const result = await zodResolver(schema, undefined, {
+      mode: 'sync',
+    })(invalidData, undefined, { fields, shouldUseNativeValidation });
+
+    expect(parseSpy).toHaveBeenCalledTimes(1);
+    expect(parseAsyncSpy).not.toHaveBeenCalled();
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from zodResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
+    const result = await zodResolver(schema)(invalidData, undefined, {
+      fields,
+      criteriaMode: 'all',
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from zodResolver when validation fails with `validateAllFieldCriteria` set to true and `mode: sync`', async () => {
+    const result = await zodResolver(schema, undefined, { mode: 'sync' })(
+      invalidData,
+      undefined,
+      {
+        fields,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should throw any error unrelated to Zod', async () => {
+    const schemaWithCustomError = schema.check(
+      z.refine(() => {
+        throw Error('custom error');
+      }),
+    );
+    const promise = zodResolver(schemaWithCustomError)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    await expect(promise).rejects.toThrow('custom error');
+  });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a zod schema', () => {
+    const resolver = zodResolver(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a zod schema using a transform', () => {
+    const resolver = zodResolver(
+      z.object({
+        id: z.pipe(
+          z.number(),
+          z.transform((val) => String(val)),
+        ),
+      }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a zod schema when a different input type is specified', () => {
+    const schema = z.pipe(
+      z.object({ id: z.number() }),
+      z.transform(({ id }) => {
+        return { id: String(id) };
+      }),
+    );
+
+    const resolver = zodResolver<{ id: number }, any, z.output<typeof schema>>(
+      schema,
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, any, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a Zod schema for the handleSubmit function in useForm', () => {
+    const schema = z.object({ id: z.number() });
+
+    const form = useForm({
+      resolver: zodResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a Zod schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = z.object({
+      id: z.pipe(
+        z.number(),
+        z.transform((val) => String(val)),
+      ),
+    });
+
+    const form = useForm({
+      resolver: zodResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
+});

package/zod/src/__tests__/{zod.ts → zod-v4.ts}

@@ -1,7 +1,7 @@
 import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { zodResolver } from '..';
-import { fields, invalidData, schema, validData } from './__fixtures__/data';
+import { fields, invalidData, schema, validData } from './__fixtures__/data-v4';
 
 const shouldUseNativeValidation = false;
 
@@ -92,6 +92,21 @@ describe('zodResolver', () => {
     await expect(promise).rejects.toThrow('custom error');
   });
 
+  it('should enforce parse params type signature', async () => {
+    const resolver = zodResolver(schema, {
+      jitless: true,
+      reportInput: true,
+      error(iss) {
+        iss.path;
+        iss.code;
+        iss.path;
+        return { message: 'asdf' };
+      },
+    });
+
+    resolver;
+  });
+
   /**
    * Type inference tests
    */

package/zod/src/zod.ts

@@ -8,13 +8,29 @@ import {
   ResolverSuccess,
   appendErrors,
 } from 'react-hook-form';
-import { ZodError, z } from 'zod';
+import * as z3 from 'zod/v3';
+import * as z4 from 'zod/v4/core';
 
-const isZodError = (error: any): error is ZodError =>
-  Array.isArray(error?.errors);
+const isZod3Error = (error: any): error is z3.ZodError => {
+  return Array.isArray(error?.issues);
+};
+const isZod3Schema = (schema: any): schema is z3.ZodSchema => {
+  return (
+    '_def' in schema &&
+    typeof schema._def === 'object' &&
+    'typeName' in schema._def
+  );
+};
+const isZod4Error = (error: any): error is z4.$ZodError => {
+  // instanceof is safe in Zod 4 (uses Symbol.hasInstance)
+  return error instanceof z4.$ZodError;
+};
+const isZod4Schema = (schema: any): schema is z4.$ZodType => {
+  return '_zod' in schema && typeof schema._zod === 'object';
+};
 
-function parseErrorSchema(
-  zodErrors: z.ZodIssue[],
+function parseZod3Issues(
+  zodErrors: z3.ZodIssue[],
   validateAllFieldCriteria: boolean,
 ) {
   const errors: Record<string, FieldError> = {};
@@ -63,37 +79,156 @@ function parseErrorSchema(
   return errors;
 }
 
+function parseZod4Issues(
+  zodErrors: z4.$ZodIssue[],
+  validateAllFieldCriteria: boolean,
+) {
+  const errors: Record<string, FieldError> = {};
+  // const _zodErrors = zodErrors as z4.$ZodISsue; //
+  for (; zodErrors.length; ) {
+    const error = zodErrors[0];
+    const { code, message, path } = error;
+    const _path = path.join('.');
+
+    if (!errors[_path]) {
+      if (error.code === 'invalid_union') {
+        const unionError = error.errors[0][0];
+
+        errors[_path] = {
+          message: unionError.message,
+          type: unionError.code,
+        };
+      } else {
+        errors[_path] = { message, type: code };
+      }
+    }
+
+    if (error.code === 'invalid_union') {
+      error.errors.forEach((unionError) =>
+        unionError.forEach((e) => zodErrors.push(e)),
+      );
+    }
+
+    if (validateAllFieldCriteria) {
+      const types = errors[_path].types;
+      const messages = types && types[error.code];
+
+      errors[_path] = appendErrors(
+        _path,
+        validateAllFieldCriteria,
+        errors,
+        code,
+        messages
+          ? ([] as string[]).concat(messages as string[], error.message)
+          : error.message,
+      ) as FieldError;
+    }
+
+    zodErrors.shift();
+  }
+
+  return errors;
+}
+
+type RawResolverOptions = {
+  mode?: 'async' | 'sync';
+  raw: true;
+};
+type NonRawResolverOptions = {
+  mode?: 'async' | 'sync';
+  raw?: false;
+};
+
+// minimal interfaces to avoid asssignability issues between versions
+interface Zod3Type<O = unknown, I = unknown> {
+  _output: O;
+  _input: I;
+  _def: {
+    typeName: string;
+  };
+}
+
+// some type magic to make versions pre-3.25.0 still work
+type IsUnresolved<T> = PropertyKey extends keyof T ? true : false;
+type UnresolvedFallback<T, Fallback> = IsUnresolved<typeof z3> extends true
+  ? Fallback
+  : T;
+type FallbackIssue = {
+  code: string;
+  message: string;
+  path: (string | number)[];
+};
+type Zod3ParseParams = UnresolvedFallback<
+  z3.ParseParams,
+  // fallback if user is on <3.25.0
+  {
+    path?: (string | number)[];
+    errorMap?: (
+      iss: FallbackIssue,
+      ctx: {
+        defaultError: string;
+        data: any;
+      },
+    ) => { message: string };
+    async?: boolean;
+  }
+>;
+type Zod4ParseParams = UnresolvedFallback<
+  z4.ParseContext<z4.$ZodIssue>,
+  // fallback if user is on <3.25.0
+  {
+    readonly error?: (
+      iss: FallbackIssue,
+    ) => null | undefined | string | { message: string };
+    readonly reportInput?: boolean;
+    readonly jitless?: boolean;
+  }
+>;
+
 export function zodResolver<Input extends FieldValues, Context, Output>(
-  schema: z.ZodSchema<Output, any, Input>,
-  schemaOptions?: Partial<z.ParseParams>,
-  resolverOptions?: {
-    mode?: 'async' | 'sync';
-    raw?: false;
-  },
+  schema: Zod3Type<Output, Input>,
+  schemaOptions?: Zod3ParseParams,
+  resolverOptions?: NonRawResolverOptions,
 ): Resolver<Input, Context, Output>;
-
 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;
-  },
+  schema: Zod3Type<Output, Input>,
+  schemaOptions: Zod3ParseParams | undefined,
+  resolverOptions: RawResolverOptions,
 ): Resolver<Input, Context, Input>;
-
+// the Zod 4 overloads need to be generic for complicated reasons
+export function zodResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+  T extends z4.$ZodType<Output, Input> = z4.$ZodType<Output, Input>,
+>(
+  schema: T,
+  schemaOptions?: Zod4ParseParams, // already partial
+  resolverOptions?: NonRawResolverOptions,
+): Resolver<z4.input<T>, Context, z4.output<T>>;
+export function zodResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+  T extends z4.$ZodType<Output, Input> = z4.$ZodType<Output, Input>,
+>(
+  schema: z4.$ZodType<Output, Input>,
+  schemaOptions: Zod4ParseParams | undefined, // already partial
+  resolverOptions: RawResolverOptions,
+): Resolver<z4.input<T>, Context, z4.input<T>>;
 /**
  * Creates a resolver function for react-hook-form that validates form data using a Zod schema
- * @param {z.ZodSchema<Input>} schema - The Zod schema used to validate the form data
- * @param {Partial<z.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing
+ * @param {z3.ZodSchema<Input>} schema - The Zod schema used to validate the form data
+ * @param {Partial<z3.ParseParams>} [schemaOptions] - Optional configuration options for Zod parsing
  * @param {Object} [resolverOptions] - Optional resolver-specific configuration
  * @param {('async'|'sync')} [resolverOptions.mode='async'] - Validation mode. Use 'sync' for synchronous validation
  * @param {boolean} [resolverOptions.raw=false] - If true, returns the raw form values instead of the parsed data
- * @returns {Resolver<z.output<typeof schema>>} A resolver function compatible with react-hook-form
+ * @returns {Resolver<z3.output<typeof schema>>} A resolver function compatible with react-hook-form
  * @throws {Error} Throws if validation fails with a non-Zod error
  * @example
- * const schema = z.object({
- *   name: z.string().min(2),
- *   age: z.number().min(18)
+ * const schema = z3.object({
+ *   name: z3.string().min(2),
+ *   age: z3.number().min(18)
  * });
  *
  * useForm({
@@ -101,41 +236,80 @@ export function zodResolver<Input extends FieldValues, Context, Output>(
  * });
  */
 export function zodResolver<Input extends FieldValues, Context, Output>(
-  schema: z.ZodSchema<Output, any, Input>,
-  schemaOptions?: Partial<z.ParseParams>,
+  schema: object,
+  schemaOptions?: object,
   resolverOptions: {
     mode?: 'async' | 'sync';
     raw?: boolean;
   } = {},
 ): Resolver<Input, Context, Output | Input> {
-  return async (values: Input, _, options) => {
-    try {
-      const data = await schema[
-        resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'
-      ](values, schemaOptions);
-
-      options.shouldUseNativeValidation && validateFieldsNatively({}, options);
-
-      return {
-        errors: {} as FieldErrors,
-        values: resolverOptions.raw ? Object.assign({}, values) : data,
-      } satisfies ResolverSuccess<Output | Input>;
-    } catch (error) {
-      if (isZodError(error)) {
+  if (isZod3Schema(schema)) {
+    return async (values: Input, _, options) => {
+      try {
+        const data = await schema[
+          resolverOptions.mode === 'sync' ? 'parse' : 'parseAsync'
+        ](values, schemaOptions);
+
+        options.shouldUseNativeValidation &&
+          validateFieldsNatively({}, options);
+
         return {
-          values: {},
-          errors: toNestErrors(
-            parseErrorSchema(
-              error.errors,
-              !options.shouldUseNativeValidation &&
-                options.criteriaMode === 'all',
+          errors: {} as FieldErrors,
+          values: resolverOptions.raw ? Object.assign({}, values) : data,
+        } satisfies ResolverSuccess<Output | Input>;
+      } catch (error) {
+        if (isZod3Error(error)) {
+          return {
+            values: {},
+            errors: toNestErrors(
+              parseZod3Issues(
+                error.errors,
+                !options.shouldUseNativeValidation &&
+                  options.criteriaMode === 'all',
+              ),
+              options,
             ),
-            options,
-          ),
-        } satisfies ResolverError<Input>;
+          } satisfies ResolverError<Input>;
+        }
+
+        throw error;
       }
+    };
+  }
 
-      throw error;
-    }
-  };
+  if (isZod4Schema(schema)) {
+    return async (values: Input, _, options) => {
+      try {
+        const parseFn =
+          resolverOptions.mode === 'sync' ? z4.parse : z4.parseAsync;
+        const data: any = await parseFn(schema, values, schemaOptions);
+
+        options.shouldUseNativeValidation &&
+          validateFieldsNatively({}, options);
+
+        return {
+          errors: {} as FieldErrors,
+          values: resolverOptions.raw ? Object.assign({}, values) : data,
+        } satisfies ResolverSuccess<Output | Input>;
+      } catch (error) {
+        if (isZod4Error(error)) {
+          return {
+            values: {},
+            errors: toNestErrors(
+              parseZod4Issues(
+                error.issues,
+                !options.shouldUseNativeValidation &&
+                  options.criteriaMode === 'all',
+              ),
+              options,
+            ),
+          } satisfies ResolverError<Input>;
+        }
+
+        throw error;
+      }
+    };
+  }
+
+  throw new Error('Invalid input: not a Zod schema');
 }