Come utilizzare i database SQL in un'applicazione NestJS con TypeORM

Un Object-Relational Mapper (ORM) è una libreria che implementa la tecnica di mappatura Object-Relational. Ciò ti consente di scrivere query di database SQL utilizzando il paradigma orientato agli oggetti del tuo linguaggio preferito.

TypeORM è un ORM TypeScript che semplifica l'interfacciamento con vari database. Funziona con i database SQL ma si interfaccia bene anche con i database NoSQL come MongoDB.

NestJS fornisce supporto di alto livello per TypeORM pronto all'uso. Il pacchetto TypeORM dedicato rende l'integrazione relativamente semplice.

Passaggio 1: installazione delle dipendenze

Prima di utilizzare TypeORM in un'applicazione NestJS, devi installarla con il suo pacchetto NestJS nativo e il tuo database SQL preferito. SQLite è un'opzione semplice e senza installazione.

Esegui il comando seguente per installare TypeORM e il suo pacchetto NestJS nativo, utilizzando il gestore di pacchetti npm:

npm installazione @nestjs/tipo o tipo

Eseguire il comando seguente per installare SQLite:

npm installare sqlite3

Passaggio 2: creazione di un'entità

Un'entità è una raccolta di campi che definiscono i dati archiviati in un database. TypeORM utilizza il file di entità per creare una tabella nel database.

Segui i passaggi seguenti per creare un'entità:

1. Crea un file nel modulo dell'applicazione e assegnagli un nome seguendo la convenzione di denominazione NestJS (.entità.ts).
2. Nel tuo file di entità, importa il file Entità, Colonna, e Colonna Generata Primaria decoratori da tipo.
3. Nel tuo file di entità, crea ed esporta una classe.
4. Popola la classe con i valori che desideri nel tuo database, ad esempio id, nome, eccetera.
5. Annota la tua classe di entità con il decoratore Entity. Questo rende la tua classe riconoscibile in TypeORM come entità.
6. Annota la tua proprietà id con il decoratore PrimaryGeneratedColumn. Questo dice a TypeORM di contrassegnare il id come chiave primaria e incrementarla automaticamente.
7. Annota le proprietà rimanenti con il decoratore Colonna. Questo li aggiunge come colonne nel tuo database.

Per esempio:

// src/test/test.entity.ts
importare { Entità, Colonna, Colonna Generata Primaria } da 'tipologia';
@Entità()
esportareclasseTest{
@PrimaryGeneratedColumn()
 id: numero;
@Colonna()
 proprietà_1: stringa;
@Colonna()
 proprietà_2: stringa;
@Colonna()
 proprietà_3: stringa;
}

Il file di entità sopra crea questa tabella nel tuo database:

Il TipodocumentazioneORM copre le entità in modo più dettagliato.

Passaggio 3: collegare l'applicazione a un database

Ora che la tua entità è configurata, dovrai connettere la tua applicazione a un database. Questo esempio usa SQLite.

Segui i passaggi seguenti per connettere la tua applicazione a un database:

1. Nel modulo radice delle tue applicazioni (di solito il file app.module.ts file), importare TipoOrmModule da @nestjs/typeorm.
2. Nello stesso file, importa tutte le tue entità.
3. Nel importazioni array, chiamare il per Root metodo su TypeOrmModule. Il metodo forRoot condivide la connessione al database attraverso tutti i moduli dell'applicazione.
4. Passa un oggetto vuoto come argomento nel metodo forRoot; questo sarà l'oggetto di configurazione TypeORM.
5. Aggiungi una proprietà, genere, all'oggetto di configurazione e impostarlo su “sqlite”. La proprietà type indica il nome del database che stai utilizzando.
6. Aggiungi un'altra proprietà, Banca dati, all'oggetto di configurazione e impostarlo su “test.db”. La proprietà database indica il tuo nome preferito per il tuo database.
7. Aggiungi un'altra proprietà, entità, all'oggetto di configurazione e impostarlo su un array vuoto. Popola l'array vuoto con le entità che hai importato in precedenza.
8. Aggiungi un'altra proprietà, sincronizzare, e impostarlo VERO; questa proprietà sincronizza le tue entità con il tuo database e lo aggiorna ogni volta che esegui il codice. Devi solo impostare questa proprietà su VERO in via di sviluppo. Durante la produzione, dovresti impostarlo su falso per evitare la perdita di dati.

// src/app.module.ts
importare {Modulo} da '@nestjs/comune';
importare { TypeOrmModule } da '@nestjs/typeorm';
importare { Test } da './test/test.entity';
importare { Entità2 } da './entità/entità.entità';
importare {Modulo di prova} da './test/test.module';
@Modulo({
 importazioni: [
TipoOrmModule.per Root({
 genere: 'sqlite',
 Banca dati: 'test.db',
entità: [Test, Entità2],
 sincronizzare: VERO, //solo sviluppo
 }),
 Modulo di prova,
 ],
controllori: [],
fornitori: [],
})
esportareclasseModulo App{}

Passaggio 4: creazione di un repository

Un repository è il livello di accesso di un'entità utilizzato per eseguire query (inserire, eliminare, salvare, trovare, ecc.) su una tabella creata dall'entità nel database. TypeORM supporta il modello di progettazione del repository, quindi ogni entità ha il proprio repository.

TypeORM crea automaticamente un repository per la tua entità quando segui i passaggi seguenti:

1. Nel file del modulo della tua entità, importa TipoOrmModule da @nestjs/typeorm e importa la tua entità.
2. Creare un importazioni matrice nel @Modulo decoratore.
3. Nell'array imports, chiama il file perCaratteristica metodo su TypeOrmModule.
4. Passa un array come argomento nel tuo e popola l'array con la tua entità.

// src/test/test.module.ts
importare {Modulo} da '@nestjs/comune';
importare { TypeOrmModule } da '@nestjs/typeorm';
importare {TestController} da './test.controller';
importare {Servizio di prova} da './test.service';
importare { Test } da './entità.di prova';
@Modulo({
importazioni: [TypeOrmModule.forFeature([Test])],
fornitori: [Servizio di prova],
controllori: [TestController],
})

Passaggio 5: iniettare il repository nel suo servizio utilizzando l'inserimento delle dipendenze

L'iniezione di dipendenza è una tecnica di ingegneria del software che è una forma del principio di inversione del controllo. Sposta il carico della gestione delle dipendenze dal codice client alla libreria o al servizio da cui dipende.

Segui i passaggi seguenti per inserire il tuo repository in un servizio:

1. Nel tuo file di servizio, importa Repository da tipo e il InjectRepository decoratore da @nestjs/typeorm. Importa anche l'entità che vuoi iniettare nel suo repository.
2. Nella tua classe di servizio, crea a costruttore.
3. dichiarare a privato variabile, repo, come parametro nel costruttore per inizializzarlo.
4. Assegna un tipo di repository al repository con un tipo generico della tua entità.
5. Annota il repository con il decoratore InjectRepository e passa la tua entità come argomento.

// test.service.ts
importare {Iniettabile} da '@nestjs/comune';
importare { Repository } da 'tipologia';
importare {InjectRepository} da '@nestjs/typeorm';
importare { Test } da './entità.di prova';
@Iniettabile()
esportareclasseServizio di prova{
costruttore(
@InjectRepository(Test)
 repository privato: repository<Test>,
 ) {}
}

Ora che la tua configurazione è completa, puoi fare Query SQL su di esso per recuperare o modificare i dati.

Fare query SQL con TypeORM

Puoi eseguire qualsiasi semplice query SQL chiamando i metodi del repository di TypeORM su repo variabile all'interno della tua classe di servizio. Puoi anche creare query SQL complesse utilizzando il generatore di query di TypeORM.