Hvordan bruke SQL-databaser i en NestJS-applikasjon med TypeORM

En Object-Relational Mapper (ORM) er et bibliotek som implementerer objektrelasjonell kartleggingsteknikk. Dette lar deg skrive SQL-databasespørringer ved å bruke det objektorienterte paradigmet til ditt foretrukne språk.

TypeORM er en TypeScript ORM som gjør grensesnitt med ulike databaser veldig enkelt. Det fungerer med SQL-databaser, men passer også godt med NoSQL-databaser som MongoDB.

NestJS gir støtte på høyt nivå for TypeORM rett ut av esken. Den dedikerte TypeORM-pakken gjør integrasjonen relativt enkel.

Trinn 1: Installere avhengigheter

Før du bruker TypeORM i en NestJS-applikasjon, må du installere den med den opprinnelige NestJS-pakken og din foretrukne SQL-database. SQLite er et enkelt, installasjonsfritt alternativ.

Kjør følgende kommando for å installere TypeORM og dens opprinnelige NestJS-pakke ved å bruke npm-pakkebehandleren:

npm installere @nestjs/typeorm typeorm

Kjør følgende kommando for å installere SQLite:

npm installere sqlite3

Trinn 2: Opprette en enhet

En enhet er en samling av felt som definerer dataene som er lagret i en database. TypeORM bruker enhetsfilen til å lage en tabell i databasen din.

Følg trinnene nedenfor for å opprette en enhet:

1. Opprett en fil i applikasjonsmodulen din og navngi den etter NestJS-navnekonvensjonen (.entity.ts).
2. Importer i enhetsfilen Entitet, Kolonne, og Primærgenerert kolonne dekoratører fra typeorm.
3. Opprett og eksporter en klasse i enhetsfilen din.
4. Fyll klassen med verdiene du vil ha i databasen din, for eksempel id, Navn, etc.
5. Annoter enhetsklassen din med enhetsdekoratøren. Dette gjør klassen din gjenkjennelig for TypeORM som en enhet.
6. Annoter id-egenskapen din med PrimaryGeneratedColumn-dekoratoren. Dette forteller TypeORM å merke id som en primærnøkkel og øker den automatisk.
7. Merk de resterende egenskapene med kolonnedekoratøren. Dette legger dem til som kolonner i databasen din.

For eksempel:

// src/test/test.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } fra 'typeorm';
@Entitet()
eksportklasseTest{
@PrimaryGeneratedColumn()
 ID-nummer;
@Kolonne()
 egenskap_1: streng;
@Kolonne()
 egenskap_2: streng;
@Kolonne()
 egenskap_3: streng;
}

Entitetsfilen ovenfor oppretter denne tabellen i databasen din:

De TypeORM dokumentasjon dekker enheter mer detaljert.

Trinn 3: Koble applikasjonen til en database

Nå som enheten din er konfigurert, må du koble programmet til en database. Dette eksemplet bruker SQLite.

Følg trinnene nedenfor for å koble programmet til en database:

1. I applikasjonens rotmodul (vanligvis app.modul.ts fil), import TypeOrmModule fra @nestjs/typeorm.
2. Importer alle enhetene dine i samme fil.
3. I import array, ring for Root metode på TypeOrmModule. ForRoot-metoden deler databaseforbindelsen gjennom alle modulene i applikasjonen din.
4. Send et tomt objekt som argument inn i forRoot-metoden; dette vil være TypeORM-konfigurasjonsobjektet.
5. Legg til en eiendom, type, til konfigurasjonsobjektet og sett det til "sqlite". Type-egenskapen angir navnet på databasen du bruker.
6. Legg til en annen eiendom, database, til konfigurasjonsobjektet og sett det til "test.db". Databaseegenskapen angir ditt foretrukne navn for databasen.
7. Legg til en annen eiendom, enheter, til konfigurasjonsobjektet og sett det til en tom matrise. Fyll den tomme matrisen med enhetene du importerte tidligere.
8. Legg til en annen eiendom, synkronisere, og sett den ekte; denne egenskapen synkroniserer enhetene dine til databasen og oppdaterer den hver gang du kjører koden. Du bør bare sette denne egenskapen til ekte under utvikling. Under produksjonen bør du sette den til falsk for å unngå tap av data.

// src/app.module.ts
import { Modul } fra '@nestjs/common';
import { TypeOrmModule } fra '@nestjs/typeorm';
import { Test } fra './test/test.entity';
import { Entitet2 } fra './entity/entity.entity';
import { TestModule } fra './test/test.modul';
@Modul({
 importerer: [
TypeOrmModule.forRoot({
 type: 'sqlite',
 database: 'test.db',
enheter: [Test, Entity2],
 synkronisere: ekte, // bare utvikling
 }),
 Testmodul,
 ],
kontrollere: [],
tilbydere: [],
})
eksportklasseAppModule{}

Trinn 4: Opprette et depot

Et depot er en enhets tilgangslag som brukes til å lage spørringer (sette inn, slette, lagre, finne osv.) på en tabell opprettet av enheten i databasen. TypeORM støtter depotdesignmønsteret, og dermed har hver enhet sitt eget depot.

TypeORM oppretter automatisk et depot for enheten din når du følger trinnene nedenfor:

1. Importer i enhetens modulfil TypeOrmModule fra @nestjs/typeorm og importer enheten din.
2. Opprett en import rekke i @Modul dekoratør.
3. I importmatrisen kaller du opp for funksjon metode på TypeOrmModule.
4. Send en matrise som et argument inn i din og fyll ut matrisen med enheten din.

// src/test/test.module.ts
import { Modul } fra '@nestjs/common';
import { TypeOrmModule } fra '@nestjs/typeorm';
import { TestController } fra './test.kontroller';
import { TestService } fra './test.service';
import { Test } fra './test.entity';
@Modul({
import: [TypeOrmModule.forFeature([Test])],
tilbydere: [TestService],
kontrollere: [TestController],
})

Trinn 5: Injiser depotet til tjenesten ved hjelp av avhengighetsinjeksjon

Avhengighetsinjeksjon er en programvareteknisk teknikk som er en form for inversjon av kontrollprinsippet. Det flytter byrden med avhengighetsstyring fra klientkode til biblioteket eller tjenesten den er avhengig av.

Følg trinnene nedenfor for å injisere depotet ditt i en tjeneste:

1. Importer i tjenestefilen Oppbevaringssted fra typeorm og InjectRepository dekoratør fra @nestjs/typeorm. Importer også enheten du vil injisere depotet til.
2. I serviceklassen din oppretter du en konstruktør.
3. Erklær en privat variabel, repo, som en parameter i konstruktøren for å initialisere den.
4. Tilordne en type depot til repo med en generisk type av enheten din.
5. Annoter repo med InjectRepository-dekoratoren og send enheten din som et argument.

// test.service.ts
import { Injiserbar } fra '@nestjs/common';
import { Oppbevaringssted } fra 'typeorm';
import { InjectRepository } fra '@nestjs/typeorm';
import { Test } fra './test.entity';
@Injiserbar()
eksportklasseTestService{
konstruktør(
@InjectRepository(Test)
 privat repo: Depot<Test>,
 ) {}
}

Nå som oppsettet er fullført, kan du gjøre det SQL-spørringer på den for å hente eller endre data.

Lage SQL-spørringer med TypeORM

Du kan lage en hvilken som helst enkel SQL-spørring ved å ringe TypeORMs depotmetoder på repo variabel innenfor tjenesteklassen din. Du kan også lage komplekse SQL-spørringer ved å bruke TypeORMs spørringsbygger.