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

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