Promises propagating intermediate objects (NodeJS + MongoDB)

Question

I'm trying to use MongoDB with Promises in Node 4.x

In this example I want to:

1. Connect to my mongodb
2. THEN delete everything with a given Key
3. THEN insert one record
4. THEN close the connection

luckily the mongodb client spits out promises when you don't give it a callback. Here's what I came up with.

const MongoClient = require('mongodb').MongoClient;
const test = require('assert');

function insertDoc(doc, collName) {
  return MongoClient.connect('mongodb://localhost:27017/myDB')
    .then(db => {
      const col = db.collection(collName);
      return col.deleteMany({ 'Key': doc.key })
        .then(() => col.insertOne(doc))
        .then(result => test.equal(1, result.insertedCount))
        .then(() => db.close);
    });
}

The code seems to work but the nested .then() "feels" wrong. Any ideas how to do it so that the db object can be used when I'm ready to .close() it?

Answer 1

One option is to treat the promises more as values, then pull out the wrapped value when you need it. It has its own readability downsides though.

e.g.

function insertDoc(doc, collName) {
  const db = MongoClient.connect('mongodb://localhost:27017/myDB');
  const col = db.then(db => db.collection(collName));

  return col.deleteMany({ 'Key': doc.key })
    .then(() => col.insertOne(doc))
    .then(result => test.equal(1, result.insertedCount))
    // You've still got the 'db' promise here, so you can get its value
    // to close it.
    .then(() => db.then(db => db.close()));
}

Answer 2

As it stands you can use a variable in the outer scope to achieve this:

let db;

function insertDoc(doc, collName) {
  return MongoClient.connect(dsn)
    .then(connectedDb => {
      db = connectedDb;
      return col.deleteMany(doc)
    }) // now you can chain `.then` and still use `db`
}

There are a few possible alternatives such as passing db along, but this would seem weird to me. If you want to keep this flow but still take advantage of asynchronicity, you can use async/await. Right now you will need a transpiler such as babel and something like the regenerator-runtime to use it.

async function insertDoc(doc, collName) {
  const db = await MongoClient.connect(dsn);
  const col = db.collection(collName);
  await col.deleteMany({Key: doc.key});
  const result = await col.insertOne(doc);
  await test.equal(1, result.insertedCount) // is this asynchronous?
  return db.close();
}

You can also use co/yield to avoid transpiling although it's a bit more verbose.

Answer 3

I find what you have to be the most readable pattern of alternatives I've seen. I myself use indentation (nested .then's) to access previous values (and that's the only time I do it!)

So many things end up affecting how the code looks and reads. Take your col temporary for example. If it weren't needed, your code might have looked like this:

var insertDoc = (doc, collName) => MongoClient.connect('mongodb://localhost:x/DB')
  .then(db => db.collection(collName).deleteMany({ 'Key': doc.key })
    .then(() => db.collection(collName).insertOne(doc))
    .then(result => test.equal(1, result.insertedCount))
    .then(() => db.close))
  .then(() => doSomethingElse());

Note the extra ) after db.close). An editor that bracket-matches is helpful. :)

I'm not suggesting dropping col for the sake of code beauty. I'm only showing this because I think it highlights how indentation shows the scope of the db value well. It's when I saw code like this, that I started liking this pattern.

In real life code doesn't always collapse neatly, but I like a pattern where it does when it can.