What is the promise disposer pattern?

by

The issue with your code

The problem with the above approach is that if you forget releasing the connection after every single time you perform getDb you have a resource leak that might freeze your app eventually when it runs out of the resource you’re leaking.

You might, in one place do:

var users = getDb().then(function(conn){
     return conn.query("SELECT name FROM users");
});

Which will leak a database connection that was never closed.

The disposer pattern

The disposer pattern is a way to couple a scope of code with owning the resource. By binding the resource to a scope we make sure it is always released when we’re done with it and we can’t easily forget to release it. It is similar to using in C#, with in Python and try-with-resource in Java as well as RAII in C++.

It looks like:

 withResource(function(resource){
     return fnThatDoesWorkWithResource(resource); // returns a promise
 }).then(function(result){
    // resource disposed here
 });

Applying it here

If we wrote our code as:

function withDb(work){
    var _db;
    return myDbDriver.getConnection().then(function(db){
        _db = db; // keep reference 
        return work(db); // perform work on db
    }).finally(function(){
        if (_db)
            _db.release();
    });
}

We could write our above code as:

 withDb(function(conn){
     return conn.query("SELECT name FROM users");
 }).then(function(users){
     // connection released here
 });

Examples of users of the disposer pattern are sequelize and knex (bookshelf’s query builder). It’s also possible to use it for simpler things like hiding a loader when all AJAX requests completed for instance.

More Related Contents:

  1. What is the explicit promise construction antipattern and how do I avoid it?
  2. How do I convert an existing callback API to promises?
  3. How do I access previous promise results in a .then() chain?
  4. Aren’t promises just callbacks?
  5. When is .then(success, fail) considered an antipattern for promises?
  6. Is “.then(function(a){ return a; })” a no-op for promises?
  7. Correct way to write loops for promise.
  8. Asynchronous exception handling with bluebird promises
  9. Object method with ES6 / Bluebird promises
  10. Handling multiple catches in promise chain
  11. Limit concurrency of promise being run
  12. How do I tell if an object is a Promise?
  13. How to check if an object is a Promise?
  14. Catching Errors in JavaScript Promises with a First Level try … catch
  15. Slowdown due to non-parallel awaiting of promises in async generators
  16. resolving an array of promises from within a parent promise
  17. Are there still reasons to use promise libraries like Q or BlueBird now that we have ES6 promises? [closed]
  18. Promise.resolve vs new Promise(resolve)
  19. How do I use Bluebird with Angular?
  20. How do I handle errors with promises?
  21. Placement of catch BEFORE and AFTER then
  22. How can I promisify the MongoDB native Javascript driver using bluebird?
  23. While loop using bluebird promises
  24. When would someone need to create a deferred?
  25. How to promisify Node’s child_process.exec and child_process.execFile functions with Bluebird?
  26. Wait promise inside for loop
  27. How to extract data out of a Promise
  28. Limit concurrency of pending promises
  29. How do you properly promisify request?
  30. Understanding JavaScript promise object

Leave a Comment