Manejo de formularios de otro nivel en React Native
Mejora el manejo de formularios en React Native con Zod y React Hook Form
El manejo de formularios es una parte fundamental de cualquier aplicación que requiera datos del usuario y, con las herramientas y librerías adecuadas, puede ser un proceso simple y fluido. Este artículo te guiará para manejar formularios en una app de react-native usando react-hook-form y zod. Combinando ambas, conseguiremos un mecanismo eficiente de manejo de formularios. Vamos a crear un formulario de registro básico para ilustrarlo.
El código fuente completo se incluye al final del artículo.
Declaración del esquema con Zod
Para empezar, declaramos nuestro esquema con zod. Este esquema define la forma esperada de los datos del formulario y configura las validaciones de cada campo. Zod ofrece un montón de funciones de validación potentes para definir estas reglas.
Aquí está el esquema completo de zod:
Este artículo da por hecho que conoces lo básico de zod.
import z from "zod";
const phoneNumberRegexp = new RegExp(
/^[\+]?([0-9][\s]?|[0-9]?)([(][0-9]{3}[)][\s]?|[0-9]{3}[-\s\.]?)[0-9]{3}[-\s\.]?[0-9]{4,6}$/im
);
const FIELD_REQUIRED_STR = "This field is required";
export const GENDER_OPTIONS = ["Male", "Female", "Other"] as const;
export const signUpFormSchema = z.object({
name: z
.string({
invalid_type_error: "Name must be a string",
required_error: FIELD_REQUIRED_STR,
})
.min(3, "Minimum 3 characters")
.max(20, "Maximum 20 characters")
.trim(),
surname: z
.string({
invalid_type_error: "Surname must be a string",
required_error: FIELD_REQUIRED_STR,
})
.min(3, "Minimum 3 characters")
.max(20, "Maximum 20 characters")
.trim(),
phoneNumber: z
.string({
invalid_type_error: "Phone number must be a number",
required_error: FIELD_REQUIRED_STR,
})
.regex(phoneNumberRegexp, "Invalid phone number"),
email: z
.string({
invalid_type_error: "Email must be a string",
required_error: FIELD_REQUIRED_STR,
})
.email("Email is invalid"),
gender: z.enum(GENDER_OPTIONS, {
required_error: FIELD_REQUIRED_STR,
invalid_type_error: `Invalid gender, must be one of the followings: ${GENDER_OPTIONS.join(
", "
)}`,
}),
birthDate: z
.date({
invalid_type_error: "Birth date must be a date",
required_error: FIELD_REQUIRED_STR,
})
.min(new Date("1900-01-01"), "Invalid date time, too old")
.max(new Date("2023-01-01"), "Invalid date time, too young")
.default(new Date()),
});
export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;
En este esquema, usamos zod para especificar qué debe contener cada campo. Por ejemplo, los campos name y surname deben ser cadenas de entre 3 y 20 caracteres, mientras que el campo phoneNumber debe ser un número.
También tenemos reglas más complejas para algunos campos. Por ejemplo, el campo email debe ser una cadena y solo admite direcciones de correo válidas. El campo gender debe ser una de las opciones de género predefinidas ('Male', 'Female' u 'Other').
Por último, el campo birthDate es de tipo fecha y debe ser una fecha válida entre 1900-01-01 y 2023-01-01. Por defecto, toma la fecha actual si no se proporciona ninguna.
Con zod podemos crear reglas de validación complejas con facilidad. Así, los datos que recibimos del formulario coincidirán con lo que esperamos.
El siguiente paso es inferir el tipo del esquema. Zod ofrece un método infer, que deriva el tipo de TypeScript de un esquema de zod dado.
export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;
Este tipo inferido se usa más adelante en useForm para asegurar que los datos del formulario se ajustan a nuestro esquema.
Configuración del formulario con React Hook Form
Después, configuramos el formulario usando el hook useForm de 'react-hook-form'. Este hook recibe nuestro esquema de zod (a través de zodResolver) como argumento para resolver la validación del formulario.
const methods = useForm<SignUpFormSchema>({
resolver: zodResolver(signUpFormSchema),
defaultValues: {
birthDate: new Date(),
},
mode: "onBlur",
});
En resolver es donde pasamos nuestro esquema. La propiedad defaultValues nos permite dar valores por defecto a los campos del formulario. En este caso, fijamos como birthDate por defecto la fecha actual. La propiedad mode indica cuándo debe ocurrir la validación. En este caso, la validación ocurrirá onBlur, es decir, cuando el usuario sale de un campo.
Renderizado y validación de campos
Usamos el componente Controller de react-hook-form para gestionar cada campo del formulario. Nos proporciona las props field y fieldState, que usamos para gestionar el valor del campo, su estado de error y su validación.
Por ejemplo, así configuramos el campo name:
<Controller
control={methods.control}
name="name"
render={({ field: { onChange, onBlur, value }, fieldState: { error } }) => {
return (
<TextInput
label="Name"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
Esto es lo que hace cada prop:
-
control: aquí pasas la prop control del hook useForm. Es necesaria para que el Controller interactúe con el estado del formulario.
-
name: es la clave para acceder al valor del input dentro del formulario. Cuando obtienes o fijas los valores del formulario, esta es la clave que se usa. Debe ser única entre todos los campos del formulario.
-
render: es una función que devuelve tu elemento de input. La función proporciona las props field y fieldState.
-
field: contiene las props onChange, onBlur y value. Deben conectarse directamente a tu componente controlado. En este caso, onChange está conectado a onChangeText del TextInput, que captura lo que escribe el usuario y lo guarda en el estado del formulario.
-
fieldState: incluye la prop error, que da información sobre los errores de validación de este campo.
Dentro de la prop render se personaliza el TextInput. onBlur y onChangeText se enlazan con los métodos correspondientes de field, y la prop value se vincula al valor actual del formulario para este input. La prop errorMessage se conecta con el mensaje de error en caso de que la validación falle.
Así, al enviar el formulario o durante la validación en tiempo real, si el campo 'name' no cumple los requisitos de validación definidos en el esquema de Zod, el mensaje de error se mostrará en este TextInput.
Disparar la validación de forma personalizada con React Hook Form
Un caso particular surge con el campo birthDate, que usa un componente selector de fecha (en este caso RNDateTimePicker). En esta situación, el proceso de validación requiere un trato especial, porque la interacción del usuario con un selector de fecha es distinta a la de los inputs de texto habituales.
<Controller
control={methods.control}
name="birthDate"
render={({ field: { onChange, onBlur, value }, fieldState: { error } }) => {
return (
<View>
<Text>Birth date</Text>
<RNDateTimePicker
value={value}
mode="date"
onChange={(e) => {
if (e.type === "set" && e.nativeEvent.timestamp) {
onChange(new Date(e.nativeEvent.timestamp));
methods.trigger("birthDate");
}
}}
/>
{!!error?.message && <Text>{error.message}</Text>}
</View>
);
}}
/>
Cuando el usuario selecciona una fecha, se dispara el evento onChange. Dentro de este manejador, primero comprobamos si el tipo de evento es 'set', lo que indica que el usuario ha fijado una fecha. Después comprobamos si hay un timestamp, para asegurarnos de que se ha seleccionado una fecha.
Tras confirmar estas condiciones, convertimos el timestamp en un objeto Date de JavaScript con new Date(e.nativeEvent.timestamp). Luego, este nuevo valor se pasa a onChange, que actualiza el valor del campo birthDate en el formulario.
Sin embargo, a diferencia de los inputs de texto habituales, que disparan la validación automáticamente al cambiar, los selectores de fecha no la disparan de la misma forma. Por eso tenemos que disparar la validación manualmente después de actualizar el valor. Lo conseguimos llamando a methods.trigger('birthDate').
Este método trigger que proporciona react-hook-form inicia la validación de un campo concreto. Aquí, dispara la validación del campo birthDate en cuanto se fija la fecha, de modo que nuestras reglas de validación se aplican de inmediato.
Por último, si hay errores de validación, se mostrarán mediante {!!error?.message &&
Envío del formulario con React Hook Form
El paquete react-hook-form ofrece métodos eficientes para gestionar el envío de formularios y el manejo de errores.
const onSubmit: SubmitHandler<SignUpFormSchema> = (data) => {
console.log(JSON.stringify(data));
};
const onError: SubmitErrorHandler<SignUpFormSchema> = (errors, e) => {
console.log(JSON.stringify(errors));
};
<Button
onPress={methods.handleSubmit(onSubmit, onError)}
title="Submit Form"
color={"#007BFF"}
/>;
Veamos el proceso paso a paso:
El manejador onSubmit recibe los datos del formulario como argumento. En este caso, solo los mostramos por consola, pero en aplicaciones reales podrían enviarse a un servidor o procesarse según las necesidades de la aplicación.
La función onError, en cambio, se invoca cuando hay errores de validación al enviar el formulario. El objeto errors contiene información detallada sobre todos los campos que no superaron la validación. En este ejemplo, simplemente mostramos estos errores por consola.
Si todos los campos tienen un error, el objeto de errores sería el siguiente:
{
"name": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "name"
}
},
"surname": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "surname"
}
},
"phoneNumber": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "phoneNumber"
}
},
"email": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "email"
}
},
"gender": {
"message": "This field is required",
"type": "invalid_type",
"ref": {
"name": "gender"
}
},
"birthDate": {
"message": "Invalid date time, too young",
"type": "too_big",
"ref": {
"name": "birthDate"
}
}
}
Prevalidación con Zod
El siguiente bloque de código muestra una forma de prevalidar manualmente los datos del formulario con el método safeParse de Zod antes del evento de envío. Aunque el método handleSubmit de React Hook Form ya se encarga de la validación, la prevalidación puede dar a los desarrolladores más control sobre el proceso de validación del formulario.
<Button
title="Submit Form"
onPress={() => {
// get current form values
const currFormValues = methods.getValues();
// Prevalidate using zod's safeParse
const result = signUpFormSchema.safeParse(currFormValues);
// If prevalidation is failed, display the error
if (!result.success) {
Alert.alert(JSON.stringify(result.error));
} else {
// If prevalidation is successful, notify the user
Alert.alert("Validation is successful with zod");
}
}}
/>
Analicemos el código anterior:
-
El evento onPress del Button se usa para ejecutar una función que realiza la prevalidación antes de enviar el formulario.
-
El método getValues de methods (que proporciona React Hook Form) se usa para obtener los valores actuales del formulario.
-
Esos valores se pasan después al método safeParse de signUpFormSchema (el esquema de zod que creamos al principio). En este paso ocurre la prevalidación con zod. A diferencia del método parse de zod, safeParse no lanza un error cuando la validación falla. En su lugar, devuelve un objeto que contiene el booleano success y, si la validación falló, un objeto de error.
-
Una sentencia condicional comprueba si result.success es false (lo que indica que la validación falló). Si es false, muestra una alerta con el error de validación.
-
Si result.success es true (lo que indica que la validación tuvo éxito), muestra una alerta que dice que la validación con zod fue correcta.
Aunque este enfoque pueda parecer redundante, porque handleSubmit de React Hook Form ya valida el formulario con el esquema proporcionado mediante zod, puede ser útil en escenarios concretos. Por ejemplo, puede que quieras realizar ciertas acciones solo después de una validación manual, o que quieras validar los inputs en tiempo real mientras el usuario rellena el formulario. En esos casos, la prevalidación con el método safeParse de zod puede resultar bastante útil.
Y así se vería el objeto de error de zod:
{
"issues": [
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"name"
],
"message": "This field is required"
},
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"surname"
],
"message": "This field is required"
},
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"phoneNumber"
],
"message": "This field is required"
},
{
"code": "invalid_type",
"expected": "string",
"received": "undefined",
"path": [
"email"
],
"message": "This field is required"
},
{
"expected": "'Male' | 'Female' | 'Other'",
"received": "undefined",
"code": "invalid_type",
"path": [
"gender"
],
"message": "This field is required"
},
{
"code": "too_big",
"message": "Invalid date time, too young",
"inclusive": true,
"exact": false,
"maximum": 1672531200000,
"type": "date",
"path": [
"birthDate"
]
}
],
"name": "ZodError"
}
Es un objeto realmente grande, y puede que incluso tenga campos innecesarios para nuestro caso. Por suerte, zod ofrece un método para formatear errores.
Simplemente podemos usar result.error.format() y zod se encarga internamente del resto.
if (!result.success) {
// Format errors using result.error.format()
const formattedError = result.error.format();
Alert.alert(JSON.stringify(formattedError));
} else {
Alert.alert("Validation is successful with zod");
}
El objeto de error formateado se vería así:
{
"name": {
"_errors": [
"This field is required"
]
},
"surname": {
"_errors": [
"This field is required"
]
},
"phoneNumber": {
"_errors": [
"This field is required"
]
},
"email": {
"_errors": [
"This field is required"
]
},
"gender": {
"_errors": [
"This field is required"
]
},
"birthDate": {
"_errors": [
"Invalid date time, too young"
]
}
}
El código más reciente
A continuación está el código más reciente (sin imports ni estilos). Si quieres ver el código fuente completo, consulta el final del artículo.
// imports...
export const SignupForm: React.FC = () => {
const [shouldValidateWithZod, setShouldValidateWithZod] =
React.useState<boolean>(false);
const [isCalendarOpenForAndroid, setIsCalendarOpenForAndroid] =
React.useState<boolean>(false);
const methods = useForm<SignUpFormSchema>({
resolver: zodResolver(signUpFormSchema),
defaultValues: {
birthDate: new Date(),
},
mode: "onBlur",
});
const onSubmit: SubmitHandler<SignUpFormSchema> = (data) => {
console.log(JSON.stringify(data));
};
const onError: SubmitErrorHandler<SignUpFormSchema> = (errors, e) => {
console.log(JSON.stringify(errors));
Alert.alert("Warning", getReadableValidationErrorMessage(errors));
};
return (
<SafeAreaView edges={["top", "bottom"]} style={styles.safeArea}>
<ScrollView>
<Text style={styles.title}>Sign Up Form</Text>
<View style={styles.root}>
<FormProvider {...methods}>
<Controller
control={methods.control}
name="name"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Name"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="surname"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Surname"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="email"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Email"
onBlur={onBlur}
value={value}
onChangeText={onChange}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="phoneNumber"
render={({
field: { onChange, onBlur, value },
fieldState: { error },
}) => {
return (
<TextInput
label="Phone number"
onBlur={onBlur}
keyboardType="decimal-pad"
value={value}
onChangeText={(val) => onChange(val.toString())}
errorMessage={error?.message}
/>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="birthDate"
render={({
field: { onChange, value },
fieldState: { error },
}) => {
return (
<View style={styles.dateWrapper}>
<Text style={styles.label}>Birth date</Text>
{Platform.OS === "android" && (
<Button
onPress={() => {
setIsCalendarOpenForAndroid(true);
}}
title={value.toString()}
/>
)}
{(isCalendarOpenForAndroid ||
Platform.OS !== "android") && (
<RNDateTimePicker
value={value}
style={styles.dateTimePicker}
mode={"date"}
onChange={(e) => {
if (Platform.OS === "android") {
setIsCalendarOpenForAndroid(false);
}
if (e.type === "set" && e.nativeEvent.timestamp) {
onChange(new Date(e.nativeEvent.timestamp));
methods.trigger("birthDate");
}
}}
/>
)}
{!!error?.message && (
<Text style={styles.errorMessageText}>
{error.message}
</Text>
)}
</View>
);
}}
/>
<View style={styles.spacing} />
<Controller
control={methods.control}
name="gender"
render={({
field: { onChange, onBlur, value, ref },
fieldState: { error },
}) => {
return (
<View style={styles.genderWrapper}>
<Text style={styles.label}>Gender</Text>
<View style={styles.genderOptionsWrapper}>
{GENDER_OPTIONS.map((genderOption) => (
<Pressable
key={genderOption}
style={[
styles.genderOptionPressable,
{
backgroundColor:
value === genderOption ? "#007BFF" : "#F2F2F2",
},
]}
onPress={() => onChange(genderOption)}
>
<Text
style={[
styles.genderOptionText,
{
color: value === genderOption ? "#fff" : "#000",
},
]}
>
{genderOption}
</Text>
</Pressable>
))}
</View>
{!!error?.message && (
<Text style={styles.errorMessageText}>
{error.message}
</Text>
)}
</View>
);
}}
/>
<View style={styles.spacing} />
<Text style={styles.label}>Should validate with zod</Text>
<Switch
value={shouldValidateWithZod}
onChange={(e) => setShouldValidateWithZod(e.nativeEvent.value)}
/>
<View style={styles.spacing} />
<Button
onPress={
shouldValidateWithZod
? () => {
/** we could also prevalidate using zod like below */
// get current form values
const currFormValues = methods.getValues();
// https://zod.dev/?id=safeparse
const result = signUpFormSchema.safeParse(currFormValues);
if (!result.success) {
const formattedError = result.error.format();
Alert.alert(JSON.stringify(formattedError));
} else {
Alert.alert("Validation is successful with zod");
}
}
: methods.handleSubmit(onSubmit, onError)
}
title="Submit Form"
color={"#007BFF"}
/>
</FormProvider>
</View>
</ScrollView>
</SafeAreaView>
);
};
// styles...
Esta app de ejemplo está escrita con expo go. ¡Eso significa que puedes probarla fácilmente con el código QR de abajo! (si el QR no funciona, consulta el enlace al código fuente al final del artículo.)

Conclusión
A lo largo de este artículo hemos visto cómo aprovechar de forma eficaz la combinación de React Hook Form, Zod y TypeScript para crear una validación de formularios robusta en nuestra aplicación de React Native. Hemos visto cómo la flexibilidad y la potencia de estas librerías nos permiten escribir código limpio y con tipos seguros, capaz de manejar requisitos de validación complejos.
La sinergia entre React Hook Form y Zod nos permite aprovechar las ventajas de ambas. React Hook Form simplifica el manejo de formularios, optimiza los re-renders e incluye funciones como la gestión del estado del formulario y el manejo de errores. Por otro lado, Zod aporta una capa extra de seguridad, ya que nos permite especificar qué tipo de datos se admiten en cada campo del formulario y hacer cumplir esas reglas.
Recuerda que, aunque las técnicas mostradas aquí se usan en el contexto de un formulario de registro sencillo, son aplicables a cualquier entrada de datos basada en formularios en tus aplicaciones de React Native. Con estas estrategias puedes asegurarte de que tus formularios sean fáciles de usar, robustos y mantenibles, lo que se traduce en mejores experiencias de usuario y aplicaciones más sólidas.