@intuitionrobotics/thunderstorm
Version:
279 lines • 9.92 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseHttpRequest = void 0;
const ts_common_1 = require("@intuitionrobotics/ts-common");
const types_1 = require("./types");
const request_types_1 = require("./request-types");
class BaseHttpRequest {
constructor(requestKey, requestData) {
this.headers = {};
this.method = types_1.HttpMethod.GET;
this.timeout = 10000;
this.defaultHeaders = {};
this.aborted = false;
this.getUrl = () => this.url;
this.addDefaultHeaders = () => {
Object.keys(this.defaultHeaders).forEach((_key) => {
// If the header has been set during the call I don't add the defaults. i.e. override
if (this.headers[_key])
return;
const defaultHeader = this.defaultHeaders[_key];
switch (typeof defaultHeader) {
case "function":
this.addHeader(_key, defaultHeader(this.url));
return;
case "string":
this.addHeader(_key, defaultHeader);
return;
case "object":
if (Array.isArray(defaultHeader)) {
this.addHeader(_key, defaultHeader);
return;
}
// I want this to follow through
default:
throw new ts_common_1.BadImplementationException("Headers values can only be of type: (() => string | string[]) | string | string[] ");
}
});
};
this.key = requestKey;
this.requestData = requestData;
this.compress = false;
}
setHandleRequestSuccess(handleRequestSuccess) {
this.handleRequestSuccess = handleRequestSuccess;
return this;
}
setHandleRequestFailure(handleRequestFailure) {
this.handleRequestFailure = handleRequestFailure;
return this;
}
getErrorMessage() {
return this.errorMessage;
}
getSuccessMessage() {
return this.successMessage;
}
getRequestData() {
return this.requestData;
}
setOrigin(origin) {
this.origin = origin;
return this;
}
setOnError(errorMessage) {
if (typeof errorMessage === "string") {
// @ts-ignore
// noinspection JSConstantReassignment
this.errorMessage = errorMessage;
}
else
this.onError = errorMessage;
return this;
}
setOnSuccessMessage(successMessage) {
// @ts-ignore
// noinspection JSConstantReassignment
this.successMessage = successMessage;
return this;
}
setOnProgressListener(onProgressListener) {
this.onProgressListener = onProgressListener;
return this;
}
setDefaultRequestHandler(processDefaultResponseHandlers) {
this.defaultResponseHandler = processDefaultResponseHandlers;
return this;
}
setLabel(label) {
this.label = label;
return this;
}
setMethod(method) {
this.method = method;
return this;
}
setResponseType(responseType) {
this.responseType = responseType;
return this;
}
setUrlParams(params) {
if (!params)
return this;
(0, ts_common_1._keys)(params).forEach((key) => {
const param = params[key];
return param && typeof param === "string" && this.setUrlParam(key, param);
});
return this;
}
setUrlParam(key, value) {
if (!this.params)
this.params = {};
else
delete this.params[key];
this.params[key] = value;
return this;
}
setUrl(url) {
this.url = url;
return this;
}
setRelativeUrl(relativeUrl) {
this.url = this.origin + relativeUrl;
return this;
}
setTimeout(timeout) {
this.timeout = timeout;
return this;
}
setHeaders(headers) {
if (!headers)
return this;
Object.keys(headers).forEach((key) => this.setHeader(key, headers[key]));
return this;
}
setDefaultHeaders(headers) {
this.defaultHeaders = headers;
return this;
}
addHeaders(headers) {
if (!headers)
return this;
Object.keys(headers).forEach((key) => this.addHeader(key, headers[key]));
return this;
}
setHeader(_key, value) {
const key = _key.toLowerCase();
delete this.headers[key];
return this.addHeader(key, value);
}
addHeader(_key, value) {
const key = _key.toLowerCase();
return this._addHeaderImpl(key, value);
}
removeHeader(key) {
delete this.headers[key];
return this;
}
_addHeaderImpl(key, value) {
const values = Array.isArray(value) ? value : [value];
if (!this.headers[key])
this.headers[key] = values;
else
this.headers[key].push(...values);
return this;
}
setJsonBody(bodyObject, compress) {
this.setHeader("content-type", "application/json");
this.setBody(this.prepareJsonBody(bodyObject), compress);
return this;
}
prepareJsonBody(bodyObject) {
return bodyObject;
}
setBody(bodyAsString, _compress) {
this.body = bodyAsString;
this.compress = _compress === undefined ? this.compress : _compress;
if (typeof bodyAsString === "string" && this.compress)
this.setHeader("Content-encoding", "gzip");
return this;
}
asJson() {
const response = this.getResponse();
if (!response)
throw new ts_common_1.BadImplementationException("No xhr.response...");
return JSON.parse(response);
}
asText() {
const response = this.getResponse();
if (!response)
throw new ts_common_1.BadImplementationException("No xhr object... maybe you didn't wait for the request to return??");
return response;
}
resolveResponse() {
const rawResponse = this.getResponse();
let response = undefined;
if (rawResponse) {
try {
response = rawResponse && this.asJson();
}
catch (e) {
response = this.asText();
}
}
return response;
}
handleFailure(reject) {
var _a;
const errorResponse = this.getErrorResponse();
(_a = this.onError) === null || _a === void 0 ? void 0 : _a.call(this, this, errorResponse);
this.handleRequestFailure(this, errorResponse);
reject === null || reject === void 0 ? void 0 : reject(errorResponse);
}
isValidStatus() {
const statusCode = this.getStatus();
return statusCode >= 200 && statusCode < 300;
}
executeSync() {
return __awaiter(this, void 0, void 0, function* () {
var _a;
this.addDefaultHeaders();
try {
yield this.executeImpl();
}
catch (e) {
this.handleFailure();
throw new request_types_1.HttpException(this.getStatus(), this.url, e);
}
if (this.aborted)
throw new request_types_1.HttpException(this.getStatus(), this.url); // should be status 0
// run this anyway to have consistent behaviour
(_a = this.defaultResponseHandler) === null || _a === void 0 ? void 0 : _a.call(this, this);
if (!this.isValidStatus()) {
this.handleFailure();
throw new request_types_1.HttpException(this.getStatus(), this.url);
}
this.handleRequestSuccess(this);
return this.resolveResponse();
});
}
execute(responseHandler) {
this.addDefaultHeaders();
const toCall = (resolve, reject) => __awaiter(this, void 0, void 0, function* () {
var _a;
yield this.executeImpl();
if (this.aborted)
return resolve();
if ((_a = this.defaultResponseHandler) === null || _a === void 0 ? void 0 : _a.call(this, this))
return resolve();
if (!this.isValidStatus())
return this.handleFailure(reject);
const response = this.resolveResponse();
responseHandler && (yield responseHandler(response, this.requestData));
this.handleRequestSuccess(this);
resolve();
});
(0, ts_common_1._setTimeout)(() => {
const label = this.label || `http request: ${this.key}`;
new Promise(toCall)
.then(() => console.log(`Async call completed: ${label}`))
.catch(reason => console.warn(`Async call error: ${label}`, reason));
});
return this;
}
abort() {
this.aborted = true;
this.abortImpl();
}
}
exports.BaseHttpRequest = BaseHttpRequest;
//# sourceMappingURL=BaseHttpRequest.js.map