fix: resolvers fails silently (#528)

computed-types/src/__tests__/computed-types.ts

@@ -21,4 +21,20 @@ describe('computedTypesResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  it('should throw any error unrelated to computed-types', async () => {
+    const schemaWithCustomError = schema.transform(() => {
+      throw Error('custom error');
+    });
+    const promise = computedTypesResolver(schemaWithCustomError)(
+      validData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    await expect(promise).rejects.toThrow('custom error');
+  });
 });

computed-types/src/computed-types.ts

@@ -1,7 +1,10 @@
 import type { FieldErrors } from 'react-hook-form';
 import { toNestError, validateFieldsNatively } from '@hookform/resolvers';
-import type { ValidationError } from 'computed-types';
 import type { Resolver } from './types';
+import type { ValidationError } from 'computed-types';
+
+const isValidationError = (error: any): error is ValidationError =>
+  error.errors != null;
 
 const parseErrorSchema = (computedTypesError: ValidationError) => {
   const parsedErrors: FieldErrors = {};
@@ -27,9 +30,13 @@ export const computedTypesResolver: Resolver =
         values: data,
       };
     } catch (error: any) {
-      return {
-        values: {},
-        errors: toNestError(parseErrorSchema(error), options),
-      };
+      if (isValidationError(error)) {
+        return {
+          values: {},
+          errors: toNestError(parseErrorSchema(error), options),
+        };
+      }
+
+      throw error;
     }
   };

superstruct/src/__tests__/superstruct.ts

@@ -21,4 +21,17 @@ describe('superstructResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  it('should return values from superstructResolver when validation pass & raw=true', async () => {
+    const result = await superstructResolver(schema, undefined, { raw: true })(
+      validData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
 });

superstruct/src/superstruct.ts

@@ -15,8 +15,9 @@ const parseErrorSchema = (error: StructError) =>
   );
 
 export const superstructResolver: Resolver =
-  (schema, resolverOptions) => (values, _, options) => {
-    const result = validate(values, schema, resolverOptions);
+  (schema, schemaOptions, resolverOptions = {}) =>
+  (values, _, options) => {
+    const result = validate(values, schema, schemaOptions);
 
     if (result[0]) {
       return {
@@ -28,7 +29,7 @@ export const superstructResolver: Resolver =
     options.shouldUseNativeValidation && validateFieldsNatively({}, options);
 
     return {
-      values: result[1],
+      values: resolverOptions.raw ? values : result[1],
       errors: {},
     };
   };

superstruct/src/types.ts

@@ -1,15 +1,18 @@
-import {
-  FieldValues,
-  ResolverOptions,
-  ResolverResult,
-} from 'react-hook-form';
+import { FieldValues, ResolverOptions, ResolverResult } from 'react-hook-form';
 import { validate, Struct } from 'superstruct';
 
 type Options = Parameters<typeof validate>[2];
 
 export type Resolver = <T extends Struct<any, any>>(
   schema: T,
   options?: Options,
+  factoryOptions?: {
+    /**
+     * Return the raw input values rather than the parsed values.
+     * @default false
+     */
+    raw?: boolean;
+  },
 ) => <TFieldValues extends FieldValues, TContext>(
   values: TFieldValues,
   context: TContext | undefined,

yup/src/__tests__/yup.ts

@@ -190,4 +190,34 @@ describe('yupResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  it('should throw any error unrelated to Yup', async () => {
+    const schemaWithCustomError = schema.transform(() => {
+      throw Error('custom error');
+    });
+    const promise = yupResolver(schemaWithCustomError)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    await expect(promise).rejects.toThrow('custom error');
+  });
+
+  it('should return values from yupResolver when validation pass & raw=true', async () => {
+    const schemaSpy = vi.spyOn(schema, 'validate');
+    const schemaSyncSpy = vi.spyOn(schema, 'validateSync');
+
+    const result = await yupResolver(schema, undefined, { raw: true })(
+      validData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(schemaSpy).toHaveBeenCalledTimes(1);
+    expect(schemaSyncSpy).not.toHaveBeenCalled();
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
 });

yup/src/types.ts

@@ -6,7 +6,17 @@ type Options<T extends Yup.ObjectSchema<any>> = Parameters<T['validate']>[1];
 export type Resolver = <T extends Yup.ObjectSchema<any>>(
   schema: T,
   schemaOptions?: Options<T>,
-  factoryOptions?: { mode?: 'async' | 'sync'; rawValues?: boolean },
+  factoryOptions?: {
+    /**
+     * @default async
+     */
+    mode?: 'async' | 'sync';
+    /**
+     * Return the raw input values rather than the parsed values.
+     * @default false
+     */
+    raw?: boolean;
+  },
 ) => <TFieldValues extends FieldValues, TContext>(
   values: TFieldValues,
   context: TContext | undefined,

yup/src/yup.ts

@@ -59,7 +59,7 @@ export const yupResolver: Resolver =
       options.shouldUseNativeValidation && validateFieldsNatively({}, options);
 
       return {
-        values: resolverOptions.rawValues ? values : result,
+        values: resolverOptions.raw ? values : result,
         errors: {},
       };
     } catch (e: any) {

zod/src/__tests__/zod.ts

@@ -4,11 +4,11 @@ import { schema, validData, invalidData, fields } from './__fixtures__/data';
 const shouldUseNativeValidation = false;
 
 describe('zodResolver', () => {
-  it('should return values from zodResolver when validation pass & rawValues=true', async () => {
+  it('should return values from zodResolver when validation pass & raw=true', async () => {
     const parseAsyncSpy = vi.spyOn(schema, 'parseAsync');
 
     const result = await zodResolver(schema, undefined, {
-      rawValues: true,
+      raw: true,
     })(validData, undefined, {
       fields,
       shouldUseNativeValidation,
@@ -77,4 +77,16 @@ describe('zodResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  it('should throw any error unrelated to Zod', async () => {
+    const schemaWithCustomError = schema.refine(() => {
+      throw Error('custom error');
+    });
+    const promise = zodResolver(schemaWithCustomError)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    await expect(promise).rejects.toThrow('custom error');
+  });
 });

zod/src/types.ts

@@ -1,8 +1,4 @@
-import {
-  FieldValues,
-  ResolverResult,
-  ResolverOptions,
-} from 'react-hook-form';
+import { FieldValues, ResolverResult, ResolverOptions } from 'react-hook-form';
 import { z } from 'zod';
 
 export type Resolver = <T extends z.Schema<any, any>>(
@@ -17,7 +13,7 @@ export type Resolver = <T extends z.Schema<any, any>>(
      * Return the raw input values rather than the parsed values.
      * @default false
      */
-    rawValues?: boolean;
+    raw?: boolean;
   },
 ) => <TFieldValues extends FieldValues, TContext>(
   values: TFieldValues,

zod/src/zod.ts

@@ -1,8 +1,10 @@
 import { appendErrors, FieldError, FieldErrors } from 'react-hook-form';
-import { z } from 'zod';
+import { z, ZodError } from 'zod';
 import { toNestError, validateFieldsNatively } from '@hookform/resolvers';
 import type { Resolver } from './types';
 
+const isZodError = (error: any): error is ZodError => error.errors != null;
+
 const parseErrorSchema = (
   zodErrors: z.ZodIssue[],
   validateAllFieldCriteria: boolean,
@@ -65,21 +67,23 @@ export const zodResolver: Resolver =
 
       return {
         errors: {} as FieldErrors,
-        values: resolverOptions.rawValues ? values : data,
+        values: resolverOptions.raw ? values : data,
       };
     } catch (error: any) {
-      return {
-        values: {},
-        errors: error.isEmpty
-          ? {}
-          : toNestError(
-              parseErrorSchema(
-                error.errors,
-                !options.shouldUseNativeValidation &&
-                  options.criteriaMode === 'all',
-              ),
-              options,
+      if (isZodError(error)) {
+        return {
+          values: {},
+          errors: toNestError(
+            parseErrorSchema(
+              error.errors,
+              !options.shouldUseNativeValidation &&
+                options.criteriaMode === 'all',
             ),
-      };
+            options,
+          ),
+        };
+      }
+
+      throw error;
     }
   };