Forms abstraction in a hook

[guibzo]

Hi there. Does someone have a good abstraction hook to deal with forms? I was looking for some abstraction with zod, rhf and maybe error messages.
The best one I came across was this one, and I was looking for improvements or suggestions:

// useFormValidation.ts
import { zodResolver } from "@hookform/resolvers/zod"
import { useState } from "react"
import { FieldErrors, useForm, type DefaultValues } from "react-hook-form"
import { z as zod } from "zod"
import { toast } from "../components/ui/use-toast"

import { FieldValues } from "react-hook-form"

export function useFormValidation<T extends FieldValues>(
	schema: zod.ZodObject<any> | zod.ZodEffects<zod.ZodObject<any>>, 
	errorMessages: { [key: string]: string }, 
	submit: (input: T) => Promise<void>, 
	defaultValues?: DefaultValues<T>
) {
	const [isSubmitting, setIsSubmitting] = useState(false)

	const { register, handleSubmit, reset, control } = useForm<T>({
		resolver: zodResolver(schema),
		defaultValues,
	})
	

	const onSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
		event.preventDefault()
		setIsSubmitting(true)
		handleSubmit(
			async (input: T) => {
				try {
					await submit(input)
					setIsSubmitting(false)
					reset()
				} catch (error: any) {
					showSubmitError(error.message)
					setIsSubmitting(false)
				}
			},
			async (errors: FieldErrors<T>) => {
				onError(errors)
				setIsSubmitting(false)
			},
		)()
	}

	const onError = (errors: FieldErrors<zod.infer<typeof schema>>) => {
		let schemaShape
		if (schema instanceof zod.ZodObject) {
			schemaShape = schema.shape
		} else if (schema instanceof zod.ZodEffects && schema._def.schema instanceof zod.ZodObject) {
			schemaShape = schema._def.schema.shape
		} else {
			throw new Error("Invalid schema type")
		}

		if (schemaShape) {
			const schemaKeys = Object.keys(schemaShape)
			for (let key of schemaKeys) {
				const error = errors?.[key]?.message
				if (error) {
					showSubmitError(error.toString())
					break
				}
			}
		}
	}

	const showSubmitError = (error: string) => {
		toast({
			variant: "destructive",
			title: errorMessages[error] ? errorMessages[error] : "Erro ao realizar a operação",
			description: errorMessages[error] ? undefined : error,
		})
	}

	return { inputs: register, onSubmit, isSubmitting, setIsSubmitting, showSubmitError, resetFields: reset, control }
}

// component.tsx
const changeAddressFormSchema = z.object({
	// schema...
})

const changeAddressFormErrorMessages: { [key: string]: string } = {
	STREET_IS_INVALID: "Error message here",
}
const handleChangeAddress = async (formData: z.infer<typeof changeAddressFormSchema>) => {
	// action function...
		// in my case, this also displays a toast with success or error when the modal is closed 
		// (different toast from the one used in useFormValidation, which only displays the error and when it is open)
}

const { inputs, onSubmit, isSubmitting } = useFormValidation<z.infer<typeof changeAddressFormSchema>>(
    changeAddressFormSchema, 
    changeAddressFormErrorMessages, 
    handleChangeAddress
)

<form onSubmit={onSubmit}>
   <Input {...inputs("street")} label="Street" defaultValue={address?.street} placeholder="Street One" />
</form>