async-promise-proxy

Usage

npm install async-promise-proxy

GeneratorToPromise

Used to wraps a es6 class that has generator methods, and proxies it into a promise. This is better expained with an example:

es6 exmpale

import req from 'some-request-library-that-supports-promises(like request-promise)';
import {GeneratorToPromise} from 'async-promise-proxy';
 
// NOTE this example is just to show case the yield -> then functionality.  This is not a great use-case.
class UserApi {
    * getUser(userId) {
        // in this instance think of yield* like await in the async/await C# 6.
        let user = yield* req.get({
            uri: `whatever.com/users/${userId}`
        });
 
        return user;
    }
 
    * postUser (user) {
 
        // one yield
        yield* req.post({
            uri: `whatever.com/`,
            json: user
        });
 
        // two yield, this will be the data in the .then(function(data) { })
        return yield* req.get({
            uri: 'whatever.com/${userId}'
        });
    }
}
 
// now we user the generator:
 
var userApi = new GeneratorToPromise(new UserApi());
 
// Now the calls to the generators will instead return promises.
userApi
    .getUser('someUserId')
    .then(function (data) {
        /* user data, that was returned in the UserApi.getUser */
        console.log(data);
    })
    .catch(function (err) {
        /* if an error happens this will be called */
        console.log(err);
    })
 
userApi
    .postUser({ userId: 'someUserId', name: 'someUser' })
    .then(function (data) {
        /* now this will be the last yield in the UserApi.postUser function, not the first yield */
        console.log(data);
    });
 
// You can even chain methods together:
someFakeApi
    .someMethodThatUpdatesTheUnderlyingInstance()
    .someOtherMethodThatUsesTheUpdatesFromThePreviousMethod()
    .then(console.log)
    // you can even chain off the thens
    .theLastMethodThatsCalled()
    .then(console.log);

NoMethodCatcher

Inherit from this class to setup a noSuchMethod like behavior in your class. Note this only works with node/io.js/)any server side js engine that supports the Proxy behavior). For node.js however you don't need to run with the --harmony-proxies flag, including the library does that for you.

es6 example:

 
import {NoMethodCatcher} from 'async-promise-proxy';
 
// class
class IAcceptAllMethods extends NoMethodCatcher {
    // these classes need constructors
    constructor() {
        super(); // call super(true) if your catch-all method is a generator.
        this.setup(this.catchTheMethods);
 
        // this is SUPER important, you must return this.proxy().
        return this.proxy();
    }
 
    // name will be the name of the unhandled method that got called, args is...the args.
    catchTheMethods(name, args) {
        console.log(`got unhandled method: ${name} with args ${args.join(", ")}`);
    }
 
    actualMethod() {
        console.log("Got a call on the actual method.");
 
        //note: if you want a fluent interface you have to return this.proxy() and not this
        return this.proxy();
    }
}
 
var test = new IAcceptAllMethods();
 
test.someMethodThatDoesntExist('does', 'not', 'exist') // --> got unhandled method: someMethodThatDoesntExist with args does, not, exist
test
    .actualMethod() // --> Got a call on the actual method.
    .soWhat('ever') // --> got unhandled method: soWhat with args ever
 

es5 example:

var NoMethodCatcher = require('async-promise-proxy').NoMethodCatcher;
 
function IAcceptAllMethods() {
    this.setup(this.catchTheMethods);
 
    return this.proxy();
};
 
// the only real difference.
IAcceptAllMethods.prototype = new NoMethodCatcher();
 
IAcceptAllMethods.prototype.catchTheMethods = function (name, args) {
    console.log("got unhandled method: "+name+" with args "+args.join(", "));
};
 
IAcceptAllMethods.prototype.actualMethod = function () {
    console.log("Got a call on the actual method.");
 
    //note: if you want a fluent interface you have to return this.proxy() and not this
    return this.proxy();
};
 
 
var test = new IAcceptAllMethods();
 
test.someMethodThatDoesntExist('does', 'not', 'exist') // --> got unhandled method: someMethodThatDoesntExist with args does, not, exist
test
    .actualMethod() // --> Got a call on the actual method.
    .soWhat('ever') // --> got unhandled method: soWhat with args ever