Tengo una clase de contenedor de base de datos que establece una conexión con alguna instancia de MongoDB:

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

Esto me dio una advertencia:

(nodo: 4833) DeprecationWarning: el analizador de cadenas de URL actual está en desuso y se eliminará en una versión futura. Para usar el nuevo analizador, pase la opción {useNewUrlParser: true} a MongoClient.connect.

El connect()método acepta una MongoClientOptionsinstancia como segundo argumento. Pero no tiene una propiedad llamada useNewUrlParser. También intenté establecer esas propiedades en la cadena de conexión de esta manera: mongodb://127.0.0.1/my-db?useNewUrlParser=truepero no tiene ningún efecto en esas advertencias.

Entonces, ¿cómo puedo configurar useNewUrlParserpara eliminar esas advertencias? Esto es importante para mí, ya que el script debe ejecutarse como cron y esas advertencias generan correo basura.

Estoy usando el mongodbcontrolador en la versión 3.1.0-beta4con el @types/mongodbpaquete correspondiente 3.0.18. Ambos son el último uso disponible npm install.

Solución alterna

Usando una versión anterior del controlador mongodb:

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

Comprueba tu mongoversión:

mongo --version

Si está utilizando la versión> = 3.1.0, cambie su mongoarchivo de conexión a ->

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

o su archivo de conexión de mangosta a ->

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

Idealmente, es una característica de la versión 4, pero v3.1.0 y superior también lo admiten. Echa un vistazo a MongoDB GitHub para más detalles.

Como se señaló, el 3.1.0-beta4lanzamiento del controlador fue "liberado en la naturaleza" un poco antes por el aspecto de las cosas. La versión es parte del trabajo en progreso para admitir nuevas características en la próxima versión de MongoDB 4.0 y hacer algunos otros cambios de API.

Uno de esos cambios que desencadena la advertencia actual es el useNewUrlParser opción, debido a algunos cambios en torno a cómo funciona realmente el URI de conexión. Más sobre eso más tarde.

Hasta que las cosas "se calmen", probablemente sería aconsejable "anclar" al menos a la versión menor para 3.0.xlanzamientos:

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

Eso debería evitar que la 3.1.xrama se instale en instalaciones "nuevas" en módulos de nodo. Si ya instaló una versión "más reciente" que es la versión "beta", entonces debe limpiar sus paquetes (ypackage-lock.json ) y asegurarse de llevarla a una 3.0.xversión en serie.

En cuanto al uso de las "nuevas" opciones de URI de conexión, la restricción principal es incluir el porten la cadena de conexión:

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

})()

Esa es una regla más "estricta" en el nuevo código. El punto principal es que el código actual es esencialmente parte del mongodbcódigo de repositorio "node-native-driver" (npm ), y el "nuevo código" realmente importa delmongodb-core biblioteca que "sustenta" el controlador de nodo "público".

El objetivo de la "opción" que se agrega es "facilitar" la transición al agregar la opción al nuevo código para que el analizador más nuevo (en realidad basado en url ) se esté utilizando en el código que agrega la opción y borra la advertencia de desaprobación y, por lo tanto, verifica que sus cadenas de conexión pasadas realmente cumplen con lo que espera el nuevo analizador.

En futuras versiones, el analizador 'heredado' se eliminaría y luego el nuevo analizador simplemente será lo que se use, incluso sin la opción. Pero para ese momento, se espera que todo el código existente tenga una amplia oportunidad de probar sus cadenas de conexión existentes contra lo que espera el nuevo analizador.

Entonces, si desea comenzar a usar las nuevas funciones del controlador a medida que se lanzan, use las versiones disponibles betay posteriores e idealmente asegúrese de proporcionar una cadena de conexión que sea válida para el nuevo analizador habilitando la useNewUrlParseropción MongoClient.connect().

Si realmente no necesita acceso a las funciones relacionadas con la vista previa de la versión MongoDB 4.0, fije la versión a una 3.0.xserie como se indicó anteriormente. Esto funcionará según lo documentado y "anclando" esto asegura que las 3.1.xversiones no se "actualicen" sobre la dependencia esperada hasta que realmente desee instalar una versión estable.

El siguiente código resaltado para la conexión de mangosta resolvió la advertencia para el controlador de mangosta:

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

No hay nada que cambiar. Pase solo en la función de conexión {useNewUrlParser: true }.

Esto funcionará:

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

Debe agregar { useNewUrlParser: true }el método mongoose.connect ().

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

El formato de la cadena de conexión debe ser mongodb: // usuario: contraseña @ host: puerto / db

Por ejemplo:

MongoClient.connect('mongodb://user:[email protected]:27017/yourDB', { useNewUrlParser: true } )

Solo necesita configurar lo siguiente antes de conectarse a la base de datos como se muestra a continuación:

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

También,

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

Lo siguiente funciona para mi

const mongoose = require('mongoose');

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

La mongooseversión es 5.8.10.

No creo que necesites agregar { useNewUrlParser: true }.

Depende de usted si ya desea utilizar el nuevo analizador de URL. Finalmente, la advertencia desaparecerá cuando MongoDB cambie a su nuevo analizador de URL.

Como se especifica en el Formato de URI de la cadena de conexión , no necesita establecer el número de puerto.

Solo agregar { useNewUrlParser: true }es suficiente.

Actualizado para ECMAScript 8 / await

El código de demostración ECMAScript 8 incorrecto que MongoDB inc proporciona también crea esta advertencia.

MongoDB proporciona el siguiente consejo, que es incorrecto

Para usar el nuevo analizador, pase la opción {useNewUrlParser: true} a MongoClient.connect.

Hacer esto provocará el siguiente error:

TypeError: el argumento final executeOperationdebe ser una devolución de llamada

En sunew MongoClient lugar , se debe proporcionar la opción para :

Vea el código a continuación:

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
}

El problema se puede resolver dando el número de puerto y usando este analizador: {useNewUrlParser: true}

La solución puede ser:

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

Resuelve mi problema.

El ejemplo completo para Express.js, el caso de llamadas API y el envío de contenido JSON es el siguiente:

...
app.get('/api/myApi', (req, res) => {
  MongoClient.connect('mongodb://user:[email protected]: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()
          },
        )
    })
}

Así es como lo tengo. La pista no apareció en mi consola hasta que actualicé npm un par de días antes.

.connect tiene tres parámetros, el URI, las opciones y err.

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

Estábamos usando:

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

→ Esto da un error de analizador de URL

La sintaxis correcta es:

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

Solo necesitas agregar

{ useNewUrlParser: true }

dentro del método mongoose.connect.

El siguiente trabajo para mí para la versión 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))

Estas líneas también sirvieron para todas las demás advertencias de desaprobación:

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

Estaba usando mlab.com como la base de datos MongoDB. Separé la cadena de conexión a una carpeta diferente llamada configy dentro del archivo keys.js Mantuve la cadena de conexión que era:

module.exports = {
  mongoURI: "mongodb://username:[email protected]:47267/projectname"
};

Y el código del servidor era

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

Debe escribir {useNewUrlParser: true} después de la cadena de conexión como hice anteriormente.

En pocas palabras, debe hacer:

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

Estoy usando Mongoose versión 5.x para mi proyecto. Después de requerir el paquete de mangosta, establezca el valor globalmente como se muestra a continuación.

const mongoose = require('mongoose');

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

Si tiene usernameo passwordtiene el @personaje, úselo así:

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