Tag: request

I am working on a project in which I have a backend in nodejs and from there I have to call external APIs, these APIs require an authentication token which is valid for 15 minutes. So if the response status of external APIs is 401, I have to generate a new token and then call the request.

In my backend, I am using a demand-promise package which does not provide any concept of interceptor as axios, so I have been trying to create my own mechanism, the code below is in typed characters

class RequestHandler {

    private token: any = {

        promiseCreator: function () {
            return new Promise((resolve, reject) => {
                this.rejects.push(reject);
                this.resolves.push(resolve);
            });
        },
        rejects: (),
        resolves: (),
        v: null,
        get value() {
            return this.v;
        },
        set value(val) {
            this.v = val;
            if (val) {
                this.resolves.forEach((resolve: any) => resolve());
            } else {
                this.rejects.forEach((reject: any) => reject());
            }
            this.resolves = ();
            this.rejects = ();
        }

    };

    constructor() {
        this.authorize();
    }

    // Test Request
    public async test(reqBody) {

        const reqOptions = {
            dataType: "json",
            headers: {
                Authorization: `Bearer ${this.token.value}`
            },
            json: reqBody,
            method: "POST",
            url: "http://localhost:8080/test-async",
        };

        const { data } = await request(reqOptions);

        // on success return data
        if (data.status === "200") {
            return data;
        }

        // if authentication fails generate new token and then request again
        if (data.status === "401") {
            return await this.unAuthorizeRequestHandler(this.test.bind(this, reqBody));
        }

        // if status other than 200 and 401 then throw error
        throw new Error(data.message);

    }

    // To Get Authentication Token
    async authorize() {

        const reqOptions = {
            dataType: "json",
            json: {},
            method: "POST",
            url: "http://localhost:8080/auth",
        };

        const { token } = await request(reqOptions);
        this.token.value = token;

    }

    // handles retry logic
    async unAuthorizeRequestHandler(requestFunction: any) {

        if (this.token.value) {
            this.token.value = null;

            try {
                await this.authorize();
            } catch (err) {
                this.token.value = null;
                throw new Error(err.toString());
            }

        } else {
            await this.token.promiseCreator();
        }
        return await requestFunction();
    }

}

In the above code, anAuthorizeRequestHandler handles the retry mechanism, it first checks to see if the value of the token is not zero. done by promiseGenerator, it returns the pending promise which will be resolved or rejected when authorizing the defined function token.value)

Please review my codes