Lors du développement d'une application Node.js à l'aide d'Express.js, la structuration efficace de votre base de code est cruciale pour la maintenabilité, l'évolutivité et la facilité de collaboration. Une structure de projet bien organisée vous permet de gérer la complexité, facilitant ainsi la navigation et la compréhension du code. Dans ce blog, nous explorerons une structure de dossiers typique pour une application Express.js et expliquerons le but de chaque répertoire et fichier.

Aperçu de la structure du projet
Voici une structure de dossiers courante pour une application Express.js :

?
├── ? app.js
├── ? bin
├── ? config
├── ? controllers
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? middleware
│   ├── ? auth.js
│   ├── ? logger.js
│   └── ...
├── ? models
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? routes
│   ├── ? api.js
│   ├── ? auth.js
│   └── ...
├── ? public
│   ├── ? css
│   ├── ? js
│   ├── ? images
│   └── ...
├── ? views
│   ├── ? index.ejs
│   ├── ? product.ejs
│   └── ...
├── ? tests
│   ├── ? unit
│   ├── ? integration
│   ├── ? e2e
│   └── ...
├── ? utils
│   ├── ? validation.js
│   ├── ? helpers.js
│   └── ...
└── ? node_modules

Explication de chaque répertoire et fichier
app.js
Le fichier app.js est le point d'entrée de votre application. C'est là que vous initialisez l'application Express, configurez le middleware, définissez les itinéraires et démarrez le serveur. Considérez-le comme le centre de contrôle de votre application Web.

const express = require('express');
const app = express();
const config = require('./config');
const routes = require('./routes');
// Middleware setup
app.use(express.json());
// Routes setup
app.use('/api', routes);
// Start server
const PORT = config.port || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});
module.exports = app;

bac
Le répertoire bin contient généralement des scripts pour démarrer votre serveur Web. Ces scripts peuvent être utilisés pour définir des variables d'environnement ou gérer différents environnements (par exemple, développement, production).

Exemple : bin/www

#!/usr/bin/env node
const app = require('../app');
const debug = require('debug')('your-app:server');
const http = require('http');
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
const server = http.createServer(app);
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
function normalizePort(val) {
  const port = parseInt(val, 10);
  if (isNaN(port)) return val;
  if (port >= 0) return port;
  return false;
}
function onError(error) {
  if (error.syscall !== 'listen') throw error;
  const bind = typeof port === 'string' ? 'Pipe '   port : 'Port '   port;
  switch (error.code) {
    case 'EACCES':
      console.error(bind   ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind   ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}
function onListening() {
  const addr = server.address();
  const bind = typeof addr === 'string' ? 'pipe '   addr : 'port '   addr.port;
  debug('Listening on '   bind);
}

configuration
Le répertoire de configuration contient les fichiers de configuration de votre application, tels que les connexions à la base de données, les paramètres du serveur et les variables d'environnement.

Exemple : config/index.js

module.exports = {
  port: process.env.PORT || 3000,
  db: {
    host: 'localhost',
    port: 27017,
    name: 'mydatabase'
  }
};

contrôleurs
Les contrôleurs contiennent la logique permettant de gérer les demandes entrantes et de générer des réponses. Chaque fichier du répertoire des contrôleurs correspond généralement à une partie différente de votre application (par exemple, clients, produits).

Exemple : contrôleurs/client.js

const Customer = require('../models/customer');
exports.getAllCustomers = async (req, res) => {
  try {
    const customers = await Customer.find();
    res.json(customers);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};

middleware
Les fonctions middleware sont utilisées pour traiter les requêtes avant qu’elles n’atteignent les contrôleurs. Ils peuvent gérer des tâches telles que l'authentification, la journalisation et la validation des demandes.

Exemple : middleware/auth.js

module.exports = (req, res, next) => {
  const token = req.header('Authorization');
  if (!token) return res.status(401).json({ message: 'Access Denied' });
  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (err) {
    res.status(400).json({ message: 'Invalid Token' });
  }
};

modèles
Les modèles définissent la structure de vos données et gèrent les interactions avec la base de données. Chaque fichier de modèle correspond généralement à une entité de données différente (par exemple, Client, Produit).

Exemple : models/customer.js

const mongoose = require('mongoose');
const customerSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
module.exports = mongoose.model('Customer', customerSchema);

itinéraires
Les routes définissent les chemins vers différentes parties de votre application et les mappent aux contrôleurs appropriés.

Exemple : routes/api.js

const express = require('express');
const router = express.Router();
const customerController = require('../controllers/customer');
router.get('/customers', customerController.getAllCustomers);
module.exports = router;

publique
Le répertoire public contient des fichiers statiques tels que CSS, JavaScript et des images qui sont servies directement au client.

Exemple : Structure de répertoire

public/
├── css/
├── js/
├── images/

vues
Les vues sont des modèles qui restituent le code HTML pour le client. À l'aide d'un moteur de création de modèles tel qu'EJS, Pug ou guidon, vous pouvez générer du HTML dynamique.

Exemple : vues/index.ejs

  
Welcome to My App
  

    
  

tests
Le répertoire tests contient des fichiers de test pour garantir le bon fonctionnement de votre application. Les tests sont souvent organisés en tests unitaires, tests d'intégration et tests de bout en bout (e2e).

Exemple : Structure de répertoire

tests/
├── unit/
├── integration/
├── e2e/

utils
Les fonctions utilitaires et les modules d'assistance sont stockés dans le répertoire utils. Ces fonctions effectuent des tâches courantes telles que la validation et le formatage qui sont utilisées dans toute l'application.

Exemple : utils/validation.js

exports.isEmailValid = (email) => {
  const re = /^[^\s@] @[^\s@] \.[^\s@] $/;
  return re.test(String(email).toLowerCase());
};

node_modules
Le répertoire node_modules contient toutes les dépendances dont votre projet a besoin. Ce répertoire est géré par npm (ou fil) et comprend les packages installés à partir du registre npm.

Conclusion
Une application Node.js bien structurée utilisant Express.js améliore la maintenabilité, l'évolutivité et la collaboration. Chaque répertoire et fichier de la structure répond à un objectif spécifique, depuis la gestion de la configuration et la définition des itinéraires jusqu'à la gestion du middleware et du rendu des vues. En organisant efficacement votre base de code, vous pouvez facilement créer des applications robustes et évolutives.