Jak používat databáze SQL v aplikaci NestJS s TypeORM

Objektově-relační mapovač (ORM) je knihovna, která implementuje techniku ​​objektově-relačního mapování. To vám umožní psát databázové dotazy SQL pomocí objektově orientovaného paradigmatu vašeho preferovaného jazyka.

TypeORM je TypeScript ORM, který velmi usnadňuje propojení s různými databázemi. Funguje s databázemi SQL, ale také dobře spolupracuje s databázemi NoSQL, jako je MongoDB.

NestJS poskytuje prvotřídní podporu pro TypeORM ihned po vybalení. Vyhrazený balíček TypeORM umožňuje integraci relativně snadno.

Krok 1: Instalace závislostí

Před použitím TypeORM v aplikaci NestJS ji musíte nainstalovat s jejím nativním balíčkem NestJS a preferovanou databází SQL. SQLite je jednoduchá možnost bez instalace.

Spusťte následující příkaz a nainstalujte TypeORM a jeho nativní balíček NestJS pomocí správce balíčků npm:

instalace npm @nestjs/typeorm typorm

Spusťte následující příkaz pro instalaci SQLite:

npm Nainstalujte sqlite3

Krok 2: Vytvoření entity

Entita je kolekce polí definujících data uložená v databázi. TypeORM používá soubor entity k vytvoření tabulky ve vaší databázi.

Chcete-li vytvořit entitu, postupujte takto:

1. Vytvořte soubor ve svém aplikačním modulu a pojmenujte jej podle konvence pojmenování NestJS (.entity.ts).
2. V souboru entity importujte soubor Entita, Sloupec, a PrimaryGeneratedColumn dekoratéři z typorm.
3. V souboru entity vytvořte a exportujte třídu.
4. Naplňte třídu hodnotami, které chcete mít ve své databázi, např id, název, atd.
5. Označte svou třídu entity pomocí Dekorátoru entity. Díky tomu bude vaše třída pro TypeORM rozpoznatelná jako entita.
6. Pomocí dekorátoru PrimaryGeneratedColumn označte svou vlastnost ID. To říká TypeORM, aby označil id jako primární klíč a automaticky jej zvýšit.
7. Přidejte poznámky ke zbývajícím vlastnostem pomocí dekorátoru sloupců. Tím je přidáte jako sloupce do vaší databáze.

Například:

// src/test/test.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } z 'typorm';
@Entity()
vývoznítřídaTest{
@PrimaryGeneratedColumn()
 identifikační číslo;
@Sloupec()
 vlastnost_1: řetězec;
@Sloupec()
 vlastnost_2: řetězec;
@Sloupec()
 vlastnost_3: řetězec;
}

Výše uvedený soubor entity vytvoří tuto tabulku ve vaší databázi:

The Dokumentace TypeORM pokrývá subjekty podrobněji.

Krok 3: Připojení vaší aplikace k databázi

Nyní, když je vaše entita nastavena, budete muset aplikaci připojit k databázi. Tento příklad používá SQLite.

Pro připojení aplikace k databázi postupujte podle následujících kroků:

1. V kořenovém modulu vašich aplikací (obvykle app.module.ts soubor), import TypeOrmModule z @nestjs/typeorm.
2. Ve stejném souboru importujte všechny své entity.
3. V dovozy pole, zavolejte forRoot metoda na TypeOrmModule. Metoda forRoot sdílí databázové připojení prostřednictvím všech modulů ve vaší aplikaci.
4. Předejte prázdný objekt jako argument do metody forRoot; toto bude objekt konfigurace TypeORM.
5. Přidat vlastnost, typ, do konfiguračního objektu a nastavte jej na "sqlite". Vlastnost type označuje název databáze, kterou používáte.
6. Přidat další vlastnost, databáze, do konfiguračního objektu a nastavte jej na "test.db". Vlastnost databáze označuje preferovaný název databáze.
7. Přidat další vlastnost, entity, do konfiguračního objektu a nastavte jej na prázdné pole. Naplňte prázdné pole entitami, které jste dříve importovali.
8. Přidat další vlastnost, synchronizovata nastavte jej skutečný; tato vlastnost synchronizuje vaše entity s vaší databází a aktualizuje ji při každém spuštění kódu. Tuto vlastnost byste měli nastavit pouze na skutečný ve vývoji. Během výroby byste jej měli nastavit na Nepravdivé aby nedošlo ke ztrátě dat.

// src/app.module.ts
import { Modul } z '@nestjs/common';
import { TypeOrmModule } z '@nestjs/typeorm';
import { Test } z './test/test.entity';
import { Entity2 } z './entity/entity.entity';
import { TestModule } z './test/test.module';
@Modul({
 dovoz: [
TypeOrmModule.forRoot({
 typ: 'sqlite',
 databáze: 'test.db',
entity: [Test, Entita2],
 synchronizovat: skutečný, //pouze vývoj
 }),
 testovací modul,
 ],
ovladače: [],
poskytovatelé: [],
})
vývoznítřídaAppModule{}

Krok 4: Vytvoření úložiště

Úložiště je přístupová vrstva entity, která se používá k vytváření dotazů (vkládání, mazání, ukládání, hledání atd.) na tabulku vytvořenou entitou v databázi. TypeORM podporuje návrhový vzor úložiště, takže každá entita má své vlastní úložiště.

TypeORM automaticky vytvoří úložiště pro vaši entitu, když budete postupovat podle následujících kroků:

1. V souboru modulu vaší entity importujte TypeOrmModule z @nestjs/typeorm a importujte svou entitu.
2. Vytvořit dovozy pole v @Modul dekoratér.
3. V poli imports zavolejte pro Funkce metoda na TypeOrmModule.
4. Předejte pole jako argument do svého a naplňte pole svou entitou.

// src/test/test.module.ts
import { Modul } z '@nestjs/common';
import { TypeOrmModule } z '@nestjs/typeorm';
import { TestController } z './test.controller';
import { TestService } z './test.service';
import { Test } z './test.entity';
@Modul({
dovozy: [TypeOrmModule.forFeature([Test])],
poskytovatelé: [TestService],
ovladače: [TestController],
})

Krok 5: Vložení vašeho úložiště do jeho služby pomocí Dependency Injection

Dependency injection je technika softwarového inženýrství, která je formou inverze principu řízení. Přesouvá zátěž správy závislostí z klientského kódu na knihovnu nebo službu, na které závisí.

Chcete-li vložit úložiště do služby, postupujte takto:

1. V souboru služby importujte Úložiště z typorm a InjectRepository dekoratér od @nestjs/typeorm. Importujte také entitu, do které chcete vložit její úložiště.
2. Ve své servisní třídě vytvořte a konstruktér.
3. Prohlásit a soukromé variabilní, repo, jako parametr v konstruktoru pro jeho inicializaci.
4. Přiřaďte typ úložiště k repo s obecným typem vaší entity.
5. Anotujte repo pomocí dekorátoru InjectRepository a předejte svou entitu jako argument.

// test.service.ts
import { Injekční } z '@nestjs/common';
import { Úložiště } z 'typorm';
import { InjectRepository } z '@nestjs/typeorm';
import { Test } z './test.entity';
@Injekční()
vývoznítřídaTestService{
konstruktér(
@InjectRepository(Test)
 soukromé repo: Úložiště<Test>,
 ) {}
}

Nyní, když je vaše nastavení dokončeno, můžete provést SQL dotazy na něm načíst nebo upravit data.

Vytváření SQL dotazů pomocí TypeORM

Můžete vytvořit jakýkoli jednoduchý SQL dotaz voláním metod úložiště TypeORM na repo proměnná uvnitř vaší třídy služeb. Můžete také vytvářet složité dotazy SQL pomocí nástroje pro tvorbu dotazů TypeORM.