MongoDB este o bază de date NoSQL fără schemă, cu structuri flexibile de documente, spre deosebire de bazele de date SQL. Utilizarea MongoDB ca bază de date aduce multe beneficii, de la scalare ușoară până la caracteristici moderne ale bazei de date, cum ar fi tranzacțiile.

MongoDB acceptă, de asemenea, biblioteci de modelare a datelor obiect (ODM) precum Mongoose. ODM-urile gestionează relațiile de date, validează scheme și convertesc obiectele în modele de date. Ele facilitează interacțiunea cu o bază de date MongoDB.

În câțiva pași, veți învăța cum să utilizați MongoDB într-o aplicație NestJS cu pachetul dedicat mangusta NestJS.

Pasul 1: Instalarea dependențelor

Înainte de a utiliza Mongoose în aplicația dvs. NestJS, trebuie să o instalați împreună cu pachetul său nativ NestJS.

Instalați mongoose și pachetul său nativ NestJS folosind managerul de pachete npm rulând:

instalare npm @nestjs/mangusta mangusta

Pasul 2: Conectarea la MongoDB

Când instalarea se termină, navigați la dvs aplicație.modul.ts fişier. Apoi import MangooseModule din @cuib/mangustă:

instagram viewer 
import { MongooseModule } din „@nestjs/mongoose”;

Apoi, în matricea dvs. de importuri, apelați pentruRoot metoda pe MangooseModule și transmiteți URI-ul dvs. MongoDB ca argument:

importurilor: [MongooseModule.forRoot (process.env. MONGDB_URI)],

The pentruRoot metoda partajează conexiunea la baza de date prin toate modulele din aplicația dvs. Este nevoie de un obiect de configurare opțional; puteți afla mai multe despre el în ale Mangustei documentația opțiunilor.

Pasul 3: Crearea unei scheme Mongoose

O schemă este un obiect JSON care definește structura și conținutul datelor dvs. Va trebui să creați unul pentru a defini modul în care Mongoose vă stochează datele în baza de date MongoDB.

În modulul rădăcină al aplicației dvs., creați un „scheme” dosar. Acest folder este locul în care veți stoca toate fișierele de schemă.

În interiorul tău scheme folder, creați un fișier de schemă și denumiți-l folosind convenția de denumire NestJS (.schema.ts).

Apoi, adăugați următoarele importuri în fișierul dvs. de schemă:

import { Prop, Schema, SchemaFactory } din „@nestjs/mongoose”;
import { Document } din "mangustă";

The Recuzită Decorator marchează proprietățile pe care le adnotă ca o proprietate în baza de date MongoDB.

The Schemă decoratorul marchează clasa pe care o adnotă ca o schemă.

The SchemaFactory clasa conține metode statice utilizate pentru crearea modelului.

Mangusta Document reprezintă o mapare unu-la-unu la documente așa cum sunt stocate în MongoDB. Veți avea nevoie de el ca adnotare de tip.

Apoi, creați o clasă, adnotă-l cu Schemă decorator să o marcheze ca schemă Mongoose și să o exporte:

@Schemă()
exportclasăDemo{}

Apoi, creați și exportați un tip de uniune cu clasa dvs. și Document:

exporttip DemoDocument = Demo & Document;

Apoi adăugați proprietățile dorite la clasă și adnotă-le cu Recuzită decorator. Puteți transmite un obiect de configurare opțional către Recuzită decorator și setați proprietatea după cum este necesar:

@Schemă()
exportclasăDemo{
@Recuzită({ necesar: Adevărat })
 proprietate_1: șir;
}

The Mangustă documentația acoperă obiectul de configurare mai detaliat.

În cele din urmă, creați și exportați un model Mongoose prin intermediul SchemaFactorylui createForClass metoda și transmiteți clasa dvs. ca argument:

exportconst DemoSchema = SchemaFactory.createForClass (Demo);

Schema dvs. finalizată ar trebui să arate astfel:

import { Prop, Schema, SchemaFactory } din „@nestjs/mongoose”;
import { Document } din 'mangustă';
exporttip DemoDocument = Demo & Document;


@Schemă()
exportclasăDemo{
@Recuzită({ necesar: Adevărat })
 proprietate_1: șir;


@Recuzită({ necesar: Adevărat })
 proprietate_2: număr;


@Recuzită()
 proprietate_3: șir;


@Recuzită({ necesar: Adevărat })
 proprietate_4: boolean;
}
exportconst DemoSchema = SchemaFactory.createForClass (Demo);

Pasul 4: Înregistrarea schemei

Navigați la folderul modulului dvs. și adăugați următoarele importuri:

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

Apoi, creați un „importurilor” matrice din interiorul @modul decorator. Apoi, în interiorul matricei, apelați pentru Caracteristică metoda pe MangooseModule.

The pentru Caracteristică metoda preia o serie de modele Mongoose. Introduceți un obiect de configurare cu a Nume proprietate setată la numele clasei dvs. de schemă și a schemă proprietate setată la schema creată de dvs.:

MangooseModule.pentruFeature([{ nume: Demo.name, schema: DemoSchema }]),

Pasul 5: Injectarea modelului Mangoose

Apoi, va trebui să injectați modelul Mongoose pentru a activa interogarea bazei de date apelând metodele Mongoose pe model.

Navigați la clasa de serviciu a modulului dvs. și adăugați următoarele importuri:

import { Model } din 'mangustă';
import { InjectModel } din „@nestjs/mongoose”;
import { Demo, DemoDocument } din '../schemas/demo.schema';

Folosește Model interfață ca definiție de tip pentru modelul dvs., oferindu-i acces la metodele Mongoose.

The InjectModel decoratorul injectează modelul Mongoose în constructorul clasei dvs. de servicii.

Apoi, creați un constructor în cadrul clasei dvs. de servicii. Ar trebui să ia o privat variabilă ca argument, a Model cu un tip generic de DemoDocument. Adnotați variabila privată cu InjectModel decorator și transmiteți numele clasei dvs. de schemă ca argument:

@Injectabil()
exportclasăDemoService{
constructor(
@InjectModel(Demo.name)
 demo privatModel: Model<DemoDocument>,
 ) {}
}

Vă puteți interoga baza de date MongoDB apelând metodele Mongoose pe variabila privată (demoModel).

Avantajele utilizării MongoDB

Pe lângă comunitatea sa online puternică și ușurința de utilizare, MongoDB oferă disponibilitate și stabilitate ridicată a datelor. Oferă analiză accelerată, agregare de date și multe altele, făcându-l baza de date ideală pentru proiectele dvs.