Brug af en MongoDB-database i en NestJS-applikation med Mongoose

MongoDB er en skemaløs NoSQL-database med fleksible dokumentstrukturer i modsætning til SQL-databaser. Brug af MongoDB som database giver mange fordele, fra nem skalering til moderne databasefunktioner såsom transaktioner.

MongoDB understøtter også objektdatamodellering (ODM) biblioteker som Mongoose. ODM'er administrerer datarelationer, validerer skemaer og konverterer objekter til datamodeller. De gør det lettere at interagere med en MongoDB-database.

I et par trin lærer du, hvordan du bruger MongoDB i en NestJS-applikation med den dedikerede NestJS mongoose-pakke.

Trin 1: Installation af afhængigheder

Før du bruger Mongoose i din NestJS-applikation, skal du installere den sammen med dens oprindelige NestJS-pakke.

Installer mongoose og dens oprindelige NestJS-pakke ved hjælp af npm-pakkehåndteringen ved at køre:

npm installere @nestjs/mongoose mongoose

Trin 2: Opret forbindelse til MongoDB

Når installationen er færdig, skal du navigere til din app.modul.ts fil. Importer derefter MongooseModul fra @rede/mongoose:

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

I dit importarray skal du derefter kalde for Root metode på MongooseModul og send din MongoDB URI som et argument:

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

Det for Root metoden deler databaseforbindelsen gennem alle modulerne i din applikation. Det kræver et valgfrit konfigurationsobjekt; du kan lære mere om det i Mongoose's dokumentation for muligheder.

Trin 3: Oprettelse af et Mongoose-skema

Et skema er et JSON-objekt, der definerer dine datas struktur og indhold. Du skal oprette en for at definere, hvordan Mongoose gemmer dine data i MongoDB-databasen.

I dit programs rodmodul skal du oprette en "skemaer” mappe. Denne mappe er hvor du gemmer alle dine skemafiler.

Inde i din skemaer mappe, opret en skemafil og navngiv den ved hjælp af NestJS-navnekonventionen (.schema.ts).

Tilføj derefter følgende importer til din skemafil:

importere { Prop, Schema, SchemaFactory } fra "@nestjs/mongoose";
importere { Dokument } fra "mangust";

Det Rekvisit decorator markerer egenskaber, den annoterer som en egenskab i din MongoDB-database.

Det Skema dekoratør markerer den klasse, den annoterer, som et skema.

Det SchemaFactory klasse indeholder statiske metoder, der bruges til modeloprettelse.

Mongosen Dokument repræsenterer en en-til-en-tilknytning til dokumenter som gemt i MongoDB. Du skal bruge den som en typeanmærkning.

Derefter, oprette en klasse, anmærk det med Skema dekorator for at markere det som et Mongoose-skema og eksportere det:

@Skema()
eksportklasseDemo{}

Derefter skal du oprette og eksportere en fagforeningstype med din klasse og Dokument:

eksporttype DemoDocument = Demo & Dokument;

Tilføj derefter dine ønskede egenskaber til klassen og annotér dem med Rekvisit dekoratør. Du kan videregive et valgfrit konfigurationsobjekt til Rekvisit dekoratør og indstil ejendommen efter behov:

@Skema()
eksportklasseDemo{
@Rekvisit({ påkrævet: rigtigt })
 egenskab_1: streng;
}

Det Mongoose dokumentationen dækker konfigurationsobjektet mere detaljeret.

Til sidst skal du oprette og eksportere en Mongoose-model via SchemaFactory’s skabeForKlasse metode og send din klasse som et argument:

eksportkonst DemoSchema = SchemaFactory.createForClass (Demo);

Dit færdige skema skulle se sådan ud:

importere { Prop, Schema, SchemaFactory } fra '@nestjs/mongoose';
importere { Dokument } fra 'mangust';
eksporttype DemoDocument = Demo & Dokument;
@Skema()
eksportklasseDemo{
@Rekvisit({ påkrævet: rigtigt })
 egenskab_1: streng;
@Rekvisit({ påkrævet: rigtigt })
 ejendom_2: nummer;
@Rekvisit()
 egenskab_3: streng;
@Rekvisit({ påkrævet: rigtigt })
 ejendom_4: boolesk;
}
eksportkonst DemoSchema = SchemaFactory.createForClass (Demo);

Trin 4: Registrering af skemaet

Naviger til dit moduls mappe og tilføj følgende importer:

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

Dernæst skal du oprette en "import” array inde i @modul dekoratør. Kald derefter inde i arrayet for Funktion metode på MongooseModul.

Det for Funktion metoden indtager en række Mongoose-modeller. Send et konfigurationsobjekt ind med en navn egenskab indstillet til navnet på din skemaklasse, og en skema egenskabssæt til dit oprettede skema:

MongooseModul.forFeature([{ navn: Demo.navn, skema: DemoSchema }]),

Trin 5: Injektion af Mongoose-modellen

Dernæst skal du injicere Mongoose-modellen for at aktivere forespørgslen i din database ved at kalde Mongoose-metoder på modellen.

Naviger til dit moduls serviceklasse, og tilføj følgende importer:

importere { Model } fra 'mangust';
importere { InjectModel } fra '@nestjs/mongoose';
importere { Demo, DemoDocument } fra '../schemas/demo.schema';

Brug Model interface som en typedefinition for din model, hvilket giver den adgang til Mongoose-metoder.

Det InjectModel decorator sprøjter Mongoose-modellen ind i din serviceklasses konstruktør.

Opret derefter en konstruktør inden for din serviceklasse. Det burde tage en privat variabel som argument, en Model med en generisk type DemoDokument. Anmærk din private variabel med InjectModel dekorator og send dit skemaklassenavn som et argument:

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

Du kan forespørge din MongoDB-database ved at kalde Mongoose-metoder på din private variabel (demomodel).

Fordele ved at bruge MongoDB

Udover det stærke online-fællesskab og brugervenlighed giver MongoDB høj datatilgængelighed og stabilitet. Den tilbyder accelereret analyse, dataaggregering og mere, hvilket gør den til den ideelle database til dine projekter.