Comment créer une API Nest.js CRUD REST à l'aide de TypeORM et PostgreSQL

Comme les autres frameworks Node.js, Nest.js fournit une boîte à outils complète pour créer des services backend robustes et évolutifs. Néanmoins, il est important de comprendre comment implémenter les fonctions de création, de lecture, de mise à jour et de suppression (CRUD) dans Nest.js de manière efficace: ce sont les opérations les plus fondamentales du développement d'API.

Découvrez comment créer une API Nest.js CRUD REST à l'aide de TypeORM et d'une base de données PostgreSQL.

Premiers pas avec Nest.js

Pour commencer, installez l'outil de ligne de commande Nest.js :

npm i -g @nestjs/cli

Ensuite, créez un nouveau projet en exécutant :

nest new crud-app

L'outil CLI vous invitera à choisir un gestionnaire de packages, choisissez l'option que vous trouvez la plus préférable. Nous utiliserons npm, le gestionnaire de paquets Node.

La CLI échafaudera un projet Nest.js de base avec tous les fichiers de configuration requis et les dépendances initiales requises pour exécuter l'application.

Enfin, accédez au répertoire du projet et démarrez le serveur de développement.

cd crud-app
démarrage de l'exécution npm

Vous pouvez trouver le code de ce projet dans son GitHub dépôt.

Créer une base de données PostgreSQL

Ce didacticiel utilise une instance Cloud PostgreSQL, mais vous pouvez configurer une base de données PostgreSQL locale à la place. Tu peux installer PostgreSQL sur Windows, sur macOS, ou sous Linux.

Pour configurer une instance Cloud PostgreSQL :

1. Dirigez-vous vers ElephantSQL, inscrivez-vous et connectez-vous à la page de présentation de votre compte.
2. Clique le Créer une nouvelle instance en haut à gauche de la page pour créer une nouvelle instance pour votre application.
3. Remplissez le nom de votre instance, choisissez le plan gratuit, et enfin sélectionnez la région pour terminer le processus de configuration.
4. Après avoir créé l'instance de base de données, accédez à la paramètres page, et copiez le fichier fourni URL de la base de données.

Configurer la connexion à la base de données

Dans le répertoire racine de votre projet, créez un .env fichier et collez l'URL de connexion à la base de données comme suit :

DATABASE_URL=""

Installez maintenant ces packages :

npm install pg typeorm @nestjs/typeorm @nestjs/config

Ensuite, continuez et créez un module de base de données à l'aide de l'outil CLI.

base de données du module nest g

Ouvrez le base de données/base de données.module.ts fichier et ajoutez le code de configuration de base de données suivant :

importer { Module } depuis'@nestjs/commun';
importer { ConfigModule, ConfigService } depuis'@nestjs/config';
importer { TypeOrmModule } depuis'@nestjs/typeorm';
importer { Utilisateur } depuis'../utilisateurs/modèles/utilisateur.entité'; 
@Module({
 importations: [
 TypeOrmModule.forRootAsync({
 importe: [ConfigModule], 
 injecter: [ConfigService],
 useFactory: asynchrone (configService: ConfigService) => ({
taper: 'postgres',
 URL: configService.get('DATABASE_URL'), 
 entités: [Utilisateur],
 synchroniser: vrai
 }),
 }),
 ],
})
exporterclasse Module de base de données {}

Ce module de base de données gère la connexion en configurant le module TypeORM avec le paramètre de connexion requis, l'URL de la base de données.

De plus, il définit l'entité Utilisateur dans le cadre de la configuration qui spécifie la structure et les propriétés des données stockées dans la table de base de données PostgreSQL.

À ce stade, votre code générera probablement une erreur car vous n'avez pas encore créé l'entité utilisateurs. Vous le ferez dans les étapes suivantes.

Mettre à jour le fichier app.module.ts

Enfin, mettez à jour le module d'application principal pour inclure la configuration du module de base de données.

importer { Module } depuis'@nestjs/commun';
importer {ConfigModule} depuis'@nestjs/config';
importer { Contrôleur d'application } depuis'./app.controller';
importer { AppService } depuis'./app.service';
importer {Module de base de données} depuis'./base de données/base de données.module';
@Module({
 importations: [
 ConfigModule.forRoot({
 envFilePath: '.env', 
 }),
 Module de base de données,
 ],
 contrôleurs: [AppController],
 fournisseurs: [AppService],
})
exporterclasse Module d'application {}

Définir un module d'utilisateurs

Le module utilisateurs sert de composant centralisé, responsable de l'encapsulation et de la gestion de la logique requise pour implémenter la fonctionnalité CRUD de l'API.

Exécutez cette commande de terminal pour créer le module des utilisateurs de l'API.

utilisateurs du module nest g

L'outil CLI met automatiquement à jour le app.module.ts fichier pour refléter les modifications apportées, en plus de créer le module utilisateur. Cela garantit que le module nouvellement créé, users, est correctement intégré dans la configuration du module de l'application.

Créer une entité utilisateur

TypeORM est une bibliothèque ORM (Object-Relational Mapping) qui simplifie les interactions de base de données dans les applications qui utilisent TypeScript en mappant des objets JavaScript à des tables de base de données.

En créant une entité Utilisateur à l'aide de TypeORM, vous définissez la structure et les propriétés des données utilisateur dans la base de données PostgreSQL.

Dans l'annuaire des utilisateurs, créez un nouveau modèles/utilisateur.entité.ts et ajoutez le code suivant.

importer { Entité, PrimaryGeneratedColumn, Colonne, } depuis"typeorm";
@Entité()
exporterclasse Utilisateur {
@PrimaryGeneratedColumn()
 identifiant: nombre;
@Colonne()
 nom: chaîne;
@Colonne()
 e-mail: chaîne;
}

Le Utilisateur L'entité définit la structure des données utilisateur stockées dans la base de données. Dans ce cas, c'est le identifiant comme colonne de clé primaire, et le nom et e-mail colonnes et leurs propriétés correspondantes.

Créer le service d'API CRUD

Maintenant, créez le service API qui gérera la logique des opérations CRUD en exécutant la commande ci-dessous :

utilisateurs du service nest g

Ouvrez le user-auth.service.ts fichier et ajoutez ce code :

importer { Injectables } depuis'@nestjs/commun';
importer { InjectRepository } depuis'@nestjs/typeorm';
importer { Référentiel } depuis'typeorm';
importer {Utilisateur} depuis'./models/user.entity';
@Injectable()
exporterclasse UtilisateursService {
constructeur(
@InjectRepository(Utilisateur)
privé userRepository: référentiel,
 ) {}
asynchrone Trouver tout(): Promesse {
retource.userRepository.find();
 }
asynchrone findOne (identifiant: nombre): Promesse {
retource.userRepository.findOne({ où: { id } });
 }
asynchrone créer (utilisateur: Partielle): Promesse {
constante nouvelutilisateur = ce.userRepository.create (utilisateur);
retource.userRepository.save (nouvelutilisateur);
 }
asynchrone mise à jour (identifiant: nombre, utilisateur: partiel): Promesse {
attendrece.userRepository.update (identifiant, utilisateur) ;
retource.userRepository.findOne({ où: { id } });
 }
asynchronesupprimer(identifiant: nombre): Promesse<annuler> {
attendrece.userRepository.delete (id);
 }
}

Cette classe UsersService définit diverses méthodes API dédiées à la gestion des opérations CRUD. Ces méthodes incluent la récupération des données de tous les utilisateurs, la recherche d'un utilisateur spécifique à l'aide de son numéro d'identification, la création un nouvel utilisateur, la mise à jour d'un utilisateur existant, et un procédé pour supprimer les données d'un utilisateur spécifique dans la base de données.

Définir un contrôleur pour l'API

Créez un contrôleur qui gérera les points de terminaison de l'API pour les opérations liées à l'utilisateur.

utilisateurs du contrôleur nest g

Ensuite, ajoutez le code ci-dessous au utilisateurs.contrôleur.ts déposer.

importer { Contrôleur, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } depuis'@nestjs/commun';
importer { UserService} depuis'./users.service';
importer { Utilisateur } depuis'./models/user.entity';
@Manette('api/utilisateurs')
exporterclasse UtilisateursContrôleur {
constructeur(privé userService en lecture seule: UsersService) {}
@Obtenir()
asynchrone Trouver tout(): Promesse {
retource.usersService.findAll();
 }
@Poste()
@HttpCode(201) 
asynchrone créer(@Corps() utilisateur: Utilisateur): Promesse {
constante utilisateur créé = attendrece.usersService.create (utilisateur) ;
retour crééUtilisateur ;
 }
@Mettre(':identifiant')
asynchrone mise à jour (@Param('identifiant') identifiant: nombre, @Corps() utilisateur: Utilisateur): Promesse<n'importe quel> {
attendrece.usersService.update (identifiant, utilisateur) ;
retour { message: "L'utilisateur a été mis à jour avec succès" };
 }
@Supprimer(':identifiant')
asynchronesupprimer(@Param('identifiant') identifiant: nombre): Promesse<n'importe quel> {
constante utilisateur = attendrece.usersService.findOne (identifiant) ;
si (!utilisateur) {
lancernouveau Exception introuvable('L'utilisateur n'existe pas!');
 }
attendrece.usersService.delete (id);
retour { message: 'Utilisateur supprimé avec succès' };
 }
}

Le contrôleur gère les points de terminaison d'API pour les opérations de l'utilisateur. Il gère les requêtes GET pour récupérer tous les utilisateurs, les requêtes POST pour créer de nouveaux utilisateurs, les requêtes PUT pour mettre à jour les utilisateurs existants et les requêtes DELETE pour supprimer des utilisateurs.

En utilisant le UsersService et en interaction avec le Utilisateur entité, ce contrôleur fournit une API complète pour gérer les opérations liées à l'utilisateur sur les données stockées dans la base de données.

Mettre à jour le fichier users.module.ts

Enfin, mettez à jour le utilisateurs.module.ts fichier comme indiqué ci-dessous pour vous assurer d'incorporer le Entité utilisateur et le module TypeORM, qui établit la connexion à la base de données.

importer { Module } depuis'@nestjs/commun';
importer { UtilisateursContrôleur } depuis'./users.controller';
importer { UserService} depuis'./users.service';
importer { TypeOrmModule } depuis'@nestjs/typeorm';
importer { Utilisateur } depuis'./models/user.entity';
@Module({
 importe: [TypeOrmModule.forFeature([User])],
 contrôleurs: [UsersController],
 fournisseurs: [UsersService]
})
exporterclasse ModuleUtilisateurs {}

Enfin, continuez et lancez le serveur de développement pour tester les opérations CRUD à l'aide de Postman.

démarrage de l'exécution npm

Le serveur démarrera sur le port 3000 et vous pourrez lui envoyer des requêtes API à http://localhost: 3000/API/utilisateurs.

Créer des applications backend avec Nest.js

Que vous développiez une API REST simple ou une application Web complexe, Nest.js offre un ensemble complet de fonctionnalités et de capacités pour construire un système backend fiable et robuste.

Nest.js offre une approche plus structurée du développement de projet qu'Express.js. Cela garantit que vous pouvez en toute confiance créer, mettre à l'échelle et maintenir des applications complexes, grâce à son modèle de conception organisé et modulaire.