@widergy/polling-handling
Version:
Utility GO! Polling Handling
114 lines (113 loc) • 4.54 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const apisauce_1 = require("apisauce");
const errorHandling_1 = require("@widergy/web-utils/lib/errorHandling");
const web_utils_1 = require("@widergy/web-utils");
const DEFAULT_INTERVAL = 1000;
const DEFAULT_TIMEOUT = 70000;
const POLLING_TIMEOUT_ERROR = 'PollingTimeoutError';
const api = (0, apisauce_1.create)({
baseURL: 'localhost',
timeout: 30000,
});
class PollingTimeoutError extends Error {
constructor(message) {
super(message);
this.message = message;
this.name = POLLING_TIMEOUT_ERROR;
}
}
const pollResource = (url, interval, timeout, headers, failureCallback, originalUrl) => {
const endTime = new Date().getTime() + timeout;
const pollingRequest = (resolve, reject) => {
api
.get(url, {}, { baseURL: '', headers })
.then((response) => {
if (response.status === 202) {
if (new Date().getTime() < endTime) {
setTimeout(pollingRequest, interval, resolve, reject);
}
else {
if (failureCallback) {
failureCallback(response, {
name: POLLING_TIMEOUT_ERROR,
originalUrl,
timeout,
});
}
reject(new PollingTimeoutError(`Polling timed out on url: ${url}`));
}
}
else if (response.ok) {
resolve(response);
}
else {
if ((0, errorHandling_1.existsErrorCode)(web_utils_1.ERROR_CODES.GATEWAY_TIMEOUT, response.data))
failureCallback(response, {
name: POLLING_TIMEOUT_ERROR,
originalUrl,
timeout,
});
reject(response);
}
})
.catch(reject);
};
return new Promise(pollingRequest);
};
const poll = async (baseUrl, request, failureCallback, originalUrl, timeout, interval) => {
const response = await request;
const url = response.data.url || `${baseUrl}${response.data.job_id ? response.data.job_id : response.data.response}`;
if (response.data.token) {
response.config.headers.Authorization = response.data.token;
}
else
delete response.config.headers['Authorization'];
const headers = response.config && response.config.headers;
return pollResource(url, interval, timeout, headers, failureCallback, originalUrl);
};
const retry = async (config, timeout, options, pollingInstance) => {
const { baseURL, headers, reqTimeout } = config;
const retryRequest = { baseURL, headers, reqTimeout };
return await pollingInstance.handle((0, apisauce_1.create)(retryRequest).get(config.url), timeout, options);
};
class Polling {
constructor(baseUrl = '', failureCallback = Function) {
this.baseUrl = baseUrl;
this.failureCallback = failureCallback;
this.apiInstance = api;
}
init(baseUrl, monitors, failureCallback) {
this.baseUrl = baseUrl;
this.failureCallback = failureCallback;
if (monitors)
monitors.forEach((monitor) => {
api.addMonitor(monitor);
});
}
async handle(originalRequest, timeout = DEFAULT_TIMEOUT, options) {
const request = await originalRequest;
const originalUrl = request.config.url;
const { retries = 0, interval = DEFAULT_INTERVAL } = options !== null && options !== void 0 ? options : {};
const response = {};
if (!request.ok) {
response.error = (0, errorHandling_1.getResponseError)(request);
response.status = request.status;
return response;
}
return poll(this.baseUrl, request, this.failureCallback, originalUrl, timeout, interval)
.then((result) => {
response.data = result.data;
return response;
})
.catch((err) => {
if (retries)
return retry(request.config, timeout, Object.assign(Object.assign({}, options), { retries: retries - 1 }), this);
response.error = (0, errorHandling_1.getResponseError)(err);
response.status = err.status;
response.originalUrl = originalUrl;
return response;
});
}
}
exports.default = new Polling();