passing cookie data on MeteorJS HTTP request

Question

It already took me several hours implementing cookie on url MeteorJS. What I need to do is that, pass a cookie data n url like 'CURLOPT_COOKIE' PHP. I cant find any example code on their docs and even to forums. For now I have these functions:

/* HTTP REQUEST */
Meteor.methods({
   httpRequest: function(type, uri, params){
    this.unblock();
    check(type, String);
    check(uri, String);
    check(params, Object);
    try {
        var result = HTTP.call(type, uri, {params: params});
        return result;
    } catch (e) {
        // Got a network error, time-out or HTTP error in the 400 or 500 range.
        return e;
    }
   }
});
// HTTP request with cooki
 getUserDetails: function(session_id, uid){
  var params = {
     headers: {
      Cookie: {
        sessid: session_i
      }
    },      
    uid: uid
  };
  var response =  Meteor.call('httpRequest', "POST", "http://example.com/rest/wp /alt_wp_resources/loaduser.json", params);
  //res = JSON.parse(response.content);  
  return response;
}
// call here
Meteor.startup(function () {
// delay for 5 sec
Meteor.setTimeout(function (){
    Meteor.call('getUserCredentials', 'api12345', '123qweasd', function (error, result) {                   
    // check user authentication
    var success = result.success;
    console.log(result);
    // user has account from lpgp site, let's save him to meteor.
    if (success){
        console.log('success');
        var session_id = result.session_id;
        //console.log(_session_id);
        Meteor.call('getUserDetails', 'SESSba071091c09f79fefd66e4884dcdde50', 68558, function (error, result) {
            if (!error)
                console.log(result);
            else
                console.log(error);         
        });         
    }else
        // app can't find user account from lpgp site.
        console.log(error);             
});
}, 5000);
});

The call is successful but, just returned a success: false.

Response:

Object {statusCode: 200, content: "{"success":false}", headers: Object, data: Object}

Answer 1

Meteor's HTTP module on the server side is merely a wrapper for the npm module named request. The request npm module includes support for specifying your own cookies as well as saving them into a cookie jar (just follow the link and search for 'cookie'). The default cookie jar is tough-cookie and interestingly, Meteor includes it even though I don't see any way to use it from Meteor.HTTP.

The upshot of these implementation details is that you can use request directly. I took a similar approach to wrapping request as Meteor's HTTP module but instead of the restricted sub-set of options that HTTP provides, my wrapper allows full access to all the capability of request and tough-cookie. The cool part is that you don't even need to directly add request as a dependency on your own since it's already a dependency of Meteor. The risk, of course, is that a later version of Meteor could use something besides request and your code would break.

Anyway, here is my own wrapper for request. It includes an example of JSessionID cookie support for making Jenkins API calls. Just put this into a file syncRequest.coffee under the \server folder and make sure you have added the coffeescript package (Meteor add coffeescript)... or compile my code and save it to a .js file in the \server folder.

request = Npm.require('request')

populateData = (response) ->
  contentType = (response.headers["content-type"] or ";").split(";")[0]
  if _.include([ "application/json", "text/javascript" ], contentType)
    try
      response.data = JSON.parse(response.content)
    catch err
      response.data = null
  else
    response.data = null

normalizeOptions = (uri, options, callback) ->
  unless uri?
    throw new Error("undefined is not a valid uri or options object.")

  if (typeof options is "function") and not callback
    callback = options

  if options and typeof options is "object"
    options.uri = uri
  else if typeof uri is "string"
    options = uri: uri
  else
    options = uri

  return {options, callback}

normalizeResponse = (error, res, body) ->
  response = null
  unless error
    response = {}
    response.statusCode = res.statusCode
    response.content = body
    response.headers = res.headers
    populateData(response)
    if response.statusCode >= 400
      error = makeErrorByStatus(response.statusCode, response.content)
  return {error, response}

wrappedRequest = (uri, options, callback) ->
  {options, callback} = normalizeOptions(uri, options, callback)
  request(options, (error, res, body) ->
    {error, response} = normalizeResponse(error, res, body)
    callback(error, response)
  )

wrappedCall = (method, uri, options, callback) ->
  options.method = method
  wrappedRequest(uri, options, callback)

wrappedGet = (uri, options, callback) -> wrappedCall("GET", uri, options, callback)
wrappedPost = (uri, options, callback) -> wrappedCall("POST", uri, options, callback)
wrappedPut = (uri, options, callback) -> wrappedCall("PUT", uri, options, callback)
wrappedDelete = (uri, options, callback) -> wrappedCall("DELETE", uri, options, callback)

getWithJSession = (j_username, j_password, securityCheckUri, uri, callback) ->
  request = request.defaults({jar: true})

  form = {j_username, j_password}

  request.post({uri: securityCheckUri, form: form}, (error, response, body) ->
    if error?
      throw new Error(error)
    else if response.statusCode isnt 302
      throw new Error("Expected response code 302 (forward). Got #{response.statusCode}")
    else
      request.get(uri, (error, res, body) ->
        {error, response} = normalizeResponse(error, res, body)
        callback(error, response)
      )
  )

syncRequest = Meteor.wrapAsync(wrappedRequest)
syncRequest.call = Meteor.wrapAsync(wrappedCall)
syncRequest.get = Meteor.wrapAsync(wrappedGet)
syncRequest.post = Meteor.wrapAsync(wrappedPost)
syncRequest.put = Meteor.wrapAsync(wrappedPut)
syncRequest.delete = Meteor.wrapAsync(wrappedDelete)
syncRequest.del = syncRequest.delete

syncRequest.getWithJSession = Meteor.wrapAsync(getWithJSession)
syncRequest.getWithJsession = syncRequest.getWithJSession

(exports ? this).syncRequest = syncRequest