Ndtyjky

Edit: 'mongodb' v3.x

according to mongoDB ES6 future
you can use this way;

let MongoClient = require('mongodb').MongoClient;

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



    (async () => {

        let client = await MongoClient.connect(connectionString,

            { useNewUrlParser: true });



        let db = client.db('dbName');

        try {

           const res = await db.collection("collectionName").updateOne({ 

               "someKey": someValue

           }, { $set: someObj }, { upsert: true });



           console.log(`res => ${JSON.stringify(res)}`);

        }

        finally {

            client.close();

        }

    })()

        .catch(err => console.error(err));

Thanks. Working great with ES6:

const middleWare = require('middleWare');

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



router.get('/', middleWare(async (req, res, next) => {

    const db = await MONGO.connect(url);

    const MyCollection = db.collection('MyCollection');

    const result = await MyCollection.find(query).toArray();

    res.send(result);

}))

If u don't pass a callback, mongodb client returns a promise.

The official MongoDB Node.js driver provides both callback based as well as Promised based interaction with MongoDB allowing applications to take full advantage of the new features in ES6

From the official
docs

I'm posting this as an answer because I can't comment on Ido Lev's answer. I will move this as soon as I have reached 50 reputation.

Don't forget to close the db connection. Otherwise it's possible that your application can't connect to the db because of too many open connections (happened to me a week ago).

Your query may succeed or fail, so it makes sense to close the connection in a finally-block.

const db = await MongoClient.connect(url);

try {

    const stuff = await db.collection("Stuff").find({});

    // Do something with the result of the query

} finally {

    db.close();

}

Update: It seems that this also didn't fix my problem. Some people say that you don't even need to close the connection manually. It seems like it's best to reuse your connection across you application if possible.

mongoose find Query Using async/await

dont Use mongoose.connect in case of async/await

    var router = require("express").Router()

    var mongoose = require("mongoose")

var await = require("await")

var async = require("async")



    var mongoUrl = "mongodb://localhost:27017/ekaushalnsdc"



    router.get("/async/await/find",async(req, res,  next) => {

      try {

        var db =  await mongoose.createConnection(mongoUrl)

          var colName = db.collection('collectionName')

        var result  = await colName.find({}).toArray()

        res.json(result)

    }catch(ex) {

       res.json(ex.message)

    }

    })

If you want to work with cursor without unloading to Array, you can't use await with find() or aggregate() functions, then you have to use the code:

UPD by Usas:
For the general case, the answers using toArray() are sufficient.

But when huge document collections are involved, using toArray() would exceed available RAM. Thus a "high performance" solution in those situations must not use toArray().

For those cases, you can use MongoDB streams, which works well, but even simpler than using streams is to:

const cursor = db.collection('name').aggregate(

    [

        {

            "$match": {code: 10}

        },

        {

          "$count": "count"

        }

    ],

    {

        "allowDiskUse": false

    }

)



for (let doc = await cursor.next(); doc != null; doc = await cursor.next()) {

    console.log('aggregate:', doc.count);

}

(Based on Pax Beach's answer. It had been downvoted, and I wanted to add a comment explaining why in some situations, Pat's answer is the best. I don't have enough rep to add comments.)

For the general case, the answers using toArray() are sufficient.

But when huge document collections are involved, using toArray() would exceed available RAM. Thus a "high performance" solution in those situations must not use toArray().

For those cases, you can use MongoDB streams, which works well, but even simpler than using streams is to:

const cursor = db.collection('someCollection').find({})

for (let doc = await cursor.next(); doc; doc = await cursor.next()) {

    // Process the document.

}