MongoDB est une base de données NoSQL sans schéma avec des structures de documents flexibles, contrairement aux bases de données SQL. L'utilisation de MongoDB en tant que base de données apporte de nombreux avantages, de la mise à l'échelle facile aux fonctionnalités de base de données modernes telles que les transactions.
MongoDB prend également en charge les bibliothèques de modélisation de données d'objet (ODM) telles que Mongoose. Les ODM gèrent les relations de données, valident les schémas et convertissent les objets en modèles de données. Ils facilitent l'interaction avec une base de données MongoDB.
En quelques étapes, vous apprendrez à utiliser MongoDB dans une application NestJS avec le package NestJS mongoose dédié.
Étape 1: Installer les dépendances
Avant d'utiliser Mongoose dans votre application NestJS, vous devez l'installer avec son package NestJS natif.
Installez mongoose et son package NestJS natif à l'aide de le gestionnaire de paquets npm en exécutant:
installation npm @nestjs/mangouste mangouste
Étape 2: Connexion à MongoDB
Une fois l'installation terminée, accédez à votre app.module.ts dossier. Puis importez Module Mangouste de @nid/mangouste :
importer {Module Mongoose} de '@nestjs/mangouste' ;
Ensuite, dans votre tableau d'importations, appelez le forRoot méthode sur Module Mangouste et passez votre URI MongoDB en argument :
importations: [MongooseModule.forRoot (process.env. MOGODB_URI)],
La forRoot La méthode partage la connexion à la base de données via tous les modules de votre application. Il prend un objet de configuration facultatif; vous pouvez en savoir plus à ce sujet dans Mangouste documentation des options.
Étape 3: Création d'un schéma Mongoose
Un schéma est un objet JSON qui définit la structure et le contenu de vos données. Vous devrez en créer un pour définir comment Mongoose stocke vos données dans la base de données MongoDB.
Dans le module racine de votre application, créez un "schémas" dossier. Ce dossier est l'endroit où vous stockerez tous vos fichiers de schéma.
A l'intérieur de votre schémas dossier, créez un fichier de schéma et nommez-le en utilisant la convention de dénomination NestJS (
Ensuite, ajoutez les importations suivantes à votre fichier de schéma :
importer { Prop, Schema, SchemaFactory } de "@nestjs/mangouste" ;
importer { Document } de "mangouste";
La Soutenir le décorateur marque les propriétés qu'il annote comme une propriété dans votre base de données MongoDB.
La Schéma décorateur marque la classe qu'il annote en tant que schéma.
La SchemaFactory La classe contient des méthodes statiques utilisées pour la création de modèles.
La Mangouste Document représente un mappage un à un aux documents tels qu'ils sont stockés dans MongoDB. Vous en aurez besoin comme annotation de type.
Alors, créer une classe, annotez-le avec le Schéma decorator pour le marquer comme un schéma Mongoose et l'exporter :
@Schéma()
exporterclasserDémo{}
Ensuite, créez et exportez un type d'union avec votre classe et Document:
exportertaper DemoDocument = Démo & Document ;
Ajoutez ensuite les propriétés souhaitées à la classe et annotez-les avec le Soutenir décorateur. Vous pouvez transmettre un objet de configuration facultatif au Soutenir décorateur et définissez la propriété selon vos besoins :
@Schéma()
exporterclasserDémo{
@Soutenir({ requis: vrai })
propriété_1: chaîne ;
}
La Mangouste La documentation couvre l'objet de configuration plus en détail.
Enfin, créez et exportez un modèle Mongoose via le SchemaFactorys createForClass méthode et passez votre classe en argument :
exporterconstante DemoSchema = SchemaFactory.createForClass (Démo);
Votre schéma terminé devrait ressembler à ceci :
importer { Prop, Schema, SchemaFactory } de '@nestjs/mangouste' ;
importer { Document } de 'mangouste';exportertaper DemoDocument = Démo & Document ;
@Schéma()
exporterclasserDémo{
@Soutenir({ requis: vrai })
propriété_1: chaîne ;@Soutenir({ requis: vrai })
propriété_2: nombre ;@Soutenir()
propriété_3: chaîne ;@Soutenir({ requis: vrai })
propriété_4: booléen;
}
exporterconstante DemoSchema = SchemaFactory.createForClass (Démo);
Étape 4: Enregistrement du schéma
Accédez au dossier de votre module et ajoutez les importations suivantes :
importer {Module Mongoose} de '@nestjs/mangouste' ;
importer { Démo, DémoSchéma } de '../schemas/demo.schema' ;
Ensuite, créez un "importations” tableau à l'intérieur du @module décorateur. Ensuite, à l'intérieur du tableau, appelez le pourFonctionnalité méthode sur Module Mangouste.
La pourFonctionnalité La méthode prend en charge un tableau de modèles Mongoose. Passez un objet de configuration avec un Nom propriété définie sur le nom de votre classe de schéma, et une schéma propriété définie sur votre schéma créé :
Module Mangouste.forFeature([{ nom: Demo.nom, schéma: DemoSchema }]),
Étape 5: injection du modèle de mangouste
Ensuite, vous devrez injecter le modèle Mongoose pour activer l'interrogation de votre base de données en appelant les méthodes Mongoose sur le modèle.
Accédez à la classe de service de votre module et ajoutez les importations suivantes :
importer { Modèle } de 'mangouste';
importer { InjectModel } de '@nestjs/mangouste' ;
importer { Démo, DémoDocument } de '../schemas/demo.schema' ;
Utilisez le Modèle interface comme définition de type pour votre modèle, lui donnant accès aux méthodes Mongoose.
La InjectModel décorateur injecte le modèle Mongoose dans le constructeur de votre classe de service.
Ensuite, créez un constructeur à l'intérieur de votre classe de service. Cela devrait prendre un privé variable comme argument, un Modèle avec un type générique de Document de démonstration. Annotez votre variable privée avec le InjectModel decorator et passez votre nom de classe de schéma comme argument :
@Injectable()
exporterclasserDemoService{
constructeur(
@InjectModel(Démo.nom)
démo privéeModèle: Modèle<Document de démonstration>,
) {}
}
Vous pouvez interroger votre base de données MongoDB en appelant les méthodes Mongoose sur votre variable privée (modèle de démonstration).
Avantages de l'utilisation de MongoDB
Outre sa forte communauté en ligne et sa facilité d'utilisation, MongoDB offre une disponibilité et une stabilité élevées des données. Il offre des analyses accélérées, une agrégation de données, etc., ce qui en fait la base de données idéale pour vos projets.