Introduzione a Zod: Convalida dei Dati con TypeScript

Benvenuto, avventuriero della tipizzazione! 🎩 TypeScript è fantastico, vero? Ci permette di strutturare meglio il nostro codice aggiungendo tipizzazione statica e ci aiuta a evitare bug fastidiosi. Ma ecco il problema: TypeScript controlla i tipi... solo durante la compilazione! 😬 Ebbene sì, una volta che il tuo codice viene eseguito, nulla garantisce che i dati provenienti dall'esterno (API, utenti, ecc.) rispetteranno la struttura prevista. Ed è qui che entra in scena Zod, per salvarci! 🚀

In questo articolo, scopriremo perché e come utilizzare Zod, una libreria che ti permette di validare e tipizzare i tuoi dati dinamicamente. Dalla validazione di base alle strutture dati più complesse, Zod ti offre tutto ciò che serve per proteggere i tuoi dati in TypeScript senza compromessi. Cominciamo! 🎉

Cos'è Zod? 🤔

Zod è una libreria di validazione degli schemi in TypeScript che verifica i tuoi dati in tempo reale. Con Zod, puoi creare schemi di validazione per qualsiasi tipo di oggetto. Immagina un'API che ti restituisce dati incerti: Zod permette di verificare al volo che i dati ricevuti corrispondano effettivamente al tipo previsto.

Alcune caratteristiche chiave di Zod 💪

• Semplice e flessibile: La sua sintassi è intuitiva ed espressiva.
• Validazione e tipizzazione combinate: Non c'è bisogno di jonglare tra tipi e validazioni separate, Zod gestisce tutto!
• Feedback istantaneo: Ottieni errori dettagliati non appena i tuoi dati non corrispondono allo schema.
• API robusta: Dalla validazione semplice alle trasformazioni complesse, Zod offre un'API completa.

Installazione di Zod 📦

Per iniziare, è sufficiente installare Zod tramite npm o yarn:

bash
1npm install zod
2# oppure
3yarn add zod
4# oppure
5pnpm add zod
6# oppure
7bun add zod

Ora che sei pronto, immergiamoci nella creazione del tuo primo schema Zod!

Creazione di Schemi Base con Zod 🎨

Uno schema Zod rappresenta una struttura dati prevista. Prendiamo un esempio semplice dove vogliamo validare un utente con un nome, un'età e un indirizzo email.

Esempio: Validazione di base

Ecco come definire uno schema Zod per un utente 👤:

typescript
1import { z } from 'zod';
2
3// Schema utente
4const userSchema = z.object({
5  name: z.string(), // Il nome deve essere una stringa
6  age: z.number().int().min(18), // L'età deve essere un intero, minimo 18
7  email: z.string().email(), // Deve essere un email valido
8});
9
10// Esempio di dati in ingresso
11const userInput = {
12  name: 'Alice',
13  age: 25,
14  email: 'alice@example.com',
15};
16
17// Validazione dei dati
18try {
19  const validUser = userSchema.parse(userInput); // Parse restituisce i dati validati
20  console.log('Utente valido:', validUser);
21} catch (e) {
22  console.error('Errore di validazione:', e.errors);
23}

Con questo esempio, Zod verificherà se userInput rispetta lo schema definito da userSchema. Se tutto è in ordine, parse restituisce i dati validati. Altrimenti, solleva un errore con un messaggio dettagliato su cosa non va. Niente sorprese in produzione! 🎉

Tipi Condizionali e Union: Gestione dei Casi Multipli 🔀

Zod gestisce anche gli schemi complessi grazie ai tipi condizionali. Diciamo che hai un form dove l'utente può essere un cliente o un amministratore. Ecco come definire questo schema con Zod.

Esempio: Schema con union

typescript
1// Schema cliente
2const clientSchema = z.object({
3  role: z.literal('client'),
4  preferences: z.array(z.string()), // Array di preferenze
5});
6
7// Schema amministratore
8const adminSchema = z.object({
9  role: z.literal('admin'),
10  accessLevel: z.number().min(1).max(5), // Livello di accesso da 1 a 5
11});
12
13// Union dei due schemi
14const userSchema = z.union([clientSchema, adminSchema]);
15
16// Esempio di utente
17const adminUser = {
18  role: 'admin',
19  accessLevel: 3,
20};
21
22// Validazione
23try {
24  const validUser = userSchema.parse(adminUser);
25  console.log('Utente valido:', validUser);
26} catch (e) {
27  console.error('Errore di validazione:', e.errors);
28}

In questo esempio, Zod valida che adminUser sia o un client o un admin con le proprietà richieste per ciascun ruolo. Pratico, vero? 👌

Le Trasformazioni: Validare e Trasformare Contemporaneamente 🔄

A volte, vuoi validare un dato e trasformarlo al passaggio. Zod permette di farlo facilmente, come per esempio trasformando una stringa in numero.

Esempio: Trasformazione dei dati

typescript
1const priceSchema = z.string().transform((val) => parseFloat(val));
2
3// Esempio di input
4const priceInput = '49.99';
5
6// Validazione e trasformazione
7const validPrice = priceSchema.parse(priceInput);
8console.log('Prezzo validato e trasformato:', validPrice); // 49.99 (numero)

Qui, Zod accetta una stringa ("49.99") e la trasforma in un numero valido.

Validazioni Personalizzate 🛠️

Zod permette anche di creare validazioni su misura con il metodo .refine(). Supponiamo che tu voglia validare una password con criteri specifici, come una lunghezza minima e la presenza di caratteri speciali.

Esempio: Validazione della password

typescript
1const passwordSchema = z
2  .string()
3  .min(8, { message: 'La password deve contenere almeno 8 caratteri' })
4  .refine((val) => /[A-Z]/.test(val), {
5    message: 'La password deve contenere almeno una maiuscola',
6  })
7  .refine((val) => /[0-9]/.test(val), {
8    message: 'La password deve contenere almeno un numero',
9  });
10
11// Esempio di input
12const passwordInput = 'Secure123';
13
14// Validazione
15try {
16  const validPassword = passwordSchema.parse(passwordInput);
17  console.log('Password valida:', validPassword);
18} catch (e) {
19  console.error('Errore di validazione:', e.errors);
20}

Il metodo .refine() permette di aggiungere una condizione personalizzata. Qui, Zod verifica che la password rispetti i criteri definiti e fornisce messaggi di errore specifici se non è così.

Perché Scegliere Zod? 🌟

Zod è diventato un punto di riferimento per la validazione in TypeScript, perché:

• Combina perfettamente validazione e tipizzazione, senza aggiungere complessità.
• Offre un'API chiara e intuitiva, anche per schemi complessi.
• Fornisce errori comprensibili e facili da debuggare.
• Si integra perfettamente nei progetti TypeScript.

In sintesi

Zod aggiunge un ulteriore livello di sicurezza e affidabilità a TypeScript validando i dati ricevuti in modo dinamico. Potrai dormire sonni tranquilli sapendo che i tuoi dati sono sani e ben tipizzati. Allora, pronto a provare Zod nel tuo prossimo progetto? 😎