Memoization of promise-based function

Question

How can I memoize a promise-based function?

Would straightforward memoization of the function suffice?

function foo() {
    return new Promise((resolve, reject) => {
      doSomethingAsync({ success: resolve, fail: reject });
    });
};

Would this suffice?

var fooMemoized = memoize(foo);

Note: this question has been updated to remove the deferred anti-pattern.

Answer 1

Yes, that will suffice. Promises are simple return values, which is their great benefit - in contrast to callbacks, where memoisation code would be horrible.

You only might want to make sure that the memoized promise is uncancellable, if your promise library does support some kind of cancellation. Also notice that this form of memoisation remembers rejections as well, so you can't recover from errors by "trying again".

Answer 2

For promises simple sync memoize will not be good, because in most of cases you will not wish to memoize errors (rejected promises).

I did a simple library for common needs: https://github.com/nodeca/promise-memoize

1. It memoize Promise-based function, except errors by default
2. You can set expiration time for result
3. If you need, you can remember (and set expiration time) for errors too.
4. Data can be prefetched prior to expire, to never leave cache in cold state.

Pseudo code:

let db = require('mongoose').createConnection('mongodb://localhost/forum');

function lastPosts(limit) {
  return db.model('Post').find()
    .limit(limit).orderBy('-_id').lean(true).exec(); // <- Promise (thenable)
}

let cachedLastPosts = require('promise-memoize')(lastPosts, { maxAge: 60000 });

// Later...
cachedLastPosts(10).then(posts => console.log(posts));