mongoose
8.8.2
Mongoose est un outil de modélisation d'objets MongoDB conçu pour fonctionner dans un environnement asynchrone. Mongoose prend en charge Node.js et Deno (alpha).
Le site Web de documentation officiel est mongoosejs.com.
Mongoose 8.0.0 est sorti le 31 octobre 2023. Vous pouvez trouver plus de détails sur les modifications rétrogrades de la version 8.0.0 sur notre site de documentation.
Consultez le site de recherche de plugins pour voir des centaines de modules associés de la communauté. Ensuite, apprenez à écrire votre propre plugin à partir de la documentation ou de cet article de blog.
Les demandes de tirage sont toujours les bienvenues ! Veuillez baser les demandes d'extraction sur la branche master et suivre le guide de contribution.
Si vos demandes d'extraction apportent des modifications à la documentation, veuillez ne modifier aucun fichier .html . Les fichiers .html sont du code compilé, veuillez donc apporter vos modifications dans docs/*.pug , lib/*.js ou test/docs/*.js .
Consultez les plus de 400 contributeurs.
Installez d'abord Node.js et MongoDB. Alors:
npm install mongooseMongoose 6.8.0 inclut également la prise en charge alpha pour Deno.
// Using Node.js `require()`
const mongoose = require ( 'mongoose' ) ;
// Using ES6 imports
import mongoose from 'mongoose' ; Ou, en utilisant createRequire() de Deno pour la prise en charge de CommonJS comme suit.
import { createRequire } from 'https://deno.land/[email protected]/node/module.ts' ;
const require = createRequire ( import . meta . url ) ;
const mongoose = require ( 'mongoose' ) ;
mongoose . connect ( 'mongodb://127.0.0.1:27017/test' )
. then ( ( ) => console . log ( 'Connected!' ) ) ;Vous pouvez ensuite exécuter le script ci-dessus en utilisant ce qui suit.
deno run --allow-net --allow-read --allow-sys --allow-env mongoose-test.jsDisponible dans le cadre de l’abonnement Tidelift
Les responsables de mongoose et de milliers d'autres packages travaillent avec Tidelift pour fournir un support commercial et une maintenance pour les dépendances open source que vous utilisez pour créer vos applications. Gagnez du temps, réduisez les risques et améliorez la santé du code, tout en rémunérant les responsables des dépendances exactes que vous utilisez. Apprendre encore plus.
Tout d’abord, nous devons définir une connexion. Si votre application n'utilise qu'une seule base de données, vous devez utiliser mongoose.connect . Si vous devez créer des connexions supplémentaires, utilisez mongoose.createConnection .
connect et createConnection prennent tous deux un URI mongodb:// , ou les paramètres host, database, port, options .
await mongoose . connect ( 'mongodb://127.0.0.1/my_database' ) ; Une fois connecté, l'événement open est déclenché sur l'instance Connection . Si vous utilisez mongoose.connect , la Connection est mongoose.connection . Sinon, la valeur de retour mongoose.createConnection est une Connection .
Remarque : si la connexion locale échoue, essayez d'utiliser 127.0.0.1 au lieu de localhost. Parfois, des problèmes peuvent survenir lorsque le nom d'hôte local a été modifié.
Important! Mongoose met en mémoire tampon toutes les commandes jusqu'à ce qu'elle soit connectée à la base de données. Cela signifie que vous n'avez pas besoin d'attendre qu'il se connecte à MongoDB pour définir des modèles, exécuter des requêtes, etc.
Les modèles sont définis via l'interface Schema .
const Schema = mongoose . Schema ;
const ObjectId = Schema . ObjectId ;
const BlogPost = new Schema ( {
author : ObjectId ,
title : String ,
body : String ,
date : Date
} ) ;En plus de définir la structure de vos documents et les types de données que vous stockez, un schéma gère la définition de :
L'exemple suivant montre certaines de ces fonctionnalités :
const Comment = new Schema ( {
name : { type : String , default : 'hahaha' } ,
age : { type : Number , min : 18 , index : true } ,
bio : { type : String , match : / [a-z] / } ,
date : { type : Date , default : Date . now } ,
buff : Buffer
} ) ;
// a setter
Comment . path ( 'name' ) . set ( function ( v ) {
return capitalize ( v ) ;
} ) ;
// middleware
Comment . pre ( 'save' , function ( next ) {
notify ( this . get ( 'email' ) ) ;
next ( ) ;
} ) ; Jetez un œil à l'exemple dans examples/schema/schema.js pour un exemple de bout en bout d'une configuration typique.
Une fois que nous avons défini un modèle via mongoose.model('ModelName', mySchema) , nous pouvons y accéder via la même fonction
const MyModel = mongoose . model ( 'ModelName' ) ;Ou faites tout simplement tout en même temps
const MyModel = mongoose . model ( 'ModelName' , mySchema ) ;Le premier argument est le nom singulier de la collection à laquelle votre modèle est destiné. Mongoose recherche automatiquement la version plurielle du nom de votre modèle. Par exemple, si vous utilisez
const MyModel = mongoose . model ( 'Ticket' , mySchema ) ; Ensuite, MyModel utilisera la collecte de tickets , pas la collecte de tickets . Pour plus de détails, lisez la documentation du modèle.
Une fois que nous avons notre modèle, nous pouvons alors l'instancier et le sauvegarder :
const instance = new MyModel ( ) ;
instance . my . key = 'hello' ;
await instance . save ( ) ;Ou on peut retrouver des documents de la même collection
await MyModel . find ( { } ) ; Vous pouvez également findOne , findById , update , etc.
const instance = await MyModel . findOne ( { /* ... */ } ) ;
console . log ( instance . my . key ) ; // 'hello'Pour plus de détails, consultez la documentation.
Important! Si vous avez ouvert une connexion distincte à l'aide de mongoose.createConnection() mais que vous essayez d'accéder au modèle via mongoose.model('ModelName') cela ne fonctionnera pas comme prévu car il n'est pas connecté à une connexion de base de données active. Dans ce cas accédez à votre modèle via la connexion que vous avez créée :
const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = conn . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // workscontre
const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = mongoose . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // does not work b/c the default connection object was never connectedDans le premier extrait d'exemple, nous avons défini une clé dans le schéma qui ressemble à :
comments: [Comment] Où Comment est un Schema que nous avons créé. Cela signifie que la création de documents intégrés est aussi simple que :
// retrieve my model
const BlogPost = mongoose . model ( 'BlogPost' ) ;
// create a blog post
const post = new BlogPost ( ) ;
// create a comment
post . comments . push ( { title : 'My comment' } ) ;
await post . save ( ) ;Il en va de même pour les supprimer :
const post = await BlogPost . findById ( myId ) ;
post . comments [ 0 ] . deleteOne ( ) ;
await post . save ( ) ;Les documents intégrés bénéficient des mêmes fonctionnalités que vos modèles. Valeurs par défaut, validateurs, middleware.
Voir la page de documentation.
Vous pouvez intercepter les arguments de méthode via un middleware.
Par exemple, cela vous permettrait de diffuser les modifications concernant vos documents chaque fois que quelqu'un set un chemin dans votre document sur une nouvelle valeur :
schema . pre ( 'set' , function ( next , path , val , typel ) {
// `this` is the current Document
this . emit ( 'set' , path , val ) ;
// Pass control to the next pre
next ( ) ;
} ) ; De plus, vous pouvez modifier les arguments method entrante afin que les middlewares suivants voient des valeurs différentes pour ces arguments. Pour cela, passez simplement les nouvelles valeurs à next :
schema . pre ( method , function firstPre ( next , methodArg1 , methodArg2 ) {
// Mutate methodArg1
next ( 'altered-' + methodArg1 . toString ( ) , methodArg2 ) ;
} ) ;
// pre declaration is chainable
schema . pre ( method , function secondPre ( next , methodArg1 , methodArg2 ) {
console . log ( methodArg1 ) ;
// => 'altered-originalValOfMethodArg1'
console . log ( methodArg2 ) ;
// => 'originalValOfMethodArg2'
// Passing no arguments to `next` automatically passes along the current argument values
// i.e., the following `next()` is equivalent to `next(methodArg1, methodArg2)`
// and also equivalent to, with the example method arg
// values, `next('altered-originalValOfMethodArg1', 'originalValOfMethodArg2')`
next ( ) ;
} ) ; type , lorsqu'il est utilisé dans un schéma, a une signification particulière dans Mongoose. Si votre schéma nécessite l'utilisation type comme propriété imbriquée, vous devez utiliser la notation objet :
new Schema ( {
broken : { type : Boolean } ,
asset : {
name : String ,
type : String // uh oh, it broke. asset will be interpreted as String
}
} ) ;
new Schema ( {
works : { type : Boolean } ,
asset : {
name : String ,
type : { type : String } // works. asset is an object with a type property
}
} ) ; Mongoose est construit sur le pilote officiel MongoDB Node.js. Chaque modèle Mongoose conserve une référence à une collection de pilotes MongoDB native. L'objet de collection est accessible à l'aide de YourModel.collection . Cependant, l'utilisation de l'objet collection contourne directement toutes les fonctionnalités de mangouste, y compris les hooks, la validation, etc. La seule exception notable est que YourModel.collection met toujours les commandes en mémoire tampon. En tant que tel, YourModel.collection.find() ne renverra pas de curseur.
Trouvez la documentation API ici, générée à l'aide de dox et acquit.
Copyright (c) 2010 LearnBoost <[email protected]>
L'autorisation est accordée par la présente, gratuitement, à toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le « Logiciel »), d'utiliser le Logiciel sans restriction, y compris, sans limitation, les droits d'utilisation, de copie, de modification, de fusion. , publier, distribuer, accorder des sous-licences et/ou vendre des copies du Logiciel, et permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :
L'avis de droit d'auteur ci-dessus et cet avis d'autorisation doivent être inclus dans toutes les copies ou parties substantielles du logiciel.
LE LOGICIEL EST FOURNI « TEL QUEL », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS MAIS SANS LIMITATION LES GARANTIES DE QUALITÉ MARCHANDE, D'ADAPTATION À UN USAGE PARTICULIER ET DE NON-VIOLATION. EN AUCUN CAS LES AUTEURS OU LES TITULAIRES DES DROITS D'AUTEUR NE SERONT RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGES OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS UNE ACTION CONTRACTUELLE, DÉLIT OU AUTRE, DÉCOULANT DE, DE OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU D'AUTRES TRANSACTIONS DANS LE LOGICIEL.
