如果 node.js 出错，请重试请求

Question

I have an application with node and my app is autenticated (as client) with JWT on an API.

How can I refresh my token when I have an 401 error ?

My project use not Express

my service :

const request = require('request');

let config = require('../../configuration');

module.exports = {
    get_movies: function () {
        return new Promise((resolve, reject) => {
            request({
                method: 'GET',
                uri   : 'http://myapi/v1/movies',
                auth  : {
                    'bearer': config.token
                },
                json  : true
            }, function (error, response, body) {
                if (!error && response.statusCode === 200) {
                    resolve(body);
                } else {
                    reject(response);
                }
            })
        });
    },
    ...
    refreshToken: function () {
        return new Promise((resolve, reject) => {
            request({
                method: 'GET',
                uri   : 'http://myapi/v1/token-refresh',
                auth  : {
                    'bearer': config.token
                },
                json  : true
            }, function (error, response, body) {
                if (!error && response.statusCode === 200) {
                    resolve(body);
                } else {
                    reject(response);
                }
            })
        });
};

I would like to know if it's possible to intercept my (error 401) request on my get_movies function for example, call my refresh token function and after retry my previous function (get_movies) ?

Answer 1

A simple way would be to put an error handler after your get_movies promise to handle the case and retry. Along the lines of:

get_retry: function () {
    return get_movies().catch((rejection) => {
        if (rejection.statusCode === 401)
            return refreshToken().then((x) => get_retry())
    })
}

Beware of the possibility of an infinite loop if your refreshToken() has a possibility to not fix the HTTP 401 .

Answer 2

I have been using got for this and have been really happy with it.

You can use the afterResponse hook to detect error, check that it is 401 and then refresh token and resubmit original request.

From the documentation:

const got = require('got');

const instance = got.extend({
    hooks: {
        afterResponse: [
            (response, retryWithMergedOptions) => {
                if (response.statusCode === 401) { // Unauthorized
                    const updatedOptions = {
                        headers: {
                            token: getNewToken() // Refresh the access token
                        }
                    };

                    // Save for further requests
                    instance.defaults.options = got.mergeOptions(instance.defaults.options, updatedOptions);

                    // Make a new retry
                    return retryWithMergedOptions(updatedOptions);
                }

                // No changes otherwise
                return response;
            }
        ],
        beforeRetry: [
            (options, error, retryCount) => {
                // This will be called on `retryWithMergedOptions(...)`
            }
        ]
    },
    mutableDefaults: true
});

It's working great for me so far :-)