MongoDB è un database NoSQL senza schema con strutture di documenti flessibili, a differenza dei database SQL. L'uso di MongoDB come database offre molti vantaggi, dal facile ridimensionamento alle moderne funzionalità del database come le transazioni.
MongoDB supporta anche librerie ODM (Object Data Modeling) come Mongoose. Gli ODM gestiscono le relazioni tra i dati, convalidano gli schemi e convertono gli oggetti in modelli di dati. Semplificano l'interazione con un database MongoDB.
In pochi passaggi imparerai come utilizzare MongoDB in un'applicazione NestJS con il pacchetto NestJS mongoose dedicato.
Passaggio 1: installazione delle dipendenze
Prima di utilizzare Mongoose nella tua applicazione NestJS, devi installarla insieme al suo pacchetto NestJS nativo.
Installa mongoose e il suo pacchetto NestJS nativo utilizzando il gestore di pacchetti npm eseguendo:
npm installazione @nestjs/mangusta mangusta
Passaggio 2: connessione a MongoDB
Al termine dell'installazione, vai al tuo app.module.ts file. Quindi importa Modulo Mangusta da @nido/mangusta:
importare {Modulo Mangusta} da '@nestjs/mangusta';
Quindi, nell'array imports, chiama il file per Root metodo attivo Modulo Mangusta e passa il tuo URI MongoDB come argomento:
importazioni: [MongooseModule.forRoot (process.env. MONGODB_URI)],
Il per Root il metodo condivide la connessione al database attraverso tutti i moduli nell'applicazione. Richiede un oggetto di configurazione opzionale; puoi saperne di più su quello della mangusta documentazione delle opzioni.
Passaggio 3: creazione di uno schema Mongoose
Uno schema è un oggetto JSON che definisce la struttura e il contenuto dei dati. Dovrai crearne uno per definire come Mongoose archivia i tuoi dati nel database MongoDB.
Nel modulo radice della tua applicazione, crea un "schemi" cartella. Questa cartella è dove memorizzerai tutti i tuoi file di schema.
Dentro il tuo schemi cartella, creare un file di schema e denominarlo utilizzando la convenzione di denominazione NestJS (
Quindi, aggiungi le seguenti importazioni al tuo file di schema:
importare { Prop, Schema, SchemaFactory } da "@nestjs/mangusta";
importare {documento} da "mangusta";
Il Puntello decoratore contrassegna le proprietà che annota come proprietà nel database MongoDB.
Il Schema decorator contrassegna la classe che annota come schema.
Il SchemaFactory class contiene metodi statici utilizzati per la creazione del modello.
La Mangusta Documento rappresenta una mappatura uno-a-uno ai documenti archiviati in MongoDB. Ne avrai bisogno come annotazione di tipo.
Quindi, creare una classe, annotalo con il Schema decorator per contrassegnarlo come schema Mongoose ed esportarlo:
@Schema()
esportareclasseDemo{}
Quindi, crea ed esporta un tipo di unione con la tua classe e Documento:
esportaregenere DemoDocument = Demo e Documento;
Quindi aggiungi le proprietà desiderate alla classe e annotale con il Puntello decoratore. È possibile passare un oggetto di configurazione facoltativo a Puntello decoratore e impostare l'immobile come richiesto:
@Schema()
esportareclasseDemo{
@Puntello({ necessario: VERO })
proprietà_1: stringa;
}
Il Mangusta la documentazione copre l'oggetto di configurazione in modo più dettagliato.
Infine, crea ed esporta un modello Mongoose tramite il file SchemaFactory'S createForClass metodo e passa la tua classe come argomento:
esportarecost DemoSchema = SchemaFactory.createForClass (Demo);
Il tuo schema completato dovrebbe assomigliare a questo:
importare { Prop, Schema, SchemaFactory } da '@nestjs/mangusta';
importare {documento} da 'mangusta';esportaregenere DemoDocument = Demo e Documento;
@Schema()
esportareclasseDemo{
@Puntello({ necessario: VERO })
proprietà_1: stringa;@Puntello({ necessario: VERO })
proprietà_2: numero;@Puntello()
proprietà_3: stringa;@Puntello({ necessario: VERO })
proprietà_4: booleano;
}
esportarecost DemoSchema = SchemaFactory.createForClass (Demo);
Passaggio 4: registrazione dello schema
Passa alla cartella del tuo modulo e aggiungi le seguenti importazioni:
importare {Modulo Mangusta} da '@nestjs/mangusta';
importare { Demo, Schema Demo } da '../schemi/demo.schema';
Quindi, crea un "importazioni” array all'interno del @modulo decoratore. Quindi, all'interno dell'array, chiama il perCaratteristica metodo attivo Modulo Mangusta.
Il perCaratteristica il metodo accetta una serie di modelli Mongoose. Passa un oggetto di configurazione con a nome proprietà impostata sul nome della classe dello schema e a schema proprietà impostata sullo schema creato:
Modulo Mangusta.perCaratteristica([{ nome: Demo.name, schema: DemoSchema }]),
Passaggio 5: iniezione del modello Mongoose
Successivamente, dovrai inserire il modello Mongoose per abilitare l'interrogazione del tuo database chiamando i metodi Mongoose sul modello.
Passa alla classe di servizio del tuo modulo e aggiungi le seguenti importazioni:
importare { Modello } da 'mangusta';
importare {Inietta modello} da '@nestjs/mangusta';
importare {Demo, DemoDocumento} da '../schemi/demo.schema';
Utilizzare il Modello interfaccia come definizione del tipo per il tuo modello, dandogli accesso ai metodi Mongoose.
Il Inietta modello decorator inserisce il modello Mongoose nel costruttore della tua classe di servizio.
Quindi, crea un costruttore all'interno della tua classe di servizio. Dovrebbe volerci un privato variabile come argomento, a Modello con un tipo generico di DemoDocumento. Annota la tua variabile privata con Inietta modello decorator e passa il nome della classe dello schema come argomento:
@Iniettabile()
esportareclasseDemoService{
costruttore(
@Inietta modello(Nome.demo)
demo privataModello: Modello<DemoDocumento>,
) {}
}
Puoi interrogare il tuo database MongoDB chiamando i metodi Mongoose sulla tua variabile privata (demoModel).
Vantaggi dell'utilizzo di MongoDB
Oltre alla sua solida comunità online e alla facilità d'uso, MongoDB offre un'elevata disponibilità e stabilità dei dati. Offre analisi accelerate, aggregazione dei dati e altro, rendendolo il database ideale per i tuoi progetti.