MongoDB är en schemalös NoSQL-databas med flexibla dokumentstrukturer, till skillnad från SQL-databaser. Att använda MongoDB som en databas ger många fördelar, från enkel skalning till moderna databasfunktioner som transaktioner.

MongoDB stöder också objektdatamodelleringsbibliotek (ODM) som Mongoose. ODM: er hanterar datarelationer, validerar scheman och konverterar objekt till datamodeller. De gör det lättare att interagera med en MongoDB-databas.

I några få steg kommer du att lära dig hur du använder MongoDB i en NestJS-applikation med det dedikerade NestJS mongoose-paketet.

Steg 1: Installera beroenden

Innan du använder Mongoose i din NestJS-applikation måste du installera den tillsammans med dess ursprungliga NestJS-paket.

Installera mongoose och dess ursprungliga NestJS-paket med hjälp av npm-pakethanteraren genom att köra:

npm installera @nestjs/mongoose mongoose

Steg 2: Anslut till MongoDB

När installationen är klar, navigera till din app.modul.ts fil. Importera sedan MongooseModule från @nest/mongoose:

instagram viewer 
importera { MongooseModule } från '@nestjs/mongoose';

Därefter, i din importmatris, anropa för Root metod på MongooseModule och skicka din MongoDB URI som ett argument:

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

De för Root metoden delar databasanslutningen genom alla moduler i din applikation. Det krävs ett valfritt konfigurationsobjekt; du kan lära dig mer om det i Mongoose's alternativ dokumentation.

Steg 3: Skapa ett Mongoose-schema

Ett schema är ett JSON-objekt som definierar din datas struktur och innehåll. Du måste skapa en för att definiera hur Mongoose lagrar dina data i MongoDB-databasen.

I din applikations rotmodul skapar du en "scheman" mapp. Den här mappen är där du kommer att lagra alla dina schemafiler.

Inuti din scheman mapp, skapa en schemafil och namnge den med hjälp av NestJS namnkonvention (.schema.ts).

Lägg sedan till följande importer till din schemafil:

importera { Prop, Schema, SchemaFactory } från "@nestjs/mongoose";
importera { Dokument } från "mungo";

De Stötta decorator markerar egenskaper den annoterar som en egenskap i din MongoDB-databas.

De Schema dekoratören markerar klassen den annoterar som ett schema.

De SchemaFactory klass innehåller statiska metoder som används för att skapa modell.

Mongoose Dokumentera representerar en en-till-en-mappning till dokument som lagras i MongoDB. Du behöver den som en typkommentar.

Sedan, skapa en klass, kommentera den med Schema dekoratör för att markera det som ett Mongoose-schema och exportera det:

@Schema()
exporteraklassDemo{}

Skapa och exportera sedan en fackföreningstyp med din klass och Dokumentera:

exporteratyp DemoDocument = Demo & Dokument;

Lägg sedan till dina önskade egenskaper till klassen och annotera dem med Stötta dekoratör. Du kan skicka ett valfritt konfigurationsobjekt till Stötta dekoratör och ställ in fastigheten efter behov:

@Schema()
exporteraklassDemo{
@Stötta({ krävs: Sann })
 egenskap_1: sträng;
}

De Mungo dokumentationen täcker konfigurationsobjektet mer i detalj.

Slutligen, skapa och exportera en Mongoose-modell via SchemaFactorys skapaForClass metod och skicka din klass som ett argument:

exporterakonst DemoSchema = SchemaFactory.createForClass (Demo);

Ditt färdiga schema bör se ut så här:

importera { Prop, Schema, SchemaFactory } från '@nestjs/mongoose';
importera { Dokument } från 'mungo';
exporteratyp DemoDocument = Demo & Dokument;


@Schema()
exporteraklassDemo{
@Stötta({ krävs: Sann })
 egenskap_1: sträng;


@Stötta({ krävs: Sann })
 egenskap_2: nummer;


@Stötta()
 egenskap_3: sträng;


@Stötta({ krävs: Sann })
 egenskap_4: booleskt;
}
exporterakonst DemoSchema = SchemaFactory.createForClass (Demo);

Steg 4: Registrera schemat

Navigera till din moduls mapp och lägg till följande importer:

importera { MongooseModule } från '@nestjs/mongoose';
importera { Demo, DemoSchema } från '../schemas/demo.schema';

Skapa sedan en "import” array inuti @modul dekoratör. Ring sedan in i arrayen för Funktion metod på MongooseModule.

De för Funktion Metoden tar in en rad Mongoose-modeller. Skicka in ett konfigurationsobjekt med en namn egenskapen inställd på namnet på din schemaklass, och en schema egenskapsuppsättning till ditt skapade schema:

MongooseModule.forFeature([{ namn: Demo.namn, schema: DemoSchema }]),

Steg 5: Injicera Mongoose-modellen

Därefter måste du injicera Mongoose-modellen för att möjliggöra sökning av din databas genom att anropa Mongoose-metoder på modellen.

Navigera till din moduls serviceklass och lägg till följande importer:

importera { Modell } från 'mungo';
importera { InjectModel } från '@nestjs/mongoose';
importera { Demo, DemoDocument } från '../schemas/demo.schema';

Använd Modell gränssnitt som en typdefinition för din modell, vilket ger den tillgång till Mongoose-metoder.

De Injicera modell decorator injicerar Mongoose-modellen i din serviceklasss konstruktör.

Skapa sedan en konstruktör inom din serviceklass. Det borde ta en privat variabel som argument, en Modell med en generisk typ av DemoDokument. Annotera din privata variabel med Injicera modell dekoratör och skicka ditt schemaklassnamn som ett argument:

@Injicerbar()
exporteraklassDemoService{
konstruktör(
@InjectModel(Demo.name)
 privat demoModell: Modell<DemoDokument>,
 ) {}
}

Du kan fråga din MongoDB-databas genom att anropa Mongoose-metoder på din privata variabel (demomodell).

Fördelar med att använda MongoDB

Förutom sin starka online-gemenskap och användarvänlighet ger MongoDB hög datatillgänglighet och stabilitet. Den erbjuder accelererad analys, dataaggregering och mer, vilket gör den till den idealiska databasen för dina projekt.