Convalida dello schema in Node.js con Joi

L'accettazione di dati non testati e non convalidati in un'applicazione Web può causare vulnerabilità di sicurezza e problemi imprevisti possono derivare dai dati non validi.

Gli ORM Node.js, come Sequelize e TypeORM, ti consentono di impostare regole di convalida pronte all'uso a livello di applicazione. Durante lo sviluppo dell'API, i dati provengono da richieste HTTP a endpoint specifici. Questo accade a livello di richiesta; pertanto, la convalida predefinita offerta dagli ORM non si applica a loro.

Joi è una descrizione dello schema e un validatore di dati per JavaScript. Qui imparerai come utilizzare la libreria di convalida Joi per convalidare i dati a livello di richiesta.

Impostazione del progetto demo

Per dimostrare come Joi convalida i dati, creerai una semplice applicazione demo che imita un'applicazione reale.

Innanzitutto, crea una cartella di progetto e spostati al suo interno eseguendo il seguente comando:

mkdir demoapp && cd demoapp

Successivamente, inizializza npm nella directory del tuo progetto eseguendo:

npm init -y

Successivamente, dovrai installare alcune dipendenze. Le dipendenze richieste per questo tutorial includono quanto segue:

• Esprimere: Express è un framework Node.js che fornisce un robusto set di funzionalità per applicazioni web e mobili. Express semplifica la creazione di applicazioni back-end con Node.js.
• Joi: Joi è una libreria di convalida dei dati per Node.js.

Installa le dipendenze con il gestore di pacchetti del nodo eseguendo il comando seguente:

npm installa express joi

Successivamente, crea un file index.js file nella tua directory principale e aggiungi il seguente blocco di codice:

cost espresso = richiedere("esprimere");
cost router = richiedere("./itinerari");
cost porto = 3000;
cost app = espresso();
app.use (express.json());
app.use (express.urlencoded({ esteso: VERO }));
app.use (router);
app.listen (porta, () => {
consolare.tronco d'albero("app in ascolto sulla porta 3000!");
});

Il blocco di codice sopra imposta un semplice server Express. Configura il middleware per analizzare i dati delle richieste in entrata e gestire le richieste in entrata e avvia il server per ascoltare le richieste in entrata sulla porta 3000.

Instradamento e gestione delle richieste

Per semplicità, creerai un middleware di gestione delle richieste che restituisce un codice di stato, insieme al corpo della richiesta, come risposta a ogni richiesta che tenta di inviare dati alla tua applicazione.

Creare un gestore.js file nella directory principale del tuo progetto e aggiungi il blocco di codice qui sotto:

cost demoHandler = (req, res, successivo) => {
 res.send({
 codice: 201,
 dati: corpo rich.,
 });
 Prossimo();
};
modulo.exports = demoHandler;

Quindi, crea un file router.js file nella directory principale del tuo progetto e aggiungi il blocco di codice seguente al tuo file:

cost espresso = richiedere("esprimere");
cost demoHandler = richiedere("./gestore");
cost router = espresso. Router();
router.post("/iscrizione", demoHandler);
modulo.exports = router;

Creazione di uno schema Joi

Uno schema Joi rappresenta la struttura prevista e le regole di convalida di un oggetto dati specifico.

Per creare uno schema Joi, puoi utilizzare il file Joi.object() metodo e catena varie regole di convalida esposte da Joi per definire la struttura e i requisiti di convalida per i tuoi dati.

Per esempio:

cost esempioSchema = Joi.object({
 nome: Joi.string().min(3).necessario(),
});

L'esempio sopra descrive un semplice schema Joi con a nome proprietà. IL nome la proprietà ha un valore di Joi.string().min (3).richiesto(). Ciò significa che il nome value deve essere una stringa, con una lunghezza minima di 3 caratteri, ed è obbligatorio.

Usando Joi, puoi concatenare vari metodi per aggiungere più vincoli di convalida a ciascun campo definito nel tuo schema.

Ecco un esempio con più campi e vincoli di convalida:

cost userSchema = Joi.object({
 email: Joi.string().email().required(),
 password: Joi.string().min(6).necessario(),
 età: Joi.numero().min(18).opzionale(),
 impiegato: Joi.boolean().optional(),
 telefono: Joi.string()
 .regex(/^\\d{3}-\\d{3}-\\d{4}$/)//"123-456-7890"
 .necessario(),
 indirizzo: Joi.object({
 via: Joi.string().min(3).necessario(),
 città: Joi.string().min(3).necessario(),
 stato: Joi.string().min(3).necessario(),
 zip: Joi.numero().min(3).necessario(),
 }).necessario(),
 hobby: Joi.array().items (Joi.string()).required(),
}).opzioni({ abortEarly: falso });

IL userSchema definisce i seguenti vincoli per ogni proprietà:

• e-mail: Deve essere una stringa email valida.
• parola d'ordine: Deve essere una stringa con un minimo di 6 caratteri.
• età: un numero facoltativo con un valore minimo di 18.
• impiegato: Un valore booleano facoltativo.
• telefono: Una stringa obbligatoria che corrisponde a quanto specificato espressione regolare (/^\d{3}-\d{3}-\d{4}$/).
• indirizzo: un oggetto che rappresenta l'indirizzo dell'utente con le seguenti proprietà secondarie.
  • strada: Una stringa obbligatoria con una lunghezza minima di 3 caratteri.
  • città: Una stringa obbligatoria con una lunghezza minima di 3 caratteri.
  • stato: Una stringa obbligatoria con una lunghezza minima di 3 caratteri.
  • cerniera lampo: un numero obbligatorio con un valore minimo di 3.
• hobby: un array di stringhe richiesto.

Oltre ai vincoli, userSchema imposta il abortEarly opzione a falso. Per impostazione predefinita, Joi interrompe l'esecuzione del programma non appena incontra il primo errore e stampa l'errore sulla console. Tuttavia, impostando questa opzione su falso assicura che Joi controlli l'intero schema e stampi tutti gli errori riscontrati nella console.

Convalida dei dati con Joi

Creare un convalida.js file e aggiungi il file userSchema codice ad esso.

Così:

//validation.js
cost Gio = richiedere("gioi");
cost userSchema = Joi.object({
//...
}).opzioni({ abortEarly: falso });
modulo.exports = userSchema;

Quindi, crea un middleware che intercetta i payload delle richieste e li verifica rispetto a uno schema fornito aggiungendo il seguente codice sotto il userSchema codice.

cost validationMiddleware = (schema) => {
ritorno(req, res, successivo) => {
cost { errore } = schema.validate (req.body);
Se (errore) {
// Gestisci l'errore di convalida
consolare.log (errore.messaggio);
 res.stato(400).json({ errori: dettagli circa l'errore });
 } altro {
// I dati sono validi, passa al middleware successivo
 Prossimo();
 }
 };
};

Quando viene effettuata una richiesta, il middleware richiama il file convalidare metodo del schema per convalidare il corpo della richiesta. Se si verificano errori di convalida, il middleware invia a 400 Richiesta errata risposta con i messaggi di errore estratti dai dettagli dell'errore di convalida.

D'altra parte, se la convalida passa senza errori, il middleware chiama il metodo Prossimo() funzione.

Infine, esporta il file validazioneMiddleware E userSchema.

modulo.esporta = {
 Schema utente,
 validazioneMiddleware,
};

Vincoli di convalida dei test

Importare validazioneMiddleware E userSchema nel tuo router.js file e impostare il middleware in questo modo:

cost { validationMiddleware, userSchema } = richiedere("./convalida");
router.post("/iscrizione", validationMiddleware (userSchema), demoHandler);

Avvia la tua applicazione eseguendo il comando seguente:

nodoindice.js

Quindi, fai una richiesta HTTP POST a localhost: 3000/iscrizione utilizzando i dati del test di seguito. Puoi ottenere ciò utilizzando cURL o qualsiasi altro client API.

{
"e-mail": "utente@esempio", // Formato email non valido
"parola d'ordine": "passaggio", // Lunghezza della password inferiore a 6 caratteri
"età": 15, // Età inferiore a 18 anni
"impiegato": VERO,
"hobby": ["lettura", "corsa"],
"telefono": "123-456-789", // Formato del numero di telefono non valido
"indirizzo": {
"strada": "123",
"città": "Città esempio",
"stato": "Esempio di stato",
"cerniera lampo": 12345
 }
}

Questa richiesta fallirebbe e restituirebbe un oggetto di errore poiché il payload contiene molti campi non validi, come e-mail, password, età e telefono. Usando l'oggetto errore fornito, puoi farlo gestire gli errori appropriatamente.

Semplificazione della convalida dei dati con Joi

Qui hai trattato la maggior parte delle basi della convalida dei dati utilizzando Joi. Tuttavia, puoi trattare tecniche e vincoli più avanzati nella documentazione di Joi.

Joi semplifica l'attività di convalida dei dati in JavaScript, fornendo una soluzione intuitiva che migliora significativamente l'affidabilità e l'integrità dei dati archiviati nella tua applicazione.