mongoose Download - mongoose Quellcode herunterladen

Mungo

Mongoose ist ein MongoDB-Objektmodellierungstool, das für den Einsatz in einer asynchronen Umgebung entwickelt wurde. Mongoose unterstützt Node.js und Deno (Alpha).

Dokumentation

Die offizielle Dokumentationswebsite ist mongoosejs.com.

Mongoose 8.0.0 wurde am 31. Oktober 2023 veröffentlicht. Weitere Details zu Backward-Breaking-Änderungen in 8.0.0 finden Sie auf unserer Dokumentationsseite.

Unterstützung

Stapelüberlauf
Fehlerberichte
Mongoose Slack Channel
Hilfeforum
MongoDB-Unterstützung

Plugins

Schauen Sie sich die Plugin-Suchseite an, um Hunderte verwandter Module aus der Community zu sehen. Als Nächstes erfahren Sie anhand der Dokumentation oder dieses Blogbeitrags, wie Sie Ihr eigenes Plugin schreiben.

Mitwirkende

Pull-Anfragen sind jederzeit willkommen! Bitte stützen Sie Pull-Anfragen auf den master -Zweig und befolgen Sie die beitragende Anleitung.

Wenn Ihre Pull-Anfragen Änderungen an der Dokumentation bewirken, ändern Sie bitte keine .html Dateien. Bei den .html Dateien handelt es sich um kompilierten Code. Bitte nehmen Sie Ihre Änderungen in docs/*.pug , lib/*.js oder test/docs/*.js vor.

Alle über 400 Mitwirkenden anzeigen.

Installation

Installieren Sie zunächst Node.js und MongoDB. Dann:

npm install mongoose

Mongoose 6.8.0 bietet auch Alpha-Unterstützung für Deno.

Importieren

 // Using Node.js `require()`
const mongoose = require ( 'mongoose' ) ;

// Using ES6 imports
import mongoose from 'mongoose' ;

Oder verwenden Sie Denos createRequire() für die CommonJS-Unterstützung wie folgt.

 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!' ) ) ;

Anschließend können Sie das obige Skript wie folgt ausführen.

deno run --allow-net --allow-read --allow-sys --allow-env mongoose-test.js

Mungo für Unternehmen

Verfügbar als Teil des Tidelift-Abonnements

Die Betreuer von mongoose und Tausenden anderer Pakete arbeiten mit Tidelift zusammen, um kommerziellen Support und Wartung für die Open-Source-Abhängigkeiten bereitzustellen, die Sie zum Erstellen Ihrer Anwendungen verwenden. Sparen Sie Zeit, reduzieren Sie Risiken und verbessern Sie den Zustand des Codes, während Sie gleichzeitig die Betreuer der genauen Abhängigkeiten bezahlen, die Sie verwenden. Erfahren Sie mehr.

Überblick

Verbindung zu MongoDB herstellen

Zuerst müssen wir eine Verbindung definieren. Wenn Ihre App nur eine Datenbank verwendet, sollten Sie mongoose.connect verwenden. Wenn Sie zusätzliche Verbindungen erstellen müssen, verwenden Sie mongoose.createConnection .

Sowohl connect als auch createConnection benötigen einen mongodb:// -URI oder die Parameter host, database, port, options .

 await mongoose . connect ( 'mongodb://127.0.0.1/my_database' ) ;

Sobald die Verbindung hergestellt ist, wird das open -Ereignis auf der Connection Instanz ausgelöst. Wenn Sie mongoose.connect verwenden, lautet die Connection mongoose.connection . Andernfalls ist der Rückgabewert mongoose.createConnection ein Connection .

Hinweis: Wenn die lokale Verbindung fehlschlägt, versuchen Sie es mit 127.0.0.1 anstelle von localhost. Manchmal können Probleme auftreten, wenn der lokale Hostname geändert wurde.

Wichtig! Mongoose puffert alle Befehle, bis eine Verbindung zur Datenbank hergestellt wird. Das bedeutet, dass Sie nicht warten müssen, bis eine Verbindung zu MongoDB hergestellt wird, um Modelle zu definieren, Abfragen auszuführen usw.

Ein Modell definieren

Modelle werden über die Schema Schnittstelle definiert.

 const Schema = mongoose . Schema ;
const ObjectId = Schema . ObjectId ;

const BlogPost = new Schema ( {
  author : ObjectId ,
  title : String ,
  body : String ,
  date : Date
} ) ;

Neben der Definition der Struktur Ihrer Dokumente und der von Ihnen gespeicherten Datentypen übernimmt ein Schema die Definition von:

Validatoren (asynchron und synchron)
Standardeinstellungen
Getter
Setter
Indizes
Middleware
Methodendefinition
Statikdefinition
Plugins
Pseudo-JOINs

Das folgende Beispiel zeigt einige dieser Funktionen:

 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 ( ) ;
} ) ;

Schauen Sie sich das Beispiel in examples/schema/schema.js an, um ein End-to-End-Beispiel für ein typisches Setup zu erhalten.

Auf ein Modell zugreifen

Sobald wir ein Modell über mongoose.model('ModelName', mySchema) definieren, können wir über dieselbe Funktion darauf zugreifen

 const MyModel = mongoose . model ( 'ModelName' ) ;

Oder machen Sie einfach alles auf einmal

 const MyModel = mongoose . model ( 'ModelName' , mySchema ) ;

Das erste Argument ist der singuläre Name der Sammlung, für die Ihr Modell bestimmt ist. Mongoose sucht automatisch nach der Pluralversion Ihres Modellnamens. Zum Beispiel, wenn Sie verwenden

 const MyModel = mongoose . model ( 'Ticket' , mySchema ) ;

Dann verwendet MyModel die Ticketsammlung , nicht die Ticketsammlung . Weitere Informationen finden Sie in den Modelldokumenten.

Sobald wir unser Modell haben, können wir es instanziieren und speichern:

 const instance = new MyModel ( ) ;
instance . my . key = 'hello' ;
await instance . save ( ) ;

Oder wir finden Dokumente aus derselben Sammlung

 await MyModel . find ( { } ) ;

Sie können auch findOne , findById , update usw. verwenden.

 const instance = await MyModel . findOne ( { /* ... */ } ) ;
console . log ( instance . my . key ) ; // 'hello'

Weitere Informationen finden Sie in den Dokumenten.

Wichtig! Wenn Sie mit mongoose.createConnection() eine separate Verbindung geöffnet haben, aber versuchen, über mongoose.model('ModelName') auf das Modell zuzugreifen, funktioniert es nicht wie erwartet, da es nicht mit einer aktiven Datenbankverbindung verbunden ist. Greifen Sie in diesem Fall über die von Ihnen erstellte Verbindung auf Ihr Modell zu:

 const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = conn . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // works

 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 connected

Eingebettete Dokumente

Im ersten Beispielausschnitt haben wir einen Schlüssel im Schema definiert, der wie folgt aussieht:

comments: [Comment]

Wobei Comment ein von uns erstelltes Schema ist. Das bedeutet, dass das Erstellen eingebetteter Dokumente so einfach ist wie:

 // 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 ( ) ;

Das Gleiche gilt für das Entfernen:

 const post = await BlogPost . findById ( myId ) ;
post . comments [ 0 ] . deleteOne ( ) ;
await post . save ( ) ;

Eingebettete Dokumente verfügen über dieselben Funktionen wie Ihre Modelle. Standardeinstellungen, Validatoren, Middleware.

Middleware

Siehe die Dokumentationsseite.

Methodenargumente abfangen und mutieren

Sie können Methodenargumente über Middleware abfangen.

Dies würde es Ihnen beispielsweise ermöglichen, Änderungen an Ihren Dokumenten jedes Mal zu übertragen, wenn jemand einen Pfad in Ihrem Dokument auf einen neuen Wert set :

 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 ( ) ;
} ) ;

Darüber hinaus können Sie die eingehenden method ändern, sodass nachfolgende Middleware andere Werte für diese Argumente sieht. Übergeben Sie dazu einfach die neuen Werte an 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 ( ) ;
} ) ;

Schema gotcha

Wenn type in einem Schema verwendet wird, hat er innerhalb von Mongoose eine besondere Bedeutung. Wenn Ihr Schema die Verwendung type als verschachtelte Eigenschaft erfordert, müssen Sie die Objektnotation verwenden:

 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
  }
} ) ;

Fahrerzugriff

Mongoose basiert auf dem offiziellen MongoDB Node.js-Treiber. Jedes Mongoose-Modell behält einen Verweis auf eine native MongoDB-Treibersammlung. Auf das Sammlungsobjekt kann über YourModel.collection zugegriffen werden. Durch die direkte Verwendung des Sammlungsobjekts werden jedoch alle Mungo-Funktionen, einschließlich Hooks, Validierung usw., umgangen. Die einzige bemerkenswerte Ausnahme besteht darin, dass YourModel.collection weiterhin Befehle puffert. Daher gibt YourModel.collection.find() keinen Cursor zurück.

API-Dokumente

Hier finden Sie die API-Dokumente, die mit dox und acquit erstellt wurden.

Lizenz

Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die „Software“) erhält, kostenlos die Erlaubnis erteilt, mit der Software ohne Einschränkung zu handeln, einschließlich und ohne Einschränkung der Rechte zur Nutzung, zum Kopieren, Ändern und Zusammenführen , Kopien der Software zu veröffentlichen, zu verteilen, unterzulizenzieren und/oder zu verkaufen und Personen, denen die Software zur Verfügung gestellt wird, dies zu gestatten, vorbehaltlich der folgenden Bedingungen:

Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.

DIE SOFTWARE WIRD „WIE BESEHEN“ ZUR VERFÜGUNG GESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER HAFTBAR FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNG, WEDER AUS EINER VERTRAGLICHEN HANDLUNG, AUS HANDLUNG ODER ANDERWEITIG, DIE SICH AUS, AUS ODER IN ZUSAMMENHANG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN HANDELN IN DER SOFTWARE ERGEBEN SOFTWARE.

Expandieren