Le moteur de détection et de surveillance des serveurs est obsolète

Mise à jour

Mongoose 5.7.1 était sorti et semble résoudre le problème, donc la configuration de l'option useUnifiedTopology fonctionne comme prévu.

mongoose.connect(mongoConnectionString, {useNewUrlParser: true, useUnifiedTopology: true});

Réponse originale

J'étais confronté au même problème et j'ai décidé de plonger en profondeur sur le code Mongoose: https://github.com/Automattic/mongoose/search?q=useUnifiedTopology&unscoped_q=useUnifiedTopology

Semble être une option ajoutée sur la version 5.7 de Mongoose et pas encore bien documentée. Je n'ai même pas pu le trouver mentionné dans l'historique de la bibliothèque https://github.com/Automattic/mongoose/blob/master/History.md

Selon un commentaire dans le code:

• @param {Boolean} [options.useUnifiedTopology = false] False par défaut. Définissez sur true pour activer le jeu de réplicas du pilote MongoDB et le moteur de surveillance de cluster partitionné.

Il y a aussi un problème sur le projet GitHub à propos de cette erreur: https://github.com/Automattic/mongoose/issues/8156

Dans mon cas, je n'utilise pas Mongoose dans un jeu de répliques ou un cluster partitionné et bien que l'option devrait être fausse. Mais s'il est faux, le paramètre doit être vrai. Une fois que c'est vrai, cela ne fonctionne toujours pas, probablement parce que ma base de données ne fonctionne pas sur un jeu de réplicas ou un cluster partitionné.

J'ai rétrogradé à la version 5.6.13 et mon projet fonctionne de nouveau correctement. Donc, la seule option que je vois pour le moment est de le rétrograder et d'attendre que le correctif se mette à jour pour une version plus récente.

Dans mongoDB, ils ont désapprouvé le package de surveillance actuel des serveurs et des moteurs, vous devez donc utiliser un nouveau package de surveillance des serveurs et des moteurs. Donc vous utilisez juste

{useUnifiedTopology: true}

mongoose.connect("paste db link", {useUnifiedTopology: true, useNewUrlParser: true, useCreateIndex: true });

Cela a fonctionné pour moi

Pour les personnes utilisant MongoClient essayez ceci:

mongoose.connect(connectionurl, 
         {useUnifiedTopology: true, useNewUrlParser: true}).then(()=>{

Pour la mangouste:

MongoClient.connect(connectionurl, 
  {useUnifiedTopology: true, useNewUrlParser: true},  callback() {

Supprimer les autres options de connexion

Vous pouvez essayer asynchrone attendre

const connectDB = async () => {
    try {
        await mongoose.connect(<database url>, {
            useNewUrlParser: true,
            useCreateIndex: true,
            useUnifiedTopology: true,
            useFindAndModify: false
        });
        console.log("MongoDB Conected")
    } catch (err) {
        console.error(err.message);
        process.exit(1);
    }
};

J'étais également confronté au même problème:

1. Je me suis assuré d'être connecté à mongoDB en exécutant ce qui suit sur le terminal:

   mongoose.connect(config.mongo_uri, {
       useUnifiedTopology: true,
       useNewUrlParser: true})
       .then(() => console.log("Connected to Database"))
       .catch(err => console.error("An error has occured", err));
   

   Et j'ai eu la sortie:

   Successfully started `mongodb-community`
   

Instructions pour l'installation de mongodb sur
https://docs.mongodb.com/manual/tutorial/install-mongodb-on-os-x/ ou https://www.youtube.com/watch?v=IGIcrMTtjoU

2. Ma configuration était la suivante:

   brew services start mongodb-community@4.2
   

Ce qui a résolu mon problème!

   const mongo = require('mongodb').MongoClient;

   mongo.connect(process.env.DATABASE,{useUnifiedTopology: true, 
   useNewUrlParser: true}, (err, db) => {
      if(err) {
    console.log('Database error: ' + err);
   } else {
    console.log('Successful database connection');
      auth(app, db)
      routes(app, db)

   app.listen(process.env.PORT || 3000, () => {
      console.log("Listening on port " + process.env.PORT);
    });  
}});

Paramétrage de la connexion mangouste useUnifiedTopology: option true

  import mongoose from 'mongoose';

        const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
        const database = 'DBName'; // REPLACE WITH YOUR DB NAME
        class Database {
          constructor() {
            this._connect();
          }
          _connect() {
            mongoose.Promise = global.Promise;
            // * Local DB SERVER *
            mongoose
              .connect(`mongodb://${server}/${database}`, {
                useNewUrlParser: true,
                useCreateIndex: true,
                useUnifiedTopology: true
              })
              .then(
                () => console.log(`mongoose version: ${mongoose.version}`),
                console.log('Database connection successful'),
              )
              .catch(err => console.error('Database connection error', err));   
          }
        }
        module.exports = new Database();

Cela a résolu mon problème.

 const url = 'mongodb://localhost:27017';

 const client = new MongoClient(url, {useUnifiedTopology: true});

mongoose.connect('mongodb://localhost:27017/Tododb', { useNewUrlParser: true, useUnifiedTopology: true });
Will remove following errors:-(node:7481) DeprecationWarning: current URL string parser is deprecated, and will be removed in a future version. To use the new parser, pass option { useNewUrlParser: true } to MongoClient.connect.(node:7481) DeprecationWarning: current Server Discovery and Monitoring engine is deprecated, and will be removed in a future version. To use the new Server Discover and Monitoring engine, pass option { useUnifiedTopology: true } to the MongoClient constructor.

Ajoutez l'option useUnifiedTopology et définissez-la sur true .

Définissez 3 autres configurations des options de mongoose.connect qui traiteront les autres DeprecationWarning restants.

Cette configuration fonctionne pour moi!

const url = 'mongodb://localhost:27017/db_name';
mongoose.connect(
    url, 
    { 
        useNewUrlParser: true, 
        useUnifiedTopology: true,
        useCreateIndex: true,
        useFindAndModify: false
    }
)

Cela résoudra 4 DeprecationWarning .

1. L'analyseur de chaînes d'URL actuel est obsolète et sera supprimé dans une version ultérieure. Pour utiliser le nouvel analyseur, passez l'option {useNewUrlParser: true} à MongoClient.connect.
2. Le moteur actuel de détection et de surveillance des serveurs est obsolète et sera supprimé dans une version ultérieure. Pour utiliser le nouveau moteur de découverte et de surveillance du serveur, transmettez l'option {useUnifiedTopology: true} au constructeur MongoClient.
3. Collection.ensureIndex est obsolète. Utilisez plutôt createIndexes.
4. DeprecationWarning: Mongoose: findOneAndUpdate() et findOneAndDelete() sans l'option useFindAndModify définie sur false sont obsolètes. Voir: https://mongoosejs.com/docs/deprecations.html#-findandmodify- .

J'espère que cela aide.

Je veux ajouter à ce fil qu'il peut également avoir à voir avec d'autres dépendances.

Par exemple, rien de ce que j'ai mis à jour ou défini pour NodeJS, MongoDB ou Mongoose n'était le problème - cependant - connect-mongodb-session avait été mis à jour et avait commencé à générer la même erreur. La solution, dans ce cas, était simplement de restaurer la version de connect-mongodb-session de la version 2.3.0 à 2.2.0 .

J'ai eu les mêmes erreurs à chaque fois et cela a fonctionné pour moi

mongoose.connect("mongodb://localhost:27017/${yourDB}", {
    useNewUrlParser: true,
    useUnifiedTopology: true

}, function (err) {
    if (err) {
        console.log(err)
    } else {
        console.log("Database connection successful")
    }
});

const mongoose = require("mongoose");

mongoose.connect('mongodb://localhost:27017/Edureka',{ useNewUrlParser: true, useUnifiedTopology: true }, (error)=> {
    const connectionStatus = !error ? 'Success': 'Error Connecting to database';
    console.log(connectionStatus);
});

utilisez cette ligne, cela a fonctionné pour moi

mongoose.set('useUnifiedTopology', true);

Si vous utilisez un serveur MongoDB, après avoir utilisé la connexion dans l'horloge du cluster lors de la connexion et la recherche de l'URL, l'URL sera quelque chose comme ça

const client = new MongoClient(url,{useUnifiedTopology:true});

Dans ce cas, n'oubliez pas de remplacer le mot de passe par votre mot de passe de base de données et votre nom de base de données, puis utilisez

<mongodb+srv://Rohan:<password>@cluster0-3kcv6.mongodb.net/<dbname>?retryWrites=true&w=majority>

mongoose.connect("DBURL", {useUnifiedTopology: true, useNewUrlParser: true, useCreateIndex: true },(err)=>{
    if(!err){
         console.log('MongoDB connection sucess');
        }
    else{ 
        console.log('connection not established :' + JSON.stringify(err,undefined,2));
    }
});

Utilisez le code suivant pour éviter cette erreur

MongoClient.connect(connectionString, {useNewUrlParser: true, useUnifiedTopology: true});

Si votre code inclut createConnetion pour une raison quelconque (dans mon cas, j'utilise GridFsStorage), essayez d'ajouter ce qui suit à votre code:

    const storage = new GridFsStorage({
    url: mongodbUrl,
    file: (req, file) => {
        return new Promise((resolve, reject) => {
            crypto.randomBytes(16, (err, buf) => {
                if (err) {
                    return reject(err);
                }
                const filename = buf.toString('hex') + path.extname(file.originalname);
                const fileInfo = {
                    filename: filename,
                    bucketName: 'uploads'
                };
                resolve(fileInfo);
            });
        });
    },
    options: {
        useUnifiedTopology: true,
    }
})

juste après le fichier, comme ceci:

    options: {
        useUnifiedTopology: true,
    }

Si votre cas ressemble au mien, cela résoudra sûrement votre problème. Cordialement

C'est simple, supprimez le code que vous avez utilisé et utilisez le code ci-dessous:

const url = 'mongodb://localhost:27017';
var dbConn = mongodb.MongoClient.connect(url, {useUnifiedTopology: true});

si vous avez utilisé du texte, ajoutez la configuration aux MongoOptions

const MongoOptions: MongoClientOptions = {
  useNewUrlParser: true,
  useUnifiedTopology: true,
};

      const client = await MongoClient.connect(url, MongoOptions);

if you not used typescript  
const MongoOptions= {
  useNewUrlParser: true,
  useUnifiedTopology: true,
};

Il est important d'exécuter votre commande mongod et de maintenir le serveur en marche. Sinon, vous verrez toujours cette erreur.

Je vous attache mon code:

const mongodb = require('mongodb')
const MongoClient = mongodb.MongoClient

const connectionURL = 'mongodb://127.0.0.1:27017'
const databaseName = 'task-manager'

MongoClient.connect(connectionURL, {useNewUrlParser: true, useUnifiedTopology: true}, (error, client) => {
    if(error) {
        return console.log('Error connecting to the server.')
    }

    console.log('Succesfully connected.')
})

Cela fonctionnera:

// Connect to Mongo
mongoose.set("useNewUrlParser", true);
mongoose.set("useUnifiedTopology", true);

mongoose
  .connect(db) // Connection String here
  .then(() => console.log("MongoDB Connected..."))
  .catch(() => console.log(err));

const client = new MongoClient(url, { useUnifiedTopology: true });