@intuitionrobotics/thunderstorm 0.41.69 → 0.41.70

package/app-backend/modules/server/server-api.js

@@ -19,19 +19,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 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) {
@@ -41,427 +28,315 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArrays = (this && this.__spreadArrays) || function () {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiResponse = exports.ServerApi_Redirect = exports.ServerApi_Proxy = exports.ServerApi_Post = exports.ServerApi_Get = exports.ServerApi = void 0;
 /**
  * Created by tacb0ss on 11/07/2018.
  */
-var ts_common_1 = require("@intuitionrobotics/ts-common");
-var url_1 = require("url");
-var HttpServer_1 = require("./HttpServer");
+const ts_common_1 = require("@intuitionrobotics/ts-common");
+const url_1 = require("url");
+const HttpServer_1 = require("./HttpServer");
 // noinspection TypeScriptPreferShortImport
-var types_1 = require("../../../shared/types");
-var to_be_removed_1 = require("../../utils/to-be-removed");
-var exceptions_1 = require("../../exceptions");
-var RemoteProxy_1 = require("../proxy/RemoteProxy");
-var ServerApi = /** @class */ (function (_super) {
-    __extends(ServerApi, _super);
-    function ServerApi(method, relativePath, tag) {
-        var _this = _super.call(this, tag || relativePath) || this;
-        _this.printResponse = true;
-        _this.headersToLog = [];
-        _this.sideEffects = [];
-        _this.assertProperty = to_be_removed_1.assertProperty;
-        _this.callWrapper = function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.call(req, res)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.releaseSideEffects()];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
+const types_1 = require("../../../shared/types");
+const to_be_removed_1 = require("../../utils/to-be-removed");
+const exceptions_1 = require("../../exceptions");
+const RemoteProxy_1 = require("../proxy/RemoteProxy");
+class ServerApi extends ts_common_1.Logger {
+    constructor(method, relativePath, tag) {
+        super(tag || relativePath);
+        this.printResponse = true;
+        this.headersToLog = [];
+        this.sideEffects = [];
+        this.assertProperty = to_be_removed_1.assertProperty;
+        this.callWrapper = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            yield this.call(req, res);
+            yield this.releaseSideEffects();
+        });
+        this.releaseSideEffects = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield Promise.all(this.sideEffects.map(sideEffect => sideEffect()));
+            }
+            catch (e) {
+                this.logError("Something went wrong while performing the side effects", e);
+            }
+            finally {
+                this.sideEffects = [];
+            }
+        });
+        this.call = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const response = new ApiResponse(this, res);
+            this.logInfo(`Intercepted Url: ${req.path}`);
+            if (this.headersToLog.length > 0) {
+                const headers = {};
+                for (const headerName of this.headersToLog) {
+                    headers[headerName] = req.header(headerName);
+                }
+                this.logDebug(`-- Headers: `, headers);
+            }
+            const reqQuery = url_1.parse(req.url, true).query;
+            if (reqQuery && typeof reqQuery === "object" && Object.keys(reqQuery).length)
+                this.logVerbose(`-- Url Params: `, reqQuery);
+            else
+                this.logVerbose(`-- No Params`);
+            const body = req.body;
+            if (body && ((typeof body === "object")))
+                this.logVerbose(`-- Body (Object): `, body);
+            else if (body && body.length)
+                this.logVerbose(`-- Body (String): `, body);
+            else
+                this.logVerbose(`-- No Body`);
+            const requestData = {
+                method: this.method,
+                originalUrl: req.path,
+                headers: req.headers,
+                url: req.url,
+                query: reqQuery,
+                body: body
+            };
+            try {
+                this.bodyValidator && ts_common_1.validate(body, this.bodyValidator);
+                this.queryValidator && ts_common_1.validate(reqQuery, this.queryValidator);
+                if (this.middlewares)
+                    yield Promise.all(this.middlewares.map(m => m(req, requestData)));
+                const toReturn = yield this.process(req, response, reqQuery, body);
+                if (response.isConsumed())
+                    return;
+                if (!toReturn)
+                    return yield response.end(200);
+                // TODO need to handle stream and buffers
+                // if (Buffer.isBuffer(toReturn))
+                // 	return response.stream(200, toReturn as Buffer);
+                const responseType = typeof toReturn;
+                if (responseType === "object")
+                    return yield response.json(200, toReturn);
+                if (responseType === "string" && toReturn.toLowerCase().startsWith("<html"))
+                    return yield response.html(200, toReturn);
+                return yield response.text(200, toReturn);
+            }
+            catch (err) {
+                let e = err;
+                let severity = ts_common_1.ServerErrorSeverity.Warning;
+                if (typeof e === "string")
+                    e = new ts_common_1.BadImplementationException(`String was thrown: ${e}`);
+                if (!(e instanceof Error) && typeof e === "object")
+                    e = new ts_common_1.BadImplementationException(`Object instance was thrown: ${JSON.stringify(e)}`);
+                try {
+                    this.logErrorBold(e);
                 }
-            });
-        }); };
-        _this.releaseSideEffects = function () { return __awaiter(_this, void 0, void 0, function () {
-            var e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, 3, 4]);
-                        return [4 /*yield*/, Promise.all(this.sideEffects.map(function (sideEffect) { return sideEffect(); }))];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 2:
-                        e_1 = _a.sent();
-                        this.logError("Something went wrong while performing the side effects", e_1);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        this.sideEffects = [];
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
+                catch (e2) {
+                    this.logErrorBold("Error while handling error on request...", e2);
+                    this.logErrorBold(`Original error thrown: ${JSON.stringify(e)}`);
+                    this.logErrorBold(`-- Someone was stupid... you MUST only throw an Error and not objects or strings!! --`);
                 }
-            });
-        }); };
-        _this.call = function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-            var response, headers, _i, _a, headerName, reqQuery, body, requestData, toReturn, responseType, err_1, e, severity, apiException, message, e_2;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        response = new ApiResponse(this, res);
-                        this.logInfo("Intercepted Url: " + req.path);
-                        if (this.headersToLog.length > 0) {
-                            headers = {};
-                            for (_i = 0, _a = this.headersToLog; _i < _a.length; _i++) {
-                                headerName = _a[_i];
-                                headers[headerName] = req.header(headerName);
-                            }
-                            this.logDebug("-- Headers: ", headers);
-                        }
-                        reqQuery = url_1.parse(req.url, true).query;
-                        if (reqQuery && typeof reqQuery === "object" && Object.keys(reqQuery).length)
-                            this.logVerbose("-- Url Params: ", reqQuery);
-                        else
-                            this.logVerbose("-- No Params");
-                        body = req.body;
-                        if (body && ((typeof body === "object")))
-                            this.logVerbose("-- Body (Object): ", body);
-                        else if (body && body.length)
-                            this.logVerbose("-- Body (String): ", body);
-                        else
-                            this.logVerbose("-- No Body");
-                        requestData = {
-                            method: this.method,
-                            originalUrl: req.path,
-                            headers: req.headers,
-                            url: req.url,
-                            query: reqQuery,
-                            body: body
-                        };
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 12, , 18]);
-                        this.bodyValidator && ts_common_1.validate(body, this.bodyValidator);
-                        this.queryValidator && ts_common_1.validate(reqQuery, this.queryValidator);
-                        if (!this.middlewares) return [3 /*break*/, 3];
-                        return [4 /*yield*/, Promise.all(this.middlewares.map(function (m) { return m(req, requestData); }))];
-                    case 2:
-                        _b.sent();
-                        _b.label = 3;
-                    case 3: return [4 /*yield*/, this.process(req, response, reqQuery, body)];
-                    case 4:
-                        toReturn = _b.sent();
-                        if (response.isConsumed())
-                            return [2 /*return*/];
-                        if (!!toReturn) return [3 /*break*/, 6];
-                        return [4 /*yield*/, response.end(200)];
-                    case 5: return [2 /*return*/, _b.sent()];
-                    case 6:
-                        responseType = typeof toReturn;
-                        if (!(responseType === "object")) return [3 /*break*/, 8];
-                        return [4 /*yield*/, response.json(200, toReturn)];
-                    case 7: return [2 /*return*/, _b.sent()];
-                    case 8:
-                        if (!(responseType === "string" && toReturn.toLowerCase().startsWith("<html"))) return [3 /*break*/, 10];
-                        return [4 /*yield*/, response.html(200, toReturn)];
-                    case 9: return [2 /*return*/, _b.sent()];
-                    case 10: return [4 /*yield*/, response.text(200, toReturn)];
-                    case 11: return [2 /*return*/, _b.sent()];
-                    case 12:
-                        err_1 = _b.sent();
-                        e = err_1;
+                if (ts_common_1.isErrorOfType(e, ts_common_1.ValidationException))
+                    e = new exceptions_1.ApiException(400, "Validator exception", e);
+                if (!ts_common_1.isErrorOfType(e, exceptions_1.ApiException))
+                    e = new exceptions_1.ApiException(500, "Unexpected server error", e);
+                const apiException = ts_common_1.isErrorOfType(e, exceptions_1.ApiException);
+                if (!apiException)
+                    throw new ts_common_1.MUSTNeverHappenException("MUST NEVER REACH HERE!!!");
+                if (apiException.responseCode >= 500)
+                    severity = ts_common_1.ServerErrorSeverity.Error;
+                else if (apiException.responseCode >= 400)
+                    severity = ts_common_1.ServerErrorSeverity.Warning;
+                switch (apiException.responseCode) {
+                    case 401:
+                        severity = ts_common_1.ServerErrorSeverity.Debug;
+                        break;
+                    case 404:
+                        severity = ts_common_1.ServerErrorSeverity.Info;
+                        break;
+                    case 403:
                         severity = ts_common_1.ServerErrorSeverity.Warning;
-                        if (typeof e === "string")
-                            e = new ts_common_1.BadImplementationException("String was thrown: " + e);
-                        if (!(e instanceof Error) && typeof e === "object")
-                            e = new ts_common_1.BadImplementationException("Object instance was thrown: " + JSON.stringify(e));
-                        try {
-                            this.logErrorBold(e);
-                        }
-                        catch (e2) {
-                            this.logErrorBold("Error while handling error on request...", e2);
-                            this.logErrorBold("Original error thrown: " + JSON.stringify(e));
-                            this.logErrorBold("-- Someone was stupid... you MUST only throw an Error and not objects or strings!! --");
-                        }
-                        if (ts_common_1.isErrorOfType(e, ts_common_1.ValidationException))
-                            e = new exceptions_1.ApiException(400, "Validator exception", e);
-                        if (!ts_common_1.isErrorOfType(e, exceptions_1.ApiException))
-                            e = new exceptions_1.ApiException(500, "Unexpected server error", e);
-                        apiException = ts_common_1.isErrorOfType(e, exceptions_1.ApiException);
-                        if (!apiException)
-                            throw new ts_common_1.MUSTNeverHappenException("MUST NEVER REACH HERE!!!");
-                        if (apiException.responseCode >= 500)
-                            severity = ts_common_1.ServerErrorSeverity.Error;
-                        else if (apiException.responseCode >= 400)
-                            severity = ts_common_1.ServerErrorSeverity.Warning;
-                        switch (apiException.responseCode) {
-                            case 401:
-                                severity = ts_common_1.ServerErrorSeverity.Debug;
-                                break;
-                            case 404:
-                                severity = ts_common_1.ServerErrorSeverity.Info;
-                                break;
-                            case 403:
-                                severity = ts_common_1.ServerErrorSeverity.Warning;
-                                break;
-                            case 500:
-                                severity = ts_common_1.ServerErrorSeverity.Critical;
-                                break;
-                        }
-                        return [4 /*yield*/, HttpServer_1.HttpServer.errorMessageComposer(requestData, apiException)];
-                    case 13:
-                        message = _b.sent();
-                        _b.label = 14;
-                    case 14:
-                        _b.trys.push([14, 16, , 17]);
-                        return [4 /*yield*/, ts_common_1.dispatch_onServerError.dispatchModuleAsync([severity,
-                                HttpServer_1.HttpServer,
-                                message])];
-                    case 15:
-                        _b.sent();
-                        return [3 /*break*/, 17];
-                    case 16:
-                        e_2 = _b.sent();
-                        this.logError("Error while handing server error", e_2);
-                        return [3 /*break*/, 17];
-                    case 17:
-                        if (apiException.responseCode === 500)
-                            return [2 /*return*/, response.serverError(apiException)];
-                        return [2 /*return*/, response.exception(apiException)];
-                    case 18: return [2 /*return*/];
+                        break;
+                    case 500:
+                        severity = ts_common_1.ServerErrorSeverity.Critical;
+                        break;
+                }
+                const message = yield HttpServer_1.HttpServer.errorMessageComposer(requestData, apiException);
+                try {
+                    yield ts_common_1.dispatch_onServerError.dispatchModuleAsync([severity,
+                        HttpServer_1.HttpServer,
+                        message]);
                 }
-            });
-        }); };
-        _this.setMinLevel(ServerApi.isDebug ? ts_common_1.LogLevel.Verbose : ts_common_1.LogLevel.Info);
-        _this.method = method;
-        _this.relativePath = "" + relativePath;
-        return _this;
-    }
-    ServerApi.prototype.addSideEffect = function (sideEffect) {
+                catch (e) {
+                    this.logError("Error while handing server error", e);
+                }
+                if (apiException.responseCode === 500)
+                    return response.serverError(apiException);
+                return response.exception(apiException);
+            }
+        });
+        this.setMinLevel(ServerApi.isDebug ? ts_common_1.LogLevel.Verbose : ts_common_1.LogLevel.Info);
+        this.method = method;
+        this.relativePath = `${relativePath}`;
+    }
+    addSideEffect(sideEffect) {
         this.sideEffects.push(sideEffect);
         return this;
-    };
-    ServerApi.prototype.setMiddlewares = function () {
-        var middlewares = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            middlewares[_i] = arguments[_i];
-        }
+    }
+    setMiddlewares(...middlewares) {
         this.middlewares = middlewares;
         return this;
-    };
-    ServerApi.prototype.addMiddlewares = function () {
-        var middlewares = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            middlewares[_i] = arguments[_i];
-        }
-        this.middlewares = __spreadArrays((this.middlewares || []), middlewares);
+    }
+    addMiddlewares(...middlewares) {
+        this.middlewares = [...(this.middlewares || []), ...middlewares];
         return this;
-    };
-    ServerApi.prototype.addHeaderToLog = function () {
-        var _a;
-        var headersToLog = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            headersToLog[_i] = arguments[_i];
-        }
-        (_a = this.headersToLog).push.apply(_a, headersToLog);
-    };
-    ServerApi.prototype.setBodyValidator = function (bodyValidator) {
+    }
+    addHeaderToLog(...headersToLog) {
+        this.headersToLog.push(...headersToLog);
+    }
+    setBodyValidator(bodyValidator) {
         this.bodyValidator = bodyValidator;
-    };
-    ServerApi.prototype.setQueryValidator = function (queryValidator) {
+    }
+    setQueryValidator(queryValidator) {
         this.queryValidator = queryValidator;
-    };
-    ServerApi.prototype.asProxy = function () {
+    }
+    asProxy() {
         return new ServerApi_Proxy(this);
-    };
-    ServerApi.prototype.getUrl = function () {
+    }
+    getUrl() {
         return this.url;
-    };
-    ServerApi.prototype.dontPrintResponse = function () {
+    }
+    dontPrintResponse() {
         // @ts-ignore
         this.printResponse = false;
-    };
-    ServerApi.prototype.setMaxResponsePrintSize = function (printResponseMaxSizeBytes) {
+    }
+    setMaxResponsePrintSize(printResponseMaxSizeBytes) {
         // @ts-ignore
         this.printResponse = printResponseMaxSizeBytes > -1;
-    };
-    ServerApi.prototype.route = function (router, prefixUrl) {
-        var fullPath = (prefixUrl ? prefixUrl : "") + "/" + this.relativePath;
+    }
+    route(router, prefixUrl) {
+        const fullPath = `${prefixUrl ? prefixUrl : ""}/${this.relativePath}`;
         this.setTag(fullPath);
         router[this.method](fullPath, this.callWrapper);
-        this.url = "" + HttpServer_1.HttpServer.getBaseUrl() + fullPath;
-    };
-    return ServerApi;
-}(ts_common_1.Logger));
+        this.url = `${HttpServer_1.HttpServer.getBaseUrl()}${fullPath}`;
+    }
+}
 exports.ServerApi = ServerApi;
-var ServerApi_Get = /** @class */ (function (_super) {
-    __extends(ServerApi_Get, _super);
-    function ServerApi_Get(apiName) {
-        return _super.call(this, types_1.HttpMethod.GET, apiName) || this;
+class ServerApi_Get extends ServerApi {
+    constructor(apiName) {
+        super(types_1.HttpMethod.GET, apiName);
     }
-    return ServerApi_Get;
-}(ServerApi));
+}
 exports.ServerApi_Get = ServerApi_Get;
-var ServerApi_Post = /** @class */ (function (_super) {
-    __extends(ServerApi_Post, _super);
-    function ServerApi_Post(apiName) {
-        return _super.call(this, types_1.HttpMethod.POST, apiName) || this;
+class ServerApi_Post extends ServerApi {
+    constructor(apiName) {
+        super(types_1.HttpMethod.POST, apiName);
     }
-    return ServerApi_Post;
-}(ServerApi));
+}
 exports.ServerApi_Post = ServerApi_Post;
-var ServerApi_Proxy = /** @class */ (function (_super) {
-    __extends(ServerApi_Proxy, _super);
-    function ServerApi_Proxy(api) {
-        var _this = _super.call(this, api.method, api.relativePath + "/proxy") || this;
-        _this.api = api;
-        _this.setMiddlewares(RemoteProxy_1.RemoteProxy.Middleware);
-        return _this;
-    }
-    ServerApi_Proxy.prototype.process = function (request, response, queryParams, body) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // @ts-ignore
-                return [2 /*return*/, this.api.process(request, response, queryParams, body)];
-            });
+class ServerApi_Proxy extends ServerApi {
+    constructor(api) {
+        super(api.method, `${api.relativePath}/proxy`);
+        this.api = api;
+        this.setMiddlewares(RemoteProxy_1.RemoteProxy.Middleware);
+    }
+    process(request, response, queryParams, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @ts-ignore
+            return this.api.process(request, response, queryParams, body);
         });
-    };
-    return ServerApi_Proxy;
-}(ServerApi));
+    }
+}
 exports.ServerApi_Proxy = ServerApi_Proxy;
-var ServerApi_Redirect = /** @class */ (function (_super) {
-    __extends(ServerApi_Redirect, _super);
-    function ServerApi_Redirect(apiName, responseCode, redirectUrl) {
-        var _this = _super.call(this, types_1.HttpMethod.ALL, apiName) || this;
-        _this.responseCode = responseCode;
-        _this.redirectUrl = redirectUrl;
-        return _this;
-    }
-    ServerApi_Redirect.prototype.process = function (request, response, queryParams, body) {
-        return __awaiter(this, void 0, void 0, function () {
-            var query;
-            return __generator(this, function (_a) {
-                query = queryParams ? ts_common_1._keys(queryParams).reduce(function (c, k) { return c + '&' + k + '=' + queryParams[k]; }, '?') : '';
-                response.redirect(this.responseCode, "" + HttpServer_1.HttpServer.getBaseUrl() + this.redirectUrl + query);
-                return [2 /*return*/];
-            });
+class ServerApi_Redirect extends ServerApi {
+    constructor(apiName, responseCode, redirectUrl) {
+        super(types_1.HttpMethod.ALL, apiName);
+        this.responseCode = responseCode;
+        this.redirectUrl = redirectUrl;
+    }
+    process(request, response, queryParams, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = queryParams ? ts_common_1._keys(queryParams).reduce((c, k) => c + '&' + k + '=' + queryParams[k], '?') : '';
+            response.redirect(this.responseCode, `${HttpServer_1.HttpServer.getBaseUrl()}${this.redirectUrl}${query}`);
         });
-    };
-    return ServerApi_Redirect;
-}(ServerApi));
+    }
+}
 exports.ServerApi_Redirect = ServerApi_Redirect;
-var ApiResponse = /** @class */ (function () {
-    function ApiResponse(api, res) {
+class ApiResponse {
+    constructor(api, res) {
         this.consumed = false;
         this.api = api;
         this.res = res;
     }
-    ApiResponse.prototype.isConsumed = function () {
+    isConsumed() {
         return this.consumed;
-    };
-    ApiResponse.prototype.consume = function () {
+    }
+    consume() {
         if (this.consumed) {
             this.api.logError("This API was already satisfied!!", new Error());
             return;
         }
         this.consumed = true;
-    };
-    ApiResponse.prototype.stream = function (responseCode, stream, headers) {
-        var _this = this;
+    }
+    stream(responseCode, stream, headers) {
         this.consume();
         this.printHeaders(headers);
         this.res.set(headers);
         this.res.writeHead(responseCode);
         stream.pipe(this.res, { end: false });
-        stream.on('end', function () {
-            _this.res.end();
+        stream.on('end', () => {
+            this.res.end();
         });
-    };
-    ApiResponse.prototype.printHeaders = function (headers) {
+    }
+    printHeaders(headers) {
         if (!headers)
-            return this.api.logVerbose(" -- No response headers");
-        this.api.logVerbose(" -- Response with headers: ", headers);
-    };
-    ApiResponse.prototype.printResponse = function (response) {
+            return this.api.logVerbose(` -- No response headers`);
+        this.api.logVerbose(` -- Response with headers: `, headers);
+    }
+    printResponse(response) {
         if (!response)
-            return this.api.logVerbose(" -- No response body");
+            return this.api.logVerbose(` -- No response body`);
         if (!this.api.printResponse)
-            return this.api.logVerbose(" -- Response: -- Not Printing --");
-        this.api.logVerbose(" -- Response:", response);
-    };
-    ApiResponse.prototype.code = function (responseCode, headers) {
+            return this.api.logVerbose(` -- Response: -- Not Printing --`);
+        this.api.logVerbose(` -- Response:`, response);
+    }
+    code(responseCode, headers) {
         this.printHeaders(headers);
         this.end(responseCode, "", headers);
-    };
-    ApiResponse.prototype.text = function (responseCode, response, _headers) {
-        var headers = (_headers || {});
+    }
+    text(responseCode, response, _headers) {
+        const headers = (_headers || {});
         headers["content-type"] = "text/plain";
         this.end(responseCode, response, headers);
-    };
-    ApiResponse.prototype.html = function (responseCode, response, _headers) {
-        var headers = (_headers || {});
+    }
+    html(responseCode, response, _headers) {
+        const headers = (_headers || {});
         headers["content-type"] = "text/html";
         this.end(responseCode, response, headers);
-    };
-    ApiResponse.prototype.json = function (responseCode, response, _headers) {
+    }
+    json(responseCode, response, _headers) {
         this._json(responseCode, response, _headers);
-    };
-    ApiResponse.prototype._json = function (responseCode, response, _headers) {
-        var headers = (_headers || {});
+    }
+    _json(responseCode, response, _headers) {
+        const headers = (_headers || {});
         headers["content-type"] = "application/json";
         this.end(responseCode, response, headers);
-    };
-    ApiResponse.prototype.end = function (responseCode, response, headers) {
+    }
+    end(responseCode, response, headers) {
         this.consume();
         this.printHeaders(headers);
         this.printResponse(response);
         this.res.set(headers);
         this.res.writeHead(responseCode);
         this.res.end(typeof response !== "string" ? JSON.stringify(response, null, 2) : response);
-    };
-    ApiResponse.prototype.redirect = function (responseCode, url) {
+    }
+    redirect(responseCode, url) {
         this.consume();
         this.res.redirect(responseCode, url);
-    };
-    ApiResponse.prototype.exception = function (exception, headers) {
-        var responseBody = exception.responseBody;
+    }
+    exception(exception, headers) {
+        const responseBody = exception.responseBody;
         if (!ServerApi.isDebug)
             delete responseBody.debugMessage;
         this._json(exception.responseCode, responseBody, headers);
-    };
-    ApiResponse.prototype.serverError = function (error, headers) {
-        var stack = error.cause ? error.cause.stack : error.stack;
-        var message = (error.cause ? error.cause.message : error.message) || "";
+    }
+    serverError(error, headers) {
+        const stack = error.cause ? error.cause.stack : error.stack;
+        const message = (error.cause ? error.cause.message : error.message) || "";
         this.text(500, ServerApi.isDebug && stack ? stack : message, headers);
-    };
-    return ApiResponse;
-}());
+    }
+}
 exports.ApiResponse = ApiResponse;
 //# sourceMappingURL=server-api.js.map