Memo sur le tutoriel : Building a RESTful API in Node and Express

Publié le .

Node.JS Memo
Memo sur le tutoriel : Building a RESTful API in Node (...)

Ca faisait longtemps que je me demandais ce qu’est une API RESTful... J’ai fait quelques recherches sur le net pour en svoir plus... Et comme d’habitude, chacun a un peu sa propre définition... J’avais trouvé une, ou plutôt des définition sur, mais la discussion a été supprimée. C’est que tout le monde n’était pas d’accord... Je pense que c’est pour cela qu’elle a été supprimée... Je me rabat donc sur la définition de wikipedia que vous trouverez ici !

Build a RESTful API Using Node and Express 4

Build a RESTful API Using Node and Express 4, c’est le titre du tutoriel que j’ai suivi. Il se trouve sur cette page.

En gros on utilise le router d’Express 4, Mongoose pour interagir avec la base MongoDB. Et on utilise Postman sur Chrome ( Chromium dans mon cas... ) pour tester...

L’application

Ce que l’API fait :

  • CRUD
  • URL standard comme http://example.com/api/bears ou http://example.com/api/bears/:bear_id
  • Utiliser les verbes HTPP propres à RESTful : GET, POST, PUT, DELETE
  • Retourner jes données JSON
  • Loggé toutes les requêtes sur la console

Pré-requis : avoir Node installé sur son ordi ! Et npm...

Pour démarrer

En fait, j’ai suivi une première fois ce tutoriel pas à pas.

Du coup, là, j’ai cloné le projet depuis git avec netbeans.

Voici la structutre du projet :

  1.         - app/
  2.         ----- models/
  3.         ---------- bear.js      // our bear model
  4.         - node_modules/     // created by npm. holds our dependencies/packages
  5.         - package.json          // define all our node app and dependencies
  6.         - server.js             // configure our application and create routes

Télécharger

Les paquets Node

Les paquets node sont définis dans package.json :

Express est le framework node. Mongoose est l’ORM qui permet de communiquer avec la base de données MongoDB. Body-parser va permettre de traiter le contenu POST des requêtes HTTP pour pouvoir l’utiliser.

Installation des paquets

Ce rendre depuis un terminal dans le dossier du projet puis faire un $ npm install.Un dossier node_modules est créé avec à l’intérieur les modules demandé dans le fichier package.json.

Mise en place du serveur

Tout ce passe dans server.js. Nous l’avons défini dans package.json par l’intermédiaire de l’attribut main.

Voici le code de server.js :

  1. // BASE SETUP
  2. // =============================================================================
  3.  
  4. // call the packages we need
  5. var express    = require('express');
  6. var bodyParser = require('body-parser');
  7. var app        = express();
  8.  
  9. // configure app
  10. app.use(bodyParser());
  11.  
  12. var port     = process.env.PORT || 8080; // set our port
  13.  
  14. var mongoose   = require('mongoose');
  15. mongoose.connect('mongodb://node:node@novus.modulusmongo.net:27017/Iganiq8o'); // connect to our database
  16. var Bear     = require('./app/models/bear');
  17.  
  18. // ROUTES FOR OUR API
  19. // =============================================================================
  20.  
  21. // create our router
  22. var router = express.Router();
  23.  
  24. // middleware to use for all requests
  25. router.use(function(req, res, next) {
  26.         // do logging
  27.         console.log('Something is happening.');
  28.         next();
  29. });
  30.  
  31. // test route to make sure everything is working (accessed at GET http://localhost:8080/api)
  32. router.get('/', function(req, res) {
  33.         res.json({ message: 'hooray! welcome to our api!' });  
  34. });
  35.  
  36. // on routes that end in /bears
  37. // ----------------------------------------------------
  38. router.route('/bears')
  39.  
  40.         // create a bear (accessed at POST http://localhost:8080/bears)
  41.         .post(function(req, res) {
  42.                
  43.                 var bear = new Bear();          // create a new instance of the Bear model
  44.                 bear.name = req.body.name;  // set the bears name (comes from the request)
  45.  
  46.                 bear.save(function(err) {
  47.                         if (err)
  48.                                 res.send(err);
  49.  
  50.                         res.json({ message: 'Bear created!' });
  51.                 });
  52.  
  53.                
  54.         })
  55.  
  56.         // get all the bears (accessed at GET http://localhost:8080/api/bears)
  57.         .get(function(req, res) {
  58.                 Bear.find(function(err, bears) {
  59.                         if (err)
  60.                                 res.send(err);
  61.  
  62.                         res.json(bears);
  63.                 });
  64.         });
  65.  
  66. // on routes that end in /bears/:bear_id
  67. // ----------------------------------------------------
  68. router.route('/bears/:bear_id')
  69.  
  70.         // get the bear with that id
  71.         .get(function(req, res) {
  72.                 Bear.findById(req.params.bear_id, function(err, bear) {
  73.                         if (err)
  74.                                 res.send(err);
  75.                         res.json(bear);
  76.                 });
  77.         })
  78.  
  79.         // update the bear with this id
  80.         .put(function(req, res) {
  81.                 Bear.findById(req.params.bear_id, function(err, bear) {
  82.  
  83.                         if (err)
  84.                                 res.send(err);
  85.  
  86.                         bear.name = req.body.name;
  87.                         bear.save(function(err) {
  88.                                 if (err)
  89.                                         res.send(err);
  90.  
  91.                                 res.json({ message: 'Bear updated!' });
  92.                         });
  93.  
  94.                 });
  95.         })
  96.  
  97.         // delete the bear with this id
  98.         .delete(function(req, res) {
  99.                 Bear.remove({
  100.                         _id: req.params.bear_id
  101.                 }, function(err, bear) {
  102.                         if (err)
  103.                                 res.send(err);
  104.  
  105.                         res.json({ message: 'Successfully deleted' });
  106.                 });
  107.         });
  108.  
  109.  
  110. // REGISTER OUR ROUTES -------------------------------
  111. app.use('/api', router);
  112.  
  113. // START THE SERVER
  114. // =============================================================================
  115. app.listen(port);
  116. console.log('Magic happens on port ' + port);

Télécharger

Je pense que les commentaires sont suffisant pour comprendre en gros ce que ce passe par l’intermédiaire de ce fichier.

Démarrer le serveur et tester

Pour lancer le serveur, un simple : $ node server.js en ligne de commande.

Tester l’API avec Postman

On trouve Postman dans le store de Chrome en suivant ce lien.

En gros, on s’en sert pour envoyer des requêtes HTTP à l’URL choisie. On peut même passer des paramètres. Pour ce faire :

  • Saisir une URL ou adresse
  • Choisir un verbe
  • Eventuellement remplir des champs pour passer des paramètres ( utiliser le formulaire de type x-www-form-urlencoded )
  • Cliquer sur le bouton : Send

Pour voir si notre API marche, saisir l’url : http://localhost:8080/api et choisir le verbe POST et cliquer sur le bouton send. Normalement, le message "hooray ! welcome to our api !" apparait !

Base de données

Il faut une base de données pour stocker... Heu, les données !

Je ne me suis pas servi de service externe pour ce faire, mais j’ai utilise MongoDB qui est déjà installé dans sur mon ordi.

Pour créer la base, il faut créer le dossier data à la racine du projet. Puis, dans un nouveau terminal, lancer quelque chose comme $ mongod --dbpath /home/robomatix/nodejs/testapp/node-api/data sans entrer dans un dossier, puis faire un $ mongo. Un message informe que l’on est connecté à test. En faite, cette base n’existe pas. Pour qu’une base existe, il commencer à la remplir... Pour utiliser une base avec un nom plus parlant, il faut saisir use nodeapi. Maintenant, le message "switched to db nodeapi" s’affiche. La base nodeapi n’existe toujours pas. Il faut toujours commencer à la remplir. Ce qui sera bientôt fait...

Il faut modofoer notre fichier principal pour qu’il se connecte à la bonne base.

Donc, dans le fichier server.js, remplacer la ligne ( 15 normalement ) :

  1. mongoose.connect('mongodb://node:node@novus.modulusmongo.net:27017/Iganiq8o');

Par

  1. mongoose.connect('localhost:27017/nodeapi');

Le modèle Bear

Avant de pouvoir enregistrer dans la base pour qu’elle existe réellement, il faut créer un modèle de données. Dans le tutotriel, il s’agit de Bear dont nout nous trouvons le modèle dans app/models/bear.js.

  1. var mongoose     = require('mongoose');
  2. var Schema       = mongoose.Schema;
  3.  
  4. var BearSchema   = new Schema({
  5.         name: String
  6. });
  7.  
  8. module.exports = mongoose.model('Bear', BearSchema);

Télécharger

Note : on appelle ce fichier dans la partie de configuration du serveur dans le fichier server.js vers la ligne 16 :

  1. var Bear     = require('./app/models/bear');

Router et Routes dans Express

Une instance d’Express Router est utilisée pour gérer les routes. Voici un tableau récapitulatif des routes utilisées et de leurs verbes et de leur description.

Route HTTP Verb Description
/api/bears GET Get all the bears.
/api/bears POST Create a bear.
/api/bears/:bear_id GET Get a single bear.
/api/bears/:bear_id PUT Update a bear with new info.
/api/bears/:bear_id DELETE Delete a bear.

Route Middleware

La définition d’un middleware se trouve ici.
Un exemple pour que quelque chose ce passe à chaque fois qu’une requête est envoyé à notre API.

  1. // middleware to use for all requests
  2. router.use(function(req, res, next) {
  3.         // do logging
  4.         console.log('Something is happening.');
  5.         next(); // make sure we go to the next routes and don't stop here
  6. });

Télécharger

router.use(function()) est donc ce dont nous avons besoin pour déclarer un middleware. L’ordre de déclaration est important. Ce la déterrmine l’ordre d’exécution.

Les middleware sont puissants. Il permettent, entre autres de tester la validiter des informations reçues. On peut aussi s’en servir pour des générer des logs et des stats.

Il est renvoyé des information au format JSON data. C’est un standard pour une API et cela facilitera les choses pour ceux qui utiliseront votre API.

Pensez à mettre next() pour indiquer que l’on continue sur les routes suivantes. Sans cela, l’application s’arrêterais...

Conclusions

Dans ce tutoriel, on apprend les bases pour faire du CRUD sur une ressource spécifique. Ce sont de bonnes fondations pour ensuite créer des APIs plus grosses et plus robustes.

Vous avez aimé ? Partager !

Twitter Facebook Google Plus Tumblr Linkedin

Répondre à cet article

Tous les champs sont obligatoires

Qui êtes-vous ?
Ajoutez votre commentaire ici

  • Pour créer des paragraphes, laissez simplement des lignes vides. Par ailleurs, les raccourcis SPIP [nom du lien->lien] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins> sont acceptés.

Suivre les commentaires : RSS 2.0 | Atom