使用Node.js抽象请求的生成

Question

Traditionally I use jQuery for all my JS code, but I'm tasked to launch a simple API with node.js. Today is my first day with Node but I know enough about JS and closures to do OK. One of the tasks of the API is to authenticate across a third party service and being a python guy, I wanted to abstract all my outbound request calls like so:

EDIT

var http = require('http');

var init = function(nconf) {
    var methods = {
    /*  
        Helper method to create the request header
    */
    headers: function(params) {
        var content = JSON.stringify(params);
        return {
            'Content-Type': 'application/json',
            'Content-Length': content.length
        }
    },
    /*
        Helper method to create the options object
        which is used in making any type of 
        outbound http request
    */
    options: function(host, path, method, params) {
         return {
            host: host,
            port: 80,
            path: path,
            method: method,
            headers: methods.headers(params)
        }
    },
    /*
        Helper method to abstract the making of
        outbound http requests
    */
    call: function(options, params, success, err) {
        var req = http.request(options, success);
        req.on('error', err);
        req.write(params);
        req.end();
    },
    /*
        Helper method to parse the response
        and return a json object
    */
    parse: function(res, result) {
        var responseString = '';
        res.on('data', function(data) {
            responseString += data;
        });

        res.on('end', function() {
            result = JSON.parse(responseString);
        });
    },
    /*
        API method to return the latest
        release and tag names
    */
    latest: function(req, res, next){
        // // var url = nconf.get('prod:authenticate');

        //authenticate the test user
        msg = methods.authenticate(nconf.get('test:user'), nconf.get("test:password"));
        res.send(msg);

        next();

    },
    /*
        Method used by this API to authenticate users.
        It is used to de-couple this API from the Database
        Schema by calling out to the TTCPAS App and requesting it
        to handle the authentication

    */
    authenticate: function(username, password){
        // create post parameters with API key
        var params = {"username": username, "password": password, "api_key": nconf.get('api_key')};
        //construct options object with params and header
        var options = methods.options(nconf.get('ttcpas:host'), nconf.get('ttcpas:auth_url'), 'POST', params);
        var result;
        var success = function(res) {
            res.setEncoding('utf-8');
            methods.parse(res, result);
        };
        methods.call(options, params, success, function(err){});
        while (typeof(result.statusCode) == 'undefined') {
            //wait 1 second;
            setTimeout(function(){
                console.log("waiting on request at " + nconf.get('ttcpas:host') + nconf.get('ttcpas:auth_url'));
            }, 1000);
        }
        //then down here
        if (result.statusCode == 200) {return result};//success
        if (result.statusCode == 403) {return "forbidden"};//forbidden


    }
}
return methods;
};
module.exports.init = init;

@jfriend00 As I said I don't know how node.js is supposed to be styled. I wanted to just abstract as much as possible to make the code clean and reusable

Now when I do http://localhost:9000/latest/

I get:

{"code":"InternalError","message":"first argument must be a string or Buffer"}

Answer 1

Uhhh, this part will simply not work:

while (typeof(result.statusCode) == 'undefined') {
    //wait 1 second;
    setTimeout(function(){
        console.log("waiting on request at " + nconf.get('ttcpas:host') + nconf.get('ttcpas:auth_url'));
    }, 1000);
}

If result.statusCode is ever undefined , this will spin forever piling up setTimeout() calls in the event queue until eventually something fills up or you run out of memory.

Because node.js is primarily single threaded, you can't loop waiting for something to change. Because you never finish this while loop, no other node.js code gets to run so result.statusCode can never change. Thus, you have an infinite loop here.

All of your nodejs code needs to be event driven, not spin/wait loops. FYI, this is similar to browser-based Javascript.