SQL-databases gebruiken in een NestJS-toepassing met TypeORM

Een Object-Relational Mapper (ORM) is een bibliotheek die de Object-Relational Mapper-techniek implementeert. Hiermee kunt u SQL-databasequery's schrijven met behulp van het objectgeoriënteerde paradigma van uw voorkeurstaal.

TypeORM is een TypeScript ORM die de interface met verschillende databases heel eenvoudig maakt. Het werkt met SQL-databases, maar sluit ook goed aan op NoSQL-databases zoals MongoDB.

NestJS biedt out-of-the-box ondersteuning op hoog niveau voor TypeORM. Het speciale TypeORM-pakket maakt integratie relatief eenvoudig.

Stap 1: Afhankelijkheden installeren

Voordat u TypeORM in een NestJS-toepassing gebruikt, moet u het installeren met het oorspronkelijke NestJS-pakket en de SQL-database van uw voorkeur. SQLite is een eenvoudige, installatievrije optie.

Voer de volgende opdracht uit om TypeORM en het oorspronkelijke NestJS-pakket te installeren, met behulp van: de npm-pakketbeheerder:

npm installeren @nestjs/typeorm typeorm

Voer de volgende opdracht uit om SQLite te installeren:

npm installeren sqlite3

Stap 2: Een entiteit maken

Een entiteit is een verzameling velden die de gegevens definiëren die in een database zijn opgeslagen. TypeORM gebruikt het entiteitsbestand om een ​​tabel in uw database te maken.

Volg de onderstaande stappen om een ​​entiteit aan te maken:

1. Maak een bestand in uw applicatiemodule en geef het een naam volgens de naamgevingsconventie van NestJS (.entity.ts).
2. Importeer in uw entiteitsbestand de Entiteit, Kolom, en PrimaireGegenereerdeKolom decorateurs van typeorm.
3. Maak en exporteer een klasse in uw entiteitsbestand.
4. Vul de klasse met de waarden die u in uw database wilt hebben, zoals ID kaart, naam, enz.
5. Annoteer uw entiteitsklasse met de Entiteitsdecorateur. Dit maakt je klas herkenbaar voor TypeORM als entiteit.
6. Annoteer uw id-eigenschap met de PrimaryGeneratedColumn-decorateur. Dit vertelt TypeORM om de. te markeren ID kaart als primaire sleutel en deze automatisch verhogen.
7. Annoteer de overige eigenschappen met de Column decorateur. Dit voegt ze toe als kolommen in uw database.

Bijvoorbeeld:

// src/test/test.entity.ts
importeren { Entiteit, Kolom, PrimaryGeneratedColumn } van 'typevorm';
@Entiteit()
exporterenklasTesten{
@PrimaryGeneratedColumn()
 ID nummer;
@Kolom()
 eigenschap_1: tekenreeks;
@Kolom()
 eigenschap_2: tekenreeks;
@Kolom()
 eigenschap_3: tekenreeks;
}

Het bovenstaande entiteitsbestand maakt deze tabel in uw database:

De TypeORM-documentatie omvat entiteiten in meer detail.

Stap 3: Uw toepassing verbinden met een database

Nu uw entiteit is ingesteld, moet u uw toepassing verbinden met een database. In dit voorbeeld wordt SQLite gebruikt.

Volg de onderstaande stappen om uw applicatie te koppelen aan een database:

1. In de root-module van uw toepassingen (meestal de app.module.ts bestand), import TypeOrmModule van @nestjs/typeorm.
2. Importeer al uw entiteiten in hetzelfde bestand.
3. In de importeert array, bel de voorRoot methode op TypeOrmModule. De forRoot-methode deelt de databaseverbinding via alle modules in uw toepassing.
4. Geef een leeg object door als argument in de forRoot-methode; dit wordt het TypeORM-configuratieobject.
5. Voeg een woning toe, type, naar het configuratie-object en stel het in op "sqlite". De eigenschap type geeft de naam aan van de database die u gebruikt.
6. Nog een eigenschap toevoegen, database, naar het configuratie-object en stel het in op “test.db”. De database-eigenschap geeft uw voorkeursnaam voor uw database aan.
7. Nog een eigenschap toevoegen, entiteiten, naar het configuratieobject en stel het in op een lege array. Vul de lege array met de entiteiten die u eerder hebt geïmporteerd.
8. Nog een eigenschap toevoegen, synchroniserenen stel het in WAAR; deze eigenschap synchroniseert uw entiteiten met uw database en werkt deze bij elke keer dat u de code uitvoert. U moet deze eigenschap alleen instellen op: WAAR in ontwikkeling. Tijdens de productie moet u deze instellen op: vals om gegevensverlies te voorkomen.

// src/app.module.ts
importeren { module } van '@nestjs/common';
importeren { TypeOrmModule } van '@nestjs/typeorm';
importeren { Testen } van './test/test.entiteit';
importeren { Entiteit2 } van './entiteit/entiteit.entiteit';
importeren { TestModule } van './test/test.module';
@Module({
 invoer: [
TypeOrmModule.forRoot({
 type: 'sqlite',
 databank: 'test.db',
entiteiten: [Test, entiteit2],
 synchroniseren: WAAR, // alleen ontwikkeling
 }),
 TestModule,
 ],
controllers: [],
aanbieders: [],
})
exporterenklasAppModule{}

Stap 4: Een opslagplaats maken

Een repository is de toegangslaag van een entiteit die wordt gebruikt om query's te maken (invoegen, verwijderen, opslaan, zoeken, enz.) op een tabel die door de entiteit in de database is gemaakt. TypeORM ondersteunt het ontwerppatroon van de repository, dus elke entiteit heeft zijn eigen repository.

TypeORM creëert automatisch een repository voor uw entiteit wanneer u de onderstaande stappen volgt:

1. Importeer in het modulebestand van uw entiteit TypeOrmModule van @nestjs/typeorm en importeer uw entiteit.
2. Creëer een importeert array in de @Module decorateur.
3. Roep in de importarray de. aan voor Functie methode op TypeOrmModule.
4. Geef een array door als argument in uw en vul de array met uw entiteit.

// src/test/test.module.ts
importeren { module } van '@nestjs/common';
importeren { TypeOrmModule } van '@nestjs/typeorm';
importeren { TestController } van './test.controller';
importeren { TestService } van './test.service';
importeren { Testen } van './test.entiteit';
@Module({
importeert: [TypeOrmModule.forFeature([Test])],
aanbieders: [Testservice],
controllers: [TestController],
})

Stap 5: Uw repository injecteren in zijn service met behulp van afhankelijkheidsinjectie

Afhankelijkheidsinjectie is een software-engineeringtechniek die een vorm is van het principe van de inversie van controle. Het verschuift de last van afhankelijkheidsbeheer van klantcode naar de bibliotheek of service waarvan het afhankelijk is.

Volg de onderstaande stappen om uw repository in een service te injecteren:

1. Importeer in uw servicebestand Opslagplaats van typeorm en de InjectRepository decorateur van @nestjs/typeorm. Importeer ook de entiteit waarvan u de repository wilt injecteren.
2. Maak in uw serviceklasse een constructeur.
3. Verklaar a privaat variabel, repo, als een parameter in de constructor om deze te initialiseren.
4. Wijs een type opslagplaats toe aan een opslagplaats met een generiek type van uw entiteit.
5. Annoteer repo met de InjectRepository-decorateur en geef uw entiteit door als argument.

// test.service.ts
importeren { Injecteerbaar } van '@nestjs/common';
importeren { Opslagplaats } van 'typevorm';
importeren { InjectRepository } van '@nestjs/typeorm';
importeren { Testen } van './test.entiteit';
@Injectable()
exporterenklasTestService{
constructeur(
@InjectRepository(Testen)
 privé repo: Repository<Testen>,
 ) {}
}

Nu uw installatie is voltooid, kunt u SQL-query's erop om gegevens op te halen of te wijzigen.

SQL-query's maken met TypeORM

U kunt elke eenvoudige SQL-query maken door de repository-methoden van TypeORM aan te roepen op de repo variabele binnen uw serviceklasse. U kunt ook complexe SQL-query's maken met behulp van de querybuilder van TypeORM.