slnodejs 6.1.410 → 6.1.429

package/tsOutputs/common/http/backend-proxy.js

@@ -8,91 +8,57 @@ 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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendProxy = void 0;
-var contracts_1 = require("./contracts");
-var http_client_1 = require("./http-client");
-var sl_routes_1 = require("./sl-routes");
-var validation_utils_1 = require("../utils/validation-utils");
-var entities_mapper_1 = require("./entities-mapper");
-var constants_1 = require("../constants/constants");
-var sl_env_vars_1 = require("../constants/sl-env-vars");
-var timer_utils_1 = require("../utils/timer-utils");
-var BackendProxy = /** @class */ (function () {
+const contracts_1 = require("./contracts");
+const http_client_1 = require("./http-client");
+const sl_routes_1 = require("./sl-routes");
+const validation_utils_1 = require("../utils/validation-utils");
+const entities_mapper_1 = require("./entities-mapper");
+const constants_1 = require("../constants/constants");
+const sl_env_vars_1 = require("../constants/sl-env-vars");
+const timer_utils_1 = require("../utils/timer-utils");
+class BackendProxy {
     // TODO: get httpClient in constructor always
-    function BackendProxy(agentInstanceData, config, logger, httpClient) {
+    constructor(agentInstanceData, config, logger, httpClient) {
         this.agentInstanceData = agentInstanceData;
         this.config = config;
         this.logger = logger;
         this.client = httpClient || new http_client_1.HttpClient(this.config, this.logger);
     }
-    BackendProxy.prototype.getBuildSession = function (buildSessionId, callback) {
-        var _this = this;
+    getBuildSession(buildSessionId, callback) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(buildSessionId, constants_1.Constants.BUILD_SESSION_ID);
-        var url = sl_routes_1.SLRoutes.buildSessionV2(buildSessionId);
-        this.client.get(url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+        const url = sl_routes_1.SLRoutes.buildSessionV2(buildSessionId);
+        this.client.get(url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.createBuildSessionId = function (request, callback) {
-        var _this = this;
+    }
+    createBuildSessionId(request, callback) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-        var url = sl_routes_1.SLRoutes.buildSessionV2();
-        this.client.post(request, url, function (err, body) {
-            _this.invokeCallback(callback, err, body, entities_mapper_1.EntitiesMapper.toCreateBuildSessionIdResponse);
+        const url = sl_routes_1.SLRoutes.buildSessionV2();
+        this.client.post(request, url, (err, body) => {
+            this.invokeCallback(callback, err, body, entities_mapper_1.EntitiesMapper.toCreateBuildSessionIdResponse);
         });
-    };
-    BackendProxy.prototype.createBuildSessionIdPromise = function (request) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url;
-            var _this = this;
-            return __generator(this, function (_a) {
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-                url = constants_1.Constants.PULL_REQUEST_PARAMS in request ? sl_routes_1.SLRoutes.prBuildSession() : sl_routes_1.SLRoutes.buildSessionV2();
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        _this.client.post(request, url, function (err, body) {
-                            if (err) {
-                                return reject(err);
-                            }
-                            return resolve(body);
-                        });
-                    })];
+    }
+    createBuildSessionIdPromise(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
+            const url = constants_1.Constants.PULL_REQUEST_PARAMS in request ? sl_routes_1.SLRoutes.prBuildSession() : sl_routes_1.SLRoutes.buildSessionV2();
+            return new Promise((resolve, reject) => {
+                this.client.post(request, url, (err, body) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    return resolve(body);
+                });
             });
         });
-    };
-    BackendProxy.prototype.getRecommendedVersion = function (request) {
-        var _this = this;
+    }
+    getRecommendedVersion(request) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-        var url = sl_routes_1.SLRoutes.recommendedAgentV2(request.componentName, request.customerId, request.appName, request.branchName, request.testStage);
-        return new Promise(function (resolve, reject) {
-            _this.client.get(url, function (err, body) {
+        const url = sl_routes_1.SLRoutes.recommendedAgentV2(request.componentName, request.customerId, request.appName, request.branchName, request.testStage);
+        return new Promise((resolve, reject) => {
+            this.client.get(url, (err, body) => {
                 if (err) {
                     return reject(err);
                 }
@@ -104,256 +70,212 @@ var BackendProxy = /** @class */ (function () {
                 }
             });
         });
-    };
-    BackendProxy.prototype.submitBuildMapping = function (request) {
+    }
+    submitBuildMapping(request) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-        var url = sl_routes_1.SLRoutes.buildMappingV4();
+        const url = sl_routes_1.SLRoutes.buildMappingV4();
         return this.submitPostRequestWithRetries(request, url);
-    };
-    BackendProxy.prototype.submitLogs = function (request, callback) {
-        var _this = this;
+    }
+    submitLogs(request, callback) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-        var url = sl_routes_1.SLRoutes.logSubmissionV2();
-        this.client.post(request, url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+        const url = sl_routes_1.SLRoutes.logSubmissionV2();
+        this.client.post(request, url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.getRemoteConfig = function (request, callback) {
-        var _this = this;
+    }
+    getRemoteConfig(request, callback) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-        var url = sl_routes_1.SLRoutes.configV3(this.agentInstanceData, request.appName, request.branch, request.build, request.testStage, request.labId);
-        this.client.get(url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+        const url = sl_routes_1.SLRoutes.configV3(this.agentInstanceData, request.appName, request.branch, request.build, request.testStage, request.labId);
+        this.client.get(url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.getRemoteConfigPromise = function (request) {
-        var _this = this;
+    }
+    getRemoteConfigPromise(request) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(request, constants_1.Constants.REQUEST);
-        return new Promise(function (resolve, reject) {
-            var url = sl_routes_1.SLRoutes.configV3(_this.agentInstanceData, request.appName, request.branch, request.build, request.testStage, request.labId);
-            _this.client.get(url, function (err, body) {
+        return new Promise((resolve, reject) => {
+            const url = sl_routes_1.SLRoutes.configV3(this.agentInstanceData, request.appName, request.branch, request.build, request.testStage, request.labId);
+            this.client.get(url, (err, body) => {
                 if (err) {
                     reject(err);
                 }
                 resolve(body);
             });
         });
-    };
-    BackendProxy.prototype.startExecution = function (request, callback) {
-        var _this = this;
-        var url = sl_routes_1.SLRoutes.testExecution();
-        this.client.post(request, url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+    }
+    startExecution(request, callback) {
+        const url = sl_routes_1.SLRoutes.testExecution();
+        this.client.post(request, url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.startColoredExecution = function (request) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var url = sl_routes_1.SLRoutes.testExecution();
-            _this.client.post(request, url, function (err) {
+    }
+    startColoredExecution(request) {
+        return new Promise((resolve, reject) => {
+            const url = sl_routes_1.SLRoutes.testExecution();
+            this.client.post(request, url, (err) => {
                 if (err) {
                     reject(err);
                 }
                 resolve();
             });
         });
-    };
-    BackendProxy.prototype.testExecutionV4 = function (labId, async, executionId) {
-        var _this = this;
-        if (async === void 0) { async = true; }
-        return new Promise(function (resolve, reject) {
-            var url = sl_routes_1.SLRoutes.testExecutionV4(labId);
-            _this.client.get(url, function (err, body) {
+    }
+    testExecutionV4(labId, async = true, executionId) {
+        return new Promise((resolve, reject) => {
+            const url = sl_routes_1.SLRoutes.testExecutionV4(labId);
+            this.client.get(url, (err, body) => {
                 if (err) {
                     reject(err);
                 }
                 resolve(body);
             }, false, async);
         });
-    };
-    BackendProxy.prototype.uploadReport = function (request, callback) {
-        var _this = this;
-        var url = sl_routes_1.SLRoutes.externalData();
-        this.client.postMultipart(request, url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+    }
+    uploadReport(request, callback) {
+        const url = sl_routes_1.SLRoutes.externalData();
+        this.client.postMultipart(request, url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.externalReport = function (request, callback) {
-        var _this = this;
-        var url = sl_routes_1.SLRoutes.externalReport();
-        this.client.post(request, url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+    }
+    externalReport(request, callback) {
+        const url = sl_routes_1.SLRoutes.externalReport();
+        this.client.post(request, url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.endExecution = function (request, callback) {
-        var _this = this;
-        var url = sl_routes_1.SLRoutes.endExecution(request.customerId, request.appName, request.buildName, request.branchName, request.environment);
-        var body = request.executionIds ? { executionIds: request.executionIds } : null;
-        this.client.delete(body, url, function (err, body) {
-            _this.invokeCallback(callback, err, body);
+    }
+    endExecution(request, callback) {
+        const url = sl_routes_1.SLRoutes.endExecution(request.customerId, request.appName, request.buildName, request.branchName, request.environment);
+        const body = request.executionIds ? { executionIds: request.executionIds } : null;
+        this.client.delete(body, url, (err, body) => {
+            this.invokeCallback(callback, err, body);
         });
-    };
-    BackendProxy.prototype.endExecutionPromise = function (request) {
-        var _this = this;
-        var url = sl_routes_1.SLRoutes.endExecution(request.customerId, request.appName, request.buildName, request.branchName, request.environment);
-        var body = request.executionIds ? { executionIds: request.executionIds } : null;
-        return new Promise(function (resolve, reject) {
-            _this.client.delete(body, url, function (err) {
+    }
+    endExecutionPromise(request) {
+        const url = sl_routes_1.SLRoutes.endExecution(request.customerId, request.appName, request.buildName, request.branchName, request.environment);
+        const body = request.executionIds ? { executionIds: request.executionIds } : null;
+        return new Promise((resolve, reject) => {
+            this.client.delete(body, url, (err) => {
                 err ? reject(err) : resolve();
             });
         });
-    };
-    BackendProxy.prototype.submitEvents = function (packetToSend, callback, async) {
-        if (async === void 0) { async = true; }
-        var url = sl_routes_1.SLRoutes.eventsV2();
+    }
+    submitEvents(packetToSend, callback, async = true) {
+        const url = sl_routes_1.SLRoutes.eventsV2();
         this.client.post(packetToSend, url, callback);
-    };
-    BackendProxy.prototype.submitEventsPromise = function (packetToSend) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var url = sl_routes_1.SLRoutes.eventsV2();
-            _this.client.post(packetToSend, url, function (err) {
+    }
+    submitEventsPromise(packetToSend) {
+        return new Promise((resolve, reject) => {
+            const url = sl_routes_1.SLRoutes.eventsV2();
+            this.client.post(packetToSend, url, err => {
                 if (err) {
                     reject(err);
                 }
                 resolve();
             });
         });
-    };
-    BackendProxy.prototype.submitBlobAsync = function (body, buildSessionId, blobId, blobType) {
-        var _this = this;
-        if (blobType === void 0) { blobType = 'unspecified'; }
-        var url = sl_routes_1.SLRoutes.blobs(buildSessionId, blobId, blobType);
-        return new Promise(function (resolve, reject) {
-            _this.client.post(body, url, function (error, statusCode) {
-                _this.logger.debug("Blob ".concat(blobId, " uploaded with status code ").concat(statusCode));
+    }
+    submitBlobAsync(body, buildSessionId, blobId, blobType = 'unspecified') {
+        const url = sl_routes_1.SLRoutes.blobs(buildSessionId, blobId, blobType);
+        return new Promise((resolve, reject) => {
+            this.client.post(body, url, (error, statusCode) => {
+                this.logger.debug(`Blob ${blobId} uploaded with status code ${statusCode}`);
                 if (error) {
-                    _this.logger.error("Error while submitting a blob, '".concat(error, "'"));
+                    this.logger.error(`Error while submitting a blob, '${error}'`);
                     return reject(error);
                 }
                 else {
-                    _this.logger.info('blob submitted successfully');
+                    this.logger.info('blob submitted successfully');
                     return resolve({});
                 }
             }, true, contracts_1.ContentType.OCTET_STREAM);
         });
-    };
-    BackendProxy.prototype.submitBlob = function (body, buildSessionId, blobId, callback) {
-        var url = sl_routes_1.SLRoutes.blobs(buildSessionId, blobId);
+    }
+    submitBlob(body, buildSessionId, blobId, callback) {
+        const url = sl_routes_1.SLRoutes.blobs(buildSessionId, blobId);
         this.client.post(body, url, callback, true, contracts_1.ContentType.OCTET_STREAM);
-    };
-    BackendProxy.prototype.getBlobsAsJson = function (buildSessionId, blobType) {
-        if (blobType === void 0) { blobType = 'unspecified'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var slMapping, url, e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        slMapping = [];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        url = sl_routes_1.SLRoutes.blobsForBsidAsJson(buildSessionId, blobType);
-                        return [4 /*yield*/, this.submitGetRequestWithRetries(url)];
-                    case 2:
-                        slMapping = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_1 = _a.sent();
-                        this.logger.error(e_1);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/, slMapping];
-                }
-            });
+    }
+    getBlobsAsJson(buildSessionId, blobType = 'unspecified') {
+        return __awaiter(this, void 0, void 0, function* () {
+            let slMapping = [];
+            try {
+                const url = sl_routes_1.SLRoutes.blobsForBsidAsJson(buildSessionId, blobType);
+                slMapping = yield this.submitGetRequestWithRetries(url);
+            }
+            catch (e) {
+                this.logger.error(e);
+            }
+            return slMapping;
         });
-    };
-    BackendProxy.prototype.getSlMappingFromServer = function (buildSessionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getBlobsAsJson(buildSessionId, 'unspecified')];
-            });
+    }
+    getSlMappingFromServer(buildSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getBlobsAsJson(buildSessionId, 'unspecified');
         });
-    };
-    BackendProxy.prototype.submitAgentEvent = function (body) {
-        var _this = this;
-        var url = sl_routes_1.SLRoutes.agentEvents();
-        return new Promise(function (resolve, reject) {
-            _this.client.post(body, url, function (error, response) {
+    }
+    submitAgentEvent(body) {
+        const url = sl_routes_1.SLRoutes.agentEvents();
+        return new Promise((resolve, reject) => {
+            this.client.post(body, url, (error, response) => {
                 if (error) {
                     return reject(error);
                 }
                 return resolve();
             });
         });
-    };
-    BackendProxy.prototype.getTestsRecommendation = function (buildSessionId, stage, testGroupId) {
-        var url = sl_routes_1.SLRoutes.testsRecommendations(buildSessionId, stage, testGroupId);
+    }
+    getTestsRecommendation(buildSessionId, stage, testGroupId) {
+        const url = sl_routes_1.SLRoutes.testsRecommendations(buildSessionId, stage, testGroupId);
         return this.submitGetRequestWithRetries(url, null, null, [400, 404], false);
-    };
-    BackendProxy.prototype.addOrUpdateIntegrationBuildComponents = function (buildSessionId, components, agentId) {
-        var url = sl_routes_1.SLRoutes.integrationBuildComponents(buildSessionId);
-        return this.submitPutRequestWithRetries({ components: components, agentId: agentId }, url);
-    };
-    BackendProxy.prototype.deleteIntegrationBuildComponents = function (buildSessionId, components, agentId) {
-        var url = sl_routes_1.SLRoutes.integrationBuildComponents(buildSessionId);
-        return this.submitDelRequestWithRetries({ components: components, agentId: agentId }, url);
-    };
-    BackendProxy.prototype.buildEnd = function (data) {
+    }
+    addOrUpdateIntegrationBuildComponents(buildSessionId, components, agentId) {
+        const url = sl_routes_1.SLRoutes.integrationBuildComponents(buildSessionId);
+        return this.submitPutRequestWithRetries({ components, agentId }, url);
+    }
+    deleteIntegrationBuildComponents(buildSessionId, components, agentId) {
+        const url = sl_routes_1.SLRoutes.integrationBuildComponents(buildSessionId);
+        return this.submitDelRequestWithRetries({ components, agentId }, url);
+    }
+    buildEnd(data) {
         return this.submitPostRequestWithRetries(data, sl_routes_1.SLRoutes.buildEnd());
-    };
-    BackendProxy.prototype.submitFootprintsV6 = function (footprintsPacket, executionBsid, testStage, buildSessionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url;
-            return __generator(this, function (_a) {
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(footprintsPacket, constants_1.Constants.FOOTPRINTS_PACKET);
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(executionBsid, constants_1.Constants.EXECUTION_BSID);
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(testStage, constants_1.Constants.TEST_STAGE);
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(buildSessionId, constants_1.Constants.BUILD_SESSION_ID);
-                url = sl_routes_1.SLRoutes.footprintsV6(executionBsid, testStage, buildSessionId);
-                return [2 /*return*/, this.submitPostRequestWithRetries(footprintsPacket, url, null, null, true, contracts_1.ContentType.OCTET_STREAM)];
-            });
+    }
+    submitFootprintsV6(footprintsPacket, executionBsid, testStage, buildSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(footprintsPacket, constants_1.Constants.FOOTPRINTS_PACKET);
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(executionBsid, constants_1.Constants.EXECUTION_BSID);
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(testStage, constants_1.Constants.TEST_STAGE);
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(buildSessionId, constants_1.Constants.BUILD_SESSION_ID);
+            const url = sl_routes_1.SLRoutes.footprintsV6(executionBsid, testStage, buildSessionId);
+            return this.submitPostRequestWithRetries(footprintsPacket, url, null, null, true, contracts_1.ContentType.OCTET_STREAM);
         });
-    };
-    BackendProxy.prototype.submitFootprintsToCollector = function (footprintsPacket, buildSessionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url;
-            return __generator(this, function (_a) {
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(footprintsPacket, constants_1.Constants.FOOTPRINTS_PACKET);
-                validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(buildSessionId, constants_1.Constants.BUILD_SESSION_ID);
-                url = sl_routes_1.SLRoutes.footprintsToCollector(buildSessionId);
-                return [2 /*return*/, this.submitPostRequestWithRetries(footprintsPacket, url, null, null, true, contracts_1.ContentType.JSON)];
-            });
+    }
+    submitFootprintsToCollector(footprintsPacket, buildSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(footprintsPacket, constants_1.Constants.FOOTPRINTS_PACKET);
+            validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(buildSessionId, constants_1.Constants.BUILD_SESSION_ID);
+            const url = sl_routes_1.SLRoutes.footprintsToCollector(buildSessionId);
+            return this.submitPostRequestWithRetries(footprintsPacket, url, null, null, true, contracts_1.ContentType.JSON);
         });
-    };
-    BackendProxy.prototype.getBuildSessionData = function (buildSessionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        _this.getBuildSession(buildSessionId, function (err, response) {
-                            err ? reject(err) : resolve(response);
-                        });
-                    })];
+    }
+    getBuildSessionData(buildSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.getBuildSession(buildSessionId, (err, response) => {
+                    err ? reject(err) : resolve(response);
+                });
             });
         });
-    };
-    BackendProxy.prototype.getRecommendedAgent = function (configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, {}];
-            });
+    }
+    getRecommendedAgent(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {};
         });
-    };
-    BackendProxy.prototype.getBuildSessionDataFromLabId = function (labid) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url;
-            return __generator(this, function (_a) {
-                url = sl_routes_1.SLRoutes.activeBuildSessionId(labid);
-                return [2 /*return*/, this.submitGetRequestWithRetries(url)];
-            });
+    }
+    getBuildSessionDataFromLabId(labid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = sl_routes_1.SLRoutes.activeBuildSessionId(labid);
+            return this.submitGetRequestWithRetries(url);
         });
-    };
-    BackendProxy.prototype.invokeCallback = function (callback, err, body, map) {
+    }
+    invokeCallback(callback, err, body, map) {
         validation_utils_1.ValidationUtils.verifyNotNullOrEmpty(callback, constants_1.Constants.CALLBACK);
         if (err != null) {
             return callback(err, body);
@@ -361,76 +283,55 @@ var BackendProxy = /** @class */ (function () {
         if (map == null) {
             return callback(null, body);
         }
-        var apiResponse = map(body);
+        const apiResponse = map(body);
         return callback(null, apiResponse);
-    };
-    BackendProxy.prototype.submitPostRequestWithRetries = function (body, url, retries, delayBetweenRetires, async, contentType) {
-        var _this = this;
-        return this.makeRequestWithRetries(function (callback) { _this.client.post(body, url, callback, async, contentType); }, retries, delayBetweenRetires);
-    };
-    BackendProxy.prototype.submitPutRequestWithRetries = function (body, url, retries, delayBetweenRetires) {
-        var _this = this;
-        return this.makeRequestWithRetries(function (callback) { _this.client.put(body, url, callback); }, retries, delayBetweenRetires);
-    };
-    BackendProxy.prototype.submitDelRequestWithRetries = function (body, url, retries, delayBetweenRetires) {
-        var _this = this;
-        return this.makeRequestWithRetries(function (callback) { _this.client.delete(body, url, callback); }, retries, delayBetweenRetires);
-    };
-    BackendProxy.prototype.submitGetRequestWithRetries = function (url, retries, delayBetweenRetires, statusesForRetry, isNotFoundAcceptable) {
-        var _this = this;
-        if (isNotFoundAcceptable === void 0) { isNotFoundAcceptable = true; }
-        return this.makeRequestWithRetries(function (callback) { _this.client.get(url, callback, isNotFoundAcceptable); }, retries, delayBetweenRetires, statusesForRetry);
-    };
-    BackendProxy.prototype.makeRequestWithRetries = function (doSingleRequest, retries, delayBetweenRetires, statusesForRetry) {
-        return __awaiter(this, void 0, void 0, function () {
-            var retriesLeft, intervalBetweenRetries, lastError, bodyAndStatusCode, errAndStatusCode_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        retriesLeft = retries || sl_env_vars_1.SlEnvVars.getHttpMaxAttempts() || BackendProxy.DEFAULT_HTTP_MAX_ATTEMPTS;
-                        intervalBetweenRetries = delayBetweenRetires || sl_env_vars_1.SlEnvVars.getHttpAttemptInterval() || BackendProxy.DEFAULT_HTTP_ATTEMPT_INTERVAL;
-                        lastError = undefined;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        retriesLeft--;
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                doSingleRequest(function (err, body, statusCode) {
-                                    err ? reject({ err: err, statusCode: statusCode }) : resolve({ body: body, statusCode: statusCode }); //Always return status code
-                                });
-                            })];
-                    case 2:
-                        bodyAndStatusCode = _a.sent();
-                        return [2 /*return*/, bodyAndStatusCode.body];
-                    case 3:
-                        errAndStatusCode_1 = _a.sent();
-                        this.logger.info(errAndStatusCode_1);
-                        lastError = errAndStatusCode_1.err;
-                        if (!this.shouldRetryRequest(errAndStatusCode_1.statusCode, statusesForRetry)) {
-                            return [3 /*break*/, 7]; //Non-retriable error, break do..while loop and
-                        }
-                        return [3 /*break*/, 4];
-                    case 4: return [4 /*yield*/, timer_utils_1.TimerUtils.sleep(intervalBetweenRetries)];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        if (retriesLeft > 0) return [3 /*break*/, 1];
-                        _a.label = 7;
-                    case 7: throw lastError;
+    }
+    submitPostRequestWithRetries(body, url, retries, delayBetweenRetires, async, contentType) {
+        return this.makeRequestWithRetries((callback) => { this.client.post(body, url, callback, async, contentType); }, retries, delayBetweenRetires);
+    }
+    submitPutRequestWithRetries(body, url, retries, delayBetweenRetires) {
+        return this.makeRequestWithRetries((callback) => { this.client.put(body, url, callback); }, retries, delayBetweenRetires);
+    }
+    submitDelRequestWithRetries(body, url, retries, delayBetweenRetires) {
+        return this.makeRequestWithRetries((callback) => { this.client.delete(body, url, callback); }, retries, delayBetweenRetires);
+    }
+    submitGetRequestWithRetries(url, retries, delayBetweenRetires, statusesForRetry, isNotFoundAcceptable = true) {
+        return this.makeRequestWithRetries((callback) => { this.client.get(url, callback, isNotFoundAcceptable); }, retries, delayBetweenRetires, statusesForRetry);
+    }
+    makeRequestWithRetries(doSingleRequest, retries, delayBetweenRetires, statusesForRetry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retriesLeft = retries || sl_env_vars_1.SlEnvVars.getHttpMaxAttempts() || BackendProxy.DEFAULT_HTTP_MAX_ATTEMPTS;
+            const intervalBetweenRetries = delayBetweenRetires || sl_env_vars_1.SlEnvVars.getHttpAttemptInterval() || BackendProxy.DEFAULT_HTTP_ATTEMPT_INTERVAL;
+            let lastError = undefined;
+            do {
+                try {
+                    retriesLeft--;
+                    const bodyAndStatusCode = yield new Promise((resolve, reject) => {
+                        doSingleRequest((err, body, statusCode) => {
+                            err ? reject({ err, statusCode }) : resolve({ body, statusCode }); //Always return status code
+                        });
+                    });
+                    return bodyAndStatusCode.body;
                 }
-            });
+                catch (errAndStatusCode) {
+                    this.logger.info(errAndStatusCode);
+                    lastError = errAndStatusCode.err;
+                    if (!this.shouldRetryRequest(errAndStatusCode.statusCode, statusesForRetry)) {
+                        break; //Non-retriable error, break do..while loop and
+                    }
+                }
+                yield timer_utils_1.TimerUtils.sleep(intervalBetweenRetries);
+            } while (retriesLeft > 0);
+            throw lastError;
         });
-    };
-    BackendProxy.prototype.shouldRetryRequest = function (statusCode, statusesForRetry) {
-        if (statusesForRetry === void 0) { statusesForRetry = []; }
+    }
+    shouldRetryRequest(statusCode, statusesForRetry = []) {
         if (statusCode >= 500 || statusCode && statusesForRetry.includes(statusCode))
             return true;
         return false;
-    };
-    BackendProxy.DEFAULT_HTTP_MAX_ATTEMPTS = 6;
-    BackendProxy.DEFAULT_HTTP_ATTEMPT_INTERVAL = 5 * 1000;
-    return BackendProxy;
-}());
+    }
+}
 exports.BackendProxy = BackendProxy;
+BackendProxy.DEFAULT_HTTP_MAX_ATTEMPTS = 6;
+BackendProxy.DEFAULT_HTTP_ATTEMPT_INTERVAL = 5 * 1000;
 //# sourceMappingURL=backend-proxy.js.map