# Formulieren afhandelen op het volgende niveau in React Native

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-06-28. Canonical: https://tarikpinarci.com/nl/blog/react-native-next-level-form-handling

## Formulieren afhandelen op het volgende niveau in React Native

Betere formulierafhandeling in React Native met Zod en React Hook Form

Formulieren afhandelen is een fundamenteel onderdeel van elke applicatie die invoer van gebruikers nodig heeft, en met de juiste tools en libraries kan dat een eenvoudig en soepel proces zijn. In dit artikel laat ik zien hoe je formulieren afhandelt in een React Native-app met [react-hook-form](https://react-hook-form.com/) en [zod](https://zod.dev/). Door die twee te combineren krijgen we een efficiënt mechanisme voor formulierafhandeling. Laten we een eenvoudig registratieformulier bouwen om dit te illustreren.

**De volledige broncode staat aan het einde van het artikel.**

### Het schema declareren met Zod

Om te beginnen declareren we ons schema met zod. Dit schema beschrijft de verwachte vorm van onze formulierdata en stelt voor elk veld validaties in. Zod biedt een hele reeks krachtige validatiefuncties om die regels te definiëren.

Dit is het volledige zod-schema:

Dit artikel gaat ervan uit dat je de basis van zod kent.

```tsx
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>;
```

In dit schema gebruiken we zod om vast te leggen wat elk veld moet bevatten. De velden name en surname moeten bijvoorbeeld strings zijn van 3 tot 20 tekens lang, terwijl het veld phoneNumber een getal moet zijn.

Voor sommige velden hebben we ook complexere regels. Het veld email moet bijvoorbeeld een string zijn, en alleen geldige e-mailadressen zijn toegestaan. Het veld gender moet een van de vooraf gedefinieerde opties zijn ('Male', 'Female' of 'Other').

Tot slot is het veld birthDate van het type date en moet het een geldige datum zijn tussen 1900-01-01 en 2023-01-01. Als er geen datum wordt opgegeven, neemt het standaard de huidige datum.

Met zod maken we zonder moeite complexe validatieregels. Zo weten we zeker dat de data die we uit ons formulier krijgen overeenkomt met wat we verwachten.

De volgende stap is het type van het schema afleiden. Zod heeft een infer-methode die het TypeScript-type van een zod-schema afleidt.

    export type SignUpFormSchema = z.infer<typeof signUpFormSchema>;

Dit afgeleide type gebruiken we later in useForm, zodat onze formulierdata aansluit op ons schema.

### Het formulier opzetten met React Hook Form

Daarna zetten we ons formulier op met de hook useForm uit 'react-hook-form'. Deze hook krijgt ons zod-schema (via zodResolver) als argument om de formuliervalidatie af te handelen.

```tsx
const methods = useForm<SignUpFormSchema>({
  resolver: zodResolver(signUpFormSchema),
  defaultValues: {
    birthDate: new Date(),
  },
  mode: "onBlur",
});
```

In de resolver geven we ons schema mee. Met de property defaultValues kunnen we standaardwaarden voor formuliervelden opgeven. Hier zetten we de standaardwaarde van birthDate op de huidige datum. De property mode bepaalt wanneer de validatie plaatsvindt. In dit geval gebeurt de validatie onBlur, dus wanneer de gebruiker een veld verlaat.

### Velden renderen en valideren

We gebruiken de component Controller uit react-hook-form om elk formulierveld te beheren. Die geeft ons de props field en fieldState, waarmee we de waarde, de foutstatus en de validatie van ons veld beheren.

Zo zetten we bijvoorbeeld het veld name op:

```tsx
<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}
      />
    );
  }}
/>
```

Dit doet elke prop:

- control: hier geef je de prop control van de hook useForm mee. De Controller heeft die nodig om met de formulierstate te kunnen werken.

- name: dit is de sleutel waarmee je de waarde van de invoer binnen het formulier opvraagt. Als je formulierwaarden ophaalt of instelt, wordt deze sleutel gebruikt. Hij moet uniek zijn over alle formuliervelden heen.

- render: dit is een functie die je invoerelement teruggeeft. De functie levert de props field en fieldState.

- field: bevat de props onChange, onBlur en value. Die moeten direct gekoppeld worden aan je controlled component. Hier is onChange verbonden met onChangeText van TextInput, zodat de invoer van de gebruiker wordt opgevangen en in de formulierstate wordt opgeslagen.

- fieldState: bevat de prop error, met informatie over validatiefouten voor dit veld.

Binnen de prop render passen we de TextInput aan. onBlur en onChangeText zijn gekoppeld aan de bijbehorende methodes van field, en de prop value is gekoppeld aan de huidige formulierwaarde voor deze invoer. De prop errorMessage is verbonden met de foutmelding voor het geval de validatie mislukt.

Als het veld 'name' bij het versturen van het formulier of bij realtime validatie niet voldoet aan de validatie-eisen uit het Zod-schema, verschijnt de foutmelding dus in dit TextInput-veld.

### Zelf validatie starten met React Hook Form

Een bijzonder geval doet zich voor bij het veld birthDate, dat een datumkiezer gebruikt (in dit geval RNDateTimePicker). Hier vraagt de validatie om een speciale aanpak, omdat de gebruiker anders met een datumkiezer werkt dan met gewone tekstvelden.

```tsx
<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>
    );
  }}
/>
```

Als de gebruiker een datum kiest, wordt het event onChange afgevuurd. In deze event handler controleren we eerst of het type van het event 'set' is, wat betekent dat de gebruiker een datum heeft ingesteld. Daarna controleren we of er een timestamp aanwezig is, om zeker te weten dat er een datum is gekozen.

Als aan die voorwaarden is voldaan, zetten we de timestamp om naar een JavaScript Date-object met new Date(e.nativeEvent.timestamp). Die nieuwe waarde geven we door aan onChange, dat de waarde van het veld birthDate in het formulier bijwerkt.

Maar in tegenstelling tot gewone tekstvelden, die bij wijzigingen automatisch de validatie starten, doen datumkiezers dat niet op dezelfde manier. Daarom moeten we de validatie handmatig starten nadat de waarde is bijgewerkt. Dat doen we door methods.trigger('birthDate') aan te roepen.

Deze methode trigger van react-hook-form start de validatie voor één specifiek veld. Hier start ze de validatie voor het veld birthDate zodra de datum is ingesteld, zodat onze validatieregels meteen worden toegepast.

Tot slot worden eventuele validatiefouten getoond via {!!error?.message && <Text>{error.message}</Text>}, waarbij error?.message de validatiefoutmelding bevat zoals die in ons zod-schema is gedefinieerd.

### Het formulier versturen met React Hook Form

Het pakket react-hook-form biedt efficiënte methodes om het versturen van formulieren en het afhandelen van fouten te regelen.

```tsx
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"}
/>;
```

Laten we het proces opsplitsen:

De handler onSubmit krijgt de formulierdata als argument. In dit voorbeeld loggen we die data alleen, maar in echte applicaties kun je ze naar een server sturen of verder bewerken, afhankelijk van wat de applicatie nodig heeft.

De functie onError wordt daarentegen aangeroepen als er bij het versturen van het formulier validatiefouten zijn. Het object errors bevat gedetailleerde informatie over alle velden die niet door de validatie kwamen. In dit voorbeeld loggen we die fouten gewoon.

Als elk veld een fout heeft, ziet het error-object er zo uit:

```tsx
    {
      "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"
        }
      }
    }
```

### Vooraf valideren met Zod

Het codeblok hieronder laat een aanpak zien waarbij je de formulierdata handmatig vooraf valideert met de methode safeParse van Zod, nog voor het event waarmee het formulier wordt verstuurd. De formuliervalidatie wordt al geregeld door de methode handleSubmit van React Hook Form, maar vooraf valideren kan developers meer controle geven over het validatieproces.

```tsx
<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");
    }
  }}
/>
```

Laten we de code hierboven analyseren:

- Het event onPress van de Button wordt gebruikt om een functie uit te voeren die vooraf valideert, voordat het formulier wordt verstuurd.

- De methode getValues van methods (die React Hook Form levert) wordt gebruikt om de huidige formulierwaarden op te halen.

- Die waarden worden vervolgens doorgegeven aan de methode safeParse van signUpFormSchema (het zod-schema dat we aan het begin hebben gemaakt). In deze stap gebeurt de voorafgaande validatie met zod. Anders dan de methode parse van zod gooit safeParse geen fout als de validatie mislukt. In plaats daarvan geeft het een object terug met de boolean success en, als de validatie is mislukt, een error-object.

- Een voorwaarde controleert of result.success false is (wat betekent dat de validatie is mislukt). Als dat zo is, verschijnt er een alert met de validatiefout.

- Als result.success true is (wat betekent dat de validatie is geslaagd), verschijnt er een alert die meldt dat de validatie met zod is gelukt.

Deze aanpak lijkt misschien overbodig, omdat handleSubmit van React Hook Form de formuliervalidatie al uitvoert met het schema dat via zod is meegegeven. Toch kan hij in specifieke situaties nuttig zijn. Misschien wil je bepaalde acties pas uitvoeren na een handmatige validatie, of wil je formulierinvoer realtime valideren terwijl de gebruiker het formulier invult. In zulke gevallen kan vooraf valideren met de methode safeParse van zod heel handig zijn.

Zo ziet het error-object van zod eruit:

```tsx
    {
      "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"
    }
```

Het is inderdaad een groot object, en er kunnen zelfs velden in zitten die we in ons geval niet nodig hebben. Gelukkig heeft zod een methode om [fouten te formatteren](https://zod.dev/?id=error-formatting).

We kunnen gewoon result.error.format() gebruiken, en zod regelt de rest intern.

```tsx
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");
}
```

Het geformatteerde error-object ziet er zo uit:

```tsx
    {
      "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"
        ]
      }
    }
```

### De nieuwste code

Hieronder staat de meest recente code (zonder imports en styles). Als je de volledige broncode wilt bekijken, kijk dan aan het einde van het artikel.

```tsx
// 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...
```

Deze voorbeeldapp is geschreven met [expo go](https://expo.dev/client). Je kunt hem dus makkelijk testen met de QR-code hieronder! _(als de QR-code niet werkt, gebruik dan de link naar de broncode aan het einde van het artikel.)_

![](https://cdn-images-1.medium.com/max/2000/1*64aqLz3tRQIFDm3ZXbvIdw.png)

### Conclusie

In dit artikel hebben we bekeken hoe we de combinatie van React Hook Form, Zod en TypeScript goed kunnen inzetten om robuuste formuliervalidatie te bouwen in onze React Native-applicatie. We hebben gezien hoe de flexibiliteit en kracht van deze libraries ons in staat stellen om nette, type-safe code te schrijven die complexe validatie-eisen aankan.

Door React Hook Form en Zod samen te gebruiken, profiteren we van de voordelen van allebei. React Hook Form maakt formulierafhandeling eenvoudiger, optimaliseert het opnieuw renderen en heeft functies zoals het beheer van formulierstate en foutafhandeling. Zod geeft daarnaast een extra laag veiligheid: we kunnen vastleggen welke soort data voor elk formulierveld is toegestaan en die regels afdwingen.

Onthoud dat de technieken hier worden gebruikt in de context van een eenvoudig registratieformulier, maar dat ze toepasbaar zijn op alle formuliergebaseerde gebruikersinvoer in je React Native-applicaties. Met deze strategieën zorg je ervoor dat je formulieren gebruiksvriendelijk, robuust en onderhoudbaar zijn, wat leidt tot betere gebruikerservaringen en robuustere applicaties.

[**Link naar de volledige broncode**](https://github.com/tarikfp/rn-zod-react-hook-form)

