Sådan bruges SQL-databaser i en NestJS-applikation med TypeORM

En Object-Relational Mapper (ORM) er et bibliotek, der implementerer Object-Relational Mapping-teknikken. Dette lader dig skrive SQL-databaseforespørgsler ved hjælp af det objektorienterede paradigme for dit foretrukne sprog.

TypeORM er en TypeScript ORM, der gør grænseflader til forskellige databaser meget let. Det fungerer med SQL-databaser, men har også en god grænseflade med NoSQL-databaser som MongoDB.

NestJS leverer support på højt niveau til TypeORM ud af kassen. Den dedikerede TypeORM-pakke gør integrationen forholdsvis nem.

Trin 1: Installation af afhængigheder

Før du bruger TypeORM i en NestJS-applikation, skal du installere den med dens oprindelige NestJS-pakke og din foretrukne SQL-database. SQLite er en enkel, installationsfri mulighed.

Kør følgende kommando for at installere TypeORM og dens oprindelige NestJS-pakke ved hjælp af npm-pakkehåndteringen:

npm installere @nestjs/typeorm typeorm

Kør følgende kommando for at installere SQLite:

npm installere sqlite3

Trin 2: Oprettelse af en enhed

En enhed er en samling af felter, der definerer de data, der er gemt i en database. TypeORM bruger entitetsfilen til at oprette en tabel i din database.

Følg nedenstående trin for at oprette en enhed:

1. Opret en fil i dit applikationsmodul og navngiv den efter NestJS navngivningskonventionen (.entity.ts).
2. I din enhedsfil skal du importere Enhed, Kolonne, og PrimærGenereret Kolonne dekoratører fra typeorm.
3. I din enhedsfil skal du oprette og eksportere en klasse.
4. Udfyld klassen med de værdier, du ønsker i din database, f.eks id, navn, etc.
5. Anmærk din enhedsklasse med enhedsdekoratøren. Dette gør din klasse genkendelig for TypeORM som en enhed.
6. Anmærk din id-ejendom med PrimaryGeneratedColumn-dekoratoren. Dette fortæller TypeORM at markere id som en primær nøgle og auto-inkrementer den.
7. Anmærk de resterende egenskaber med kolonnedekoratøren. Dette tilføjer dem som kolonner i din database.

For eksempel:

// src/test/test.entity.ts
importere { Enhed, Column, PrimaryGeneratedColumn } fra 'typeorm';
@Enhed()
eksportklassePrøve{
@PrimaryGeneratedColumn()
 ID-nummer;
@Kolonne()
 egenskab_1: streng;
@Kolonne()
 egenskab_2: streng;
@Kolonne()
 egenskab_3: streng;
}

Enhedsfilen ovenfor opretter denne tabel i din database:

Det TypeORM dokumentation dækker enheder mere detaljeret.

Trin 3: Tilslutning af din applikation til en database

Nu hvor din enhed er konfigureret, skal du forbinde din applikation til en database. Dette eksempel bruger SQLite.

Følg nedenstående trin for at forbinde din applikation til en database:

1. I dit applikationsrodmodul (normalt app.modul.ts fil), import TypeOrmModule fra @nestjs/typeorm.
2. Importer alle dine enheder i den samme fil.
3. I den import array, ring til for Root metode på TypeOrmModule. ForRoot-metoden deler databaseforbindelsen gennem alle modulerne i din applikation.
4. Send et tomt objekt som et argument ind i forRoot-metoden; dette vil være TypeORM-konfigurationsobjektet.
5. Tilføj en ejendom, type, til konfigurationsobjektet og indstil det til "sqlite". Egenskaben type angiver navnet på den database, du bruger.
6. Tilføj en anden ejendom, database, til konfigurationsobjektet og indstil det til "test.db". Databaseegenskaben angiver dit foretrukne navn til din database.
7. Tilføj en anden ejendom, enheder, til konfigurationsobjektet og sæt det til et tomt array. Udfyld den tomme matrix med de enheder, du importerede tidligere.
8. Tilføj en anden ejendom, synkronisere, og sæt den rigtigt; denne egenskab synkroniserer dine enheder til din database og opdaterer den, hver gang du kører koden. Du bør kun indstille denne egenskab til rigtigt under udvikling. Under produktionen skal du indstille den til falsk for at undgå tab af data.

// src/app.module.ts
importere { Modul } fra '@nestjs/common';
importere { TypeOrmModule } fra '@nestjs/typeorm';
importere { Test } fra './test/test.entity';
importere { Enhed2 } fra './entity/entity.entity';
importere { TestModule } fra './test/test.modul';
@Modul({
 import: [
TypeOrmModule.forRoot({
 type: 'sqlite',
 database: 'test.db',
enheder: [Test, enhed2],
 synkronisere: rigtigt, //kun udvikling
 }),
 Testmodul,
 ],
controllere: [],
udbydere: [],
})
eksportklasseAppModul{}

Trin 4: Oprettelse af et lager

Et lager er en enheds adgangslag, der bruges til at lave forespørgsler (indsætte, slette, gemme, finde osv.) på en tabel, der er oprettet af enheden i databasen. TypeORM understøtter lagerdesignmønsteret, så hver enhed har sit eget lager.

TypeORM opretter automatisk et lager for din enhed, når du følger nedenstående trin:

1. Importer i din enheds modulfil TypeOrmModule fra @nestjs/typeorm og importer din enhed.
2. Opret en import række i @Modul dekoratør.
3. I importarrayet skal du kalde for Funktion metode på TypeOrmModule.
4. Send et array som et argument ind i din og udfyld arrayet med din enhed.

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

Trin 5: Injicer dit lager til dets service ved hjælp af afhængighedsinjektion

Afhængighedsinjektion er en softwareingeniørteknik, der er en form for inversion af kontrolprincippet. Det flytter byrden af ​​afhængighedsstyring fra klientkode til det bibliotek eller den tjeneste, den afhænger af.

Følg nedenstående trin for at injicere dit lager i en tjeneste:

1. Importer i din servicefil Depot fra typeorm og InjectRepository dekoratør fra @nestjs/typeorm. Importer også den enhed, du vil injicere dens repository.
2. I din serviceklasse skal du oprette en konstruktør.
3. Erklære en privat variabel, repo, som en parameter i konstruktøren for at initialisere den.
4. Tildel en type Repository til repo med en generisk type af din enhed.
5. Annoter repo med InjectRepository-dekoratoren og send din enhed som et argument.

// test.service.ts
importere { Injicerbar } fra '@nestjs/common';
importere { Repository } fra 'typeorm';
importere { InjectRepository } fra '@nestjs/typeorm';
importere { Test } fra './test.entity';
@Injicerbar()
eksportklasseTestService{
konstruktør(
@InjectRepository(Prøve)
 privat repos: Depot<Prøve>,
 ) {}
}

Nu hvor din opsætning er færdig, kan du lave SQL-forespørgsler på den for at hente eller ændre data.

Lav SQL-forespørgsler med TypeORM

Du kan lave enhver simpel SQL-forespørgsel ved at kalde TypeORMs repository-metoder på repo variabel inden for din serviceklasse. Du kan også oprette komplekse SQL-forespørgsler ved at bruge TypeORMs forespørgselsbygger.