CODEWITHSUNDEEP
javascriptnode.jsgenerator
scott
scott

Reputation: 122

Node.js Generators

I am unsure how to structure Javascript generator code such that it will execute correctly.

...

var http = require('http');

emails.send = function *(next) {
    // Pull the HTML for email to be sent from another local server
    mailOptions['html'] = yield* emailHtml();
    ...
};

function* emailHtml() {
    // Get the data from the database -- ends up using node-sqlite
    var data = yield mea.getMeasurements();

    // Callback function to deal with http request below
    function callback(response) {
        var str = '';

        response.on('data', function(chunk) {
            str += chunk;
        });
        response.on('end', function(chunk) {
            return str;
        });
    }

    // Make a request to the other server to get it's HTML
    var req = http.request(options, callback);
    // Post the data from this server's database connection to the other server to be processed and sent back
    req.write(JSON.stringify(data));
    req.end();

    return ??????;

}
...

I already have the emailHtml() function yielding data from the local sqlite database and passing that data via POST with the http.request but can't figure out how to structure my code to have the emailHtml() function return the callback's final string.

Do I need to make callback a generator function also? I've tried var req = yield http.request(options, callback); but since that stops the request, the POST data is never written and the request is never completed in the following two lines.

What other options do I have if a generator is not the right way to go about this?

Upvotes: 2

Views: 1201

Answers (2)

scott
scott

Reputation: 122

Just to add on Chris' answer, here's the cleaned up version of the code I'm now using:

var http = require('http');

emails.send = function *(next) {
    // Pull the HTML for email to be sent from another local server
    mailOptions['html'] = yield* emailHtml();
};

function makeHttpRequest(options, data) {
    // Note we're returning a promise here
    return new Promise(function (resolve, reject) {
        var req = http.request(options, callback);
        req.write(JSON.stringify(data));
        req.end();

        function callback(response) {
            var str = '';
            response.on('data', function (chunk) {
                str += chunk;
            });
            response.on('end', function (chunk) {
                // -- Resolve promise to complete the request
                resolve(str);
            });
        }
    });
}

function* emailHtml() {
    // Get the data from the database -- ends up using node-sqlite
    var data = yield mea.getMeasurements()

    // Make a request to the other server to get it's HTML
    return yield makeHttpRequest(options, data);

}

Promises are already built in to Node v0.12.7 when you use the --harmony flag so an additional library is not necessary

Upvotes: 1

Chris Tavares
Chris Tavares

Reputation: 30411

You need to turn the HTTP call into something you can yield on. It's messy as currently written, so time to pull in some other tools - in particular, promises. Since you're using Koa, which under the hood uses a library called co, promises are probably the easiest way to to this. I tend to use a library called Bluebird for my promise implementation, there are other options.

So basically you want something like this:

var http = require('http');
var Promise = require('bluebird');

emails.send = function *(next) {
    // Pull the HTML for email to be sent from another local server
    mailOptions['html'] = yield* emailHtml();
    ...
};

function makeHttpRequest(options, data) {
    // Note we're returning a promise here
    return new Promise(function (resolve, reject) {
        var req = http.request(options, callback);
        req.write(JSON.stringify(data));
        req.end();

        function callback(response) {
            var str = '';
            response.on('data', function (chunk) {
                str += chunk;
            });
            response.on('end', function (chunk) {
                // -- Resolve promise to complete the request
                resolve(str);
            });
        }
    });
}

function* emailHtml() {
    // Get the data from the database -- ends up using node-sqlite
    var data = yield mea.getMeasurements();

    // Callback function to deal with http request below
    function callback(response) {
        var str = '';

        response.on('data', function(chunk) {
            str += chunk;
        });
        response.on('end', function(chunk) {
            return str;
        });
    }

    // Make a request to the other server to get it's HTML
    var str = yield makeHttpRequest(options, data);

    // do whatever you want with the result
    return ??????;
}

This wraps up the http stuff inside a promise object, which you generator runner at the outer layer knows how to wait for completion of.

There's other ways to do this, and libraries (like co-request) that wrap this stuff natively, but this is the basic idea.

Upvotes: 3

Related Questions