feat(standardSchema): type inference

Author: jorisre

standard-schema/src/__tests__/__fixtures__/data.ts

@@ -59,15 +59,15 @@ export const validData = {
     },
   ],
   dateStr: '2020-01-01T00:00:00.000Z',
-} as any as z.infer<typeof schema>;
+} satisfies z.input<typeof schema>;
 
 export const invalidData = {
   password: '___',
   email: '',
   birthYear: 'birthYear',
   like: [{ id: 'z' }],
   url: 'abc',
-} as any as z.infer<typeof schema>;
+} as unknown as z.input<typeof schema>;
 
 export const fields: Record<InternalFieldName, Field['_f']> = {
   username: {

standard-schema/src/__tests__/standard-schema.ts

@@ -1,3 +1,4 @@
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
 import { standardSchemaResolver } from '..';
 import {
   customSchema,
@@ -6,6 +7,7 @@ import {
   schema,
   validData,
 } from './__fixtures__/data';
+import { z } from 'zod';
 
 const shouldUseNativeValidation = false;
 
@@ -71,4 +73,73 @@ describe('standardSchemaResolver', () => {
 
     expect(result).toMatchSnapshot();
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a standardSchema schema', () => {
+    const resolver = standardSchemaResolver(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a standardSchema schema using a transform', () => {
+    const resolver = standardSchemaResolver(
+      z.object({ id: z.number().transform((val) => String(val)) }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: string }>
+    >();
+  });
+
+  it('should correctly infer the output type from a standardSchema schema when a different input type is specified', () => {
+    const schema = z.object({ id: z.number() }).transform(({ id }) => {
+      return { id: String(id) };
+    });
+
+    const resolver = standardSchemaResolver<
+      { 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 standardSchema schema for the handleSubmit function in useForm', () => {
+    const schema = z.object({ id: z.number() });
+
+    const form = useForm({
+      resolver: standardSchemaResolver(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 standardSchema schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = z.object({ id: z.number().transform((val) => String(val)) });
+
+    const form = useForm({
+      resolver: standardSchemaResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
 });

standard-schema/src/standard-schema.ts

@@ -3,7 +3,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 import { getDotPath } from '@standard-schema/utils';
 import { FieldError, FieldValues, Resolver } from 'react-hook-form';
 
-function parseIssues(
+function parseErrorSchema(
   issues: readonly StandardSchemaV1.Issue[],
   validateAllFieldCriteria: boolean,
 ) {
@@ -32,6 +32,28 @@ function parseIssues(
   return errors;
 }
 
+export function standardSchemaResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+>(
+  schema: StandardSchemaV1<Input, Output>,
+  resolverOptions?: {
+    raw?: false;
+  },
+): Resolver<Input, Context, Output>;
+
+export function standardSchemaResolver<
+  Input extends FieldValues,
+  Context,
+  Output,
+>(
+  schema: StandardSchemaV1<Input, Output>,
+  resolverOptions: {
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
 /**
  * Creates a resolver for react-hook-form that validates data using a Standard Schema.
  *
@@ -53,21 +75,23 @@ function parseIssues(
  * ```
  */
 export function standardSchemaResolver<
-  Schema extends StandardSchemaV1<FieldValues>,
+  Input extends FieldValues,
+  Context,
+  Output,
 >(
-  schema: Schema,
+  schema: StandardSchemaV1<Input, Output>,
   resolverOptions: {
     raw?: boolean;
   } = {},
-): Resolver<StandardSchemaV1.InferOutput<Schema>> {
+): Resolver<Input, Context, Output | Input> {
   return async (values, _, options) => {
     let result = schema['~standard'].validate(values);
     if (result instanceof Promise) {
       result = await result;
     }
 
     if (result.issues) {
-      const errors = parseIssues(
+      const errors = parseErrorSchema(
         result.issues,
         !options.shouldUseNativeValidation && options.criteriaMode === 'all',
       );