Ho una classe wrapper di database che stabilisce una connessione ad alcune istanze MongoDB:

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

Questo mi ha dato un avvertimento:

(nodo: 4833) DeprecationWarning: il parser della stringa URL corrente è obsoleto e verrà rimosso in una versione futura. Per utilizzare il nuovo parser, passare l'opzione {useNewUrlParser: true} a MongoClient.connect.

Il connect()metodo accetta MongoClientOptionsun'istanza come secondo argomento. Ma non ha una proprietà chiamata useNewUrlParser. Ho anche provato a impostare tali proprietà nella stringa di connessione in questo modo: mongodb://127.0.0.1/my-db?useNewUrlParser=truema non ha alcun effetto su tali avvisi.

Quindi, come posso impostare useNewUrlParserper rimuovere tali avvisi? Questo è importante per me dal momento che lo script dovrebbe essere eseguito come cron e tali avvisi comportano lo spam nella spazzatura.

Sto usando il mongodbdriver nella versione 3.1.0-beta4con il @types/mongodbpacchetto corrispondente in 3.0.18. Entrambi sono gli ultimi disponibili disponibili npm install.

Soluzione

Utilizzando una versione precedente del driver mongodb:

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

Controlla la tua mongoversione:

mongo --version

Se si utilizza la versione> = 3.1.0, modificare il mongofile di connessione in ->

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

o il tuo file di connessione mongoose a ->

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

Idealmente, è una funzionalità della versione 4, ma v3.1.0 e successive la supportano anche. Dai un'occhiata a MongoDB GitHub per i dettagli.

Come notato, il 3.1.0-beta4rilascio del driver è stato "rilasciato in natura" un po 'presto dall'aspetto delle cose. La versione fa parte dei lavori in corso per supportare le nuove funzionalità della prossima versione di MongoDB 4.0 e apportare alcune altre modifiche all'API.

Una di queste modifiche che attiva l'avviso corrente è l' useNewUrlParseropzione, a causa di alcune modifiche al funzionamento effettivo del passaggio dell'URI di connessione. Ne parleremo più avanti.

Fino a quando le cose non si "sistemeranno", sarebbe probabilmente consigliabile "bloccare" almeno la versione minore per le 3.0.xversioni:

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

Ciò dovrebbe impedire l' 3.1.xinstallazione della diramazione su installazioni "nuove" sui moduli del nodo. Se hai già installato una versione "più recente" che è la versione "beta", allora dovresti ripulire i tuoi pacchetti (e package-lock.json) e assicurarti di 3.0.xscaricarlo fino a una versione in serie.

Per quanto riguarda effettivamente l'utilizzo delle "nuove" opzioni di URI di connessione, la restrizione principale è quella di includere effettivamente portla stringa di connessione:

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

})()

Questa è una regola più "rigorosa" nel nuovo codice. Il punto principale è che il codice corrente è essenzialmente parte del mongodbcodice del repository "nodo-nativo-driver" (npm ) e il "nuovo codice" in realtà importa dalla mongodb-corelibreria che "sostiene" il driver del nodo "pubblico".

Il punto dell '"opzione" che viene aggiunta è quello di "facilitare" la transizione aggiungendo l'opzione al nuovo codice in modo che il parser più recente (attualmente basato intorno url) venga utilizzato nel codice aggiungendo l'opzione e cancellando l'avvertimento di deprecazione, e quindi verificando che le stringhe di connessione passate sono effettivamente conformi a quanto previsto dal nuovo parser.

Nelle versioni future il parser 'legacy' verrebbe rimosso e quindi il nuovo parser sarà semplicemente quello che viene usato anche senza l'opzione. Ma a quel punto, si prevede che tutto il codice esistente avesse ampie opportunità di testare le stringhe di connessione esistenti rispetto a ciò che il nuovo parser si aspetta.

Quindi, se si desidera iniziare a utilizzare le nuove funzionalità del driver man mano che vengono rilasciate, utilizzare le versioni disponibili betae successive e idealmente assicurarsi di fornire una stringa di connessione valida per il nuovo parser abilitando l' useNewUrlParseropzione in MongoClient.connect().

Se in realtà non hai bisogno di accedere alle funzionalità relative all'anteprima della versione MongoDB 4.0, aggiungi la versione a una 3.0.xserie come notato in precedenza. Funzionerà come documentato e il "blocco" garantisce che le 3.1.xversioni non vengano "aggiornate" rispetto alla dipendenza prevista fino a quando non si desidera effettivamente installare una versione stabile.

Il codice evidenziato di seguito alla connessione della mangusta ha risolto l'avvertimento per il driver della mangusta:

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

Non c'è nulla da cambiare. Passa solo nella funzione di connessione {useNewUrlParser: true }.

Questo funzionerà:

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

Devi aggiungere { useNewUrlParser: true }il metodo mongoose.connect ().

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

Il formato della stringa di connessione deve essere mongodb: // user: password @ host: port / db

Per esempio:

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

Devi solo impostare le seguenti cose prima di connetterti al database come di seguito:

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

Anche,

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

Quanto segue funziona per me

const mongoose = require('mongoose');

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

La mongooseversione è 5.8.10.

Non penso che tu debba aggiungere { useNewUrlParser: true }.

Dipende da te se desideri già utilizzare il nuovo parser URL. Alla fine l'avviso scompare quando MongoDB passa al nuovo parser URL.

Come specificato nel formato URI della stringa di connessione , non è necessario impostare il numero di porta.

Basta aggiungere { useNewUrlParser: true }.

Aggiornato per ECMAScript 8 / waitit

Anche il codice demo ECMAScript 8 errato fornito da MongoDB inc crea questo avviso.

MongoDB fornisce i seguenti consigli, che non sono corretti

Per utilizzare il nuovo parser, passare l'opzione {useNewUrlParser: true} a MongoClient.connect.

Ciò causerà il seguente errore:

TypeError: l'argomento finale executeOperationdeve essere un callback

Invece l'opzione deve essere fornita anew MongoClient :

Vedi il codice qui sotto:

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
}

Il problema può essere risolto fornendo il numero di porta e usando questo parser: {useNewUrlParser: true}

La soluzione può essere:

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

Risolve il mio problema.

L'esempio completo per Express.js, il caso di chiamata API e l'invio di contenuto JSON è il seguente:

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

Ecco come ce l'ho. Il suggerimento non è stato mostrato sulla mia console fino a quando non ho aggiornato npm un paio di giorni prima.

.connect ha tre parametri, l'URI, le opzioni e err.

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

Stavamo usando:

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

→ Ciò genera un errore del parser URL

La sintassi corretta è:

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

Hai solo bisogno di aggiungere

{ useNewUrlParser: true }

all'interno del metodo mongoose.connect.

Il seguente lavoro per me per la versione 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))

Queste righe sono state utili anche per tutti gli altri avvisi di deprecazione:

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

Stavo usando mlab.com come database MongoDB. Ho separato la stringa di connessione in un'altra cartella denominata confige all'interno del file keys.js Ho mantenuto la stringa di connessione che era:

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

E il codice del server 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

Devi scrivere {useNewUrlParser: true} dopo la stringa di connessione come ho fatto sopra.

In poche parole, devi fare:

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

Sto usando mongoose versione 5.x per il mio progetto. Dopo aver richiesto il pacchetto mongoose, impostare il valore a livello globale come di seguito.

const mongoose = require('mongoose');

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

Se usernameo passwordha il @personaggio, allora usalo in questo modo:

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