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? 😎

Condividi questo articolo


Sébastien Timoner

Sébastien TIMONER

Lead Developer
Esperto in Sviluppo su Misura
Aix-en-Provence, France

Esperto nello sviluppo web e nella gestione di team tecnici, mi specializzo nella creazione e ottimizzazione di soluzioni digitali performanti. Grazie a una profonda padronanza di tecnologie moderne come React.js, Node.js, TypeScript e Symfony, garantisco il successo di progetti SaaS complessi, dalla progettazione alla messa in produzione, per aziende di diversi settori, all'interno di offroadLabs.

In offroadLabs, offro servizi di sviluppo su misura, combinando competenza tecnica e approccio collaborativo. Che si tratti di creare una soluzione SaaS innovativa, modernizzare un'applicazione esistente o accompagnare la crescita professionale di un team, mi impegno a fornire soluzioni robuste e performanti, adattate alle esigenze specifiche di ogni progetto.

Sono disponibile per incarichi intorno ad Aix-en-Provence o in full remote.