J'ai une classe d'encapsuleur de base de données qui établit une connexion à une instance MongoDB:

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

Cela m'a donné un avertissement:

(nœud: 4833) DeprecationWarning: l'analyseur de chaîne d'URL actuel est obsolète et sera supprimé dans une future version. Pour utiliser le nouvel analyseur, passez l'option {useNewUrlParser: true} à MongoClient.connect.

La connect()méthode accepte une MongoClientOptionsinstance comme deuxième argument. Mais il n'a pas de propriété appelée useNewUrlParser. J'ai également essayé de définir ces propriétés dans la chaîne de connexion comme ceci: mongodb://127.0.0.1/my-db?useNewUrlParser=truemais cela n'a aucun effet sur ces avertissements.

Alors, comment puis-je configurer useNewUrlParserpour supprimer ces avertissements? Ceci est important pour moi car le script doit s'exécuter en tant que cron et ces avertissements entraînent un spam de corbeille.

J'utilise le mongodbpilote dans la version 3.1.0-beta4avec le @types/mongodbpackage correspondant dans 3.0.18. Les deux sont les derniers disponibles disponiblesnpm install .

solution de contournement

Utilisation d'une ancienne version du pilote mongodb:

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

Vérifiez votre mongoversion:

mongo --version

Si vous utilisez la version> = 3.1.0, changez votre mongofichier de connexion en ->

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

ou votre fichier de connexion mangouste à ->

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

Idéalement, c'est une fonctionnalité de la version 4, mais la v3.1.0 et les versions ultérieures la prennent également en charge. Consultez MongoDB GitHub pour plus de détails.

Comme indiqué, la 3.1.0-beta4libération du pilote a été "libérée dans la nature" un peu tôt par l'apparence des choses. La version fait partie des travaux en cours pour prendre en charge les nouvelles fonctionnalités de la prochaine version de MongoDB 4.0 et apporter d'autres modifications à l'API.

L'un de ces changements déclenchant l'avertissement actuel est l' useNewUrlParseroption, en raison de certains changements sur la façon dont le passage de l'URI de connexion fonctionne réellement. Plus sur cela plus tard.

Jusqu'à ce que les choses "se calment", il serait probablement conseillé de "fixer " au moins la version mineure pour les 3.0.xversions:

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

Cela devrait empêcher l' 3.1.xinstallation de la branche sur des installations "récentes" vers des modules de nœuds. Si vous avez déjà installé une «dernière» version qui est la version «bêta», vous devez nettoyer vos packages (et package-lock.json) et vous assurer de les transférer vers une 3.0.xversion de série.

Quant à l'utilisation effective des "nouvelles" options d'URI de connexion, la principale restriction est en fait d'inclure le portdans la chaîne de connexion:

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

})()

C'est une règle plus "stricte" dans le nouveau code. Le point principal étant que le code actuel fait essentiellement partie du mongodbcode du référentiel "node-native-driver" (npm ), et que le "nouveau code" est en fait importé dumongodb-core bibliothèque qui "sous-tend" le pilote de nœud "public".

Le point de "l'option" ajoutée est de "faciliter" la transition en ajoutant l'option au nouveau code de sorte que le nouvel analyseur (en fait basé sur url ) soit utilisé dans le code ajoutant l'option et effaçant l'avertissement de dépréciation, et donc vérifiant que vos chaînes de connexion passées sont en fait conformes à ce que le nouvel analyseur attend.

Dans les versions futures, l'analyseur «hérité» serait supprimé, puis le nouvel analyseur sera simplement ce qui est utilisé même sans l'option. Mais à ce moment-là, il est prévu que tout le code existant ait amplement l'occasion de tester leurs chaînes de connexion existantes par rapport à ce que le nouvel analyseur attend.

Donc, si vous souhaitez commencer à utiliser les nouvelles fonctionnalités du pilote au fur betaet à mesure de leur publication , utilisez les versions disponibles et suivantes et assurez-vous idéalement de fournir une chaîne de connexion valide pour le nouvel analyseur en activant l' useNewUrlParseroption in MongoClient.connect().

Si vous n'avez pas réellement besoin d'accéder aux fonctionnalités liées à l'aperçu de la version MongoDB 4.0, épinglez la version à une 3.0.xsérie comme indiqué précédemment. Cela fonctionnera comme documenté et "épinglé" cela garantit que les 3.1.xversions ne sont pas "mises à jour" sur la dépendance attendue jusqu'à ce que vous souhaitiez réellement installer une version stable.

Le code en surbrillance ci-dessous pour la connexion mangouste a résolu l'avertissement du pilote mangouste:

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

Il n'y a rien à changer. Passez uniquement dans la fonction de connexion {useNewUrlParser: true }.

Cela fonctionnera:

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

Vous devez ajouter { useNewUrlParser: true }la méthode mongoose.connect ().

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

Le format de la chaîne de connexion doit être mongodb: // user: password @ host: port / db

Par exemple:

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

Il vous suffit de définir les éléments suivants avant de vous connecter à la base de données comme ci-dessous:

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');

Aussi,

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().

Les travaux suivants pour moi

const mongoose = require('mongoose');

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

La mongooseversion est 5.8.10.

Je ne pense pas que vous ayez besoin d'ajouter { useNewUrlParser: true }.

C'est à vous de décider si vous souhaitez déjà utiliser le nouvel analyseur d'URL. Finalement, l'avertissement disparaîtra lorsque MongoDB passe à son nouvel analyseur d'URL.

Comme spécifié dans Connection String URI Format , vous n'avez pas besoin de définir le numéro de port.

Il suffit d'ajouter { useNewUrlParser: true }.

Mise à jour pour ECMAScript 8 / attente

Le code de démonstration ECMAScript 8 incorrect fourni par MongoDB inc crée également cet avertissement.

MongoDB fournit les conseils suivants, qui sont incorrects

Pour utiliser le nouvel analyseur, passez l'option {useNewUrlParser: true} à MongoClient.connect.

Cela entraînera l'erreur suivante:

TypeError: l'argument final executeOperationdoit être un rappel

Au lieu de cela, l'option doit être fournie pournew MongoClient :

Voir le code ci-dessous:

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
}

Le problème peut être résolu en donnant le numéro de port et en utilisant cet analyseur: {useNewUrlParser: true}

La solution peut être:

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

Cela résout mon problème.

L'exemple complet pour Express.js, le cas d'appel de l'API et l'envoi de contenu JSON est le suivant:

...
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()
          },
        )
    })
}

Voici comment je l'ai. L'astuce ne s'est pas affichée sur ma console jusqu'à ce que je mette à jour npm quelques jours auparavant.

.connect a trois paramètres, l'URI, les options et err.

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

Nous utilisions:

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

→ Cela donne une erreur d'analyseur d'URL

La syntaxe correcte est:

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

Vous avez juste besoin d'ajouter

{ useNewUrlParser: true }

à l'intérieur de la méthode mongoose.connect.

Le travail suivant pour moi pour la version 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))

Ces lignes ont également fait l'affaire pour tous les autres avertissements de dépréciation:

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

J'utilisais mlab.com comme base de données MongoDB. J'ai séparé la chaîne de connexion dans un dossier différent nommé configet dans le fichier keys.js J'ai conservé la chaîne de connexion qui était:

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

Et le code du serveur était

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

Vous devez écrire {useNewUrlParser: true} après la chaîne de connexion comme je l'ai fait ci-dessus.

Autrement dit, vous devez faire:

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

J'utilise la version 5.x de mangouste pour mon projet. Après avoir requis le paquet mangouste, définissez la valeur globalement comme ci-dessous.

const mongoose = require('mongoose');

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

Si usernameou passworda le @caractère, alors utilisez-le comme ceci:

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