typeschema

Author: jorisre

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

@@ -116,6 +116,9 @@ describe('standardSchemaResolver', () => {
 
     const form = useForm({
       resolver: standardSchemaResolver(schema),
+      defaultValues: {
+        id: 3,
+      },
     });
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
@@ -132,6 +135,9 @@ describe('standardSchemaResolver', () => {
 
     const form = useForm({
       resolver: standardSchemaResolver(schema),
+      defaultValues: {
+        id: 3,
+      },
     });
 
     expectTypeOf(form.watch('id')).toEqualTypeOf<number>();

typeschema/src/__tests__/Form.tsx

@@ -11,18 +11,16 @@ const schema = z.object({
   password: z.string().min(1, { message: 'password field is required' }),
 });
 
-type FormData = Infer<typeof schema> & { unusedProperty: string };
-
 interface Props {
-  onSubmit: (data: FormData) => void;
+  onSubmit: (data: Infer<typeof schema>) => void;
 }
 
 function TestComponent({ onSubmit }: Props) {
   const {
     register,
     handleSubmit,
     formState: { errors },
-  } = useForm<FormData>({
+  } = useForm({
     resolver: typeschemaResolver(schema), // Useful to check TypeScript regressions
   });
 

typeschema/src/__tests__/__fixtures__/data.ts

@@ -66,7 +66,7 @@ export const invalidData = {
   birthYear: 'birthYear',
   like: [{ id: 'z' }],
   url: 'abc',
-};
+} as unknown as z.input<typeof schema>;
 
 export const fields: Record<InternalFieldName, Field['_f']> = {
   username: {

typeschema/src/__tests__/typeschema.ts

@@ -1,4 +1,6 @@
 import * as typeschema from '@typeschema/main';
+import { Resolver, SubmitHandler, useForm } from 'react-hook-form';
+import { z } from 'zod';
 import { typeschemaResolver } from '..';
 import { fields, invalidData, schema, validData } from './__fixtures__/data';
 
@@ -67,4 +69,79 @@ describe('typeschemaResolver', () => {
 
     await expect(promise).rejects.toThrow('custom error');
   });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a typeschema schema', () => {
+    const resolver = typeschemaResolver(z.object({ id: z.number() }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<{ id: number }, unknown, { id: number }>
+    >();
+  });
+
+  it('should correctly infer the output type from a typeschema schema using a transform', () => {
+    const resolver = typeschemaResolver(
+      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 typeschema schema when a different input type is specified', () => {
+    const schema = z.object({ id: z.number() }).transform(({ id }) => {
+      return { id: String(id) };
+    });
+
+    const resolver = typeschemaResolver<
+      { 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 typeschema schema for the handleSubmit function in useForm', () => {
+    const schema = z.object({ id: z.number() });
+
+    const form = useForm({
+      resolver: typeschemaResolver(schema),
+      defaultValues: {
+        id: 3,
+      },
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: number;
+      }>
+    >();
+  });
+
+  it('should correctly infer the output type from a typeschema 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: typeschemaResolver(schema),
+      defaultValues: {
+        id: 3,
+      },
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit).parameter(0).toEqualTypeOf<
+      SubmitHandler<{
+        id: string;
+      }>
+    >();
+  });
 });

typeschema/src/index.ts

@@ -1,2 +1 @@
 export * from './typeschema';
-export * from './types';

typeschema/src/types.ts

@@ -1,16 +1,21 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
-import type { ValidationIssue } from '@typeschema/core';
-import { validate } from '@typeschema/main';
-import { FieldError, FieldErrors, appendErrors } from 'react-hook-form';
-import type { Resolver } from './types';
+import {
+  FieldError,
+  FieldErrors,
+  FieldValues,
+  Resolver,
+  appendErrors,
+} from 'react-hook-form';
+import { StandardSchemaV1 } from 'zod/lib/standard-schema';
 
 const parseErrorSchema = (
-  typeschemaErrors: ValidationIssue[],
+  typeschemaErrors: readonly StandardSchemaV1.Issue[],
   validateAllFieldCriteria: boolean,
 ): FieldErrors => {
+  const schemaErrors = Object.assign([], typeschemaErrors);
   const errors: Record<string, FieldError> = {};
 
-  for (; typeschemaErrors.length; ) {
+  for (; schemaErrors.length; ) {
     const error = typeschemaErrors[0];
 
     if (!error.path) {
@@ -37,12 +42,28 @@ const parseErrorSchema = (
       ) as FieldError;
     }
 
-    typeschemaErrors.shift();
+    schemaErrors.shift();
   }
 
   return errors;
 };
 
+export function typeschemaResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
+  resolverOptions?: {
+    raw?: false;
+  },
+): Resolver<Input, Context, Output>;
+
+export function typeschemaResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions: never | undefined,
+  resolverOptions: {
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
 /**
  * Creates a resolver for react-hook-form using TypeSchema validation
  * @param {any} schema - The TypeSchema to validate against
@@ -60,30 +81,36 @@ const parseErrorSchema = (
  *   resolver: typeschemaResolver(schema)
  * });
  */
-export const typeschemaResolver: Resolver =
-  (schema, _, resolverOptions = {}) =>
-  async (values, _, options) => {
-    const result = await validate(schema, values);
+export function typeschemaResolver<Input extends FieldValues, Context, Output>(
+  schema: StandardSchemaV1<Input, Output>,
+  _schemaOptions?: never,
+  resolverOptions: {
+    raw?: boolean;
+  } = {},
+): Resolver<Input, Context, Output | Input> {
+  return async (values, _, options) => {
+    let result = schema['~standard'].validate(values);
+    if (result instanceof Promise) {
+      result = await result;
+    }
 
-    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+    if (result.issues) {
+      const errors = parseErrorSchema(
+        result.issues,
+        !options.shouldUseNativeValidation && options.criteriaMode === 'all',
+      );
 
-    if (result.success) {
       return {
-        errors: {} as FieldErrors,
-        values: resolverOptions.raw
-          ? Object.assign({}, values)
-          : (result.data as any),
+        values: {},
+        errors: toNestErrors(errors, options),
       };
     }
 
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
     return {
-      values: {},
-      errors: toNestErrors(
-        parseErrorSchema(
-          result.issues,
-          !options.shouldUseNativeValidation && options.criteriaMode === 'all',
-        ),
-        options,
-      ),
+      values: resolverOptions.raw ? Object.assign({}, values) : result.value,
+      errors: {},
     };
   };
+}