frenchdev

Créer des formulaires modernes et type-safe avec TanStack Form [Bonus]

Après la mise en place d'un formulaire TanStack Form (partie 1) puis l'ajout de validations et l'affichage d'erreurs (partie 2), voici quelques idées d'amélioration faciles dont peuvent bénéficier la plupart des formulaires et faciles à mettre en œuvre avec TanStack Form.

Tip #1 - Ajouter un délai avant validation (debounce)

Lorsqu'on souhaite valider un input à la fin d'une saisie, introduire un léger délai avant vérification évite d'enclencher une validation prématurée inutile. Cette pause pour s'assurer que l'input est "stabilisé" avant de le tester permet d'optimiser notre formulaire surtout si la validation requiert un appel API.

Si on combine OnChangeAsyncDebounceMs avec onChangeAsync on peut ainsi trouver un rythme de validation plus intelligent 👇


1  function validateUsername(value: string) {
2    fetch(`/api/validate-username?username=${value}`)
3      .then(response => response.json())
4      .then(data => {
5        if (data.error) {
6          return "Ce nom d'utilisateur est déjà pris"
7        }
8        return null
9      })
10      .catch(error => {
11        return "Une erreur est survenue lors de la validation du nom d'utilisateur"
12      })
13  }
14
15  <form.Field
16        name="username"
17        validators={
18          // On prend ici pour l'exemple une validation asynchrone
19          // mais on peut aussi introduire un debounce sur une validation synchrone
20          onChangeAsyncDebounceMs: 500,
21          onChangeAsync: ({ value }) => validateUsername(value),
22          onChange: ({ value }) => {
23            if (value.length < 3) {
24              return "Le nom d'utilisateur doit contenir au moins 3 caractères"
25            }
26          }
27        }
28        children={({ field }) =>
29          <input
30            id={field.id}
31            type="text"
32            name={field.name}
33            value={field.state.value}
34            onChange={(e) => field.handleChange(e.target.value)}
35          />
36        }
37      />

Tip #2 - Ajouter un indicateur de validation en cours

Quelle que soit la durée de la validation, n'importe quel champ peut afficher son propre indicateur de validation en regardant son field.getMeta().isValidating.

1  <form.Field
2        name="username"
3        children={({ field }) =>
4          <>
5            <input
6              id={field.id}
7              type="text"
8              name={field.name}
9              value={field.state.value}
10              onChange={(e) => field.handleChange(e.target.value)}
11            />
12            {field.getMeta().isValidating && <div>Validation en cours...</div>}
13          </>
14        }
15      />

Tip #3 - Valider plusieurs champs en même temps

Pensons à l'exemple courant d'un formulaire de création de compte comportant un champ pour entrer un mot de passe et un autre pour le confirmer en le rentrant à l'identique. Chacun de ces champs n'est valide que si l'autre contient la même valeur.

En précisant à onChangeListenTo ou onBlurListenTo le tableau de champs qu'on souhaite lui lier, on s'assure que les deux champs sont toujours re-validés en même temps même si l'utilisateur n'interagit qu'avec l'un des deux.

1  <form.Field
2        name="password"
3        validators={{
4          onChangeListenTo: ["confirmPassword"],
5          onChange: ({ value, fieldApi }) => {
6            if (value !== fieldApi.form.getFieldValue("confirmPassword")) {
7              return "Les mot de passe ne correspondent pas"
8            }
9          }
10        }}
11        children={({ field }) =>
12            <input
13              id={field.id}
14              type="password"
15              name={field.name}
16              value={field.state.value}
17              onChange={(e) => field.handleChange(e.target.value)}
18            />
19        }
20      />
21  <form.Field
22        name="confirmPassword"
23        validators={{
24          onChangeListenTo: ["password"],
25          onChange: ({ value, fieldApi }) => {
26            if (value !== fieldApi.form.getFieldValue("password")) {
27              return "Les mot de passe ne correspondent pas"
28            }
29          }
30        }}
31        children={({ field }) =>
32            <input
33              id={field.id}
34              type="password"
35              name={field.name}
36              value={field.state.value}
37              onChange={(e) => field.handleChange(e.target.value)}
38            />
39        }
40      />

On remarquera au passage que nous pouvons récupérer au niveau du field n'importe quelle valeur du form grâce à fieldApi.form.getFieldValue() 🤓

Tip #4 - Utiliser une librairie de validation externe

Plutôt que de définir notre logique de validation à l'aide de fonctions passées dans les validators du formulaire ou du champ, TanStack Form laisse la possibilité d'utiliser des schémas de validation de Zod, Valibot, ArkType et autres librairies pour définir nos règles.

L'association de TanStack Form avec une librairie de validation requiert parfois d'installer un adaptateur pour faire le pont entre les deux. Dans le cas de Zod, on l'obtient avec npm install @tanstack/zod-form-adapter

On passe ensuite notre schéma de validation à onChange, onBlurou onSubmit au niveau du champ... 👇

1import { zodValidator } from "@tanstack/zod-form-adapter"
2import { z } from "zod"
3import { useForm } from "@tanstack/react-form"
4
5const PasswordSchema = z.string().min(8, "Le mot de passe doit contenir au moins 8 caractères")
6
7  <form.Field
8        name="password"
9        validators={{
10          onChange: ({ value, fieldApi }) => {
11            if (value !== fieldApi.form.getFieldValue("confirmPassword")) {
12              return "Les mot de passe ne correspondent pas"
13            }
14          }
15        }}
16        children={({ field })>
17            <input
18              id={field.id}
19              type="password"
20              name={field.name}
21              value={field.state.value}
22              validatorAdapter={zodValidator}
23              onChange={PasswordSchema}
24            />
25        }
26      />

...ou du formulaire tout entier 👇

1import { useForm } from "@tanstack/react-form"
2import { zodValidator } from "@tanstack/zod-form-adapter"
3import { z } from "zod"
4
5const LoginSchema = z.object({
6  username: z.string().min(3, "Le nom de l'utilisateur doit contenir au moins 3 caractères"),
7  password: z.string().min(8, "Le mot de passe doit contenir au moins 8 caractères")
8})
9
10const form = useForm({
11  defaultValues: {
12    username: "",
13    password: "",
14  },
15  validators: {
16    onChange: LoginSchema,
17  },
18  validatorAdapter: zodValidator(),
19  onSubmit: async ({ value}) => {
20    console.log(value)
21  },
22 })

Liens additionnels