Eu tenho uma classe de wrapper de banco de dados que estabelece uma conexão com alguma instância do MongoDB:

async connect(connectionString: string): Promise<void> {
        this.client = await MongoClient.connect(connectionString)
        this.db = this.client.db()
}

Isso me deu um aviso:

(nó: 4833) DeprecationWarning: o analisador de cadeia de URL atual foi descontinuado e será removido em uma versão futura. Para usar o novo analisador, passe a opção {useNewUrlParser: true} para MongoClient.connect.

O connect()método aceita uma MongoClientOptionsinstância como segundo argumento. Mas não tem uma propriedade chamada useNewUrlParser. Também tentei definir essas propriedades na cadeia de conexão como esta: mongodb://127.0.0.1/my-db?useNewUrlParser=truemas não tem efeito sobre esses avisos.

Então, como posso definir useNewUrlParserpara remover esses avisos? Isso é importante para mim, pois o script deve ser executado como cron e esses avisos resultam em spam de lixo eletrônico.

Estou usando o mongodbdriver na versão 3.1.0-beta4com o @types/mongodbpacote correspondente 3.0.18. Ambos são os mais recentes disponíveis npm install.

Gambiarra

Usando uma versão mais antiga do driver mongodb:

"mongodb": "~3.0.8",
"@types/mongodb": "~3.0.18"

Verifique sua mongoversão:

mongo --version

Se você estiver usando a versão> = 3.1.0, altere seu mongoarquivo de conexão para ->

MongoClient.connect("mongodb://localhost:27017/YourDB", { useNewUrlParser: true })

ou seu arquivo de conexão mangusto para ->

mongoose.connect("mongodb://localhost:27017/YourDB", { useNewUrlParser: true });

Idealmente, é um recurso da versão 4, mas a v3.1.0 e superior também o suportam. Confira o MongoDB GitHub para obter detalhes.

Como observado, a 3.1.0-beta4liberação do driver foi "liberada na natureza" um pouco cedo pela aparência das coisas. O lançamento faz parte do trabalho em andamento para oferecer suporte a novos recursos do MongoDB 4.0 e fazer outras alterações na API.

Uma dessas alterações que acionam o aviso atual é a useNewUrlParseropção, devido a algumas alterações na forma como a transmissão do URI da conexão realmente funciona. Mais sobre isso mais tarde.

Até que as coisas se acalmem, provavelmente seria aconselhável "fixar" pelo menos a versão menor para 3.0.xlançamentos:

  "dependencies": {
    "mongodb": "~3.0.8"
  }

Isso deve impedir que a 3.1.xramificação seja instalada em instalações "novas" nos módulos do nó. Se você já instalou uma versão "mais recente", que é a versão "beta", limpe seus pacotes (e package-lock.json) e certifique-se de incluir a 3.0.xversão em série.

Quanto ao uso das "novas" opções de URI da conexão, a principal restrição é realmente incluir a portstring de conexão:

const { MongoClient } = require("mongodb");
const uri = 'mongodb://localhost:27017';  // mongodb://localhost - will fail

(async function() {
  try {

    const client = await MongoClient.connect(uri,{ useNewUrlParser: true });
    // ... anything

    client.close();
  } catch(e) {
    console.error(e)
  }

})()

Essa é uma regra mais "estrita" no novo código. O ponto principal é que o código atual é essencialmente parte do mongodbcódigo do repositório "node-native-driver" (npm ) e o "novo código" realmente importa da mongodb-corebiblioteca que "sustenta" o driver do nó "público".

O ponto da "opção" que está sendo adicionada é "facilitar" a transição adicionando a opção ao novo código, para que o analisador mais recente (atualmente baseado em torno de url) esteja sendo usado no código que adiciona a opção e apaga o aviso de descontinuação e, portanto, verifica se suas cadeias de conexão transmitidas realmente estão de acordo com o que o novo analisador está esperando.

Em versões futuras, o analisador 'legado' será removido e, em seguida, o novo analisador será simplesmente o que é usado, mesmo sem a opção. Porém, nesse momento, espera-se que todo o código existente tenha ampla oportunidade de testar suas cadeias de conexão existentes contra o que o novo analisador está esperando.

Então, se você quiser começar a usar os novos recursos do driver como eles são liberados, em seguida, usar os disponíveis betalançamentos e subsequentes e, idealmente, certifique-se que você está fornecendo uma seqüência de conexão que é válido para o novo analisador, permitindo a useNewUrlParseropção na MongoClient.connect().

Se você realmente não precisa acessar recursos relacionados à visualização da versão MongoDB 4.0, atribua a versão a uma 3.0.xsérie, conforme observado anteriormente. Isso funcionará conforme documentado e "fixar" isso garante que as 3.1.xliberações não sejam "atualizadas" sobre a dependência esperada até que você realmente deseje instalar uma versão estável.

O código destacado abaixo para a conexão do mangusto resolveu o aviso para o driver do mangusto:

mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true });

Não há nada para mudar. Passe apenas na função de conexão {useNewUrlParser: true }.

Isso funcionará:

MongoClient.connect(url, {useNewUrlParser: true}, function(err, db) {
    if(err) {
        console.log(err);
    }
    else {
        console.log('connected to ' + url);
        db.close();
    }
})

Você precisa adicionar { useNewUrlParser: true }o método mongoose.connect ().

mongoose.connect('mongodb://localhost:27017/Notification',{ useNewUrlParser: true });

O formato da cadeia de conexão deve ser mongodb: // usuário: senha @ host: port / db

Por exemplo:

MongoClient.connect('mongodb://user:password@127.0.0.1:27017/yourDB', { useNewUrlParser: true } )

Você só precisa definir o seguinte antes de conectar-se ao banco de dados, conforme abaixo:

const mongoose = require('mongoose');

mongoose.set('useNewUrlParser', true);
mongoose.set('useFindAndModify', false);
mongoose.set('useCreateIndex', true);
mongoose.set('useUnifiedTopology', true);

mongoose.connect('mongodb://localhost/testaroo');

Além disso,

Replace update() with updateOne(), updateMany(), or replaceOne()
Replace remove() with deleteOne() or deleteMany().
Replace count() with countDocuments(), unless you want to count how many documents are in the whole collection (no filter).
In the latter case, use estimatedDocumentCount().

O seguinte funciona para mim

const mongoose = require('mongoose');

mongoose.connect("mongodb://localhost/playground", { useNewUrlParser: true,useUnifiedTopology: true })
.then(res => console.log('Connected to db'));

A mongooseversão é 5.8.10.

Eu não acho que você precise adicionar { useNewUrlParser: true }.

Você decide se já deseja usar o novo analisador de URL. Eventualmente, o aviso desaparecerá quando o MongoDB alternar para seu novo analisador de URL.

Conforme especificado no Formato URI da cadeia de conexão , você não precisa definir o número da porta.

Basta adicionar { useNewUrlParser: true }é suficiente.

Atualizado para ECMAScript 8 / waitit

O código de demonstração ECMAScript 8 incorreto que o MongoDB inc fornece também cria esse aviso.

O MongoDB fornece os seguintes conselhos, incorretos

Para usar o novo analisador, passe a opção {useNewUrlParser: true} para MongoClient.connect.

Fazer isso causará o seguinte erro:

TypeError: o argumento final executeOperationdeve ser um retorno de chamada

Em vez disso, a opção deve ser fornecida paranew MongoClient :

Veja o código abaixo:

const DATABASE_NAME = 'mydatabase',
    URL = `mongodb://localhost:27017/${DATABASE_NAME}`

module.exports = async function() {
    const client = new MongoClient(URL, {useNewUrlParser: true})
    var db = null
    try {
        // Note this breaks.
        // await client.connect({useNewUrlParser: true})
        await client.connect()
        db = client.db(DATABASE_NAME)
    } catch (err) {
        console.log(err.stack)
    }

    return db
}

O problema pode ser resolvido fornecendo o número da porta e usando este analisador: {useNewUrlParser: true}

A solução pode ser:

mongoose.connect("mongodb://localhost:27017/cat_app", { useNewUrlParser: true });

Isso resolve meu problema.

O exemplo completo para Express.js, caso de chamada de API e envio de conteúdo JSON é o seguinte:

...
app.get('/api/myApi', (req, res) => {
  MongoClient.connect('mongodb://user:password@domain.com:port/dbname',
    { useNewUrlParser: true }, (err, db) => {

      if (err) throw err
      const dbo = db.db('dbname')
      dbo.collection('myCollection')
        .find({}, { _id: 0 })
        .sort({ _id: -1 })
        .toArray(
          (errFind, result) => {
            if (errFind) throw errFind
            const resultJson = JSON.stringify(result)
            console.log('find:', resultJson)
            res.send(resultJson)
            db.close()
          },
        )
    })
}

Aqui está como eu o tenho. A dica não apareceu no meu console até que eu atualizei a NPM alguns dias antes.

.connect possui três parâmetros, o URI, opções e err.

mongoose.connect(
    keys.getDbConnectionString(),
    { useNewUrlParser: true },
    err => {
        if (err) 
            throw err;
        console.log(`Successfully connected to database.`);
    }
);

Estávamos usando:

mongoose.connect("mongodb://localhost/mean-course").then(
  (res) => {
   console.log("Connected to Database Successfully.")
  }
).catch(() => {
  console.log("Connection to database failed.");
});

→ Isso gera um erro no analisador de URL

A sintaxe correta é:

mongoose.connect("mongodb://localhost:27017/mean-course" , { useNewUrlParser: true }).then(
  (res) => {
   console.log("Connected to Database Successfully.")
  }
).catch(() => {
  console.log("Connection to database failed.");
});

Você só precisa adicionar

{ useNewUrlParser: true }

dentro do método mongoose.connect.

O seguinte trabalho para mim para a versão 5.9.16

const mongoose = require('mongoose');

mongoose.set('useNewUrlParser', true);
mongoose.set('useFindAndModify', false);
mongoose.set('useCreateIndex', true);
mongoose.set('useUnifiedTopology', true);

mongoose.connect('mongodb://localhost:27017/dbName')
    .then(() => console.log('Connect to MongoDB..'))
    .catch(err => console.error('Could not connect to MongoDB..', err))

Essas linhas também fizeram o truque para todos os outros avisos de descontinuação:

const db = await mongoose.createConnection(url, { useNewUrlParser: true });
mongoose.set('useCreateIndex', true);
mongoose.set('useFindAndModify', false);

Eu estava usando mlab.com como o banco de dados MongoDB. Separei a cadeia de conexão em uma pasta diferente chamada confige dentro do arquivo keys.js. Mantive a cadeia de conexão que era:

module.exports = {
  mongoURI: "mongodb://username:password@ds147267.mlab.com:47267/projectname"
};

E o código do servidor foi

const express = require("express");
const mongoose = require("mongoose");
const app = express();

// Database configuration
const db = require("./config/keys").mongoURI;

// Connect to MongoDB

mongoose
  .connect(
    db,
    { useNewUrlParser: true } // Need this for API support
  )
  .then(() => console.log("MongoDB connected"))
  .catch(err => console.log(err));

app.get("/", (req, res) => res.send("hello!!"));

const port = process.env.PORT || 5000;

app.listen(port, () => console.log(`Server running on port ${port}`)); // Tilde, not inverted comma

Você precisa escrever {useNewUrlParser: true} após a cadeia de conexão, como fiz acima.

Simplificando, você precisa fazer:

mongoose.connect(connectionString,{ useNewUrlParser: true } 
// Or
MongoClient.connect(connectionString,{ useNewUrlParser: true } 
    

Estou usando o mangusto versão 5.x para o meu projeto. Depois de exigir o pacote mangusto, defina o valor globalmente como abaixo.

const mongoose = require('mongoose');

// Set the global useNewUrlParser option to turn on useNewUrlParser for every connection by default.
mongoose.set('useNewUrlParser', true);

Se usernameou passwordtiver o @personagem, use-o assim:

mongoose
    .connect(
        'DB_url',
        { user: '@dmin', pass: 'p@ssword', useNewUrlParser: true }
    )
    .then(() => console.log('Connected to MongoDB'))
    .catch(err => console.log('Could not connect to MongoDB', err));