Comment créer une API Nest.js CRUD REST à l'aide de TypeORM et PostgreSQL
À l'instar d'autres infrastructures Node.js, Nest.js propose une panoplie d'outils pour édifier des services backend solides et évolutifs. Il est néanmoins crucial de comprendre comment mettre en œuvre de façon performante les opérations de création, lecture, mise à jour et suppression (CRUD) dans Nest.js, car ce sont les opérations fondamentales dans le développement d'API.
Découvrez comment concevoir une API REST CRUD avec Nest.js en utilisant TypeORM et une base de données PostgreSQL.
Premiers pas avec Nest.js
Pour commencer, installez l'interface de ligne de commande Nest.js :
npm i -g @nestjs/cli
Ensuite, créez un nouveau projet en exécutant la commande suivante :
nest new crud-app
L'outil CLI vous invitera à choisir un gestionnaire de paquets. Optez pour celui qui vous convient le mieux. Nous utiliserons npm, le gestionnaire de paquets Node.
L'interface de ligne de commande établira un projet Nest.js de base avec tous les fichiers de configuration et les dépendances initiales nécessaires pour l'exécution de l'application.
Enfin, accédez au répertoire du projet et démarrez le serveur de développement.
cd crud-app
npm run start
Le code source de ce projet est disponible sur le dépôt GitHub.
Créer une base de données PostgreSQL
Ce tutoriel utilise une instance Cloud PostgreSQL, mais vous pouvez tout aussi bien configurer une base de données PostgreSQL locale. Vous pouvez installer PostgreSQL sur Windows, macOS ou Linux.
Pour configurer une instance Cloud PostgreSQL :
Configurer la connexion à la base de données
Dans le répertoire racine de votre projet, créez un fichier .env et insérez l'URL de connexion à la base de données comme suit :
DATABASE_URL="<votre URL de connexion ici>"
Installez maintenant ces packages :
npm install pg typeorm @nestjs/typeorm @nestjs/config
Ensuite, créez un module de base de données à l'aide de l'outil CLI.
nest g module database
Ouvrez le fichier database/database.module.ts et ajoutez le code de configuration de base de données suivant :
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from '../users/models/user.entity'; @Module({
imports: [
TypeOrmModule.forRootAsync({
imports: [ConfigModule],
inject: [ConfigService],
useFactory: async (configService: ConfigService) => ({
type: 'postgres',
url: configService.get('DATABASE_URL'),
entities: [User],
synchronize: true
}),
}),
],
})
export class DatabaseModule {}
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 spécifie l'entité Utilisateur dans le cadre de la configuration qui définit la structure et les propriétés des données stockées dans la table de la 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 prochaines étapes.
Mettre à jour le fichier app.module.ts
Enfin, mettez à jour le module d'application principal pour y inclure la configuration du module de base de données.
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { DatabaseModule } from './database/database.module';@Module({
imports: [
ConfigModule.forRoot({
envFilePath: '.env',
}),
DatabaseModule,
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
Définir un module d'utilisateurs
Le module des utilisateurs est un composant centralisé qui a pour rôle d'encapsuler et de gérer la logique nécessaire à la mise en œuvre de la fonctionnalité CRUD de l'API.
Exécutez cette commande dans le terminal afin de créer le module des utilisateurs de l'API.
nest g module users
L'outil CLI met automatiquement à jour le fichier app.module.ts pour refléter les modifications apportées, en plus de créer le module utilisateur. Cela permet de s'assurer 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 avec la base de données dans les applications qui utilisent TypeScript en mettant en correspondance des objets JavaScript avec des tables de la base de données.
La création d'une entité Utilisateur à l'aide de TypeORM vous permet de définir la structure et les propriétés des données utilisateur dans la base de données PostgreSQL.
Dans le répertoire des utilisateurs, créez un nouveau fichier models/user.entity.ts et ajoutez le code suivant.
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
L'entité Utilisateur définit la structure des données utilisateur stockées dans la base de données. Dans ce cas, il s'agit de l'ID en tant que colonne de clé primaire, ainsi que des colonnes nom et e-mail et de leurs propriétés correspondantes.
Créer le service d'API CRUD
Créez maintenant le service API qui gérera la logique des opérations CRUD en exécutant la commande ci-dessous :
nest g service users
Ouvrez le fichier user-auth.service.ts et ajoutez ce code :
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import {User} from './models/user.entity';@Injectable()
export class UsersService {
constructor(
@InjectRepository(User)
private userRepository: Repository<User>,
) {}
async findAll(): Promise<User[]> {
return this.userRepository.find();
}
async findOne(id: number): Promise<User> {
return this.userRepository.findOne({ where: { id } });
}
async create(user: Partial<User>): Promise<User> {
const newuser = this.userRepository.create(user);
return this.userRepository.save(newuser);
}
async update(id: number, user: Partial<User>): Promise<User> {
await this.userRepository.update(id, user);
return this.userRepository.findOne({ where: { id } });
}
async delete(id: number): Promise<void> {
await this.userRepository.delete(id);
}
}
Cette classe UsersService définit différentes méthodes API dédiées à la gestion des opérations CRUD. Ces méthodes comprennent 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 d'un nouvel utilisateur, la mise à jour d'un utilisateur existant et une méthode de suppression des 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.
nest g controller users
Ensuite, ajoutez le code ci-dessous au fichier users.controller.ts.
import { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './models/user.entity';@Controller('api/users')
export class UsersController {
constructor(private readonly usersService: UsersService) {}
@Get()
async findAll(): Promise<User[]> {
return this.usersService.findAll();
}
@Post()
@HttpCode(201)
async create(@Body() user: User): Promise<User> {
const createdUser = await this.usersService.create(user);
return createdUser;
}
@Put(':id')
async update (@Param('id') id: number, @Body() user: User): Promise<any> {
await this.usersService.update(id, user);
return { message: 'User updated successfully' };
}
@Delete(':id')
async delete(@Param('id') id: number): Promise<any> {
const user = await this.usersService.findOne(id);
if (!user) {
throw new NotFoundException('User does not exist!');
}
await this.usersService.delete(id);
return { message: 'User deleted successfully' };
}
}
Le contrôleur gère les points de terminaison d'API pour les opérations sur 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 interagissant avec l'entité Utilisateur, 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 fichier users.module.ts comme indiqué ci-dessous afin de vous assurer d'intégrer l'entité User et le module TypeORM, qui établit la connexion à la base de données.
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './models/user.entity';@Module({
imports: [TypeOrmModule.forFeature([User])],
controllers: [UsersController],
providers: [UsersService]
})
export class UsersModule {}
Enfin, lancez le serveur de développement afin de tester les opérations CRUD à l'aide de Postman.
npm run start
Le serveur démarrera sur le port 3000 et vous pourrez lui envoyer des requêtes API à http://localhost:3000/api/users.
Créer des applications backend avec Nest.js
Que vous développiez une simple API REST ou une application Web complexe, Nest.js offre un ensemble complet de fonctionnalités et de capacités pour élaborer un système backend fiable et robuste.
Nest.js propose une approche plus structurée du développement de projet que Express.js. Cela vous 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.