How to handle Recursive Promise

Question

function Auth() {
    this.accessTokenError = false;

}
Auth.prototype.validateToken = function (accessToken, refreshToken) {
    var token;
    var self = this;
    return new Promise(function (resolve, reject) {
        AuthCron.secret()
            .then(function (secret) {

                if (self.accessTokenError) {
                    token = refreshToken;
                    secret = secret.substr(0, secret.length / 2);
                }
                else
                    token = accessToken;
                JWT.verify(token, secret, function (error, decoded) {
                    console.log(error, decoded);
                    if (error) {
                        if (!self.accessTokenError) {
                            self.accessTokenError = true;
                             // I don't know how to handle  this
                            self.validateToken(accessToken, refreshToken)
                        }
                        else {
                            self.accessTokenError = false;
                            reject(error);
                        }
                    }
                    else
                        resolve(decoded.user);
                });

            })
            .catch(function (err) {

                reject(err)
            });
    })
};

I am bit confused on how to handle recursive promise. The problem here is first promise never resolves nor rejects. What is the best way to handle this situation? This function accepts two tokens if access token is expired or invalid then refresh token is validated, if refresh token is also invalid then promise should reject.

Avoid the [`Promise` constructor antipattern](http://stackoverflow.com/q/23803743/1048572)! — Bergi, Nov 12 '16 at 11:09
promisify only `JWT.verify` with `new Promise`, in a separate function. Then call that and use `then` callbacks for everything else — Bergi, Nov 12 '16 at 13:13
i am unable to refactor above becoz i have to call that jwt function again for refresh token if there is error — Rayees, Nov 12 '16 at 14:01
Doing as Bergi suggests won't prevent a recursive call on error. In fact, it will help enormously. — Roamer-1888, Nov 12 '16 at 18:04

score 0 · Answer 1 · edited Sep 23 '17 at 01:07

With problems like this, it's generally best to separate the creation of promises from the higher order application logic. This is done by promisifying at the lowest possible level - JWT.verify() in this case.

JWT.verifyAsync = function(token, secret) {
    return new Promise((resolve, reject) => {
        JWT.verify(token, secret, (error, decoded) => {
            error ? reject(error) : resolve(decoded);
        });
    });
};

Now, you could still write the Auth.prototype.validateToken() method to perform its tries recursively, but, as there would only ever be a maximum of two levels of recursion, it's far simpler to hard-code both tries with (pseudo-code) first_try().catch(() => second_try()). As a bonus, the need for that awkward .accessTokenError boolean disappears.

Here it is in full :

Auth.prototype.validateToken = function(accessToken, refreshToken) {
    return AuthCron.secret()
    .then(secret => {
        return JWT.verifyAsync(accessToken, secret) // first try
        .catch(() => JWT.verifyAsync(refreshToken, secret.substr(0, secret.length / 2))); // second try
    })
    .then(decoded => decoded.user);
};

How to handle Recursive Promise

1 Answers1