feat(computed-types): type inference

Author: jorisre

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

@@ -1,5 +1,7 @@
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { computedTypesResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
+import Schema, { number } from 'computed-types';
 
 const shouldUseNativeValidation = false;
 
@@ -28,7 +30,6 @@ describe('computedTypesResolver', () => {
     });
 
     const promise = computedTypesResolver(schemaWithCustomError)(
-      // @ts-expect-error expect to throw
       validData,
       undefined,
       {
@@ -39,4 +40,57 @@ describe('computedTypesResolver', () => {
 
     await expect(promise).rejects.toThrow('custom error');
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a computedTypes schema', () => {
+    const resolver = computedTypesResolver(Schema({ id: number }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a computedTypes schema using a transform', () => {
+    const resolver = computedTypesResolver(
+      Schema({ id: number.transform((val) => String(val)) }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a computedTypes schema for the handleSubmit function in useForm', () => {
+    const schema = Schema({ id: number });
+
+    const form = useForm({
+      resolver: computedTypesResolver(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 computedTypes schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = Schema({ id: number.transform((val) => String(val)) });
+
+    const form = useForm({
+      resolver: computedTypesResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
 });

computed-types/src/computed-types.ts

@@ -1,7 +1,7 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
 import { Type, ValidationError } from 'computed-types';
 import FunctionType from 'computed-types/lib/schema/FunctionType';
-import type { FieldErrors, Resolver } from 'react-hook-form';
+import type { FieldErrors, FieldValues, Resolver } from 'react-hook-form';
 
 const isValidationError = (error: any): error is ValidationError =>
   error.errors != null;
@@ -32,9 +32,11 @@ function parseErrorSchema(computedTypesError: ValidationError) {
  *   resolver: computedTypesResolver(schema)
  * });
  */
-export function computedTypesResolver<Schema extends FunctionType<any, any>>(
-  schema: Schema,
-): Resolver<Type<typeof schema>> {
+export function computedTypesResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+>(schema: FunctionType<Output, [Input]>): Resolver<Input, Context, Output> {
   return async (values, _, options) => {
     try {
       const data = await schema(values);