• 10 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 13/03/2020

Optimisez la structure du back-end

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Avant de nous lancer dans le sujet complexe qu'est l'authentification, nous allons réorganiser la structure de notre back-end pour en faciliter la compréhension et la gestion. Il est techniquement possible de conserver toute notre logique dans le fichier app.js , mais ce fichier peut vite devenir bien trop volumineux, ce qui compliquerait la gestion. Par conséquent, rendons les choses un peu plus modulaires.

Configurez le routage

La première chose que nous allons faire est de dissocier notre logique de routing et la logique globale de l'application. Créez, dans votre dossier backend , un dossier routes puis, dans ce nouveau dossier, un fichier stuff.js . Celui-ci contiendra la logique de nos routes stuff :

const express = require('express');
const router = express.Router();
module.exports = router;

Ci-dessus, nous créons un routeur Express. Jusqu'à présent, nous avions enregistré nos routes directement dans notre application. Maintenant, nous allons les enregistrer dans notre routeur Express, puis enregistrer celui-ci dans l'application.

Il est temps de couper toutes nos routes de app.js et de les coller dans notre routeur. Veillez à remplacer toutes les occurrences de app par router , car nous enregistrons les routes dans notre routeur :

const express = require('express');
const router = express.Router();
const Thing = require('../models/thing');
router.post('/', (req, res, next) => {
const thing = new Thing({
title: req.body.title,
description: req.body.description,
imageUrl: req.body.imageUrl,
price: req.body.price,
userId: req.body.userId
});
thing.save().then(
() => {
res.status(201).json({
message: 'Post saved successfully!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
});
router.get('/:id', (req, res, next) => {
Thing.findOne({
_id: req.params.id
}).then(
(thing) => {
res.status(200).json(thing);
}
).catch(
(error) => {
res.status(404).json({
error: error
});
}
);
});
router.put('/:id', (req, res, next) => {
const thing = new Thing({
_id: req.params.id,
title: req.body.title,
description: req.body.description,
imageUrl: req.body.imageUrl,
price: req.body.price,
userId: req.body.userId
});
Thing.updateOne({_id: req.params.id}, thing).then(
() => {
res.status(201).json({
message: 'Thing updated successfully!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
});
router.delete('/:id', (req, res, next) => {
Thing.deleteOne({_id: req.params.id}).then(
() => {
res.status(200).json({
message: 'Deleted!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
});
router.get('/' +
'', (req, res, next) => {
Thing.find().then(
(things) => {
res.status(200).json(things);
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
});
module.exports = router;

Nous devons désormais enregistrer notre nouveau routeur dans notre fichier app.js . D'abord, nous devons l'importer :

const stuffRoutes = require('./routes/stuff');

Nous l'enregistrerons ensuite comme nous le ferions pour une route unique. Nous voulons enregistrer notre routeur pour toutes les demandes effectuées vers /api/stuff . Par conséquent, tapez :

app.use('/api/stuff', stuffRoutes);

Restez dans la section « Parties 1 + 2 » pour le moment. Si vous actualisez l'application front-end, tout devrait encore fonctionner comme avant.

Configurez les contrôleurs

Pour rendre notre structure encore plus modulaire, simplifier la lecture et la gestion de notre code, nous allons séparer la logique métier de nos routes en contrôleurs.

Créez un dossier controllers dans votre dossier backend et créez un autre fichier stuff.js . Celui-ci sera notre contrôleur stuff . Copions le premier élément de logique métier de la route POST vers notre contrôleur :

// in controllers/stuff.js
const Thing = require('../models/thing');
exports.createThing = (req, res, next) => {
const thing = new Thing({
title: req.body.title,
description: req.body.description,
imageUrl: req.body.imageUrl,
price: req.body.price,
userId: req.body.userId
});
thing.save().then(
() => {
res.status(201).json({
message: 'Post saved successfully!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
};

Ici, nous exposons la logique de notre route POST en tant que fonction appelée createThing() . Pour réimplémenter cela dans notre route, nous devons importer notre contrôleur puis enregistrer createThing :

// in routes/stuff.js
const stuffCtrl = require('../controllers/stuff');
router.get('/', stuffCtrl.getAllStuff);

Nous pouvons maintenant faire de même pour toutes nos autres routes. Voici le contrôleur final :

const Thing = require('../models/thing');
exports.createThing = (req, res, next) => {
const thing = new Thing({
title: req.body.title,
description: req.body.description,
imageUrl: req.body.imageUrl,
price: req.body.price,
userId: req.body.userId
});
thing.save().then(
() => {
res.status(201).json({
message: 'Post saved successfully!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
};
exports.getOneThing = (req, res, next) => {
Thing.findOne({
_id: req.params.id
}).then(
(thing) => {
res.status(200).json(thing);
}
).catch(
(error) => {
res.status(404).json({
error: error
});
}
);
};
exports.modifyThing = (req, res, next) => {
const thing = new Thing({
_id: req.params.id,
title: req.body.title,
description: req.body.description,
imageUrl: req.body.imageUrl,
price: req.body.price,
userId: req.body.userId
});
Thing.updateOne({_id: req.params.id}, thing).then(
() => {
res.status(201).json({
message: 'Thing updated successfully!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
};
exports.deleteThing = (req, res, next) => {
Thing.deleteOne({_id: req.params.id}).then(
() => {
res.status(200).json({
message: 'Deleted!'
});
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
};
exports.getAllStuff = (req, res, next) => {
Thing.find().then(
(things) => {
res.status(200).json(things);
}
).catch(
(error) => {
res.status(400).json({
error: error
});
}
);
};

Voici notre routeur final :

const express = require('express');
const router = express.Router();
const stuffCtrl = require('../controllers/stuff');
router.get('/', stuffCtrl.getAllStuff);
router.post('/', stuffCtrl.createThing);
router.get('/:id', stuffCtrl.getOneThing);
router.put('/:id', stuffCtrl.modifyThing);
router.delete('/:id', stuffCtrl.deleteThing);
module.exports = router;

Comme vous le voyez, cela facilite la compréhension de notre fichier de routeur. Il est évident quelles routes sont disponibles à quels points de terminaison, et les noms descriptifs donnés aux fonctions de notre contrôleur permettent de mieux comprendre la fonction de chaque route.

Structurer le code de manière modulaire comme cela n'est pas absolument nécessaire pour chaque projet, mais c'est une bonne habitude à prendre car cela simplifie la maintenance.

Maintenant que tout est prêt, commençons à implémenter l'authentification utilisateur.

Exemple de certificat de réussite
Exemple de certificat de réussite