Mongoose: DeprecationWarning: `open()` est√° obsoleto no mangusto >= 4.11.0, use `openUri()` em vez disso

Criado em 25 jun. 2017  ¬∑  158Coment√°rios  ¬∑  Fonte: Automattic/mongoose

Aviso de descontinuação: open() está obsoleto no mangusto >= 4.11.0, use openUri() ou defina a opção useMongoClient se estiver usando connect() ou createConnection()

Mongoose 4.11.0, MongoDB 2.2.29, NodeJS 8.1.2

Coment√°rios muito √ļteis

A corre√ß√£o mais f√°cil para isso; " npm remove mongoose " ent√£o " npm install [email protected] --save " problema resolvido. A atualiza√ß√£o nem sempre √© a melhor op√ß√£o.

Todos 158 coment√°rios

+1 , n√£o tenho ideia de onde corrigir para me livrar desse aviso

O aviso é para um código dentro do Mongoose, na verdade, quando a string de conexão tem um conjunto de réplicas:

Mongoose.prototype.connect = function() {
  var conn = this.connection;
  if ((arguments.length === 2 || arguments.length === 3) &&
      typeof arguments[0] === 'string' &&
      typeof arguments[1] === 'object' &&
      arguments[1].useMongoClient === true) {
    return conn.openUri(arguments[0], arguments[1], arguments[2]);
  }
  if (rgxReplSet.test(arguments[0]) || checkReplicaSetInUri(arguments[0])) {
    return new MongooseThenable(this, conn.openSet.apply(conn, arguments));
  }

  return new MongooseThenable(this, conn.open.apply(conn, arguments));
};

@tinovyatkin

Então, isso é um bug?

parece um bug, podemos contornar adicionando useMongoClient: true √†s op√ß√Ķes (voc√™ pode ver uma deprecia√ß√£o do driver MongoDB, mas isso n√£o √© lan√ßado)

Adicionar useMongoClient: true faz com que a mensagem desapareça, mas meus documentos simplesmente param de carregar. Não o depurei mais profundamente, mas prefiro ouvir as melhores práticas antes de adaptar meu código.

Meu aplicativo também não funciona com a solução sugerida acima. Ele simplesmente não executa mais o método MyModel.find e não apresenta nenhum erro e nenhum tempo limite.

A razão pela qual a opção "useMongoclient: true" não funciona na maioria dos casos é para essa opção, todo objeto relacionado à conexão do mangusto retorna objeto fictício porque não é possível acessar o mongodb

Eu tentei us√°-lo como

const server = express();
mongoose.connect('mongodb://localhost/advisorDemoTestDB', { useMongoClient: true })
    .then(() => require('./db-init')(server))
    .catch(err => console.error(err));

mas n√£o funciona

Tendo o mesmo problema, mesmo sem conjuntos de réplicas.

Tendo o mesmo problema:

(node:4138) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0,
 use `openUri()` instead, or set the `useMongoClient` option if using `connect()` 
or `createConnection()`

Mesmo...

Depois de adicionar o código abaixo à minha conexão mongo, não posso consultar nada agora.
{useMongoClient: true}.
Todas as sugest√Ķes ser√£o apreciadas!!

+1 mesmo com conjuntos de réplicas, sem fragmentação

+1

+1

+1

+1

+1

+1

+1

A corre√ß√£o mais f√°cil para isso; " npm remove mongoose " ent√£o " npm install [email protected] --save " problema resolvido. A atualiza√ß√£o nem sempre √© a melhor op√ß√£o.

+1

+1

Recebo 2 mensagens:

(node:9260) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0,
use `openUri()` instead, or set the `useMongoClient` option if using `connect()`
or `createConnection()`

Server started on port 3000

Db.prototype.authenticate method will no longer be available in the next major
release 3.x as MongoDB 3.6 will only allow auth against users in the admin db
and will no longer allow multiple credentials on a socket. Please authenticate
using MongoClient.connect with auth credentials.

O primeiro erro apareceu em 4.11.0. O segundo erro também apareceu na versão anterior do Mongoose.

plhosk, o segundo deveria ter sido corrigido no 4.11, mas parece que ainda está lá, para mim também.

+1

+1 infelizmente.

Instalado 4.10.8 sem problemas. Por favor, considere mudar npm install mongoose --save para o padrão 4.10.8 até que 11 esteja estável.

+1

+1

+1

+1

Também encontrei este problema.
__Versão do nó__: v6.10.0

__MongoDB__ emvironment: (executei a versão mais recente do contêiner do docker Mongo)

2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] db version v3.4.5
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] git version: 520b8f3092c48d934f0cd78ab5f40fe594f96863
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] OpenSSL version: OpenSSL 1.0.1t  3 May 2016
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] allocator: tcmalloc
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] modules: none
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] build environment:
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     distmod: debian81
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     distarch: x86_64
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten]     target_arch: x86_64
2017-06-20T08:04:24.509+0000 I CONTROL  [initandlisten] options: { security: { authorization: "enabled" } }

Minha configuração de conexão:

var dbURL = `mongodb://${dbHost}:${dbPort}/${dbName}?authSource=admin`;
var dbAuth = { 
    useMongoClient: false
    user: dbUser,
    pass: dbPass
}
mongoose.connect(dbURL, dbAuth);

Quando eu uso useMongoClient para ser falso. Mongoose mostra os seguintes avisos:

(node:7868) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, or set the `useMongoClient` option if using `connect()` or `createConnection()`
Express server listening on port 3222 in development mode
Db.prototype.authenticate method will no longer be available in the next major release 3.x as MongoDB 3.6 will only allow auth against users in the admin db and will no longer allow multiple credentials on a socket. Please authenticate u
sing MongoClient.connect with auth credentials.

Mas funciona muito bem.

No entanto, quando configurei para true , encontrei este erro:

Unhandled rejection MongoError: not authorized on users to execute command { listIndexes: "sessions", cursor: {} }
    at Function.MongoError.create (<my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\error.js:31:11)
    at queryCallback (<my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\cursor.js:212:36)
    at <my project path>\node_modules\mongoose\node_modules\mongodb-core\lib\connection\pool.js:469:18
    at _combinedTickCallback (internal/process/next_tick.js:67:7)
    at process._tickCallback (internal/process/next_tick.js:98:9)

Eu também tento remover authSource=admin do URL de conexão, mas ainda não funciona

(node:451) DeprecationWarning: open() est√° obsoleto no mangusto >= 4.11.0, use
openUri() ou defina a opção useMongoClient se estiver usando connect() ou createConnection()
O método Db.prototype.authenticate não estará mais disponível na próxima grande re
lease 3.x como MongoDB 3.6 só permitirá autenticação contra usuários no admin db e w
doente n√£o permite mais v√°rias credenciais em um soquete. Por favor, autentique usando M
ongoClient.connect com credenciais de autenticação.

Recebo esse problema com o mongoose vers√£o 4.11.0 e o MongoDB vers√£o 3.4.5

+1

+1

Usar

mongoose.createConnection(URI)

@nandofalcao Ao usar:

  • mongoose.createConnection (URI);
  • mongoose.connect (URI, {useMongoClient: true});

Aparentemente n√£o consigo salvar novos registros.

let userSchema = mongoose.Schema({ name: String });
let User = mongoose.model('User', userSchema);
let joao = new User({ name: 'NewJoao ' });
joao.save((err) => err ? throw err : console.log('User created!'));//nothing happens

Adicionando poliglota hoje à noite e +1 experimentando isso.

// Load Mongoose
const mongoose = require('mongoose');
// import mongoose from 'mongoose' didn't give access to .connect()

// Use native Promises
mongoose.Promise = global.Promise;

// Connect database
export const Mongoose = new Promise((resolve, reject) => {
  const uri = `mongodb://${Singleton.currentConfig.databases.mongodb.host}/${Singleton.currentConfig.databases.mongodb.database}`;

  const options = {
    user: Singleton.currentConfig.databases.mongodb.user,
    pass: Singleton.currentConfig.databases.mongodb.password,
    server: {
      reconnectTries: Singleton.currentConfig.databases.mongodb.reconnectTries,
      reconnectInterval: Singleton.currentConfig.databases.mongodb.reconnectInterval,
      socketOptions: {
        keepAlive: Singleton.currentConfig.databases.mongodb.keepAlive,
        connectTimeoutMS: Singleton.currentConfig.databases.mongodb.connectTimeoutMS
      },
    },
  };

  // Initiate document store
  mongoose.connect(uri, options)

  // Check for anomalies
  .then((connected) => {
    if (mongoose.connection.readyState !== 1) {
      reject(connected);
    }
    resolve(connected);
  })

  // Complete meltdown
  .catch((error) => {
    console.log(`MongoDB Connection Error: ${error}`);
    process.exit(0);
  });
});

+1

e recebo a segunda mensagem:

[2017-06-27 16:14:23.702] [INFO] :: - Servidor iniciado na porta 2000

(node:1193) DeprecationWarning: open() está obsoleto no mangusto >= 4.11.0, use openUri() ou defina a opção useMongoClient se estiver usando connect() ou createConnection()

O m√©todo Db.prototype.authenticate n√£o estar√° mais dispon√≠vel na pr√≥xima vers√£o principal 3.x, pois o MongoDB 3.6 s√≥ permitir√° autentica√ß√£o contra usu√°rios no banco de dados admin e n√£o permitir√° mais credenciais m√ļltiplas em um soquete. Por favor, autentique usando MongoClient.connect com credenciais de autentica√ß√£o.

+1

+1

+1

+1

+1

Algu√©m pode bloquear isso para evitar +1s in√ļteis?

Como cortesia aos assinantes desta conversa, pare de responder com +1 porque gera notifica√ß√Ķes in√ļteis por e-mail. Este n√£o √© um f√≥rum. Se voc√™ quiser seguir este t√≥pico, use o bot√£o de inscri√ß√£o na barra lateral direita. Voc√™ tamb√©m pode fazer algumas pesquisas e contribuir com solu√ß√Ķes.

Mudei a vers√£o de volta para 4.10.8 e est√° funcionando bem agora.

Parece que o ValYouW tem uma possível correção para o problema de carregamento de documentos aqui: #5404

mongoose.connection.openUri('mongodb://127.0.0.1/camp_v12')

alguem ja tentou isso? meu aviso obsoleto desapareceu quando eu uso isso, era da documentação

http://mongoosejs.com/docs/connections.html

@crisamdegracia que assume que você já tem uma conexão

// Or, if you already have a connection
connection.openUri('mongodb://localhost/myapp', { /* options */ });

o que não fazemos (pelo menos eu, pois costumava me conectar ao mongodb usando o método mongoose.connect)

mongoose.connect(config.get('mongo'), {
  useMongoClient: true,
});

N√£o encontrei nenhum documento... O que h√° de errado?

+1

Então, depois de analisar o problema vinculado de @phased90 que explica que você pode se conectar assim:

const mongoose = require('mongoose');

mongoose.Promise = global.Promise;
mongoose.connect('mongodb://localhost/test', {useMongoClient: true})
    .then(() => {
        let Cat = mongoose.model('Cat', {name: String});
        let kitty = new Cat({name: 'Zildjian'});

        kitty.save(err => {
            if (err) {
                console.log(err);
            } else {
                console.log('meow');
            }
        });
    })
    .catch(err => console.error(err));

Eu fiz um mergulho r√°pido no c√≥digo e parece que 4.11 retorna MongooseThenable exceto quando a op√ß√£o {useMongoClient: true} √© fornecida. Nessa inst√Ęncia ele chama Connection.prototype.openUri que retorna uma nova inst√Ęncia de Promise.ES6 . Essa chamada Connection.prototype.openUri deve ser envolvida em um MongooseThenable ?

Minhas desculpas pela pergunta, esta √© minha primeira vez olhando para esta base de c√≥digo, ent√£o estou um pouco inseguro. Mas ficaria feliz em tentar ajudar a fornecer uma corre√ß√£o se puder obter alguns esclarecimentos sobre se Moongoose.prototype.connect deve sempre retornar uma inst√Ęncia de MongooseThenable .

Esteja ciente de que usar {useMongoClient: true} far√° com que Connection.prototype.openUri seja chamado, o que n√£o aciona comandos em buffer que foram criados __antes__ conectando-se a um banco de dados devido a #5404

+1

Desculpe, as coisas est√£o loucas, vou dar uma olhada daqui a pouco.

@varunjayaraman não precisa se desculpar amigo. As pessoas podem esperar ou tentar consertar por conta própria.

+1

Ent√£o, em rela√ß√£o ao problema real que foi aberto, o aviso de deprecia√ß√£o n√£o √© um bug, √© apenas um aviso: o mangusto vai depreciar sua l√≥gica de conex√£o atual, ent√£o voc√™ deve passar o par√Ęmetro useMongoClient . Isso pode ser encontrado na documenta√ß√£o

Em uma nota separada, parece que essa foi uma mudança para trás, espero que isso possa ser corrigido na próxima versão menor (ou talvez não seja, estou dormindo muito pouco aqui):

isso normalmente funcionaria (exceto pela parte useMongoClient , que é nova):

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5399`


exec()
  .then(() => {
    console.log('successfully ran program');
    process.exit(0);
  })
  .catch(error => {
    console.error(`Error: ${ error }\n${ error.stack }`);
  });


function exec() {
  return co(function*() {
    const db = mongoose.createConnection(`mongodb://localhost:27017/${ GITHUB_ISSUE }`, { useMongoClient: true })
    const schema = new mongoose.Schema({
      name: String
    });


    const Model = db.model('Model', schema);
  });
}

Isso parece gerar um erro para mim porque db.model não é mais uma função.

Ao usar mongoose.model , funciona:

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5399`


exec()
  .then(() => {
    console.log('successfully ran program');
    process.exit(0);
  })
  .catch(error => {
    console.error(`Error: ${error}\n${error.stack}`);
  });


function exec() {
  return co(function* () {
    const db = mongoose.connect(`mongodb://localhost:27017/${GITHUB_ISSUE}`, { useMongoClient: true })

    return db
      .then(() => {
        const schema = new mongoose.Schema({
          name: String
        });


        const Model = mongoose.model('Model', schema);

        return Model.create({ name: 'test' });
      })
      .then(doc => console.log(doc));

  });
}

@varunjayaraman Acabei de atualizar o Mongoose e usar useMongoClient: true como você sugere, mas tenho um problema.
Ele n√£o suporta, de acordo com a documenta√ß√£o oficial do Mongoose , as op√ß√Ķes user e pass :

the options [user] is not supported
the options [pass] is not supported

E, sim, falhou ao autenticar. :-1:

Vou tentar adicionar usu√°rio e passar a string de conex√£o.
Funciona quando adiciono nome de usu√°rio e senha √† string de conex√£o. Talvez voc√™ devesse atualizar a documenta√ß√£o. ūüėź

@itpcc tente usar a versão 4.10.8 é a melhor solução no momento.

npm remove mongoose
npm install [email protected] --save

Crédito: @Chenz62

@CQBinh Obrigado pelo seu conselho. J√° li esses coment√°rios sobre isso.
No entanto, não acho que usar a versão mais antiga seja a melhor solução por enquanto. E pode resolver inserindo na string de conexão.
Só me sinto confuso porque foi mencionado no documento, mas não funciona. :/
BTW, eu reporto como um novo problema aqui

@varunjayaraman se db.model n√£o estiver mais presente, como algu√©m lidaria com v√°rias conex√Ķes diferentes de mangusto com modelos diferentes?

por exemplo, model1 e model2 anexados a mongooseConnection1 e model3 e model4 anexados a mongooseConnection2.

Anteriormente, isso era feito chamando mongoose.createConnection para cada uma das conex√Ķes e anexando os modelos a cada um desses valores de retorno.

Edit: Ou ainda est√° funcionando neste caso:

const conn = mongoose.createConnection(...);
const Model = conn.model('ModelName', schema);

+1

@boyce-ywr S√ČRIO, outro +1??? O que h√° de errado com voc√™s pessoas??
Poste coment√°rios construtivos, n√£o coisas assim.

Em rela√ß√£o ao mangusto, n√£o est√° claro para mim se o m√©todo mongoose.connect() ser√° substitu√≠do em vers√Ķes futuras ou n√£o. Algu√©m poderia explicar por favor?

@simonemazzoni Você está certo, eles estão nos enviando SPAM.

Se voc√™ quiser ser inclu√≠do nas notifica√ß√Ķes deste t√≥pico, tudo que voc√™ precisa fazer √© se inscrever (h√° um bot√£o no topo do t√≥pico),

Tudo o que você faz quando marca com +1 é enviar a todos aqui um e- mail dizendo

Ola, eu estou aqui!

Não nos importamos , estamos aguardando comentários construtivos e uma solução .

Além disso, por que todos vocês não excluem suas postagens com +1 desta lista, elas são uma monstruosidade e uma dor na parte traseira ter que rolar apenas para chegar aos comentários reais.

Como algumas pessoas disseram antes, a √ļnica "solu√ß√£o" √© voltar para [email protected]_ ...
Pelo menos por enquanto!

Parece um bug, voltei para [email protected] para resolver o problema

Use mongoose.createConnection(...) em vez de mongoose.connect(...)

Aqui est√° um exemplo de trabalho completo do uso do [email protected] com base na recomenda√ß√£o de @diegoazh

const mongoose = require('mongoose')
mongoose.Promise = require('bluebird')  // optional, use this to get rid of 
                                        // the mpromise DeprecationWarning
const conn = mongoose.createConnection('mongodb://localhost/testDB')
const Schema = mongoose.Schema

const UserSchema = new Schema({
    username: String,
    email: String
})

const User = conn.model('User', UserSchema)
module.exports = User

@midnightcodr Ent√£o, apenas descartamos o connect e usamos createConnection?

@bertolo1988 assim como o ppl sugeriu nesta quest√£o, atualmente existem duas solu√ß√Ķes alternativas

  1. Voltar para 4.10.8
  2. Use o novo padr√£o se quiser ficar com a nova vers√£o
const conn = mongoose.createConnection(...)
const Model = conn.model(...)

Eu pessoalmente prefiro a segunda solução.

Obrigado!!!
resolvido por createConnection e use essa conex√£o para fazer modelo (em vez de mangusto)

let mongoose = require('mongoose');

mongoose.Promise = global.Promise;

module.exports = mongoose;
const mongoose = require('./set-mongoose');
module.exports = mongoose.createConnection('mongodb://localhost/advisorDemoTestDB');

O novo padrão de conexão requer algumas mudanças de código, e dependendo do tamanho do seu projeto isso pode significar muito tempo e talvez até mudanças de arquitetura (dado que criar um modelo requer uma conexão).

Teria sido ótimo se o modelo de conexão antigo pudesse envolver o novo modelo de conexão.

Tem muito post, ent√£o vou tentar resumir:

  1. O aviso é um aviso obsoleto, ou seja, não há pressa. Se não mudarmos nada, ainda vai funcionar como sempre funcionou, tudo parece estar bem

  2. De acordo com o aviso, connect() será/foi modificado e passar useMongoClient será uma obrigação. Mas aqui está o possível bug/problema

  • connect('myurl', {useMongoClient: true}) => o documento para de carregar e n√£o √© poss√≠vel escrever no db

  • connect('myurl', {useMongoClient: false}) => parece funcionar bem, mas o aviso ainda √© exibido

Portanto, o objetivo deste problema é corrigir o uso de useMongoClient no caso da chamada do método connect.

Concordar?

Ainda assim, enquanto um aviso de deprecia√ß√£o √© de fato "apenas" um aviso, ter isso exibido me faz pensar quando ele realmente ser√° removido. Se o mangusto estiver seguindo semver, ele ainda deve estar no branch 4.x. Portanto, ele ainda deve funcionar com compatibilidade com vers√Ķes anteriores at√© que o 5.x seja lan√ßado.

Em relação à mudança em si, é meio chato que eu não consegui encontrar rapidamente nada sobre essa mudança, exceto a mencionada no changelog. E mesmo quando você muda, as coisas ainda quebram e de acordo com várias pessoas aqui, é por causa da chamada .model() .

Al√©m disso, mesmo os documentos ainda mostram mongoose.connect() e mongoose.model() , o que torna esse assunto ainda mais confuso. A altera√ß√£o mongoose.connect() √© mencionada apenas em Pools de conex√Ķes e n√£o em outras partes desta p√°gina . Portanto, a pergunta permanece, essa altera√ß√£o √© um bug ou intencional?

N√£o sei onde isso vai dar, mas passei a maior parte deste fim de semana tentando fazer uma conex√£o com o Atlas do MongoDB. O driver mongodb nativo foi instantaneamente instalado e executando o material CRUD.

No entanto, tentar manter o mangusto √© um pesadelo total. Se eu usar createConnection com 4.11, as conex√Ķes do cluster ser√£o eliminadas:

MongoError: connection 4 to cluster0-myshard.mongodb.net:27017 closed

Alternativamente, eu poderia definir

useMongoClient: true

mas ent√£o eu fico indefinido no connection.model

<info> atlas-api-test.js:65 (Test.testVendors) conn.model undefined

@Archomeda n√£o planeja remover o comportamento de conex√£o herdado em 4.xeo 5.x est√° bloqueado para obter a nova l√≥gica de conex√£o para um estado est√°vel. Existem documentos nos documentos de conex√£o que o 4.11.1 melhorar√° e um link para isso deve ser √ļtil. Re: a chamada model() , se voc√™ especificar useMongoClient: true , createConnection() n√£o retornar√° uma conex√£o, mas sim uma promessa que resolve uma conex√£o que voc√™ precisa .then() em. A justificativa √© descrita aqui: https://github.com/Automattic/mongoose/issues/5404#issuecomment -312522539 Sinta-se √† vontade para expressar quaisquer preocupa√ß√Ķes sobre isso na quest√£o #5404 .

@mkastner parece que você está usando createConnection() . Com useMongoClient: true , createConnection() retorna uma promessa que resolve uma conexão. Por favor, use await mongoose.createConnection() ou mongoose.createConnection().then()

@peterpeterparker #5404 apontou um problema com a nova lógica de conexão que será corrigida na 4.11.1, a ser lançada nas próximas 24 horas.

@cosminn777 quais problemas de arquitetura você está tendo? Por favor, abra uma questão separada para discuti-los. O plano de longo prazo é que no 5.x não suportaremos Node < 4, então todos que usam mangusto terão acesso nativo a geradores e/ou async/await, então essa mudança seria tão fácil quanto adicionar um yield ou await declaração.

@alanpurple o problema ao qual você está se referindo é o mesmo mencionado #5404 e será corrigido com 4.11.1.

@itpcc Abri um problema separado para rastrear # 5432. Por enquanto, coloque seu nome de usu√°rio/senha no URI: var dbURL = mongodb://${dbUser}:${dbPass}@${dbHost}:${dbPort}/${dbName}?authSource= administrador`.

Em geral, agradecemos a todos pela paciência em tentar esse novo comportamento. Percebo que a mudança causará alguma dor de cabeça, e é por isso que escondemos esse comportamento atrás de um sinalizador, mas algumas mudanças que chegam ao MongoDB 3.6 exigem uma revisão completa da lógica de conexão interna do mongoose. Espero que a nova lógica de conexão leve a menos bugs de conexão específicos do mangusto a longo prazo, mas tenha paciência conosco enquanto corrigimos o comportamento e a documentação. Seu feedback é muito apreciado.

Enquanto você estiver no 4.x, sua lógica de conexão atual funcionará, ela apenas imprimirá um aviso. Enquanto isso, sinta-se à vontade para relatar quaisquer problemas que você tenha em um problema separado do github.

Acabei de adotar o novo método e funciona muito bem. Obrigado a todos!

@vkarpov15 obrigado pelos esclarecimentos.

Como um FYI, o mesmo aviso de depreciação é lançado com openSet também (estou usando um conjunto de réplicas).

Então, para resumir, é seguro ignorar este aviso por enquanto, pois ele se refere apenas ao funcionamento interno do Mongoose, e poderíamos tentar usar useMongoClient mas ainda não precisamos.

Qu√£o est√°vel voc√™ considera? √Č seguro usar? Eu n√£o gostaria de gastar 2 horas refatorando todos os nossos modelos e l√≥gica de conex√£o para descobrir que ainda √© inutiliz√°vel em produ√ß√£o.

√Č poss√≠vel remover o aviso de descontinua√ß√£o at√© que o uso do sinalizador seja est√°vel e a maneira recomendada de se conectar daqui para frente? Ou esse ponto j√° foi alcan√ßado?

@vkarpov15

Mas estou usando async em createConnection. Configurei dois testes no servidor db. O primeiro é o teste canário mongo-js nativo para garantir que o URL funcione e que eu possa escrever e ler:

tape('test connection via mongo native', async function testMongoConnection(t) {

  try {

    t.plan(1);
    let db = await MongoClient.connect(dbURL);
    await db.collection('users').insert({name: 'username'});
    let result = await db.collection('users').find({});
    let docs = await result.toArray();
    log.info('result', await result.toArray());
    t.equal(1, docs.length);
    db.collection('users').remove({});

    await db.close();

  } catch (err) {
  console.error(err)
  }
});

Resultado:

2017-07-04T09:00:34+0200 <info> atlas-api-test.js:28 (Test.testMongoConnection) result [ { _id: 595b3d1146734207bad88f9d, name: 'username' } ]
‚úĒ should be equal

Sucedido pelo teste do mangusto usando o mongoose createConnection com await:

tape('test connection via mongoose', async function testMongooseConnection(t) {

  try {
      let conn = await mongoose.createConnection(dbURL, {
        useMongoClient: true,
        /*
        // tried these settings too
        user: 'myUserName',
        pass: 'myPassword',
        connectTimeoutMS: 30000,
        rs_name: 'myReplSetName',
        ssl: true,
        auto_reconnect: true,
        */
      });

      let UserSchema = new mongoose.Schema({
        name: String,
      });

      let User = mongoose.model('User', UserSchema);
      let newUser = new User({name: 'username'});
      let createdUser = await newUser.save();

      // just ending test without validating any results
      t.end();

  } catch (err) {
    log.error(err);
  }

});

E d√° o seguinte erro:

/mypath/node_modules/mongodb/lib/replset.js:390 process.nextTick(function() { throw err; })
                                    ^
MongoError: connection 8 to cluster0-shard-00-02-c4nst.domain.com:27017 closed at Function.MongoError.create (/mypath/node_modules/mongodb-core/lib/error.js:29:11)
at Socket.<anonymous> (/mypath/node_modules/mongodb-core/lib/connection/connection.js:202:22)
at Object.onceWrapper (events.js:316:30)
at emitOne (events.js:115:13)
at Socket.emit (events.js:210:7)
at TCP._handle.close [as _onclose] (net.js:549:12)`

Eu posso estar terrivelmente errado aqui, mas para mim não parece um problema de assíncrona/promessa;

Estou usando o Mongo Atlas. Quando eu uso {useMongoClient: true}, meu aplicativo se conectar√° ao banco de dados com sucesso, mas o banco de dados n√£o responde ao aplicativo, certo?

Meu código:
mongoose.connect(config.dbhost, {useMongoClient: true}, function(err){ if(err){ console.log(err); } else { console.log('connected to the database successfuly.'); } });

Apenas um aviso para todos, porque eu não vi isso mencionado aqui: 4.11.1 foi lançado e depois de uma rápida olhada parece que o problema de buffer ao usar useMongoClient=true foi corrigido. Vou testar mais amanhã. Alguém mais?

Qual é a solução definitiva?

Isso funcionou para mim (v.4.11.1):

banco de dados.js

mongoose.connect(databaseUri, { useMongoClient: true })
      .then(() => console.log(`Database connected at ${databaseUri}`))
      .catch(err => console.log(`Database connection error: ${err.message}`));

user.model.js

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const userSchema = new Schema({ ... });
const User = mongoose.connection.model('User', userSchema);

ATUALIZAR

Fazer referência à conexão pode não ser necessário ao inicializar seu modelo (obrigado, @kyrylkov @peterpeterparker):

user.model.js

const User = mongoose.model('User', userSchema);

Alguém poderia explicar brevemente o que exatamente é { useMongoClient: true } ou o que esse sinalizador faz?

Estou um pouco perdido, qual a vantagem de usar?

Quer dizer, como eu disse antes, eu poderia viver com o aviso, portanto, n√£o sinto pressa em adicionar este par√Ęmetro.
N√£o encontrei muito no documento, obrigado antecipadamente por esclarecer isso.

@Blackbaud-SteveBrush N√£o funciona. Estou usando o Mongo Atlas. Por que n√£o funciona?

@Thinkdiff

Não funciona como? Funciona para nós no mLab e no MongoDB Atlas com o habitual:

const User = mongoose.model('User', userSchema);

ao invés de:

const User = mongoose.connection.model('User', userSchema);

Se eu tentar habilitar a opção useMongoClient com poucos hosts definidos no URI, ele trava e lança erro:
MongoError: no mongos proxy available at Timeout._onTimeout (/home/ubuntu/code/pss/node_modules/mongoose/node_modules/mongodb-core/lib/topologies/mongos.js:636:28) at ontimeout (timers.js:386:14) at tryOnTimeout (timers.js:250:5) at Timer.listOnTimeout (timers.js:214:5) name: 'MongoError', message: 'no mongos proxy available'
uri: mongodb://10.0.1.49 ,10.0.2.158,10.0.3.84/pss
op√ß√Ķes: { useMongoClient: true, autoReconnect: true, keepAlive: 300000, connectTimeoutMS: 30000 }

Para quem estiver interessado, aqui est√£o os documentos do Mongoose no par√Ęmetro useMongoClient : http://mongoosejs.com/docs/connections.html#use -mongo-client

"A lógica de conexão padrão do Mongoose está obsoleta a partir da versão 4.11.0... Esta descontinuação ocorre porque o driver do MongoDB preteriu uma API que é crítica para a lógica de conexão do mongoose para oferecer suporte ao MongoDB 3.6, consulte este problema do github para obter mais detalhes." Aqui está o problema do GitHub: https://github.com/Automattic/mongoose/issues/5304

@Blackbaud-SteveBrush obrigado por apontar que nosso. Ent√£o, se eu entendi corretamente

useMongoClient = true => ativar nova lógica de conexão que também funcionará com o Mongo 3.6
useMongoClient = false => valor padrão. lógica de conexão antiga < 4.11.0. aquele que está obsoleto.

certo?

@Blackbaud-SteveBrush sobre seu código, no meu caso eu não uso

const User = mongoose.connection.model('User', userSchema);

mas

const User = mongoose.model('User', userSchema);

e ainda foi bem sucedido. THX

Mangusto funciona para mim 4.10.8 :|

Eu descobri que isso é provavelmente um bug com mangusto

problema desapareceu depois de reverter a vers√£o mangusto

npm desinstalar - salvar mangusto
npm install -save [email protected]

Eu ignorei completamente este aviso e tudo está funcionando como esperado. Talvez, esta seja a solução para agora. Só ignore.

reverter para 4.10.8 fez minha conex√£o funcionar novamente, mas ainda recebo o erro

Db.prototype.authenticate method will no longe against users in the admin db and will no long connect with auth credentials.

@peterpeterparker correto. O c√≥digo de autentica√ß√£o atual do Mongoose n√£o funcionar√° no mongodb 3.6 com base no meu entendimento, ent√£o useMongoClient nos representa tentando nos antecipar a esse problema, mantendo a compatibilidade com vers√Ķes anteriores. At√© onde eu sei, ainda n√£o h√° data de lan√ßamento agendada para o mongodb 3.6, ent√£o a mudan√ßa n√£o √© urgente.

@adamreisnz tivemos alguns bugs, mas realmente a nova lógica de conexão é um wrapper muito fino em torno do uso da função MongoClient.connect() do driver nativo, que tem sido o método preferido para se conectar ao mongodb há alguns anos. Uma vez que sua conexão é estabelecida, é a mesma lógica do driver mongodb que mantém a conexão. useMongoClient deve afetar apenas a conexão inicial.

@vkarpov15 muito obrigado pela explicação e claro pelo trabalho, muito obrigado!

@vkarpov15 obrigado, vou tentar e mudar para useMongoClient e ver onde isso nos leva.

const mangusto = require("mangusto");
const db = " mongodb://localhost/testaroo ";

mangusto.conex√£o.openUri(db);
mongoose.connection.once("abrir", function() {
console.log("conex√£o estabelecida");
}).on("erro", function (erro) {
console.log(erro);
})

--eu uso isso e nenhum erro encontrado

var mongoose = require('mongoose');
mongoose.Promise = global.Promise;

var mongoDB = mongoose.connect('mongodb://your_database', {
    useMongoClient: true
});

mongoDB
    .then(function (db) {
        console.log('mongodb has been connected');
    })
    .catch(function (err) {
        console.log('error while trying to connect with mongodb');
    });

module.exports = mongoDB;

Eu uso isso e nenhum erro encontrado

@vitorbarros Funcionou para mim. Obrigado!

Funciona para mim:
http://mongoosejs.com/docs/connections.html#use-mongo-client

Fiz este teste r√°pido e funcionou:

// index.js
const mongoose = require('mongoose')
mongoose.Promise = global.Promise;
const db = mongoose.createConnection(`mongodb://localhost/test`)

db.on('error', err => console.log(err))
db.once('open', () => {
  console.log(`Connected to Mongo at: ${new Date()}`)
  db.close(() => {
    console.log(`Disconnected from Mongo at: ${new Date()}`)
  })
})

ent√£o node index.js me d√°:

Connected to Mongo at: Thu Jul 13 2017 22:54:50 GMT+0000 (UTC)
Disconnected from Mongo at: Thu Jul 13 2017 22:54:50 GMT+0000 (UTC)

Obrigado a todos!

@vitorbarros sua solução funciona! obrigado.

Posso confirmar que com 4.11.3 substituir a l√≥gica de conex√£o pelo que @vitorbarros sugeriu remove os avisos e parece funcionar bem ūüĎć

Não há necessidade de refatorar as referências do modelo, conforme sugerido anteriormente neste tópico.

A solução do @vitorbarros é de fato a forma recomendada de acordo com a documentação "The useMongoClient Option" .

No entanto, observe que mongoose.Promise = global.Promise; _não_ promete o driver Mongo subjacente . De acordo com a documentação "Promises for the MongoDB Driver" , a propriedade promiseLibrary também deve ser definida no objeto options do método connect .

Por exemplo:

var mongoDB = mongoose.connect('mongodb://your_database', {
    useMongoClient: true,
    promiseLibrary: global.Promise
});

global.Promise usaria o mecanismo de promessa nativo. Naturalmente, também é possível usar o Bluebird ou qualquer outro motor, por exemplo promiseLibrary: require('bluebird')

A solução @vitorbarros funciona para mim. E também precisamos usar o promiseLibrary como @boaz-amit disse.
Mas qual é a melhor maneira de usar dados de autenticação?
Em URL

mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]

ou melhor definir usu√°rio e senha nas op√ß√Ķes? N√£o consigo encontrar o lugar certo por enquanto.

Esta é apenas uma maneira de autenticar?

E aqui está a minha solução. Isso também funciona mesmo se a primeira conexão falhar.

let firstConnectTimeout = null;
const mongoConnect = () => {
    const mongoDB = mongoose.connect('mongodb://localhost/test', {
        useMongoClient: true
    });

    mongoDB
        .then((db) => {
            clearTimeout(firstConnectTimeout);
        })
        .catch((err) => {
            firstConnectTimeout = setTimeout(mongoConnect, 5000);
        });
};

mongoConnect();

Tem que estar na url, as op√ß√Ķes user/pass n√£o funcionam mais com
useMongoClient true eu encontrei.

Em segunda-feira, 17 de julho de 2017, 20:28 Andrey Prisniak [email protected]
escrevi:

@vitorbarros https://github.com/vitorbarros solução funciona para mim. E
também precisamos usar a promiseLibrary como @boaz-amit
https://github.com/boaz-amit disse.
Mas qual é a melhor maneira de usar dados de autenticação? Em URL
mongodb://[ nome de usu√°rio:senha@
]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
ou melhor definir usu√°rio e senha nas op√ß√Ķes? N√£o consigo encontrar o lugar certo para
agora.

‚ÄĒ
Você está recebendo isso porque foi mencionado.
Responda a este e-mail diretamente, visualize-o no GitHub
https://github.com/Automattic/mongoose/issues/5399#issuecomment-315694642 ,
ou silenciar o thread
https://github.com/notifications/unsubscribe-auth/AAd8Qup1YY4lhUhQccv2kLKtraARxvP0ks5sOxs_gaJpZM4OEnIt
.

@adamreisnz @aprisniak trabalhando nisso, veja #5419. Enquanto isso, coloque o nome de usu√°rio e a senha em seu URI: mongodb://user:pass<strong i="7">@hostname</strong>:port/db

Além disso, escrevi um post no blog sobre essa opção e por que ela é necessária: http://thecodebarbarian.com/mongoose-4.11-use-mongo-client.html

@vkarpov15 Estou usando user:pass no URI, mas ainda tenho o aviso.

Para quem usa mangusto com gridfs-stream:

const mongooseConnect = mongoose.connect(
    process.env.MONGODB_URI || process.env.MONGOLAB_URI,
    {
        useMongoClient: true
    }
)

let gfs
mongooseConnect.then(conn => {
    gfs = Grid(conn.db)
    /** Setting up GFS storage here */
})

Voc√™s podem adicionar a op√ß√£o de conex√£o ausente "useMongoClient" nas digita√ß√Ķes datilografadas" e adicionar digita√ß√Ķes de volta a este projeto em vez de adicionar pacotes de digita√ß√£o.

N√£o tenho certeza se devo fazer algo com este aviso ou n√£o? Ser√° corrigido, certo?

Acabei de adicionar o useMongoClient nas tipagens para que funcione. @iamdubx

@FinalDes como? Adicionei mongoose.connect(process.env.DATABASE, { useMongoClient: true }) mas ainda recebi a mensagem. E estou usando user:pass no URI

A melhor maneira de se livrar desse problema é usar estes dois comandos:
npm desinstalar - salvar mangusto
npm install -save [email protected]

NB: [email protected] √© a vers√£o est√°vel.

Como vocês estão lidando com a criação de seu Schema e Model, bem como acessá-los?

J√° tentei todas as corre√ß√Ķes do t√≥pico. Com o aviso, tudo funciona bem. Uma vez que eu tento useMongoClient: true ou mongoose.createConnection ele se livra do aviso e eu posso me conectar ao banco de dados, por√©m qualquer c√≥digo que tente acessar o modelo n√£o √© acionado. N√£o h√° erros, o c√≥digo simplesmente nunca √© executado.

@iamdubx
apenas faltando as tipagens, ent√£o quando executado com "noImplicitAny": true , n√£o ter√° erro

import mangusto = require("mangusto");
import dotenv = require("dotenv");
dotenv.config();
mangusto.Promessa = global.Promessa;
const MONGO_URI=`mongodb://${process.env.MONGODB_HOST}:${process.env.MONGODB_PORT}/${process.env.MONGODB_DB}`;
mongoose.connect(MONGO_URI, {
useMongoClient: true,
});

@FinalDes a que voc√™ est√° se referindo? Quais digita√ß√Ķes est√£o faltando? Eu tenho o mesmo c√≥digo acima e tenho um erro.

Eu encontrei o mesmo problema com @Snow-Okami

  1. const mongoDB = mongoose.connect(config.database, { useMongoClient: true });
    Isso elimina o aviso e se conecta ao banco de dados. No entanto, tudo que tenta acessar o modelo falha (get/post). Nenhum erro retorna.
  2. const mongoDB = mongoose.connect(config.database, function(){ useMongoClient: true });
    E isso dá esses dois avisos, mas tudo além disso funciona bem.

Por favor, pelo menos forne√ßa compatibilidade com vers√Ķes anteriores, nosso servidor de compila√ß√£o de produ√ß√£o falha.
a atualização de recursos é boa, mas não altere a assinatura ou a chamada do método.

@Nikunjksanghavi √Č apenas um aviso, nada deve estar falhando.

@iamdubx que tipo de erro?

Erro de descontinuação @FinalDes , do que mais estamos falando neste tópico?

Isso funcionou para mim: (v.4.11.4)

const MONGO_URI = process.env.MONGO_URI
const mongoose = require('mongoose');

// Use your own promis library
mongoose.Promise = require('bluebird');

// connect to mongo, use Mongo Client
mongoose.connect(MONGO_URI, {useMongoClient: true})
  .then(({db: {databaseName}}) => console.log(`Connected to ${databaseName}`))
  .catch(err => console.error(err));

const poemSchema = mongoose.Schema({
    name: String,
    text: String
});

const Poem = mongoose.model('Poem', poemSchema);

const insertPoem = poem =>
  (new Poem(poem)).save( (err, newPoem) => 
    console.log(err || newPoem));

insertPoem({name: 'poemName', text: 'this is a poem'})

// conex√£o de banco de dados
var mangusto = require('mangusto');
mangusto.Promessa = global.Promessa;
mongoose.connect('mongodb://localhost/login_register', {
useMongoClient: true
})
.then(() => console.log('conex√£o bem-sucedida'))
.catch((err) => console.error(err));
// fim da conex√£o do banco de dados

Isso não funciona para mim. Eu ainda tenho aviso do console. E nenhuma explicação clara fornecer.

Mangusto é horrível. Também pior site de documentação que vi em bibliotecas tão populares. Que pena!

Agora estou pensando em mudar para o RethinkDB. Linux Foundation - isso é sério.
Também Postgre incrível.

Mongo - muito, muito vergonha.

@iamdubx você tentou minha solução acima? Você poderia colar o aviso sobre isso? Talvez eu possa ajudar :)

@iamdubx pode postar sua mensagem de aviso?

@FinalDes @shams-ali que postei antes, é o mesmo erro de depreciação que o tópico. De quem trata este tópico!

(node:3304) DeprecationWarning: `open()` is deprecated in mongoose >= 4.11.0, use `openUri()` instead, or set the `useMongoClient` option if using `connect()` or `createConnection()`. See http://mongoosejs.com/docs/connections.html#use-mongo-client
Server listening on port: 7777
Db.prototype.authenticate method will no longer be available in the next major release 3.x as MongoDB 3.6 will only allow auth against users in the admin db and will no longer allow multiple credentials on a socket. Please authenticate using MongoClient.connect with auth credentials.

@iamdubx interessante, esse é o mesmo aviso que tive e a solução acima que postei parecia corrigi-lo para mim. Você poderia colar seu código atualizado que não está funcionando?

Isto é o que funcionou para mim:

// ES6 promises
mongoose.Promise = Promise;

// mongodb connection
mongoose.connect("mongodb://localhost:27017/sandbox", {
  useMongoClient: true,
  promiseLibrary: global.Promise
});

var db = mongoose.connection;

// mongodb error
db.on('error', console.error.bind(console, 'connection error:'));

// mongodb connection open
db.once('open', () => {
  console.log(`Connected to Mongo at: ${new Date()}`)
});

@afoke est√° funcionando obrigado

@FinalDes De nada amigo.

Este √© meu novo fluxo de trabalho, tentando estar em conformidade com os avisos e reprova√ß√Ķes:

// db.js
const model = require('./model');
const mongoose = require('mongoose');
mongoose.Promise = global.Promise;


async function db(uri) {
  const con = await mongoose
    .createConnection(uri, {
      useMongoClient: true,
    });

  const {User} = model(con);

  // do something with User
  ...

  // the interface for the server
  return {
    create: params => User.create(params),
    ...
  };
}


module.exports = db;

E agora o módulo models retorna uma função de conexão

// model.js
const {Schema} = require('mongoose');


const UserSchema = new Schema({
  name: String,
  age: Number,
});

// Other Schemas
...

module.exports = con => ({
  User: con.model('User', UserSchema),
  ...
});

Alguma orientação oficial sobre o assunto?

@iamdubx Parece que você não entende a diferença entre um aviso e um erro .

O aviso em questão não quebra nada, mas avisa o usuário de algo que será removido na próxima versão principal.

Mangusto é horrível.

Portanto, lembre-se de que voc√™ est√° tendo essa rea√ß√£o aos desenvolvedores avisando com anteced√™ncia antes de remover um recurso. Eu tamb√©m recomendo que voc√™ se lembre de que est√° usando isso gratuitamente, ent√£o talvez d√™ aos desenvolvedores o benef√≠cio da d√ļvida antes de fazer birra

@chrisdothtml

O aviso em questão não quebra nada, mas avisa o usuário de algo que será removido na próxima versão principal.

Ele polui os testes e o console, o que é levemente irritante.

Mangusto é horrível. Também pior site de documentação que vi em bibliotecas tão populares. Que pena!

Ele está sendo indelicado, o que também é um pouco irritante, mas ele faz um ponto muito válido em relação à documentação do Mongoose. Não é a pior documentação de todos os tempos, mas poderia realmente ser melhorada.

O fato de que o mongoose encaminha a API do cliente mongo. que funciona de uma maneira muito diferente, torna o uso e a documentação do Mongoose confusos.

Uma possível solução para isso seria:

  • pare de fazer isso
  • remova a documenta√ß√£o dos m√©todos do cliente Mongo
  • fornecer uma maneira de compartilhar a conex√£o entre o cliente oficial e o Mongoose

Eu tamb√©m sugeriria melhorar a pesquisa de documentos dividindo-a em v√°rias p√°ginas e dando mais informa√ß√Ķes aos novos usu√°rios sobre o que o Mongoose realmente est√° fazendo para obter alguns dos resultados.

Eu tive esse erro, mas ele desapareceu depois que adicionei a opção {useMongoClient: true}.
Eu uso o Debian 9, vers√£o de teste, com MongoDb ver. 3.2.11 e mangusto ver. 4.10.4.
Eu tenho a mensagem 'Connected to MongoDB' (veja o código no Typescript abaixo), tudo funciona perfeitamente.

(< qualquer > mangusto).Promise = global.Promise;
mongoose.connect(process.env.MONGODB_URI, {useMongoClient: true});
const db = mangusto.conex√£o;
db.on('erro', console.error.bind(console, 'erro de conex√£o:'));
db.once('abrir', () => {
console.log('Conectado ao MongoDB');
setRoutes(aplicativo);
app.get('/*', function(req, res) {
res.sendFile(path.join(__dirname, '../public/index.html'));
});
app.listen(app.get('porta'), () => {
console.log('MyApp escutando na porta ' + app.get('port'));
});
});

Basta desinstalar a vers√£o atual do mangusto que voc√™ possui e instalar a vers√£o inferior npm install [email protected] --save . N√£o h√° necessidade de fazer mais nada, isso definitivamente funcionar√° para voc√™.

mongoose.connect(database.host, { useMongoClient: true });

Isso resolveu meu problema. Mas eu tive outro aviso depois que fiz essa alteração.

DeprecationWarning: Mongoose: mpromise (biblioteca de promessas padrão do mongoose) está obsoleta, conecte sua própria biblioteca de promessas: http://mongoosejs.com/docs/promises.html

Este código resolve todos os avisos de descontinuação:
```javascript
mangusto.Promessa = global.Promessa;
mangusto.connect(uri, {
KeepAlive: verdade,
reconnectTries: Number.MAX_VALUE,
useMongoClient: true
});
````
Mais informa√ß√Ķes pelo link -> http://mongoosejs.com/docs/connections.html#use -mongo-client

@bricss Fant√°stico! Obrigado!

@bricss Você fez meu dia.

alguém ganhou um distintivo de herói...

edit: @bricss Eliminou os avisos de descontinuação para mim, mas não consegui recuperar dados das minhas caixas de areia mLab. Pode ser porque eles estão usando uma versão mais antiga do MongoDB. Vou tentar verificar mais tarde.

edit: @bricss Agora est√° funcionando corretamente com o √ļltimo mongoose 4.11.9 e uma conex√£o com o Cosmos DB no Azure.

@bricss : Tijolos bem feitos! Funcionou para mim, embora eu esteja usando uma vers√£o muito antiga do mongodb no meu local :+1:

@bricss Awesowe! Mas voc√™ pode considerar colocar um n√ļmero menor para "reconnectTries". Voc√™ n√£o quer passar o dia inteiro se reconectando se houver um problema com seu banco de dados.

A solução do @afoke funcionou para mim, apenas quando eu declaro explicitamente o db na string de conexão, ou seja mongodb://localhost:27017/test mas não mongodb://localhost:27017

Posso criar conex√£o com 2 DB's sem este aviso? Eu preciso usar meus modelos com diferentes DB's.

Usando mangusto v^4.11.6 , quando adicionado useMongoClient o aviso desapareceu.

const uri = "http://blablabla.blo/blaDB"; mongoose.Promise = global.Promise; mongoose.connection.on('error', (err) => { console.error( Erro de conex√£o do Mongoose: ${err}`);
processo.exit(1);
});
mongoose.connect(uri, {useMongoClient: true});

 // load models
 require('./model1');
 // ...
 require('./modelN');`

conectar-se ao banco de dados dessa maneira resolve o problema:
mongoose.connect(url,{usu√°rio:'username',pass:'mypassword',useMongoClient:true});

Esses erros causarão problemas, por exemplo, na segurança?

Nenhum aviso "obsoleto" aparece se eu usar essa sintaxe ūüéČ

mongoose.connection.openUri('mongodb://localhost/test')
  .once('open', () => console.log('Good to go !'))
  .on('error', (error) => {
    console.warn('Warning', error);
  });

Eu enfrentei o mesmo aviso de depreciação abaixo:
(node:2300) DeprecationWarning: open() está obsoleto no mangusto >= 4.11.0, use openUri() ou defina a opção useMongoClient se estiver usando connect() ou createConnection() . Consulte http://mongoosejs.com/docs/connections.html#use -mongo-client

Solução

Eu tentei o seguinte e funciona bem. Não dá avisos de depreciação.

mongoose.connect('mongodb://127.0.0.1:27017/your-database-name', { useMongoClient: true, promiseLibrary: global.Promise });

Espero que isso ajude a todos que enfrentam esse problema.

Eu tenho o mesmo problema, mas ao tentar se conectar ao serviço Mongo Atlas, ele simplesmente não se conecta com a opção {useMo ngoClient:true } e sem ela a conexão não é mais executada.

Alguém com o mesmo problema?

Eu resolvi meu problema apenas alterando o mongoose.connect para mongoose.createConnection

mongoose.createConnection(config.uri, (err) => {
se (erro) {
console.log('Não foi possível conectar ao banco de dados: ', err);
} outro {
console.log('Conectado ao banco de dados: ' + config.db);
}
});

Eu resolvi esse problema assim (Mongoose 4.12.0, NodeJS - 7.10.1)

mongoose.Promise = require('bluebird');
mongoose.connect('mongodb://localhost:27017/books_exchange', {
  useMongoClient: true,
  promiseLibrary: require('bluebird')
}).then(() => {
  var userSchema = new mongoose.Schema({
    name: String,
    password: String
  });
  var User = mongoose.model('User', userSchema);

  var person = new User({
    name: "John",
    password: "qwerty"
  });

  person.save().then(() => {
    console.log('Data saved');
  }).catch(e => {
    console.log(e);
  });
}).catch(e => {
  console.log('Error while DB connecting');
  console.log(e);
});
Esta p√°gina foi √ļtil?
0 / 5 - 0 avalia√ß√Ķes