Come creare un'API REST CRUD Nest.js utilizzando TypeORM e PostgreSQL

Come altri framework Node.js, Nest.js fornisce un toolkit completo per la creazione di servizi di backend robusti e scalabili. Tuttavia, è importante capire come implementare la creazione, la lettura, l'aggiornamento e l'eliminazione (CRUD) in Nest.js in modo efficiente: queste sono le operazioni più fondamentali nello sviluppo delle API.

Scopri come creare un'API REST CRUD Nest.js utilizzando TypeORM e un database PostgreSQL.

Guida introduttiva a Nest.js

Per iniziare, installa lo strumento a riga di comando Nest.js:

npm i -g @nestjs/cli

Successivamente, crea un nuovo progetto eseguendo:

nest nuova app crud

Lo strumento CLI ti chiederà di scegliere un gestore di pacchetti, scegli l'opzione che ritieni più preferibile. Useremo npm, il gestore di pacchetti Node.

L'interfaccia a riga di comando eseguirà l'impalcatura di un progetto Nest.js di base con tutti i file di configurazione richiesti e le dipendenze iniziali necessarie per eseguire l'applicazione.

Infine, vai alla directory del progetto e avvia il server di sviluppo.

cd crud-app
avvio della corsa npm

Puoi trovare il codice di questo progetto nel suo file Git Hub deposito.

Crea un database PostgreSQL

Questo tutorial utilizza un'istanza PostgreSQL cloud, ma puoi invece configurare un database PostgreSQL locale. Puoi installa PostgreSQL su Windows, su macOSo su Linux.

Per configurare un'istanza PostgreSQL cloud:

1. Vai a ElephantSQL, registrati e accedi alla pagina di panoramica del tuo account.
2. Clicca il Crea nuova istanza pulsante nella sezione in alto a sinistra della pagina per creare una nuova istanza per la tua applicazione.
3. Inserisci il nome della tua istanza, scegli il piano gratuito e infine seleziona la regione per completare il processo di configurazione.
4. Dopo aver creato l'istanza del database, vai al file impostazioni pagina e copia il file fornito URL della banca dati.

Configurare la connessione al database

Nella directory principale del tuo progetto, crea un file .env file e incollare l'URL di connessione al database come segue:

DATABASE_URL=""

Ora installa questi pacchetti:

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

Successivamente, vai avanti e crea un modulo di database utilizzando lo strumento CLI.

database del modulo nest g

Apri il database/database.modulo.ts file e aggiungere il seguente codice di configurazione del database:

importare { Modulo } da'@nestjs/comune';
importare {ConfigModule, ConfigService} da'@nestjs/config';
importare { TypeOrmModule } da'@nestjs/typeorm';
importare { Utente } da'../utenti/modelli/utente.entità'; 
@Modulo({
 importazioni: [
 TypeOrmModule.forRootAsync({
 importazioni: [ConfigModule], 
 iniettare: [ConfigService],
 usoFabbrica: asincrono (configService: ConfigService) => ({
tipo: 'postgres',
 URL: configService.get("URL_DATABASE"), 
 entità: [Utente],
 sincronizzare: VERO
 }),
 }),
 ],
})
esportareclasse Modulo database {}

Questo modulo database gestisce la connessione configurando il modulo TypeORM con il parametro di connessione richiesto, l'URL del database.

Inoltre, definisce l'entità Utente come parte della configurazione che specifica la struttura e le proprietà dei dati archiviati nella tabella del database PostgreSQL.

In questa fase, il tuo codice genererà probabilmente un errore perché non hai ancora creato l'entità utenti. Lo farai nei seguenti passaggi.

Aggiorna il file app.module.ts

Infine, aggiorna il modulo principale dell'applicazione per includere la configurazione per il modulo database.

importare { Modulo } da'@nestjs/comune';
importare {ConfigModule} da'@nestjs/config';
importare {Controller dell'applicazione} da'./app.controllore';
importare {Servizio app} da'./servizio.app';
importare { Modulo database } da'./database/database.module';
@Modulo({
 importazioni: [
 ConfigModule.forRoot({
 envFilePath: '.env', 
 }),
 Modulo database,
 ],
 controller: [AppController],
 fornitori: [AppService],
})
esportareclasse Modulo applicazione {}

Definire un modulo utenti

Il modulo utenti funge da componente centralizzato, responsabile dell'incapsulamento e della gestione della logica richiesta per implementare la funzionalità CRUD dell'API.

Esegui questo comando da terminale per creare il modulo utenti dell'API.

utenti del modulo nest g

Lo strumento CLI aggiorna automaticamente il file app.module.ts file per riflettere le modifiche apportate, oltre a creare il modulo utente. Ciò garantisce che il modulo appena creato, users, sia correttamente integrato nella configurazione del modulo dell'applicazione.

Crea un'entità utente

TypeORM è una libreria Object-Relational Mapping (ORM) che semplifica le interazioni del database nelle applicazioni che utilizzano TypeScript mappando gli oggetti JavaScript alle tabelle del database.

Creando un'entità utente utilizzando TypeORM, definisci la struttura e le proprietà dei dati utente nel database PostgreSQL.

Nella directory degli utenti, crea un nuovo file modelli/user.entity.ts e aggiungi il seguente codice.

importare {Entità, PrimaryGeneratedColumn, Colonna,} da"tipotipo";
@Entità()
esportareclasse Utente {
@PrimaryGeneratedColumn()
 id: numero;
@Colonna()
 nome: corda;
@Colonna()
 e-mail: corda;
}

IL Utente entità definisce la struttura dei dati utente archiviati nel database. In questo caso, questo è il id come colonna della chiave primaria e la nome E e-mail colonne e le relative proprietà.

Crea il servizio API CRUD

Ora, crea il servizio API che gestirà la logica per le operazioni CRUD eseguendo il comando seguente:

utenti del servizio nest g

Apri il utente-auth.service.ts file e aggiungi questo codice:

importare { Iniettabile } da'@nestjs/comune';
importare {InjectRepository} da'@nestjs/typeorm';
importare { Deposito } da'tipotipo';
importare {Utente} da'./modelli/utente.entità';
@Iniettabile()
esportareclasse Servizio utenti {
costruttore(
@InjectRepository(Utente)
privato userRepository: archivio,
 ) {}
asincrono trova tutto(): Promettere {
ritornoQuesto.userRepository.find();
 }
asincrono trovaUno (id: numero): Promettere {
ritornoQuesto.userRepository.findOne({ dove: { id } });
 }
asincrono creare (utente: Partial): Promettere {
cost nuovoutente = Questo.userRepository.create (utente);
ritornoQuesto.userRepository.save (nuovoutente);
 }
asincrono aggiornare (id: numero, utente: parziale): Promettere {
aspettaQuesto.userRepository.update (id, utente);
ritornoQuesto.userRepository.findOne({ dove: { id } });
 }
asincronoeliminare(id: numero): Promettere<vuoto> {
aspettaQuesto.userRepository.delete (id);
 }
}

Questa classe UsersService definisce vari metodi API dedicati alla gestione delle operazioni CRUD. Questi metodi includono il recupero dei dati di tutti gli utenti, la ricerca di un utente specifico utilizzando il proprio numero ID, la creazione un nuovo utente, l'aggiornamento di un utente esistente e un metodo per eliminare i dati di un utente specifico nel database.

Definire un controller per l'API

Crea un controller che gestirà gli endpoint API per le operazioni relative agli utenti.

utenti del controller Nest G

Successivamente, aggiungi il codice seguente al file utenti.controllore.ts file.

importare { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } da'@nestjs/comune';
importare {Servizio utenti} da'./utenti.servizio';
importare { Utente } da'./modelli/utente.entità';
@Controller('API/utenti')
esportareclasse UsersController {
costruttore(privato sola lettura usersService: UsersService) {}
@Ottenere()
asincrono trova tutto(): Promettere {
ritornoQuesto.usersService.findAll();
 }
@Inviare()
@HttpCode(201) 
asincrono creare(@Corpo() utente: Utente): Promettere {
cost creatoUtente = aspettaQuesto.usersService.create (utente);
ritorno utente creato;
 }
@Mettere(':id')
asincrono aggiornamento (@Param('id') id: numero, @Corpo() utente: Utente): Promettere<Qualunque> {
aspettaQuesto.usersService.update (id, utente);
ritorno { Messaggio: 'Utente aggiornato con successo' };
 }
@Eliminare(':id')
asincronoeliminare(@Param('id') id: numero): Promettere<Qualunque> {
cost utente = aspettaQuesto.usersService.findOne (id);
Se (!utente) {
gettarenuovo NotFoundException('L'utente non esiste!');
 }
aspettaQuesto.usersService.delete (id);
ritorno { Messaggio: "Utente eliminato con successo" };
 }
}

Il controller gestisce gli endpoint API per le operazioni degli utenti. Gestisce le richieste GET per recuperare tutti gli utenti, le richieste POST per creare nuovi utenti, le richieste PUT per aggiornare gli utenti esistenti e le richieste DELETE per eliminare gli utenti.

Utilizzando il Servizio Utenti e interagire con il Utente entità, questo controller fornisce un'API completa per la gestione delle operazioni relative all'utente sui dati archiviati nel database.

Aggiorna il file users.module.ts

Infine, aggiorna il file utenti.modulo.ts file come mostrato di seguito per assicurarti di incorporare il file Entità utente e il modulo TypeORM, che stabilisce la connessione al database.

importare { Modulo } da'@nestjs/comune';
importare { controllore utenti } da'./utenti.controllore';
importare {Servizio utenti} da'./utenti.servizio';
importare { TypeOrmModule } da'@nestjs/typeorm';
importare { Utente } da'./modelli/utente.entità';
@Modulo({
 importazioni: [TypeOrmModule.forFeature([Utente])],
 controller: [UsersController],
 fornitori: [UtentiServizio]
})
esportareclasse Modulo utenti {}

Infine, vai avanti e avvia il server di sviluppo per testare le operazioni CRUD utilizzando Postman.

avvio della corsa npm

Il server verrà avviato sulla porta 3000 e puoi inviargli richieste API a http://localhost: 3000/api/utenti.

Creazione di applicazioni back-end con Nest.js

Che tu stia sviluppando una semplice API REST o un'app Web complessa, Nest.js offre un set completo di funzionalità e capacità per creare un sistema di back-end affidabile e robusto.

Nest.js offre un approccio più strutturato allo sviluppo del progetto rispetto a Express.js. Ciò garantisce la possibilità di creare, ridimensionare e gestire con sicurezza applicazioni complesse, grazie al modello di progettazione organizzato e modulare.