Parse.com and closures

Question

I have a Cloud Code function that will execute n times the same block. The block consist in an http call with auth header. to make things simple, I have created a function at the root of my main.js . The function needs to return a result and keep in memory the authData (in order to reuse it for future calls).

function requestURI (uri){
    var authData; // gets generated if null, should be reused if not null
    var result; // supposingly contains the results

    return something();
}

The function something() is a Parse.Promise because I need my calls to be asynchronous. As I understand I can't attach the result nor the authData to my promise.... If I run a console.log() within the function requestURI() , I see authData and result correctly populated as expected

Then I want this function from a Parse function. (the whole purpose is to have the function being re-usable by any other)

Parse.Cloud.define("testCall", function(request, response) {
    var uri1 = '...';
    var uri2 = '...';
    var uri3 = '...';

    return requestURI(uri1).then(function(){
        // how do I get the result of my request?
        return request(uri2);
    }).then(function(){
        // how do I get the result of my request?
        return request(uri3);
    });
}

The problem I have is that I can't retrieve my result out of the requestURI function and it seems that authData is reset everytime I run the function

I read the solution lies in closures but I can't get my head around them...

edit: add the function something():

 return Parse.Cloud.httpRequest({
        method: 'GET',
        url: url,
        headers: {
            "Authorization" : digestAuthHeader
        },
        success: function(httpResponse) {
            // all went well, let's increase the nonceCount, for future calls
            authData["nc"] += 1;
            // I need to return the result object in a promise
            result = httpResponse.data;
            // return a Promise that can be handled by any function
            return Parse.Promise.as(result)); // this promise doesn't work
        },
        error: function(httpResponse) {
            console.error('Request failed with response code ' + httpResponse.status);
            return (null,Parse.Promise.error(httpResponse.text));
        }
    });

edit: here is what I'm trying

// authData is not null, we can make an authenticated call
function makeAuthenticatedRequest(){
    // generate the appropriate auth Header;
    var digestAuthHeader = generateDigestAuthHeader();

    return Parse.Cloud.httpRequest({
        method: 'GET',
        url: url,
        headers: {
            "Authorization" : digestAuthHeader
        }}).then(function(httpResponse) {
            // all went well, let's increase the nonceCount, for future calls
            authData["nc"] += 1;
            // create the final object to return in a promise
            result = httpResponse.data;

            console.log(result) // returns something not null!!!

            // return a Promise that can be handled by any function
            return promise.resolve({'authData': authData, 'result': result});
        },
        function(error) {
            console.error('Request failed with response code ' + error.status);
            return (null,Parse.Promise.error(error));
        });
}


Parse.Cloud.define("testCall", function(request, response) {
    var uri1 = '...';
    var authData;


    return apiCall1001Menus(authData,uri1).then(function(result){
        response.success(result); // returns {}
    });

});

my response callback is {}!!! which is not what I would expect at all

Answer 1

I will give you an example to prevent my bad english cause misleading.

The following rewrite function makeAuthenticatedRequest() in callback deferred antipattern and promise fashion.

Callback:

Deferred antipattern:

function makeAuthenticatedRequest(){
    // generate the appropriate auth Header;
    var digestAuthHeader = generateDigestAuthHeader();
    var promise = new Parse.promise();
    Parse.Cloud.httpRequest({
        method: 'GET',
        url: url,
        headers: {
            "Authorization" : digestAuthHeader
        },
        success: function(httpResponse) {
            // all went well, let's increase the nonceCount, for future calls
            authData["nc"] += 1;
            // create the final object to return in a promise
            result = httpResponse.data;

            console.log(result) // returns something not null!!!

            // return a Promise that can be handled by any function
            promise.resolve({'authData': authData, 'result': result});
        },
        error: function(error) {
            console.error('Request failed with response code ' + error.status);
            // it could be promise.resolve (success) or promise.reject (error)
            promise.reject(error);
        }
    });
    return promise;
}

Promise :

function makeAuthenticatedRequest(){
    // generate the appropriate auth Header;
    var digestAuthHeader = generateDigestAuthHeader();

    return Parse.Cloud.httpRequest({
            method: 'GET',
            url: url,
            headers: {
                "Authorization" : digestAuthHeader
            }
        }).then(function(httpResponse) {
            // all went well, let's increase the nonceCount, for future calls
            authData["nc"] += 1;
            // create the final object to return in a promise
            result = httpResponse.data;

            console.log(result) // returns something not null!!!

            // return a Promise that can be handled by any function
            return {'authData': authData, 'result': result};
        }, function(error) {
            console.error('Request failed with response code ' + error.status);
            return Parse.Promise.error(error);
        });
}