Bruke en MongoDB-database i en NestJS-applikasjon med Mongoose

MongoDB er en skjemaløs NoSQL-database med fleksible dokumentstrukturer, i motsetning til SQL-databaser. Å bruke MongoDB som database gir mange fordeler, fra enkel skalering til moderne databasefunksjoner som transaksjoner.

MongoDB støtter også objektdatamodellering (ODM) biblioteker som Mongoose. ODM-er administrerer datarelasjoner, validerer skjemaer og konverterer objekter til datamodeller. De gjør det lettere å samhandle med en MongoDB-database.

I noen få trinn vil du lære hvordan du bruker MongoDB i en NestJS-applikasjon med den dedikerte NestJS mongoose-pakken.

Trinn 1: Installere avhengigheter

Før du bruker Mongoose i NestJS-applikasjonen din, må du installere den sammen med den opprinnelige NestJS-pakken.

Installer mongoose og dens opprinnelige NestJS-pakke ved å bruke npm-pakkebehandleren ved å kjøre:

npm installere @nestjs/mongoose mongoose

Trinn 2: Koble til MongoDB

Når installasjonen er ferdig, naviger til din app.modul.ts fil. Importer deretter MongooseModule fra @nest/mongoose:

import { MongooseModule } fra '@nestjs/mongoose';

Deretter ringer du til i importmatrisen for Root metode på MongooseModule og send MongoDB URI som et argument:

import: [MongooseModule.forRoot (process.env. MONGODB_URI)],

De for Root metoden deler databasetilkoblingen gjennom alle modulene i applikasjonen din. Det krever et valgfritt konfigurasjonsobjekt; du kan lære mer om det i Mongoose's alternativ dokumentasjon.

Trinn 3: Opprette et Mongoose-skjema

Et skjema er et JSON-objekt som definerer dataenes struktur og innhold. Du må opprette en for å definere hvordan Mongoose lagrer dataene dine i MongoDB-databasen.

I programmets rotmodul oppretter du en "skjemaer" mappe. Denne mappen er der du vil lagre alle skjemafilene dine.

Inne i din skjemaer mappen, lag en skjemafil og navngi den ved hjelp av NestJS-navnekonvensjonen (.schema.ts).

Deretter legger du til følgende importer til skjemafilen din:

import { Prop, Schema, SchemaFactory } fra "@nestjs/mongoose";
import { Dokument } fra "mangus";

De Rekvisitt decorator merker egenskaper den merker som en egenskap i MongoDB-databasen din.

De Skjema dekoratør markerer klassen den merker som et skjema.

De SchemaFactory klasse inneholder statiske metoder som brukes for modelloppretting.

Mongosen Dokument representerer en en-til-en-tilordning til dokumenter som er lagret i MongoDB. Du trenger den som en typekommentar.

Deretter, opprette en klasse, merk den med Skjema dekoratør for å merke det som et Mongoose-skjema, og eksportere det:

@Skjema()
eksportklasseDemo{}

Deretter oppretter og eksporterer du en fagforeningstype med klassen din og Dokument:

eksporttype DemoDocument = Demo & Dokument;

Legg deretter til de ønskede egenskapene til klassen og merk dem med Rekvisitt dekoratør. Du kan sende et valgfritt konfigurasjonsobjekt til Rekvisitt dekoratør og angi eiendommen etter behov:

@Skjema()
eksportklasseDemo{
@Rekvisitt({ kreves: ekte })
 egenskap_1: streng;
}

De Mongoose dokumentasjon dekker konfigurasjonsobjektet mer detaljert.

Til slutt oppretter og eksporterer du en Mongoose-modell via SchemaFactory's createForClass metode og gi klassen din som et argument:

eksportkonst DemoSchema = SchemaFactory.createForClass (Demo);

Det ferdige skjemaet ditt skal se slik ut:

import { Prop, Schema, SchemaFactory } fra '@nestjs/mongoose';
import { Dokument } fra 'mangus';
eksporttype DemoDocument = Demo & Dokument;
@Skjema()
eksportklasseDemo{
@Rekvisitt({ kreves: ekte })
 egenskap_1: streng;
@Rekvisitt({ kreves: ekte })
 eiendom_2: nummer;
@Rekvisitt()
 egenskap_3: streng;
@Rekvisitt({ kreves: ekte })
 eiendom_4: boolsk;
}
eksportkonst DemoSchema = SchemaFactory.createForClass (Demo);

Trinn 4: Registrering av skjemaet

Naviger til modulens mappe og legg til følgende importer:

import { MongooseModule } fra '@nestjs/mongoose';
import { Demo, DemoSchema } fra '../schemas/demo.schema';

Deretter oppretter du en "import”-array inne i @modul dekoratør. Deretter, inne i matrisen, ringer du til for funksjon metode på MongooseModule.

De for funksjon metoden tar inn en rekke Mongoose-modeller. Send inn et konfigurasjonsobjekt med en Navn egenskap satt til navnet på skjemaklassen din, og en skjema egenskap satt til det opprettede skjemaet:

MongooseModule.forFeature([{ navn: Demo.navn, skjema: DemoSchema }]),

Trinn 5: Injeksjon av Mongoose-modellen

Deretter må du injisere Mongoose-modellen for å aktivere spørring i databasen din ved å kalle Mongoose-metoder på modellen.

Naviger til modulens serviceklasse, og legg til følgende importer:

import { Modell } fra 'mangus';
import { InjectModel } fra '@nestjs/mongoose';
import { Demo, DemoDocument } fra '../schemas/demo.schema';

Bruke Modell grensesnitt som en typedefinisjon for modellen din, og gir den tilgang til Mongoose-metoder.

De InjectModel decorator injiserer Mongoose-modellen i din serviceklasses konstruktør.

Deretter oppretter du en konstruktør innenfor serviceklassen din. Det bør ta en privat variabel som argument, en Modell med en generisk type DemoDokument. Annoter din private variabel med InjectModel dekorator og send skjemaklassenavnet ditt som et argument:

@Injiserbar()
eksportklasseDemoService{
konstruktør(
@InjectModel(Demo.name)
 privat demoModel: Modell<DemoDokument>,
 ) {}
}

Du kan spørre MongoDB-databasen din ved å kalle Mongoose-metoder på din private variabel (demomodell).

Fordeler med å bruke MongoDB

I tillegg til det sterke nettsamfunnet og brukervennligheten, gir MongoDB høy datatilgjengelighet og stabilitet. Den tilbyr akselerert analyse, dataaggregering og mer, noe som gjør den til den ideelle databasen for prosjektene dine.