Securizează-ți aplicațiile validând datele la nivel de solicitare folosind biblioteca de validare Joi.
Acceptarea datelor netestate și nevalidate într-o aplicație web poate cauza vulnerabilități de securitate și pot apărea probleme neprevăzute din datele nevalide.
ORM-urile Node.js, cum ar fi Sequelize și TypeORM, vă permit să setați reguli de validare imediate la nivel de aplicație. În timpul dezvoltării API, datele provin de la solicitări HTTP către anumite puncte finale. Acest lucru se întâmplă la nivelul cererii; astfel, validarea implicită oferită de ORM-uri nu se aplică acestora.
Joi este o descriere a schemei și un validator de date pentru JavaScript. Aici veți învăța cum să utilizați biblioteca de validare Joi pentru a valida datele la nivel de solicitare.
Configurarea proiectului Demo
Pentru a demonstra cum Joi validează datele, veți construi o aplicație demonstrativă simplă care imită o aplicație reală.
Mai întâi, creați un folder de proiect și treceți în el executând următoarea comandă:
mkdir demoapp && cd demoapp
Apoi, inițializați npm în directorul de proiect rulând:
npm init -y
În continuare, va trebui să instalați unele dependențe. Dependențele necesare pentru acest tutorial includ următoarele:
- Expres: Express este un cadru Node.js care oferă un set robust de caracteristici pentru aplicații web și mobile. Express facilitează crearea de aplicații backend cu Node.js.
- Joi: Joi este o bibliotecă de validare a datelor pentru Node.js.
Instalați dependențele cu managerul de pachete nod rulând comanda de mai jos:
npm install express joi
Apoi, creați un index.js fișier în directorul rădăcină și adăugați următorul bloc de cod la acesta:
const expres = cere("expres");
const router = cere(„./rute”);
const port = 3000;const aplicație = expres();
app.use (express.json());
app.use (express.urlencoded({ extins: Adevărat }));
app.use (router);
app.listen (port, () => {
consolă.Buturuga(„Aplicație care ascultă pe portul 3000!”);
});
Blocul de cod de mai sus configurează un server Express simplu. Configura middleware-ul pentru a analiza datele cererilor primite și a gestiona cererile primite și pornește serverul să asculte cererile primite pe portul 3000.
Dirijarea și gestionarea cererilor
Pentru simplitate, veți crea un middleware de gestionare a cererii care returnează un cod de stare, împreună cu corpul solicitării, ca răspuns la fiecare solicitare care încearcă să trimită date către aplicația dvs.
Creeaza o handler.js fișier în directorul rădăcină al proiectului și adăugați blocul de cod de mai jos:
const demoHandler = (cerere, res, următor) => {
res.send({
cod: 201,
date: req.body,
});
Următorul();
};
modul.exports = demoHandler;
Apoi, creați un router.js fișier în directorul rădăcină al proiectului și adăugați blocul de cod de mai jos la fișierul dvs.:
const expres = cere("expres");
const demoHandler = cere("./handler");
const router = expres. Router();router.post("/Inscrie-te", demoHandler);
modul.exports = router;
Crearea unei scheme Joi
O schemă Joi reprezintă structura și regulile de validare așteptate ale unui anumit obiect de date.
Pentru a crea o schemă Joi, puteți utiliza Joi.object() metoda și lanțul diferitelor reguli de validare expuse de Joi pentru a defini structura și cerințele de validare pentru datele dvs.
De exemplu:
const exampleSchema = Joi.object({
nume: Joi.string().min(3).necesar(),
});
Exemplul de mai sus descrie o schemă Joi simplă cu a Nume proprietate. The Nume proprietatea are o valoare de Joi.string().min (3).required(). Aceasta înseamnă că Nume valoarea ar trebui să fie un șir, cu o lungime minimă de 3 caractere și este obligatoriu.
Folosind Joi, puteți înlănțui diferite metode pentru a adăuga mai multe constrângeri de validare la fiecare câmp definit în schema dvs.
Iată un exemplu cu mai multe câmpuri și constrângeri de validare:
const userSchema = Joi.object({
e-mail: Joi.string().email().required(),parola: Joi.string().min(6).necesar(),
vârsta: Joi.number().min(18).optional(),
folosit: Joi.boolean().optional(),
telefon: Joi.string()
.regex(/^\\d{3}-\\d{3}-\\d{4}$/)//"123-456-7890"
.necesar(),adresa: Joi.object({
strada: Joi.string().min(3).necesar(),
oraș: Joi.string().min(3).necesar(),
stare: Joi.string().min(3).necesar(),
zip: Joi.number().min(3).necesar(),
}).necesar(),hobby-uri: Joi.array().items (Joi.string()).required(),
}).Opțiuni({ avortaDevreme: fals });
The userSchema definește următoarele constrângeri pentru fiecare proprietate:
- e-mail: trebuie să fie un șir de e-mail valid.
- parola: trebuie să fie un șir cu minimum 6 caractere.
- vârstă: Un număr opțional cu o valoare minimă de 18.
- angajat: un boolean opțional.
- telefon: Un șir obligatoriu care se potrivește cu cel specificat expresie regex (/^\d{3}-\d{3}-\d{4}$/).
-
abordare: Un obiect care reprezintă adresa utilizatorului cu următoarele sub-proprietăți.
- stradă: Un șir obligatoriu cu o lungime minimă de 3 caractere.
- oraș: Un șir obligatoriu cu o lungime minimă de 3 caractere.
- stat: Un șir obligatoriu cu o lungime minimă de 3 caractere.
- fermoar: Un număr necesar cu o valoare minimă de 3.
- hobby-uri: O matrice necesară de șiruri de caractere.
Pe lângă constrângeri, userSchema stabilește avortaDevreme opțiunea pentru fals. În mod implicit, Joi oprește execuția programului de îndată ce întâlnește prima eroare și imprimă eroarea pe consolă. Cu toate acestea, setarea acestei opțiuni la fals se asigură că Joi verifică întreaga schemă și imprimă pe consolă toate erorile întâlnite.
Validarea datelor cu Joi
Creeaza o validare.js fișier și adăugați userSchema cod pentru el.
Ca astfel:
//validation.js
const Joi = cere("joi");const userSchema = Joi.object({
//...
}).Opțiuni({ avortaDevreme: fals });
modul.exports = userSchema;
Apoi, creați un middleware care interceptează sarcinile utile de solicitare și le verifică în raport cu o schemă furnizată, adăugând următorul cod sub userSchema cod.
const validareMiddleware = (schemă) => {
întoarcere(cerere, res, următor) => {
const { eroare } = schema.validate (req.body);dacă (eroare) {
// Gestionează eroarea de validare
consolă.log (mesaj.de eroare);
starea res.(400).json({ erori: eroare.detalii });
} altfel {
// Datele sunt valide, treceți la următorul middleware
Următorul();
}
};
};
Când se face o solicitare, middleware-ul invocă valida metoda de schemă pentru a valida corpul de cerere. Dacă apar erori de validare, middleware-ul trimite un 400 Solicitare greșită răspuns cu mesajele de eroare extrase din detaliile erorii de validare.
Pe de altă parte, dacă validarea trece fără erori, middleware-ul apelează Următorul() funcţie.
În cele din urmă, exportați validareMiddleware și userSchema.
modul.exports = {
userSchema,
validareMiddleware,
};
Testarea constrângerilor de validare
Import validareMiddleware și userSchema în tine router.js fișier și configurați middleware-ul astfel:
const { validationMiddleware, userSchema } = cere("./validare");
router.post("/Inscrie-te", validareMiddleware (userSchema), demoHandler);
Porniți aplicația rulând comanda de mai jos:
nodulindex.js
Apoi, faceți o solicitare HTTP POST către localhost: 3000/înscriere folosind datele de testare de mai jos. Puteți realiza acest lucru folosind cURL sau orice alt client API.
{
"e-mail": „utilizator@exemplu”, // Format de email invalid
"parola": "trece", // Lungimea parolei este mai mică de 6 caractere
"vârstă": 15, // Vârsta sub 18 ani
"angajat": Adevărat,
"hobby-uri": ["citind", "alergare"],
"telefon": "123-456-789", // Formatul numărului de telefon este nevalid
"abordare": {
"stradă": "123",
"oraș": "Exemplu de oraș",
"stat": „Exemplu de stat”,
"zip": 12345
}
}
Această solicitare ar eșua și va returna un obiect de eroare, deoarece încărcarea utilă conține o mulțime de câmpuri nevalide, cum ar fi e-mail, parolă, vârstă și telefon. Folosind obiectul de eroare furnizat, puteți gestionează erorile în mod corespunzător.
Simplificarea validării datelor cu Joi
Aici ați acoperit majoritatea elementelor de bază ale validării datelor folosind Joi. Cu toate acestea, puteți acoperi tehnici și constrângeri mai avansate în documentația Joi.
Joi simplifică sarcina de validare a datelor în JavaScript, oferind o soluție intuitivă care îmbunătățește semnificativ fiabilitatea și integritatea datelor stocate în aplicația dvs.
