Node.js Backend Créer une application évolutive : un guide pratique sur la structure du projet

En tant que développeur junior, l'un des aspects les plus difficiles de la création d'un backend Node.js n'est pas d'écrire le code lui-même, mais de l'organiser de manière évolutive. Aujourd'hui, nous allons explorer une structure de projet Node.js prête pour la production que vous pouvez utiliser comme modèle pour vos applications.

Le problème du code non structuré
Avant de plonger dans le vif du sujet, imaginez que vous essayez de trouver un livre spécifique dans une bibliothèque où les livres sont placés au hasard sur les étagères. Frustrant, non ? La même chose s’applique au code. Sans une structure appropriée, votre application Node.js peut rapidement devenir un labyrinthe de code spaghetti difficile à maintenir et à faire évoluer.

Une meilleure façon : la structure moderne du projet Node.js
Décomposons une structure de projet Node.js de qualité professionnelle que de nombreuses entreprises prospères utilisent :

? BACK-END/
├─? src/
│ └── ? @types # Définitions de types TypeScript
│ └── ? config # Fichiers de configuration
│ └── ? contrôleurs # Gestionnaires de requêtes
│ └── ? entité # Modèles/entités de base de données
│ └── ? helper # Fonctions d'assistance/utilitaires
│ └── ? middlewares # Middlewares express
│ └── ? routes # définitions de routes API
│ └── ? services # Logique métier
│ └── ? types # Définitions de types supplémentaires
│ └── ? utils # Fonctions utilitaires
└── ? app.ts # Point d'entrée de l'application
└── ? .eslintrc.js #Configuration ESLint
└── ? .prettierrc # Configuration plus jolie
└── ? Dockerfile # Configuration Docker
└── ? package.json # Dépendances du projet
└── ? tsconfig.json # Configuration TypeScript
└── ? .dockerignore # Docker ignore les règles
└── ? .env # Variables d'environnement
└── ? docker-compose.yml # Configuration de Docker Compose

Comprendre chaque composant
1. @types et types Répertoires

`// @types/express/index.d.ts
declare namespace Express {
 export interface Request {
 user?: {
 id: string;
 role: string;
 };
 }
}`

Ces dossiers contiennent des définitions de type TypeScript. Le dossier @types contient généralement des déclarations pour les modules externes, tandis que types contient les types spécifiques à votre application.

2. Répertoire de configuration

// config/database.ts
export const dbConfig = {
 host: process.env.DB_HOST,
 port: process.env.DB_PORT,
 username: process.env.DB_USER,
 // … other configuration
};

Ce répertoire abrite tous les fichiers de configuration, facilitant la gestion des différents environnements (développement, staging, production).

3. Contrôleurs

// controllers/userController.ts
export class UserController {
  async getUser(req: Request, res: Response) {
    try {
      const user = await userService.findById(req.params.id);
      res.json(user);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }
}

Les contrôleurs gèrent les requêtes et les réponses HTTP, agissant comme un pont entre vos routes et vos services.

4. Entité

typescript// entity/User.ts
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @Column()
  email: string;
}

Le répertoire d'entités contient vos modèles de base de données, utilisant généralement un ORM comme TypeORM ou Sequelize.

5. Prestations

services/userService.ts
export class UserService {
  async createUser(userData: CreateUserDto) {
    const user = new User();
    Object.assign(user, userData);
    return await this.userRepository.save(user);
  }
}

Les services contiennent votre logique métier, en la séparant de vos contrôleurs.

6. Middlewares

`// @types/express/index.d.ts
declare namespace Express {
 export interface Request {
 user?: {
 id: string;
 role: string;
 };
 }
}`

Les middlewares gèrent des problèmes transversaux tels que l'authentification, la journalisation et la gestion des erreurs.

Bonnes pratiques et conseils

1. Responsabilité unique : Chaque annuaire doit avoir un objectif clair et unique. Ne mélangez pas la logique métier avec les définitions d'itinéraire.

2. Injection de dépendances : Utilisez l'injection de dépendances pour rendre votre code plus testable et maintenable.

// config/database.ts
export const dbConfig = {
 host: process.env.DB_HOST,
 port: process.env.DB_PORT,
 username: process.env.DB_USER,
 // … other configuration
};

3. Configuration de l'environnement : Utilisez les fichiers .env pour les variables spécifiques à l'environnement et ne les validez jamais dans le contrôle de version.

4. Intégration Docker : La présence de Dockerfile et docker-compose.yml indique la prise en charge de la conteneurisation, rendant le déploiement cohérent dans tous les environnements.

Pièges courants à éviter
Dépendances circulaires : veillez à ne pas créer de dépendances circulaires entre vos modules.
Fichiers massifs : si un fichier devient trop volumineux, il en fait probablement trop. Divisez-le en modules plus petits et ciblés.
Gestion des erreurs incohérentes : établissez une stratégie cohérente de gestion des erreurs dans l'ensemble de votre application.

Conclusion

Une application Node.js bien structurée est cruciale pour la maintenabilité et l'évolutivité à long terme. Cette structure fournit une base solide sur laquelle vous pouvez vous appuyer à mesure que votre application se développe. N'oubliez pas que l'objectif n'est pas seulement de le faire fonctionner, il s'agit de le rendre maintenable, évolutif et agréable à utiliser.

La prochaine fois que vous démarrerez un nouveau projet Node.js, pensez à utiliser cette structure comme modèle. Cela vous fera gagner d'innombrables heures de refactorisation et rendra votre base de code plus professionnelle dès le premier jour.

Conseil de pro : créez un référentiel de modèles avec cette structure afin de pouvoir démarrer rapidement de nouveaux projets avec la même organisation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!