mongoose
8.8.2
Mongoose es una herramienta de modelado de objetos de MongoDB diseñada para funcionar en un entorno asincrónico. Mongoose es compatible con Node.js y Deno (alfa).
El sitio web de documentación oficial es mongoosejs.com.
Mongoose 8.0.0 se lanzó el 31 de octubre de 2023. Puede encontrar más detalles sobre los cambios anteriores en 8.0.0 en nuestro sitio de documentos.
Consulte el sitio de búsqueda de complementos para ver cientos de módulos relacionados de la comunidad. A continuación, aprenda cómo escribir su propio complemento en los documentos o en esta publicación de blog.
¡Las solicitudes de extracción siempre son bienvenidas! Base las solicitudes de extracción en la rama master y siga la guía de contribución.
Si sus solicitudes de extracción realizan cambios en la documentación, no modifique ningún archivo .html . Los archivos .html son código compilado, así que realice los cambios en docs/*.pug , lib/*.js o test/docs/*.js .
Ver los más de 400 colaboradores.
Primero instale Node.js y MongoDB. Entonces:
npm install mongooseMongoose 6.8.0 también incluye soporte alfa para Deno.
// Using Node.js `require()`
const mongoose = require ( 'mongoose' ) ;
// Using ES6 imports
import mongoose from 'mongoose' ; O bien, utilizando createRequire() de Deno para compatibilidad con CommonJS de la siguiente manera.
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!' ) ) ;Luego puede ejecutar el script anterior usando lo siguiente.
deno run --allow-net --allow-read --allow-sys --allow-env mongoose-test.jsDisponible como parte de la suscripción a Tidelift
Los mantenedores de mongoose y miles de otros paquetes están trabajando con Tidelift para brindar soporte comercial y mantenimiento para las dependencias de código abierto que utiliza para crear sus aplicaciones. Ahorre tiempo, reduzca el riesgo y mejore la salud del código, mientras paga a los mantenedores de las dependencias exactas que utiliza. Obtenga más información.
Primero, necesitamos definir una conexión. Si su aplicación usa solo una base de datos, debe usar mongoose.connect . Si necesita crear conexiones adicionales, utilice mongoose.createConnection .
Tanto connect como createConnection toman un URI mongodb:// , o los parámetros host, database, port, options .
await mongoose . connect ( 'mongodb://127.0.0.1/my_database' ) ; Una vez conectado, el evento open se activa en la instancia Connection . Si está utilizando mongoose.connect , la Connection es mongoose.connection . De lo contrario, el valor de retorno mongoose.createConnection es Connection .
Nota: Si la conexión local falla, intente usar 127.0.0.1 en lugar de localhost. A veces pueden surgir problemas cuando se cambia el nombre del host local.
¡Importante! Mongoose almacena en búfer todos los comandos hasta que se conecta a la base de datos. Esto significa que no tiene que esperar hasta que se conecte a MongoDB para definir modelos, ejecutar consultas, etc.
Los modelos se definen a través de la interfaz Schema .
const Schema = mongoose . Schema ;
const ObjectId = Schema . ObjectId ;
const BlogPost = new Schema ( {
author : ObjectId ,
title : String ,
body : String ,
date : Date
} ) ;Además de definir la estructura de sus documentos y los tipos de datos que almacena, un esquema maneja la definición de:
El siguiente ejemplo muestra algunas de estas características:
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 ( ) ;
} ) ; Eche un vistazo al ejemplo en examples/schema/schema.js para ver un ejemplo completo de una configuración típica.
Una vez que definimos un modelo a través de mongoose.model('ModelName', mySchema) , podemos acceder a él a través de la misma función.
const MyModel = mongoose . model ( 'ModelName' ) ;O simplemente hazlo todo de una vez
const MyModel = mongoose . model ( 'ModelName' , mySchema ) ;El primer argumento es el nombre singular de la colección a la que pertenece su modelo. Mongoose busca automáticamente la versión plural del nombre de su modelo. Por ejemplo, si usas
const MyModel = mongoose . model ( 'Ticket' , mySchema ) ; Entonces MyModel usará la colección de boletos , no la colección de boletos . Para obtener más detalles, lea los documentos del modelo.
Una vez que tengamos nuestro modelo, podemos crear una instancia y guardarlo:
const instance = new MyModel ( ) ;
instance . my . key = 'hello' ;
await instance . save ( ) ;O podemos encontrar documentos de la misma colección.
await MyModel . find ( { } ) ; También puedes findOne , findById , update , etc.
const instance = await MyModel . findOne ( { /* ... */ } ) ;
console . log ( instance . my . key ) ; // 'hello'Para obtener más detalles, consulte los documentos.
¡Importante! Si abrió una conexión separada usando mongoose.createConnection() pero intenta acceder al modelo a través de mongoose.model('ModelName') no funcionará como se esperaba ya que no está conectado a una conexión de base de datos activa. En este caso accede a tu modelo a través de la conexión que creaste:
const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = conn . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // worksvs
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 connectedEn el primer fragmento de ejemplo, definimos una clave en el esquema que se ve así:
comments: [Comment] Donde Comment es un Schema que creamos. Esto significa que crear documentos incrustados es tan simple como:
// 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 ( ) ;Lo mismo ocurre con su eliminación:
const post = await BlogPost . findById ( myId ) ;
post . comments [ 0 ] . deleteOne ( ) ;
await post . save ( ) ;Los documentos incrustados disfrutan de las mismas características que sus modelos. Valores predeterminados, validadores, middleware.
Consulte la página de documentos.
Puede interceptar argumentos de métodos a través de middleware.
Por ejemplo, esto le permitiría transmitir cambios sobre sus Documentos cada vez que alguien set una ruta en su Documento con un nuevo valor:
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 ( ) ;
} ) ; Además, puede modificar los argumentos method entrante para que el middleware posterior vea valores diferentes para esos argumentos. Para hacerlo, simplemente pase los nuevos valores al 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 , cuando se usa en un esquema, tiene un significado especial dentro de Mongoose. Si su esquema requiere el uso type como propiedad anidada, debe usar notación de objetos:
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á construido sobre el controlador oficial MongoDB Node.js. Cada modelo de mangosta mantiene una referencia a una colección de controladores nativos de MongoDB. Se puede acceder al objeto de la colección mediante YourModel.collection . Sin embargo, el uso del objeto de colección omite directamente todas las funciones de mangosta, incluidos los ganchos, la validación, etc. La única excepción notable es que YourModel.collection aún almacena en búfer los comandos. Como tal, YourModel.collection.find() no devolverá un cursor.
Encuentre los documentos API aquí, generados usando dox y acquit.
Copyright (c) 2010 LearnBoost <[email protected]>
Por el presente se otorga permiso, sin cargo, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el 'Software'), para operar con el Software sin restricciones, incluidos, entre otros, los derechos de uso, copia, modificación, fusión. , publicar, distribuir, sublicenciar y/o vender copias del Software, y permitir que las personas a quienes se les proporciona el Software lo hagan, sujeto a las siguientes condiciones:
El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO, PERO NO LIMITADO A, LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGÚN RECLAMO, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, AGRAVIO O DE OTRA MANERA, QUE SURJA DE, FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS NEGOCIOS EN EL SOFTWARE.
