api-def 0.12.1 → 0.13.0

package/cjs/Requester.js

@@ -1,109 +1,61 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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());
-    });
-};
-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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["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 };
-    }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.submit = void 0;
-var ApiConstants_1 = require("./ApiConstants");
-var ApiUtils_1 = require("./ApiUtils");
-var RequestContext_1 = require("./RequestContext");
-var RequestError_1 = require("./RequestError");
-var TextDecoding_1 = require("./TextDecoding");
-var MockRequestBackend_1 = require("./backend/MockRequestBackend");
-var retry_1 = require("./util/retry");
-var locks = {};
-var runningOperations = {};
-var MOCK_REQUEST_BACKEND = new MockRequestBackend_1.default();
-var submit = function (host, config, mocking) { return __awaiter(void 0, void 0, void 0, function () {
-    var computedConfig, backend, context, key, lock, lockedContext, response, successEventResult, error_1;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                computedConfig = host.computeConfig(config);
-                backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
-                context = new RequestContext_1.default(backend, host, computedConfig, host.path, mocking);
-                key = context.key;
-                lock = (context.requestConfig || {}).lock;
-                if (typeof lock === "string") {
-                    lockedContext = locks[lock];
-                    if (lockedContext && lockedContext.id !== context.id) {
-                        lockedContext.cancel();
-                    }
-                    locks[lock] = context;
-                }
-                _a.label = 1;
-            case 1:
-                _a.trys.push([1, 4, 5, 6]);
-                return [4 /*yield*/, (runningOperations[key] = makeRequest(context))];
-            case 2:
-                response = _a.sent();
-                return [4 /*yield*/, context.triggerEvent(ApiConstants_1.RequestEvent.SUCCESS)];
-            case 3:
-                successEventResult = _a.sent();
-                if (successEventResult && successEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
-                    context.response = response = successEventResult.response;
-                }
-                delete runningOperations[key];
-                return [2 /*return*/, response];
-            case 4:
-                error_1 = _a.sent();
-                delete runningOperations[key];
-                throw error_1;
-            case 5:
-                if (typeof lock === "string") {
-                    delete locks[lock];
-                }
-                return [7 /*endfinally*/];
-            case 6: return [2 /*return*/];
+const ApiConstants_1 = require("./ApiConstants");
+const ApiUtils_1 = require("./ApiUtils");
+const MockRequestBackend_1 = __importDefault(require("./backend/MockRequestBackend"));
+const RequestContext_1 = __importDefault(require("./RequestContext"));
+const RequestError_1 = require("./RequestError");
+const TextDecoding_1 = require("./TextDecoding");
+const retry_1 = __importDefault(require("./util/retry"));
+const locks = {};
+const runningOperations = {};
+const MOCK_REQUEST_BACKEND = new MockRequestBackend_1.default();
+const submit = async (host, config, mocking) => {
+    const computedConfig = host.computeConfig(config);
+    const backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
+    const context = new RequestContext_1.default(backend, host, computedConfig, host.path, mocking);
+    const { key } = context;
+    // don't do this -- should only be for GET requests anyway and should be opt-in
+    /*
+    // if we are already running this request just return the same promise, no need to do it again
+    const sameRequest = runningOperations[key];
+    if (sameRequest) {
+      return sameRequest;
+    }
+    */
+    const { lock } = context.requestConfig || {};
+    if (typeof lock === "string") {
+        const lockedContext = locks[lock];
+        if (lockedContext && lockedContext.id !== context.id) {
+            lockedContext.cancel();
+        }
+        locks[lock] = context;
+    }
+    try {
+        let response = await (runningOperations[key] = makeRequest(context));
+        const successEventResult = await context.triggerEvent(ApiConstants_1.RequestEvent.SUCCESS);
+        if (successEventResult && successEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
+            context.response = response = successEventResult.response;
         }
-    });
-}); };
+        delete runningOperations[key];
+        return response;
+    }
+    catch (error) {
+        delete runningOperations[key];
+        throw error;
+    }
+    finally {
+        if (typeof lock === "string") {
+            delete locks[lock];
+        }
+    }
+};
 exports.submit = submit;
-var parseRetryOptions = function (retryConfig) {
+const parseRetryOptions = (retryConfig) => {
     if (retryConfig && typeof retryConfig === "object") {
         return retryConfig;
     }
@@ -112,222 +64,188 @@ var parseRetryOptions = function (retryConfig) {
     }
     return { maxAttempts: 0 };
 };
-var makeRequest = function (context) { return __awaiter(void 0, void 0, void 0, function () {
-    var beforeSendEventResult, retryOptions, internalRetryOptions, performRequest, response;
-    var _a, _b, _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0: return [4 /*yield*/, context.triggerEvent(ApiConstants_1.RequestEvent.BEFORE_SEND)];
-            case 1:
-                beforeSendEventResult = _d.sent();
-                if (beforeSendEventResult && beforeSendEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
-                    return [2 /*return*/, (context.response = beforeSendEventResult.response)];
-                }
-                context.validatePath();
-                // validation
-                if (context.validation.query) {
-                    try {
-                        context.requestConfig.queryObject = context.validation.query.parse(context.requestConfig.queryObject);
-                    }
-                    catch (error) {
-                        throw (0, RequestError_1.convertToRequestError)({
-                            error: error,
-                            code: RequestError_1.RequestErrorCode.VALIDATION_QUERY_VALIDATE_ERROR,
-                            context: context,
-                        });
-                    }
-                }
-                if (context.validation.body) {
-                    try {
-                        context.requestConfig.body = context.validation.body.parse(context.requestConfig.body);
-                    }
-                    catch (error) {
-                        throw (0, RequestError_1.convertToRequestError)({
-                            error: error,
-                            code: RequestError_1.RequestErrorCode.VALIDATION_BODY_VALIDATE_ERROR,
-                            context: context,
-                        });
-                    }
-                }
-                retryOptions = parseRetryOptions((_a = context.requestConfig) === null || _a === void 0 ? void 0 : _a.retry);
-                internalRetryOptions = {
-                    retries: retryOptions.maxAttempts,
-                    // assume most users won't want to tune the delay between retries
-                    minTimeout: (_b = retryOptions.minDelay) !== null && _b !== void 0 ? _b : 200,
-                    maxTimeout: (_c = retryOptions.maxDelay) !== null && _c !== void 0 ? _c : 1000,
-                    randomize: true,
-                };
-                context.stats.attempt = 0;
-                performRequest = function (fnBail, attemptCount) { return __awaiter(void 0, void 0, void 0, function () {
-                    var _a, promise, canceler, response_1, parsedResponse, rawError_1, error, errorEventResult, forceRetry, unrecoverableErrorEventResult;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                context.stats.attempt++;
-                                _b.label = 1;
-                            case 1:
-                                _b.trys.push([1, 4, , 8]);
-                                _a = context.backend.makeRequest(context), promise = _a.promise, canceler = _a.canceler;
-                                context.addCanceller(canceler);
-                                return [4 /*yield*/, promise];
-                            case 2:
-                                response_1 = _b.sent();
-                                return [4 /*yield*/, parseResponse(context, response_1)];
-                            case 3:
-                                parsedResponse = (_b.sent());
-                                if (!(0, ApiUtils_1.isAcceptableStatus)(parsedResponse.status, context.requestConfig.acceptableStatus)) {
-                                    throw (0, RequestError_1.convertToRequestError)({
-                                        error: new Error("[api-def] Invalid response status code '".concat(parsedResponse.status, "'")),
-                                        response: parsedResponse,
-                                        code: RequestError_1.RequestErrorCode.REQUEST_INVALID_STATUS,
-                                        context: context,
-                                    });
-                                }
-                                context.response = parsedResponse;
-                                context.stats.endTimestamp = Date.now();
-                                return [2 /*return*/, parsedResponse];
-                            case 4:
-                                rawError_1 = _b.sent();
-                                if (context.cancelled) {
-                                    rawError_1.isCancelledRequest = true;
-                                }
-                                return [4 /*yield*/, parseError(context, rawError_1)];
-                            case 5:
-                                error = _b.sent();
-                                context.error = error;
-                                context.response = error.response;
-                                context.stats.endTimestamp = Date.now();
-                                return [4 /*yield*/, context.triggerEvent(ApiConstants_1.RequestEvent.ERROR)];
-                            case 6:
-                                errorEventResult = _b.sent();
-                                if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === ApiConstants_1.EventResultType.RESPOND) {
-                                    return [2 /*return*/, errorEventResult.response];
-                                }
-                                forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === ApiConstants_1.EventResultType.RETRY;
-                                if (forceRetry) {
-                                    return [2 /*return*/, performRequest(fnBail, attemptCount)];
-                                }
-                                // allow retry logic to handle
-                                if (!retryOptions.shouldRetry || retryOptions.shouldRetry(error)) {
-                                    throw error;
-                                }
-                                return [4 /*yield*/, context.triggerEvent(ApiConstants_1.RequestEvent.UNRECOVERABLE_ERROR)];
-                            case 7:
-                                unrecoverableErrorEventResult = _b.sent();
-                                if (unrecoverableErrorEventResult) {
-                                    if (unrecoverableErrorEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
-                                        return [2 /*return*/, unrecoverableErrorEventResult.response];
-                                    }
-                                }
-                                fnBail(error);
-                                return [3 /*break*/, 8];
-                            case 8: return [2 /*return*/];
-                        }
-                    });
-                }); };
-                return [4 /*yield*/, (0, retry_1.default)(performRequest, internalRetryOptions)];
-            case 2:
-                response = _d.sent();
-                if (context.validation.response) {
-                    try {
-                        response.data = context.validation.response.parse(response.data);
-                    }
-                    catch (error) {
-                        throw (0, RequestError_1.convertToRequestError)({
-                            error: error,
-                            code: RequestError_1.RequestErrorCode.VALIDATION_RESPONSE_VALIDATE_ERROR,
-                            context: context,
-                        });
-                    }
+const makeRequest = async (context) => {
+    const beforeSendEventResult = await context.triggerEvent(ApiConstants_1.RequestEvent.BEFORE_SEND);
+    if (beforeSendEventResult && beforeSendEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
+        return (context.response = beforeSendEventResult.response);
+    }
+    context.validatePath();
+    // validation
+    if (context.validation.query) {
+        try {
+            context.requestConfig.queryObject = context.validation.query.parse(context.requestConfig.queryObject);
+        }
+        catch (error) {
+            throw (0, RequestError_1.convertToRequestError)({
+                error: error,
+                code: RequestError_1.RequestErrorCode.VALIDATION_QUERY_VALIDATE_ERROR,
+                context: context,
+            });
+        }
+    }
+    if (context.validation.body) {
+        try {
+            context.requestConfig.body = context.validation.body.parse(context.requestConfig.body);
+        }
+        catch (error) {
+            throw (0, RequestError_1.convertToRequestError)({
+                error: error,
+                code: RequestError_1.RequestErrorCode.VALIDATION_BODY_VALIDATE_ERROR,
+                context: context,
+            });
+        }
+    }
+    const retryOptions = parseRetryOptions(context.requestConfig?.retry);
+    const internalRetryOptions = {
+        retries: retryOptions.maxAttempts,
+        // assume most users won't want to tune the delay between retries
+        minTimeout: retryOptions.minDelay ?? 200,
+        maxTimeout: retryOptions.maxDelay ?? 1000,
+        randomize: true,
+    };
+    context.stats.attempt = 0;
+    const performRequest = async (fnBail, attemptCount) => {
+        context.stats.attempt++;
+        try {
+            const { promise, canceler } = context.backend.makeRequest(context);
+            context.addCanceller(canceler);
+            const response = await promise;
+            const parsedResponse = (await parseResponse(context, response));
+            if (!(0, ApiUtils_1.isAcceptableStatus)(parsedResponse.status, context.requestConfig.acceptableStatus)) {
+                throw (0, RequestError_1.convertToRequestError)({
+                    error: new Error(`[api-def] Invalid response status code '${parsedResponse.status}'`),
+                    response: parsedResponse,
+                    code: RequestError_1.RequestErrorCode.REQUEST_INVALID_STATUS,
+                    context: context,
+                });
+            }
+            context.response = parsedResponse;
+            context.stats.endTimestamp = Date.now();
+            return parsedResponse;
+        }
+        catch (rawError) {
+            if (context.cancelled) {
+                rawError.isCancelledRequest = true;
+            }
+            const error = await parseError(context, rawError);
+            context.error = error;
+            context.response = error.response;
+            context.stats.endTimestamp = Date.now();
+            const errorEventResult = await context.triggerEvent(ApiConstants_1.RequestEvent.ERROR);
+            if (errorEventResult?.type === ApiConstants_1.EventResultType.RESPOND) {
+                return errorEventResult.response;
+            }
+            // allow retry logic to handle network errors
+            //const shouldNaturallyRetry = ApiUtils.isNetworkError(error);
+            //if (shouldNaturallyRetry) {
+            //  throw error;
+            //}
+            // if we have an event that tells us to retry, we must do it
+            const forceRetry = errorEventResult?.type === ApiConstants_1.EventResultType.RETRY;
+            if (forceRetry) {
+                return performRequest(fnBail, attemptCount);
+            }
+            // allow retry logic to handle
+            if (!retryOptions.shouldRetry || retryOptions.shouldRetry(error)) {
+                throw error;
+            }
+            // error is unrecoverable, bail
+            const unrecoverableErrorEventResult = await context.triggerEvent(ApiConstants_1.RequestEvent.UNRECOVERABLE_ERROR);
+            if (unrecoverableErrorEventResult) {
+                if (unrecoverableErrorEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
+                    return unrecoverableErrorEventResult.response;
                 }
-                return [2 /*return*/, response];
+            }
+            fnBail(error);
         }
-    });
-}); };
-var parseResponse = function (context, response, error) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedResponse, contentType, inferredResponseType, data, decodedData;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                if (!response) return [3 /*break*/, 2];
-                return [4 /*yield*/, context.backend.convertResponse(context, response)];
-            case 1:
-                parsedResponse = _b.sent();
-                contentType = parsedResponse.headers.get("content-type");
-                inferredResponseType = (0, ApiUtils_1.inferResponseType)(contentType);
-                if (!error) {
-                    // expand to array buffer once we support that in inferResponseType
-                    if (inferredResponseType === "text" && context.responseType === "json") {
-                        throw (0, RequestError_1.convertToRequestError)({
-                            error: new Error("[api-def] Expected '".concat(context.responseType, "' response, got '").concat(inferredResponseType, "' (from 'Content-Type' of '").concat(contentType, "')")),
-                            code: RequestError_1.RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                            response: parsedResponse,
-                            context: context,
-                        });
-                    }
-                    // transform arrayBuffer to json
-                    if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
-                        if (parsedResponse.data && typeof parsedResponse.data === "object") {
-                            data = response.data;
-                            if (((_a = data.constructor) === null || _a === void 0 ? void 0 : _a.name) === "ArrayBuffer") {
-                                try {
-                                    decodedData = (response.data = (0, TextDecoding_1.textDecode)(data));
-                                    response.data = JSON.parse(decodedData);
-                                }
-                                catch (e) {
-                                    throw (0, RequestError_1.convertToRequestError)({
-                                        error: new Error("[api-def] Expected '".concat(context.responseType, "' response, got '").concat(inferredResponseType, "' (from 'Content-Type' of '").concat(contentType, "')")),
-                                        code: RequestError_1.RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                                        response: parsedResponse,
-                                        context: context,
-                                    });
-                                }
-                            }
+    };
+    const response = await (0, retry_1.default)(performRequest, internalRetryOptions);
+    if (context.validation.response) {
+        try {
+            response.data = context.validation.response.parse(response.data);
+        }
+        catch (error) {
+            throw (0, RequestError_1.convertToRequestError)({
+                error: error,
+                code: RequestError_1.RequestErrorCode.VALIDATION_RESPONSE_VALIDATE_ERROR,
+                context: context,
+            });
+        }
+    }
+    return response;
+};
+const parseResponse = async (context, response, error) => {
+    if (response) {
+        const parsedResponse = await context.backend.convertResponse(context, response);
+        const contentType = parsedResponse.headers.get("content-type");
+        const inferredResponseType = (0, ApiUtils_1.inferResponseType)(contentType);
+        if (!error) {
+            // expand to array buffer once we support that in inferResponseType
+            if (inferredResponseType === "text" && context.responseType === "json") {
+                throw (0, RequestError_1.convertToRequestError)({
+                    error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
+                    code: RequestError_1.RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                    response: parsedResponse,
+                    context: context,
+                });
+            }
+            // transform arrayBuffer to json
+            if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
+                if (parsedResponse.data && typeof parsedResponse.data === "object") {
+                    const data = response.data;
+                    if (data.constructor?.name === "ArrayBuffer") {
+                        try {
+                            const decodedData = (response.data = (0, TextDecoding_1.textDecode)(data));
+                            response.data = JSON.parse(decodedData);
+                        }
+                        catch (e) {
+                            throw (0, RequestError_1.convertToRequestError)({
+                                error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
+                                code: RequestError_1.RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                                response: parsedResponse,
+                                context: context,
+                            });
                         }
                     }
                 }
-                return [2 /*return*/, parsedResponse];
-            case 2: return [2 /*return*/, response];
+            }
         }
-    });
-}); };
-var parseError = function (context, rawError) { return __awaiter(void 0, void 0, void 0, function () {
-    var error, extractedResponse, errorResponse, code, errorInfo;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                if (!(0, RequestError_1.isRequestError)(rawError)) return [3 /*break*/, 1];
-                error = rawError;
-                return [3 /*break*/, 5];
-            case 1: return [4 /*yield*/, context.backend.extractResponseFromError(rawError)];
-            case 2:
-                extractedResponse = _b.sent();
-                errorResponse = undefined;
-                if (!(extractedResponse !== undefined)) return [3 /*break*/, 4];
-                return [4 /*yield*/, parseResponse(context, extractedResponse, true)];
-            case 3:
-                errorResponse = _b.sent();
-                _b.label = 4;
-            case 4:
-                code = (0, ApiUtils_1.isNetworkError)(rawError)
-                    ? RequestError_1.RequestErrorCode.REQUEST_NETWORK_ERROR
-                    : RequestError_1.RequestErrorCode.MISC_UNKNOWN_ERROR;
-                if (errorResponse) {
-                    if (!(0, ApiUtils_1.isAcceptableStatus)(errorResponse.status, context.requestConfig.acceptableStatus)) {
-                        code = RequestError_1.RequestErrorCode.REQUEST_INVALID_STATUS;
-                    }
-                }
-                else {
-                    if (rawError.code === "ENOTFOUND" || ((_a = rawError.cause) === null || _a === void 0 ? void 0 : _a.code) === "ENOTFOUND") {
-                        code = RequestError_1.RequestErrorCode.REQUEST_HOST_NAME_NOT_FOUND;
-                    }
-                }
-                errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
-                error = (0, RequestError_1.convertToRequestError)(__assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
-                _b.label = 5;
-            case 5: return [2 /*return*/, error];
+        return parsedResponse;
+    }
+    return response;
+};
+const parseError = async (context, rawError) => {
+    let error;
+    if ((0, RequestError_1.isRequestError)(rawError)) {
+        error = rawError;
+    }
+    else {
+        const extractedResponse = await context.backend.extractResponseFromError(rawError);
+        let errorResponse;
+        if (extractedResponse !== undefined) {
+            errorResponse = await parseResponse(context, extractedResponse, true);
+        }
+        let code = (0, ApiUtils_1.isNetworkError)(rawError)
+            ? RequestError_1.RequestErrorCode.REQUEST_NETWORK_ERROR
+            : RequestError_1.RequestErrorCode.MISC_UNKNOWN_ERROR;
+        if (errorResponse) {
+            if (!(0, ApiUtils_1.isAcceptableStatus)(errorResponse.status, context.requestConfig.acceptableStatus)) {
+                code = RequestError_1.RequestErrorCode.REQUEST_INVALID_STATUS;
+            }
         }
-    });
-}); };
+        else {
+            if (rawError.code === "ENOTFOUND" || rawError.cause?.code === "ENOTFOUND") {
+                code = RequestError_1.RequestErrorCode.REQUEST_HOST_NAME_NOT_FOUND;
+            }
+        }
+        const errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
+        error = (0, RequestError_1.convertToRequestError)({
+            error: rawError,
+            response: errorResponse,
+            code: code,
+            context: context,
+            ...errorInfo,
+        });
+    }
+    return error;
+};