How To Promisify Moltin APIs

If you’ve read my last post, then you know that I am having all kinds of geeky fun with Moltin and its APIs. Today I will show you how you can quickly promisify them all.

Moltin APIs

Moltin APIs are all asynchronous HTTP calls with very lightweight wrappers for JavaScript, Python, and many other languages. I am using it with node.js and the main pattern is fairly straightforward (look for js examples).

I am writing a batch import to create a playground product catalog so I find myself doing a lot of this:

const inventory = Promise.all(goGetTheData()); 

inventory.then((data) => {
    return Promise.all(data.products.map(product => {
        return new Promise((resolve, reject) => {
            moltin.Authenticate(function() {
                moltin.Product.Create({
                    // .. product attributes            
                }, (result) => {
                    resolve(result);
                }, (error, details) => {
                    reject(details);
                });
            });
        });    
    }));
}).then((products) => {
    return Promise.all(products.map(p => {
        return new Promise((resolve, reject) => {
            moltin.Authenticate(function() {
                // ...
            });
        });
    }));
}).then((modifiers) => {
    // ... you got the idea, a lot of noise
});

I wish I could instead write:

inventory.then((data) => Promise.all(data.products.map(p => {
    return moltin.Product.Create(...);
}))).then((products) => Promise.all(products.map(p => {
    return moltin.Modifier.Create(...);
}))).then((modifiers) => {
    // ... a lot cleaner and more readable, isn't it?
});

Promisification

There’s moltin-util on NPM that uses Promises but it seems to introduce a new API and I would like to retain the original. Here’s what I quickly put together and I now wonder if it’s worth posting to NPM. Is it? Let me know!

const request = require('request');
const fs = require('fs');

const promisify = (moltin) => {
    const promisified = {}

    const executor = (actor, action) => function () {
        const args = [...arguments];

        let success = (result, pagination) => {
            if (result && pagination) {
                result.pagination = pagination;
            }
            
            return result;
        };

        let error = (error, details) => details;

        if (typeof (args[args.length - 1]) === 'function') {
            if (typeof (args[args.length - 2]) === 'function') {
                error = args.pop();
                success = args.pop();
            } else {
                success = args.pop();
            }
        }

        return new Promise((resolve, reject) => {
            moltin.Authenticate(function () {
                actor[action].call(actor, ...args,
                    (result, pagination) => {
                        resolve(success.call(null, result, pagination));
                    },
                    (err, details) => {
                        console.error(details);
                        reject(error.call(null, details));
                    });
            });
        });
    };

    Object.keys(moltin)
        .filter(key => key !== 'options' && typeof (moltin[key]) === 'object')
        .forEach(member => {
            promisified[member] = {};
            let actor = moltin[member];

            Object.keys(actor.__proto__)
                .concat(Object.keys(actor.__proto__.__proto__))
                .filter(action => typeof (actor[action]) === 'function')
                .forEach(action => {
                    promisified[member][action] = executor(actor, action);
                });
        });
    
    return promisified;
}

module.exports = function (moltin) {
    return promisify(moltin);
};

My code is now a whole lot cleaner and smaller too. I will soon post it on Github so stay tuned! Here is, for example, how I would go about deleting a whole bunch of products:

const moltin = require('moltin')({
    publicId: process.env.MOLTIN_PUBLIC_ID,
    secretKey: process.env.MOLTIN_SECRET_KEY
});
const moltin_p = require('./promisify-moltin')(moltin);

moltin_p.Product.List(null)
    .then((products) => Promise.all(products.map(p => {
        console.log('Requesting a delete of %s', p.title);
        return moltin_p.Product.Delete(p.id);
    })))
    .then((result) => {
        console.log('Deleted %s products', result.length);
    })
    .catch((error) => {
        console.error(error);
    });