Sécurisez vos applications en validant les données au niveau de la demande à l'aide de la bibliothèque de validation Joi.
L'acceptation de données non testées et non validées dans une application Web peut entraîner des failles de sécurité et des problèmes imprévus peuvent survenir à cause des données non valides.
Les ORM Node.js, tels que Sequelize et TypeORM, vous permettent de définir des règles de validation prêtes à l'emploi au niveau de l'application. Lors du développement de l'API, les données proviennent de requêtes HTTP adressées à des points de terminaison spécifiques. Cela se produit au niveau de la demande; ainsi, la validation par défaut offerte par les ORM ne s'applique pas à eux.
Joi est une description de schéma et un validateur de données pour JavaScript. Ici, vous apprendrez à utiliser la bibliothèque de validation Joi pour valider les données au niveau de la demande.
Configuration du projet de démonstration
Pour démontrer comment Joi valide les données, vous créerez une application de démonstration simple qui imite une application réelle.
Tout d'abord, créez un dossier de projet et déplacez-vous dedans en exécutant la commande suivante :
Application de démonstration mkdir et application de démonstration cd
Ensuite, initialisez npm dans votre répertoire de projet en exécutant :
npm init -y
Ensuite, vous devrez installer certaines dépendances. Les dépendances requises pour ce didacticiel incluent les éléments suivants :
- Exprimer: Express est un framework Node.js qui fournit un ensemble robuste de fonctionnalités pour les applications Web et mobiles. Express facilite la création d'applications backend avec Node.js.
- Joi: Joi est une bibliothèque de validation de données pour Node.js.
Installez les dépendances avec le gestionnaire de paquets de nœud en exécutant la commande ci-dessous :
npm installer express joi
Ensuite, créez un index.js fichier dans votre répertoire racine et ajoutez-y le bloc de code suivant :
constante exprimer = exiger("exprimer");
constante routeur = exiger("./routes");
constante port = 3000;constante app = express();
app.use (express.json());
app.use (express.urlencodé({ étendu: vrai }));
app.use (routeur);
app.listen (port, () => {
console.enregistrer("application écoute sur le port 3000 !");
});
Le bloc de code ci-dessus configure un serveur Express simple. Il configure le middleware pour analyser les données de demande entrantes et gérer les demandes entrantes et démarre le serveur pour écouter les demandes entrantes sur le port 3000.
Acheminement et traitement des demandes
Pour plus de simplicité, vous allez créer un middleware de gestionnaire de requêtes qui renvoie un code d'état, ainsi que le corps de la requête, en réponse à chaque requête qui tente d'envoyer des données à votre application.
Créer un gestionnaire.js fichier dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous :
constante demoHandler = (req, res, suivant) => {
res.send({
code: 201,
données: req.body,
});
suivant();
};
module.exports = demoHandler;
Ensuite, créez un routeur.js dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous à votre fichier :
constante exprimer = exiger("exprimer");
constante demoHandler = exiger("./gestionnaire");
constante routeur = express. Routeur();routeur.post("/s'inscrire", demoHandler);
module.exports = routeur ;
Créer un schéma Joi
Un schéma Joi représente la structure attendue et les règles de validation d'un objet de données spécifique.
Pour créer un schéma Joi, vous pouvez utiliser le Joi.object() méthode et chaînez diverses règles de validation exposées par Joi pour définir la structure et les exigences de validation de vos données.
Par exemple:
constante exampleSchema = Joi.object({
nom: Joi.chaîne().min(3).requis(),
});
L'exemple ci-dessus décrit un schéma Joi simple avec un nom propriété. Le nom propriété a une valeur de Joi.string().min (3).required(). Cela signifie que le nom La valeur doit être une chaîne, d'une longueur minimale de 3 caractères, et elle est obligatoire.
En utilisant Joi, vous pouvez enchaîner diverses méthodes pour ajouter plus de contraintes de validation à chaque champ défini dans votre schéma.
Voici un exemple avec plus de champs et de contraintes de validation :
constante userSchema = Joi.object({
email: Joi.string().email().required(),mot de passe: Joi.string().min(6).requis(),
âge: Joi.numéro().min(18).facultatif(),
employé: Joi.boolean().optional(),
téléphone: Joi.string()
.regex(/^\\d{3}-\\d{3}-\\d{4}$/)//"123-456-7890"
.requis(),adresse: Joi.object({
rue: Joi.string().min(3).requis(),
ville: Joi.string().min(3).requis(),
état: Joi.string().min(3).requis(),
zip: Joi.numéro().min(3).requis(),
}).requis(),loisirs: Joi.array().items (Joi.string()).required(),
}).options({ AbandonTôt: FAUX });
Le userSchema définit les contraintes suivantes pour chaque propriété :
- e-mail: Doit être une chaîne d'e-mail valide.
- mot de passe: Doit être une chaîne avec un minimum de 6 caractères.
- âge: Un nombre facultatif avec une valeur minimale de 18.
- employé: Un booléen facultatif.
- téléphone: Une chaîne obligatoire qui correspond à la valeur spécifiée expression régulière (/^\d{3}-\d{3}-\d{4}$/).
-
adresse: Un objet représentant l'adresse de l'utilisateur avec les sous-propriétés suivantes.
- rue: Une chaîne obligatoire d'une longueur minimale de 3 caractères.
- ville: Une chaîne obligatoire d'une longueur minimale de 3 caractères.
- État: Une chaîne obligatoire d'une longueur minimale de 3 caractères.
- zipper: Un nombre requis avec une valeur minimale de 3.
- loisirs: Un tableau de chaînes requis.
Outre les contraintes, userSchema fixe le AbandonTôt possibilité de FAUX. Par défaut, Joi arrête l'exécution du programme dès qu'il rencontre la première erreur et affiche l'erreur sur la console. Cependant, en définissant cette option sur FAUX s'assure que Joi vérifie l'intégralité du schéma et imprime toutes les erreurs rencontrées sur la console.
Valider les données avec Joi
Créer un validation.js fichier et ajouter le userSchema coder dessus.
Ainsi:
//validation.js
constante Joï = exiger("joi");constante userSchema = Joi.object({
//...
}).options({ AbandonTôt: FAUX });
module.exports = userSchema;
Ensuite, créez un middleware qui intercepte les charges utiles des requêtes et les vérifie par rapport à un schéma fourni en ajoutant le code suivant sous le userSchema code.
constante validationMiddleware = (schéma) => {
retour(req, res, suivant) => {
constante { erreur } = schema.validate (req.body);si (erreur) {
// Gérer l'erreur de validation
console.log (erreur.message);
res.statut(400).json({ les erreurs: détails de l'erreur });
} autre {
// Les données sont valides, passez au middleware suivant
suivant();
}
};
};
Lorsqu'une demande est faite, le middleware invoque le valider méthode de la schéma pour valider le corps de la requête. Si des erreurs de validation se produisent, le middleware envoie un 400 Mauvaise demande réponse avec les messages d'erreur extraits des détails de l'erreur de validation.
En revanche, si la validation passe sans erreur, le middleware appelle le suivant() fonction.
Enfin, exportez le validationMiddleware et userSchema.
module.exports = {
userSchema,
validationMiddleware,
};
Tester les contraintes de validation
Importer validationMiddleware et userSchema Dans votre routeur.js fichier et configurez le middleware comme suit :
constante { validationMiddleware, userSchema } = exiger("./validation");
routeur.post("/s'inscrire", validationMiddleware (userSchema), demoHandler);
Démarrez votre application en exécutant la commande ci-dessous :
nœudindice.js
Ensuite, faites une requête HTTP POST à localhost: 3000/inscription en utilisant les données de test ci-dessous. Vous pouvez y parvenir en utilisant cURL ou tout autre client API.
{
"e-mail": "utilisateur@exemple", // Format d'email invalide
"mot de passe": "passer", // Longueur du mot de passe inférieure à 6 caractères
"âge": 15, // Âge inférieur à 18 ans
"employé": vrai,
"loisirs": ["en lisant", "en cours d'exécution"],
"téléphone": "123-456-789", // Format de numéro de téléphone invalide
"adresse": {
"rue": "123",
"ville": « Exemple de ville »,
"État": "Exemple d'état",
"zipper": 12345
}
}
Cette demande échouerait et renverrait un objet d'erreur car la charge utile contient de nombreux champs non valides, tels que l'adresse e-mail, le mot de passe, l'âge et le téléphone. À l'aide de l'objet d'erreur fourni, vous pouvez gérer les erreurs de manière appropriée.
Simplifier la validation des données avec Joi
Ici, vous avez couvert la plupart des bases de la validation des données à l'aide de Joi. Cependant, vous pouvez couvrir des techniques et des contraintes plus avancées dans la documentation Joi.
Joi simplifie la tâche de validation des données en JavaScript, fournissant une solution intuitive qui améliore considérablement la fiabilité et l'intégrité des données stockées dans votre application.
