Hur man använder SQL-databaser i en NestJS-applikation med TypeORM

En Object-Relational Mapper (ORM) är ett bibliotek som implementerar objektrelationell kartläggningsteknik. Detta låter dig skriva SQL-databasfrågor med hjälp av det objektorienterade paradigmet för ditt föredragna språk.

TypeORM är en TypeScript ORM som gör gränssnittet med olika databaser mycket enkelt. Det fungerar med SQL-databaser men gränssnitt också bra med NoSQL-databaser som MongoDB.

NestJS tillhandahåller högnivåstöd för TypeORM direkt från förpackningen. Det dedikerade TypeORM-paketet gör integrationen relativt enkel.

Steg 1: Installera beroenden

Innan du använder TypeORM i en NestJS-applikation måste du installera den med dess ursprungliga NestJS-paket och din föredragna SQL-databas. SQLite är ett enkelt, installationsfritt alternativ.

Kör följande kommando för att installera TypeORM och dess ursprungliga NestJS-paket med hjälp av npm-pakethanteraren:

npm installera @nestjs/typeorm typorm

Kör följande kommando för att installera SQLite:

npm Installera sqlite3

Steg 2: Skapa en enhet

En entitet är en samling fält som definierar data som lagras i en databas. TypeORM använder entitetsfilen för att skapa en tabell i din databas.

Följ stegen nedan för att skapa en enhet:

1. Skapa en fil i din applikationsmodul och namnge den enligt NestJS namnkonvention (.entity.ts).
2. Importera filen i entitetsfilen Entitet, Kolumn, och PrimaryGenerated Column dekoratörer från typorm.
3. Skapa och exportera en klass i din entitetsfil.
4. Fyll klassen med de värden du vill ha i din databas, till exempel id, namn, etc.
5. Annotera din enhetsklass med Entity-dekoratören. Detta gör din klass igenkännbar för TypeORM som en enhet.
6. Annotera din id-egendom med PrimaryGeneratedColumn-dekoratören. Detta talar om för TypeORM att markera id som en primärnyckel och automatiskt öka den.
7. Annotera de återstående egenskaperna med kolumndekoratören. Detta lägger till dem som kolumner i din databas.

Till exempel:

// src/test/test.entity.ts
importera { Entity, Column, PrimaryGenerated Column } från 'typorm';
@Entitet()
exporteraklassTesta{
@PrimaryGeneratedColumn()
 id nummer;
@Kolumn()
 egenskap_1: sträng;
@Kolumn()
 egenskap_2: sträng;
@Kolumn()
 egenskap_3: sträng;
}

Entitetsfilen ovan skapar den här tabellen i din databas:

De TypORM dokumentation omfattar enheter mer i detalj.

Steg 3: Anslut din applikation till en databas

Nu när din enhet är konfigurerad måste du ansluta din applikation till en databas. Det här exemplet använder SQLite.

Följ stegen nedan för att ansluta din applikation till en databas:

1. I din applikations rotmodul (vanligtvis app.modul.ts fil), importera TypOrmModule från @nestjs/typeorm.
2. Importera alla dina enheter i samma fil.
3. I den import array, ring för Root metod på TypeOrmModule. Metoden forRoot delar databasanslutningen genom alla moduler i din applikation.
4. Skicka ett tomt objekt som ett argument till metoden forRoot; detta kommer att vara TypeORM-konfigurationsobjektet.
5. Lägg till en egenskap, typ, till konfigurationsobjektet och ställ in det på "sqlite". Egenskapen type anger namnet på databasen du använder.
6. Lägg till en annan egenskap, databas, till konfigurationsobjektet och ställ in det på "test.db". Databasegenskapen anger ditt föredragna namn för din databas.
7. Lägg till en annan egenskap, enheter, till konfigurationsobjektet och ställ in det till en tom array. Fyll den tomma arrayen med de enheter du importerade tidigare.
8. Lägg till en annan egenskap, synkronisera, och ställ in den Sann; den här egenskapen synkroniserar dina enheter till din databas och uppdaterar den varje gång du kör koden. Du bör bara ställa in den här egenskapen till Sann under utveckling. Under produktionen bör du ställa in den på falsk för att undvika dataförlust.

// src/app.module.ts
importera { Modul } från '@nestjs/common';
importera { TypeOrmModule } från '@nestjs/typeorm';
importera { Test } från './test/test.entity';
importera { Entity2 } från './entity/entity.entity';
importera { TestModule } från './test/test.modul';
@Modul({
 importer: [
TypOrmModule.forRoot({
 typ: 'sqlite',
 databas: 'test.db',
enheter: [Test, Entity2],
 synkronisera: Sann, //endast utveckling
 }),
 Testmodul,
 ],
kontroller: [],
leverantörer: [],
})
exporteraklassAppModul{}

Steg 4: Skapa ett arkiv

Ett arkiv är en entitets åtkomstlager som används för att göra frågor (infoga, ta bort, spara, hitta, etc.) på en tabell som skapats av entiteten i databasen. TypeORM stöder förvarsdesignmönstret, så varje enhet har sitt eget förvar.

TypeORM skapar automatiskt ett arkiv för din enhet när du följer stegen nedan:

1. Importera i din enhets modulfil TypOrmModule från @nestjs/typeorm och importera din enhet.
2. Skapa en import array i @Modul dekoratör.
3. I importmatrisen, anropa för Funktion metod på TypeOrmModule.
4. Skicka en array som ett argument till din och fyll i arrayen med din enhet.

// src/test/test.module.ts
importera { Modul } från '@nestjs/common';
importera { TypeOrmModule } från '@nestjs/typeorm';
importera { TestController } från './test.controller';
importera { TestService } från './test.service';
importera { Test } från './test.entity';
@Modul({
import: [TypeOrmModule.forFeature([Test])],
leverantörer: [TestService],
kontroller: [TestController],
})

Steg 5: Injicera ditt förråd till dess tjänst med hjälp av beroendeinjektion

Beroendeinjektion är en mjukvaruteknik som är en form av inversion av styrprincipen. Det flyttar bördan av beroendehantering från klientkod till biblioteket eller tjänsten den är beroende av.

Följ stegen nedan för att injicera ditt arkiv i en tjänst:

1. Importera i din tjänstfil Förvar från typorm och den InjectRepository dekoratör från @nestjs/typeorm. Importera också den enhet du vill injicera dess arkiv.
2. I din serviceklass skapar du en konstruktör.
3. Deklarera a privat variabel, repo, som en parameter i konstruktorn för att initiera den.
4. Tilldela en typ av repository att repor med en generisk typ av din enhet.
5. Annotera repo med InjectRepository-dekoratören och skicka din enhet som ett argument.

// test.service.ts
importera { Injicerbar } från '@nestjs/common';
importera { Repository } från 'typorm';
importera { InjectRepository } från '@nestjs/typeorm';
importera { Test } från './test.entity';
@Injicerbar()
exporteraklassTestService{
konstruktör(
@InjectRepository(Testa)
 privat repo: Förvar<Testa>,
 ) {}
}

Nu när din installation är klar kan du göra SQL-frågor på den för att hämta eller ändra data.

Göra SQL-frågor med TypeORM

Du kan göra vilken enkel SQL-fråga som helst genom att anropa TypeORMs repository-metoder på repo variabel inom din serviceklass. Du kan också skapa komplexa SQL-frågor genom att använda TypeORMs frågebyggare.