Cum să utilizați baze de date SQL într-o aplicație NestJS cu TypeORM

Un Object-Relational Mapper (ORM) este o bibliotecă care implementează tehnica de mapare Object-Relational. Acest lucru vă permite să scrieți interogări de baze de date SQL utilizând paradigma orientată pe obiect a limbajului dvs. preferat.

TypeORM este un ORM TypeScript care face interfața cu diferite baze de date foarte ușoară. Funcționează cu baze de date SQL, dar și interfețe frumos cu baze de date NoSQL precum MongoDB.

NestJS oferă asistență la nivel înalt pentru TypeORM imediat. Pachetul dedicat TypeORM face integrarea relativ ușoară.

Pasul 1: Instalarea dependențelor

Înainte de a utiliza TypeORM într-o aplicație NestJS, trebuie să o instalați cu pachetul său nativ NestJS și baza de date SQL preferată. SQLite este o opțiune simplă, fără instalare.

Rulați următoarea comandă pentru a instala TypeORM și pachetul său nativ NestJS, folosind managerul de pachete npm:

instalare npm @nestjs/typeorm tipoorm

Rulați următoarea comandă pentru a instala SQLite:

npm instalare sqlite3

Pasul 2: Crearea unei entități

O entitate este o colecție de câmpuri care definesc datele stocate într-o bază de date. TypeORM folosește fișierul de entitate pentru a crea un tabel în baza de date.

Urmați pașii de mai jos pentru a crea o entitate:

1. Creați un fișier în modulul aplicației și denumiți-l urmând convenția de denumire NestJS (.entitate.ts).
2. În fișierul dvs. de entitate, importați Entitate, Coloană, și PrimaryGeneratedColumn decoratori din tipoorm.
3. În fișierul dvs. de entitate, creați și exportați o clasă.
4. Populați clasa cu valorile pe care le doriți în baza de date, de exemplu id, Nume, etc.
5. Adnotă clasa ta de entitate cu decoratorul Entitate. Acest lucru face ca clasa să fie recunoscută de TypeORM ca entitate.
6. Adnotă proprietatea ID-ului cu decoratorul PrimaryGeneratedColumn. Aceasta îi spune TypeORM să marcheze id ca cheie primară și o incrementa automat.
7. Adnotați proprietățile rămase cu decoratorul Coloane. Acest lucru le adaugă ca coloane în baza de date.

De exemplu:

// src/test/test.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } din „tipoorm”;
@Entitate()
exportclasăTest{
@PrimaryGeneratedColumn()
 numar de identificare;
@Coloană()
 proprietate_1: șir;
@Coloană()
 proprietate_2: șir;
@Coloană()
 proprietate_3: șir;
}

Fișierul de entitate de mai sus creează acest tabel în baza de date:

The Documentație de tip ORM acoperă entitățile mai detaliat.

Pasul 3: Conectarea aplicației la o bază de date

Acum că entitatea dvs. este configurată, va trebui să vă conectați aplicația la o bază de date. Acest exemplu folosește SQLite.

Urmați pașii de mai jos pentru a vă conecta aplicația la o bază de date:

1. În modulul rădăcină al aplicațiilor dvs. (De obicei, aplicație.modul.ts fișier), import TypeOrmModule din @nestjs/typeorm.
2. În același fișier, importați toate entitățile.
3. În importurilor matrice, apelați pentruRoot metoda pe TypeOrmModule. Metoda forRoot partajează conexiunea la baza de date prin toate modulele din aplicația dumneavoastră.
4. Treceți un obiect gol ca argument în metoda forRoot; acesta va fi obiectul de configurare TypeORM.
5. Adăugați o proprietate, tip, la obiectul de configurare și setați-l la „sqlite”. Proprietatea tip indică numele bazei de date pe care o utilizați.
6. Adăugați o altă proprietate, Bază de date, la obiectul de configurare și setați-l la „test.db”. Proprietatea bazei de date indică numele dvs. preferat pentru baza de date.
7. Adăugați o altă proprietate, entitati, la obiectul de configurare și setați-l într-o matrice goală. Populați matricea goală cu entitățile pe care le-ați importat mai devreme.
8. Adăugați o altă proprietate, sincroniza, și setați-l Adevărat; această proprietate sincronizează entitățile cu baza de date și o actualizează de fiecare dată când rulați codul. Ar trebui să setați numai această proprietate la Adevărat în dezvoltare. În timpul producției, ar trebui să îl setați la fals pentru a evita pierderea datelor.

// src/app.module.ts
import { Modulul } din „@nestjs/common”;
import { TypeOrmModule } din „@nestjs/typeorm”;
import { Test } din './test/test.entity';
import { Entitate2 } din './entity/entity.entity';
import { TestModule } din './test/test.module';
@Modul({
 importuri: [
TypeOrmModule.pentruRoot({
 tip: 'sqlite',
 Bază de date: 'test.db',
entitati: [Test, Entitate2],
 sincroniza: Adevărat, //doar dezvoltare
 }),
 TestModule,
 ],
controlorii: [],
furnizorii: [],
})
exportclasăAppModule{}

Pasul 4: Crearea unui depozit

Un depozit este stratul de acces al unei entități folosit pentru a face interogări (inserare, ștergere, salvare, găsire etc.) pe un tabel creat de entitate în baza de date. TypeORM acceptă modelul de proiectare a depozitului, astfel, fiecare entitate are propriul său depozit.

TypeORM creează automat un depozit pentru entitatea dvs. atunci când urmați pașii de mai jos:

1. În fișierul de modul al entității dvs., importați TypeOrmModule din @nestjs/typeorm și importați-vă entitatea.
2. Creaza un importurilor matrice în @Modul decorator.
3. În matricea de importuri, apelați pentru Caracteristică metoda pe TypeOrmModule.
4. Treceți o matrice ca argument în dvs. și populați matricea cu entitatea dvs.

// src/test/test.module.ts
import { Modulul } din „@nestjs/common”;
import { TypeOrmModule } din „@nestjs/typeorm”;
import { TestController } din './test.controller';
import { TestService } din './test.service';
import { Test } din './test.entity';
@Modul({
importurilor: [TypeOrmModule.forFeature([Test])],
furnizorii: [Serviciul de testare],
controlorii: [TestController],
})

Pasul 5: Injectarea depozitului dvs. în serviciul său utilizând Dependency Injection

Injecția de dependență este o tehnică de inginerie software care este o formă a principiului inversării controlului. Mută ​​povara gestionării dependenței de la codul clientului la biblioteca sau serviciul de care depinde.

Urmați pașii de mai jos pentru a vă injecta depozitul într-un serviciu:

1. În fișierul de serviciu, importați Repertoriu din tipoorm si InjectRepository decorator din @nestjs/typeorm. De asemenea, importați entitatea pe care doriți să-i injectați depozitul.
2. În clasa dvs. de servicii, creați un constructor.
3. Declara a privat variabil, repo, ca parametru în constructor pentru a-l inițializa.
4. Atribuiți un tip de depozit pentru repo cu un tip generic al entității dvs.
5. Adnotați repo cu decoratorul InjectRepository și transmiteți entitatea dvs. ca argument.

// test.service.ts
import { injectabil } din „@nestjs/common”;
import { Depozit } din „tipoorm”;
import { InjectRepository } din „@nestjs/typeorm”;
import { Test } din './test.entity';
@Injectabil()
exportclasăTestService{
constructor(
@InjectRepository(Test)
 private repo: depozit<Test>,
 ) {}
}

Acum că configurarea este completă, puteți face interogări SQL pe acesta pentru a prelua sau modifica date.

Efectuarea de interogări SQL cu TypeORM

Puteți face orice interogare SQL simplă apelând metodele de depozit ale TypeORM pe repo variabilă în cadrul clasei dvs. de servicii. De asemenea, puteți crea interogări SQL complexe utilizând generatorul de interogări TypeORM.