mongoose
8.8.2
Mongoose é uma ferramenta de modelagem de objetos MongoDB projetada para funcionar em um ambiente assíncrono. Mongoose oferece suporte a Node.js e Deno (alfa).
O site oficial de documentação é mongoosejs.com.
O Mongoose 8.0.0 foi lançado em 31 de outubro de 2023. Você pode encontrar mais detalhes sobre alterações anteriores na versão 8.0.0 em nosso site de documentos.
Confira o site de busca de plug-ins para ver centenas de módulos relacionados da comunidade. A seguir, aprenda como escrever seu próprio plugin na documentação ou nesta postagem do blog.
Solicitações pull são sempre bem-vindas! Baseie as solicitações pull no branch master e siga o guia de contribuição.
Se suas solicitações pull fizerem alterações na documentação, não modifique nenhum arquivo .html . Os arquivos .html são código compilado, portanto, faça suas alterações em docs/*.pug , lib/*.js ou test/docs/*.js .
Veja todos os mais de 400 colaboradores.
Primeiro instale o Node.js e o MongoDB. Então:
npm install mongooseO Mongoose 6.8.0 também inclui suporte alfa para Deno.
// Using Node.js `require()`
const mongoose = require ( 'mongoose' ) ;
// Using ES6 imports
import mongoose from 'mongoose' ; Ou, usando createRequire() do Deno para suporte CommonJS como segue.
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!' ) ) ;Você pode então executar o script acima usando o seguinte.
deno run --allow-net --allow-read --allow-sys --allow-env mongoose-test.jsDisponível como parte da assinatura Tidelift
Os mantenedores do mongoose e de milhares de outros pacotes estão trabalhando com o Tidelift para fornecer suporte comercial e manutenção para as dependências de código aberto que você usa para construir seus aplicativos. Economize tempo, reduza riscos e melhore a integridade do código, enquanto paga os mantenedores das dependências exatas que você usa. Saber mais.
Primeiro, precisamos definir uma conexão. Se seu aplicativo usar apenas um banco de dados, você deverá usar mongoose.connect . Se você precisar criar conexões adicionais, use mongoose.createConnection .
Tanto connect quanto createConnection usam um URI mongodb:// ou os parâmetros host, database, port, options .
await mongoose . connect ( 'mongodb://127.0.0.1/my_database' ) ; Uma vez conectado, o evento open é disparado na instância Connection . Se você estiver usando mongoose.connect , a Connection será mongoose.connection . Caso contrário, o valor de retorno mongoose.createConnection será Connection .
Nota: Se a conexão local falhar, tente usar 127.0.0.1 em vez de localhost. Às vezes, podem surgir problemas quando o nome do host local é alterado.
Importante! O Mongoose armazena em buffer todos os comandos até que esteja conectado ao banco de dados. Isso significa que você não precisa esperar até que ele se conecte ao MongoDB para definir modelos, executar consultas, etc.
Os modelos são definidos por meio da interface Schema .
const Schema = mongoose . Schema ;
const ObjectId = Schema . ObjectId ;
const BlogPost = new Schema ( {
author : ObjectId ,
title : String ,
body : String ,
date : Date
} ) ;Além de definir a estrutura dos seus documentos e os tipos de dados que você está armazenando, um Schema trata da definição de:
O exemplo a seguir mostra alguns desses recursos:
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 ( ) ;
} ) ; Dê uma olhada no exemplo em examples/schema/schema.js para obter um exemplo completo de uma configuração típica.
Depois de definirmos um modelo por meio de mongoose.model('ModelName', mySchema) , podemos acessá-lo por meio da mesma função
const MyModel = mongoose . model ( 'ModelName' ) ;Ou apenas faça tudo de uma vez
const MyModel = mongoose . model ( 'ModelName' , mySchema ) ;O primeiro argumento é o nome singular da coleção à qual seu modelo se destina. O Mongoose procura automaticamente a versão plural do nome do seu modelo. Por exemplo, se você usar
const MyModel = mongoose . model ( 'Ticket' , mySchema ) ; Então MyModel usará a coleta de tickets , não a coleta de tickets . Para mais detalhes, leia a documentação do modelo.
Assim que tivermos nosso modelo, podemos instanciá-lo e salvá-lo:
const instance = new MyModel ( ) ;
instance . my . key = 'hello' ;
await instance . save ( ) ;Ou podemos encontrar documentos da mesma coleção
await MyModel . find ( { } ) ; Você também pode findOne , findById , update , etc.
const instance = await MyModel . findOne ( { /* ... */ } ) ;
console . log ( instance . my . key ) ; // 'hello'Para mais detalhes confira os documentos.
Importante! Se você abriu uma conexão separada usando mongoose.createConnection() mas tentou acessar o modelo através de mongoose.model('ModelName') ele não funcionará como esperado, pois não está conectado a uma conexão de banco de dados ativa. Neste caso acesse seu modelo através da conexão que você criou:
const conn = mongoose . createConnection ( 'your connection string' ) ;
const MyModel = conn . model ( 'ModelName' , schema ) ;
const m = new MyModel ( ) ;
await m . save ( ) ; // workscontra
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 connectedNo primeiro trecho de exemplo, definimos uma chave no esquema que se parece com:
comments: [Comment] Onde Comment é um Schema que criamos. Isto significa que criar documentos incorporados é tão simples quanto:
// 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 ( ) ;O mesmo vale para removê-los:
const post = await BlogPost . findById ( myId ) ;
post . comments [ 0 ] . deleteOne ( ) ;
await post . save ( ) ;Os documentos incorporados desfrutam dos mesmos recursos dos seus modelos. Padrões, validadores, middleware.
Veja a página de documentos.
Você pode interceptar argumentos de método via middleware.
Por exemplo, isso permitiria que você transmitisse alterações sobre seus documentos sempre que alguém set um caminho em seu documento com um novo 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 ( ) ;
} ) ; Além disso, você pode alterar os argumentos method recebido para que o middleware subsequente veja valores diferentes para esses argumentos. Para fazer isso, basta passar os novos valores para 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 , quando usado em um esquema, tem um significado especial no Mongoose. Se o seu esquema exigir o uso type como uma propriedade aninhada, você deverá usar a notação de objeto:
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
}
} ) ; O Mongoose é construído sobre o driver oficial MongoDB Node.js. Cada modelo mongoose mantém uma referência a uma coleção de drivers nativos do MongoDB. O objeto de coleção pode ser acessado usando YourModel.collection . No entanto, usar o objeto de coleção ignora diretamente todos os recursos do mongoose, incluindo ganchos, validação, etc. A única exceção notável é que YourModel.collection ainda armazena comandos em buffer. Como tal, YourModel.collection.find() não retornará um cursor.
Encontre os documentos da API aqui, gerados usando dox e acquit.
Direitos autorais (c) 2010 LearnBoost <[email protected]>
É concedida permissão, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e dos arquivos de documentação associados (o 'Software'), para negociar o Software sem restrições, incluindo, sem limitação, os direitos de usar, copiar, modificar, mesclar , publicar, distribuir, sublicenciar e/ou vender cópias do Software e permitir que as pessoas a quem o Software seja fornecido o façam, sujeito às seguintes condições:
O aviso de direitos autorais acima e este aviso de permissão serão incluídos em todas as cópias ou partes substanciais do Software.
O SOFTWARE É FORNECIDO 'TAL COMO ESTÁ', SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM HIPÓTESE ALGUMA OS AUTORES OU DETENTORES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER RECLAMAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU DE OUTRA FORMA, DECORRENTE DE, OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO SOFTWARE.
