I have a database wrapper class that establishes a connection to some MongoDB instance:
async connect(connectionString: string): Promise<void> {
this.client = await MongoClient.connect(connectionString)
this.db = this.client.db()
}
This gave me a warning:
(node:4833) 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.
The connect()
method accepts a MongoClientOptions
instance as second argument. But it doesn't have a property called useNewUrlParser
. I also tried to set those property in the connection string like this: mongodb://127.0.0.1/my-db?useNewUrlParser=true
but it has no effect on those warning.
So how can I set useNewUrlParser
to remove those warning? This is important to me since the script should run as cron and those warnings result in trash-mail spam.
I'm using mongodb
driver in version 3.1.0-beta4
with corresponding @types/mongodb
package in 3.0.18
. Both of them are the latest avaliable using npm install
.
Using an older version of mongodb driver:
"mongodb": "~3.0.8",
"@types/mongodb": "~3.0.18"
This question is related to
node.js
mongodb
typescript
express
mongoose
You just need to set the following things before connecting to the database as below:
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');
Also,
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().
The following work for me
for the mongoose
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))
The below highlighted code to the mongoose connection solved the warning for the mongoose driver:
mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true });
The connection string format must be mongodb://user:password@host:port/db
For example:
MongoClient.connect('mongodb://user:[email protected]:27017/yourDB', { useNewUrlParser: true } )
const mongoose = require('mongoose');
mongoose
.connect(connection_string, {
useNewUrlParser: true,
useUnifiedTopology: true,
useCreateIndex: true,
useFindAndModify: false,
})
.then((con) => {
console.log("connected to db");
});
try to use this
The complete example for Express.js, API calling case and sending JSON content is the following:
...
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()
},
)
})
}
mongoose.connect("mongodb://localhost/mean-course").then(
(res) => {
console.log("Connected to Database Successfully.")
}
).catch(() => {
console.log("Connection to database failed.");
});
? This gives a URL parser error
mongoose.connect("mongodb://localhost:27017/mean-course" , { useNewUrlParser: true }).then(
(res) => {
console.log("Connected to Database Successfully.")
}
).catch(() => {
console.log("Connection to database failed.");
});
Here's how I have it. The hint didn't show on my console until I updated npm a couple of days prior.
.connect has three parameters, the URI, options, and err.
mongoose.connect(
keys.getDbConnectionString(),
{ useNewUrlParser: true },
err => {
if (err)
throw err;
console.log(`Successfully connected to database.`);
}
);
If username
or password
has the @
character, then use it like this:
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));
As noted the 3.1.0-beta4
release of the driver got "released into the wild" a little early by the looks of things. The release is part of work in progress to support newer features in the MongoDB 4.0 upcoming release and make some other API changes.
One such change triggering the current warning is the useNewUrlParser
option, due to some changes around how passing the connection URI actually works. More on that later.
Until things "settle down", it would probably be advisable to "pin" at least to the minor version for 3.0.x
releases:
"dependencies": {
"mongodb": "~3.0.8"
}
That should stop the 3.1.x
branch being installed on "fresh" installations to node modules. If you already did install a "latest" release which is the "beta" version, then you should clean up your packages ( and package-lock.json
) and make sure you bump that down to a 3.0.x
series release.
As for actually using the "new" connection URI options, the main restriction is to actually include the port
on the connection string:
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)
}
})()
That's a more "strict" rule in the new code. The main point being that the current code is essentially part of the "node-native-driver" ( npm mongodb
) repository code, and the "new code" actually imports from the mongodb-core
library which "underpins" the "public" node driver.
The point of the "option" being added is to "ease" the transition by adding the option to new code so the newer parser ( actually based around url
) is being used in code adding the option and clearing the deprecation warning, and therefore verifying that your connection strings passed in actually comply with what the new parser is expecting.
In future releases the 'legacy' parser would be removed and then the new parser will simply be what is used even without the option. But by that time, it is expected that all existing code had ample opportunity to test their existing connection strings against what the new parser is expecting.
So if you want to start using new driver features as they are released, then use the available beta
and subsequent releases and ideally make sure you are providing a connection string which is valid for the new parser by enabling the useNewUrlParser
option in MongoClient.connect()
.
If you don't actually need access to features related to preview of the MongoDB 4.0 release, then pin the version to a 3.0.x
series as noted earlier. This will work as documented and "pinning" this ensures that 3.1.x
releases are not "updated" over the expected dependency until you actually want to install a stable version.
The following works for me
const mongoose = require('mongoose');
mongoose.connect("mongodb://localhost/playground", { useNewUrlParser: true,useUnifiedTopology: true })
.then(res => console.log('Connected to db'));
The mongoose
version is 5.8.10
.
I don't think you need to add { useNewUrlParser: true }
.
It's up to you if you want to use the new URL parser already. Eventually the warning will go away when MongoDB switches to their new URL parser.
As specified in Connection String URI Format, you don't need to set the port number.
Just adding { useNewUrlParser: true }
is enough.
This works for me nicely:
mongoose.set("useNewUrlParser", true);
mongoose.set("useUnifiedTopology", true);
mongoose
.connect(db) //Connection string defined in another file
.then(() => console.log("Mongo Connected..."))
.catch(() => console.log(err));
You need to add { useNewUrlParser: true }
in the mongoose.connect() method.
mongoose.connect('mongodb://localhost:27017/Notification',{ useNewUrlParser: true });
There is nothing to change. Pass only in the connect function {useNewUrlParser: true }
.
This will work:
MongoClient.connect(url, {useNewUrlParser:true,useUnifiedTopology: true }, function(err, db) {
if(err) {
console.log(err);
}
else {
console.log('connected to ' + url);
db.close();
}
})
The problem can be solved by giving the port number and using this parser: {useNewUrlParser: true}
The solution can be:
mongoose.connect("mongodb://localhost:27017/cat_app", { useNewUrlParser: true });
It solves my problem.
Check your mongo
version:
mongo --version
If you are using version >= 3.1.0, change your mongo
connection file to ->
MongoClient.connect("mongodb://localhost:27017/YourDB", { useNewUrlParser: true })
or your mongoose connection file to ->
mongoose.connect("mongodb://localhost:27017/YourDB", { useNewUrlParser: true });
Ideally, it's a version 4 feature, but v3.1.0 and above are supporting it too. Check out MongoDB GitHub for details.
I was using mlab.com as the MongoDB database. I separated the connection string to a different folder named config
and inside file keys.js I kept the connection string which was:
module.exports = {_x000D_
mongoURI: "mongodb://username:[email protected]:47267/projectname"_x000D_
};
_x000D_
And the server code was
const express = require("express");_x000D_
const mongoose = require("mongoose");_x000D_
const app = express();_x000D_
_x000D_
// Database configuration_x000D_
const db = require("./config/keys").mongoURI;_x000D_
_x000D_
// Connect to MongoDB_x000D_
_x000D_
mongoose_x000D_
.connect(_x000D_
db,_x000D_
{ useNewUrlParser: true } // Need this for API support_x000D_
)_x000D_
.then(() => console.log("MongoDB connected"))_x000D_
.catch(err => console.log(err));_x000D_
_x000D_
app.get("/", (req, res) => res.send("hello!!"));_x000D_
_x000D_
const port = process.env.PORT || 5000;_x000D_
_x000D_
app.listen(port, () => console.log(`Server running on port ${port}`)); // Tilde, not inverted comma
_x000D_
You need to write { useNewUrlParser: true } after the connection string as I did above.
Simply put, you need to do:
mongoose.connect(connectionString,{ useNewUrlParser: true } _x000D_
// Or_x000D_
MongoClient.connect(connectionString,{ useNewUrlParser: true } _x000D_
_x000D_
The incorrect ECMAScript 8 demo code MongoDB inc provides also creates this warning.
MongoDB provides the following advice, which is incorrect
To use the new parser, pass option { useNewUrlParser: true } to MongoClient.connect.
Doing this will cause the following error:
TypeError: final argument to
executeOperation
must be a callback
Instead the option must be provided to new MongoClient
:
See the code below:
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
}
These lines did the trick for all other deprecation warnings too:
const db = await mongoose.createConnection(url, { useNewUrlParser: true });
mongoose.set('useCreateIndex', true);
mongoose.set('useFindAndModify', false);
I am using mongoose version 5.x for my project. After requiring the mongoose package, set the value globally as below.
const mongoose = require('mongoose');
// Set the global useNewUrlParser option to turn on useNewUrlParser for every connection by default.
mongoose.set('useNewUrlParser', true);
Source: Stackoverflow.com