ExpressJS - Base de données

Nous continuons à recevoir des demandes, mais finissons par ne les stocker nulle part. Nous avons besoin d'une base de données pour stocker les données. Pour cela, nous utiliserons la base de données NoSQL appeléeMongoDB.

Pour installer et lire sur Mongo, suivez ce lien.

Afin d'utiliser Mongo avec Express, nous avons besoin d'une API client pour le nœud. Il y a plusieurs options pour nous, mais pour ce tutoriel, nous nous en tiendrons à la mangouste . La mangouste est utilisée pourdocument Modelingdans Node pour MongoDB. Pour la modélisation de documents, nous créons unModel (un peu comme un class en programmation orientée document), puis nous produisons documents en utilisant ce modèle (comme nous créons documents of a classen POO). Tous nos traitements se feront sur ces "documents", puis enfin, nous écrirons ces documents dans notre base de données.

Configurer Mongoose

Maintenant que vous avez installé Mongo, laissez-nous installer Mongoose, de la même manière que nous avons installé nos autres packages de nœuds -

npm install --save mongoose

Avant de commencer à utiliser mangouste, nous devons créer une base de données à l'aide du shell Mongo. Pour créer une nouvelle base de données, ouvrez votre terminal et entrez "mongo". Un shell Mongo va démarrer, entrez le code suivant -

use my_db

Une nouvelle base de données sera créée pour vous. Chaque fois que vous ouvrez le shell mongo, il sera par défaut "test" db et vous devrez changer votre base de données en utilisant la même commande que ci-dessus.

Pour utiliser Mongoose, nous en aurons besoin dans notre index.js puis connectez-vous au mongodb service en cours d’exécution mongodb://localhost.

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

Maintenant que notre application est connectée à notre base de données, créons un nouveau modèle. Ce modèle agira comme une collection dans notre base de données. Pour créer un nouveau modèle, utilisez le code suivant, avant de définir un itinéraire -

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});
var Person = mongoose.model("Person", personSchema);

Le code ci-dessus définit le schéma d'une personne et est utilisé pour créer un mode Mongoose Person.

Enregistrer des documents

Maintenant, nous allons créer un nouveau formulaire html; ce formulaire vous aidera à obtenir les détails d'une personne et à l'enregistrer dans notre base de données. Pour créer le formulaire, créez un nouveau fichier de vue appeléperson.pug dans le répertoire de vues avec le contenu suivant -

html
head
   title Person
   body
      form(action = "/person", method = "POST")
      div
         label(for = "name") Name: 
         input(name = "name")
      br
      div
         label(for = "age") Age: 
         input(name = "age")
      br
      div
         label(for = "nationality") Nationality: 
         input(name = "nationality")
      br
      button(type = "submit") Create new person

Ajoutez également un new get route dans index.js pour rendre ce document -

app.get('/person', function(req, res){
   res.render('person');
});

Aller à "localhost:3000/person"pour vérifier si le formulaire affiche la sortie correcte. Notez qu'il ne s'agit que de l'interface utilisateur, il ne fonctionne pas encore. La capture d'écran suivante montre comment le formulaire est affiché -

Nous allons maintenant définir un gestionnaire de route post à '/person' qui traitera cette demande

app.post('/person', function(req, res){
   var personInfo = req.body; //Get the parsed information
   
   if(!personInfo.name || !personInfo.age || !personInfo.nationality){
      res.render('show_message', {
         message: "Sorry, you provided worng info", type: "error"});
   } else {
      var newPerson = new Person({
         name: personInfo.name,
         age: personInfo.age,
         nationality: personInfo.nationality
      });
		
      newPerson.save(function(err, Person){
         if(err)
            res.render('show_message', {message: "Database error", type: "error"});
         else
            res.render('show_message', {
               message: "New person added", type: "success", person: personInfo});
      });
   }
});

Dans le code ci-dessus, si nous recevons un champ vide ou ne recevons aucun champ, nous enverrons une réponse d'erreur. Mais si nous recevons un document bien formé, nous créons unnewPerson document à partir du modèle de personne et enregistrez-le dans notre base de données en utilisant le newPerson.save()fonction. Ceci est défini dans Mongoose et accepte un rappel comme argument. Ce rappel a 2 arguments - erreur et réponse. Ces arguments rendront leshow_message vue.

Pour afficher la réponse de cette route, nous devrons également créer un show_messagevue. Créez une nouvelle vue avec le code suivant -

html
   head
      title Person
   body
      if(type == "error")
         h3(style = "color:red") #{message}
      else
         h3 New person, 
            name: #{person.name}, 
            age: #{person.age} and 
            nationality: #{person.nationality} added!

Nous recevrons la réponse suivante après avoir soumis avec succès le form(show_message.pug) -

Nous avons maintenant une interface pour créer persons.

Récupération de documents

Mongoose fournit de nombreuses fonctions pour récupérer des documents, nous nous concentrerons sur 3 d'entre elles. Toutes ces fonctions prennent également un rappel comme dernier paramètre, et tout comme la fonction de sauvegarde, leurs arguments sont l'erreur et la réponse. Les trois fonctions sont les suivantes -

Model.find (conditions, rappel)

Cette fonction trouve tous les documents correspondant aux champs de l'objet conditions. Les mêmes opérateurs utilisés dans Mongo fonctionnent également dans la mangouste. Par exemple,

Person.find(function(err, response){
   console.log(response);
});

Cela récupérera tous les documents de la collection de la personne.

Person.find({name: "Ayush", age: 20}, 
   function(err, response){
      console.log(response);
});

Cela récupérera tous les documents où le nom du champ est "Ayush" et l'âge est 20.

Nous pouvons également fournir la projection dont nous avons besoin, c'est-à-dire les champs dont nous avons besoin. Par exemple, si nous voulons seulement lenames de personnes dont nationalityest "indien" , nous utilisons -

Person.find({nationality: "Indian"}, "name", function(err, response){
   console.log(response);
});

Model.findOne (conditions, rappel)

Cette fonction récupère toujours un seul document le plus pertinent. Il a les mêmes arguments exacts queModel.find().

Model.findById (id, rappel)

Cette fonction prend dans le _id(défini par mongo) comme premier argument, une chaîne de projection facultative et un rappel pour gérer la réponse. Par exemple,

Person.findById("507f1f77bcf86cd799439011", function(err, response){
   console.log(response);
});

Créons maintenant un itinéraire pour afficher tous les enregistrements de personnes -

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.get('/people', function(req, res){
   Person.find(function(err, response){
      res.json(response);
   });
});

app.listen(3000);

Mise à jour des documents

Mongoose fournit 3 fonctions pour mettre à jour les documents. Les fonctions sont décrites ci-dessous -

Model.update (condition, mises à jour, rappel)

Cette fonction prend une condition et met à jour un objet en entrée et applique les modifications à tous les documents correspondant aux conditions de la collection. Par exemple, le code suivant mettra à jour la nationalité "américaine" dans tous les documents Personne -

Person.update({age: 25}, {nationality: "American"}, function(err, response){
   console.log(response);
});

Model.findOneAndUpdate (condition, mises à jour, rappel)

Il trouve un document basé sur la requête et le met à jour en fonction du deuxième argument. Il prend également un rappel comme dernier argument. Exécutons l'exemple suivant pour comprendre la fonction

Person.findOneAndUpdate({name: "Ayush"}, {age: 40}, function(err, response) {
   console.log(response);
});

Model.findByIdAndUpdate (id, mises à jour, rappel)

Cette fonction met à jour un seul document identifié par son identifiant. Par exemple,

Person.findByIdAndUpdate("507f1f77bcf86cd799439011", {name: "James"}, 
   function(err, response){
      console.log(response);
});

Créons maintenant un itinéraire pour mettre à jour les gens. Ce sera unPUT route avec l'id comme paramètre et les détails dans la charge utile.

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.put('/people/:id', function(req, res){
   Person.findByIdAndUpdate(req.params.id, req.body, function(err, response){
      if(err) res.json({message: "Error in updating person with id " + req.params.id});
      res.json(response);
   });
});

app.listen(3000);

Pour tester cet itinéraire, entrez ce qui suit dans votre terminal (remplacez l'id par un identifiant de votre people) -

curl -X PUT --data "name = James&age = 20&nationality = American
"http://localhost:3000/people/507f1f77bcf86cd799439011

Cela mettra à jour le document associé à l'identifiant fourni dans l'itinéraire avec les détails ci-dessus.

Supprimer des documents

Nous avons couvert Create, Read et Update, maintenant nous allons voir comment Mongoose peut être utilisé pour Deletedocuments. Nous avons 3 fonctions ici, exactement comme la mise à jour.

Model.remove (condition, [rappel])

Cette fonction prend un objet de condition en entrée et supprime tous les documents correspondant aux conditions. Par exemple, si nous devons supprimer toutes les personnes âgées de 20 ans, utilisez la syntaxe suivante -

Person.remove({age:20});

Model.findOneAndRemove (condition, [rappel])

Cette fonction supprime un single, document le plus pertinent selon les conditions objet. Exécutons le code suivant pour comprendre la même chose.

Person.findOneAndRemove({name: "Ayush"});

Model.findByIdAndRemove (id, [rappel])

Cette fonction supprime un seul document identifié par son identifiant. Par exemple,

Person.findByIdAndRemove("507f1f77bcf86cd799439011");

Créons maintenant une route pour supprimer des personnes de notre base de données.

var express = require('express');
var app = express();

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_db');

var personSchema = mongoose.Schema({
   name: String,
   age: Number,
   nationality: String
});

var Person = mongoose.model("Person", personSchema);

app.delete('/people/:id', function(req, res){
   Person.findByIdAndRemove(req.params.id, function(err, response){
      if(err) res.json({message: "Error in deleting record id " + req.params.id});
      else res.json({message: "Person with id " + req.params.id + " removed."});
   });
});

app.listen(3000);

Pour vérifier la sortie, utilisez la commande curl suivante -

curl -X DELETE http://localhost:3000/people/507f1f77bcf86cd799439011

Cela supprimera la personne avec un identifiant donné produisant le message suivant -

{message: "Person with id 507f1f77bcf86cd799439011 removed."}

Cela conclut comment nous pouvons créer des applications CRUD simples à l'aide de MongoDB, Mongoose et Express. Pour explorer davantage Mongoose, lisez la documentation de l' API.