api-def 0.4.1-alpha3 → 0.5.1

package/esm/Requester.js

@@ -1,3 +1,14 @@
+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) {
@@ -35,18 +46,27 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import * as ApiUtils from "./ApiUtils";
+import { isAcceptableStatus, isNetworkError } from "./ApiUtils";
 import RequestContext from "./RequestContext";
 import * as Api from "./Api";
 import { EventResultType, RequestEvent } from "./ApiConstants";
+import retry from "./util/retry";
+import MockRequestBackend from "./backend/MockRequestBackend";
+import { convertToRequestError, isRequestError, RequestErrorCode } from "./RequestError";
 var locks = {};
 var runningOperations = {};
-export var submit = function (host, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var computedConfig, context, key, sameRequest, lock, lockedContext, response, successEventResult, error_1;
+var MOCK_REQUEST_BACKEND = new MockRequestBackend();
+export var submit = function (host, config, mocking) { return __awaiter(void 0, void 0, void 0, function () {
+    var computedConfig, backend, context, key, sameRequest, lock, lockedContext, response, successEventResult, error_1;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 computedConfig = host.computeConfig(config);
-                context = new RequestContext(host, computedConfig, host.computePath(host.path, config));
+                backend = mocking ? MOCK_REQUEST_BACKEND : Api.getRequestBackend();
+                if (!backend) {
+                    throw new Error("[api-def] Please specify a backend you wish to use, this can be done either with 'setRequestBackend()'");
+                }
+                context = new RequestContext(backend, host, computedConfig, host.computePath(host.path, config), mocking);
                 key = context.key;
                 sameRequest = runningOperations[key];
                 if (sameRequest) {
@@ -90,87 +110,153 @@ export var submit = function (host, config) { return __awaiter(void 0, void 0, v
 }); };
 var defaultBackendMessageShown = false;
 var makeRequest = function (context) { return __awaiter(void 0, void 0, void 0, function () {
-    var backend, beforeSendEventResult, _a, promise, canceler, response, parsedResponse, error_2, errorResponse, _b, errorEventResult, retry, shouldNaturallyRetry, shouldRetry, unrecoverableErrorEventResult;
-    var _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
+    var beforeSendEventResult, maxRetries, retryOpts, performRequest, response;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
             case 0:
-                backend = Api.requestBackend;
-                if (!backend) {
-                    throw new Error("[api-def] Please specify a backend you wish to use, this can be done either with 'setRequestBackend()'");
-                }
                 if (process.env.NODE_ENV === "development") {
-                    if (Api.requestBackendIsDefault && !defaultBackendMessageShown) {
+                    if (Api.isRequestBackendDefault() && !defaultBackendMessageShown) {
                         defaultBackendMessageShown = true;
                         console.warn("[api-def] Using default fetch backend, you can use a different one with 'setRequestBackend()' (dev only message)");
                     }
                 }
-                context.stats.attempt++;
                 return [4 /*yield*/, context.triggerEvent(RequestEvent.BeforeSend)];
             case 1:
-                beforeSendEventResult = _d.sent();
+                beforeSendEventResult = _b.sent();
                 if (beforeSendEventResult &&
                     beforeSendEventResult.type === EventResultType.Respond) {
                     return [2 /*return*/, (context.response = beforeSendEventResult.response)];
                 }
-                _d.label = 2;
+                maxRetries = ((_a = context.computedConfig) === null || _a === void 0 ? void 0 : _a.retry) || 0;
+                retryOpts = {
+                    retries: maxRetries,
+                    // assume most users won't want to tune the delay between retries
+                    minTimeout: 1 * 1000,
+                    maxTimeout: 5 * 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, shouldNaturallyRetry, 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 (!isAcceptableStatus(parsedResponse.status, context.computedConfig.acceptableStatus)) {
+                                    throw convertToRequestError({
+                                        error: new Error("[api-def] Invalid response status code '" + parsedResponse.status + "'"),
+                                        response: parsedResponse,
+                                        code: RequestErrorCode.REQUEST_INVALID_STATUS,
+                                    });
+                                }
+                                context.response = parsedResponse;
+                                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;
+                                // transform array buffer responses to objs
+                                if (context.response) {
+                                    ApiUtils.parseResponseDataToObject(context.response);
+                                }
+                                return [4 /*yield*/, context.triggerEvent(RequestEvent.Error)];
+                            case 6:
+                                errorEventResult = _b.sent();
+                                if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Respond) {
+                                    return [2 /*return*/, errorEventResult.response];
+                                }
+                                shouldNaturallyRetry = ApiUtils.isNetworkError(error);
+                                if (shouldNaturallyRetry) {
+                                    throw error;
+                                }
+                                forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Retry;
+                                if (forceRetry) {
+                                    return [2 /*return*/, performRequest(fnBail, attemptCount)];
+                                }
+                                return [4 /*yield*/, context.triggerEvent(RequestEvent.UnrecoverableError)];
+                            case 7:
+                                unrecoverableErrorEventResult = _b.sent();
+                                if (unrecoverableErrorEventResult) {
+                                    if (unrecoverableErrorEventResult.type === EventResultType.Respond) {
+                                        return [2 /*return*/, unrecoverableErrorEventResult.response];
+                                    }
+                                }
+                                fnBail(error);
+                                return [3 /*break*/, 8];
+                            case 8: return [2 /*return*/];
+                        }
+                    });
+                }); };
+                return [4 /*yield*/, retry(performRequest, retryOpts)];
+            case 2:
+                response = _b.sent();
+                return [2 /*return*/, (response)];
+        }
+    });
+}); };
+var parseResponse = function (context, response, error) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedResponse;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!response) return [3 /*break*/, 2];
+                return [4 /*yield*/, context.backend.convertResponse(context, response, error)];
+            case 1:
+                parsedResponse = _a.sent();
+                if (parsedResponse) {
+                    ApiUtils.parseResponseDataToObject(parsedResponse);
+                }
+                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;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!isRequestError(rawError)) return [3 /*break*/, 1];
+                error = rawError;
+                return [3 /*break*/, 5];
+            case 1: return [4 /*yield*/, context.backend.extractResponseFromError(rawError)];
             case 2:
-                _d.trys.push([2, 5, , 11]);
-                _a = backend.makeRequest(context), promise = _a.promise, canceler = _a.canceler;
-                context.addCanceller(canceler);
-                return [4 /*yield*/, promise];
+                extractedResponse = _a.sent();
+                errorResponse = undefined;
+                if (!(extractedResponse !== undefined)) return [3 /*break*/, 4];
+                return [4 /*yield*/, parseResponse(context, extractedResponse, true)];
             case 3:
-                response = _d.sent();
-                return [4 /*yield*/, backend.convertResponse(context, response)];
+                errorResponse = _a.sent();
+                _a.label = 4;
             case 4:
-                parsedResponse = _d.sent();
-                context.response = parsedResponse;
-                return [2 /*return*/, parsedResponse];
-            case 5:
-                error_2 = _d.sent();
-                if (context.cancelled) {
-                    error_2.isCancelledRequest = true;
-                }
-                context.error = error_2;
-                return [4 /*yield*/, backend.extractResponseFromError(error_2)];
-            case 6:
-                errorResponse = _d.sent();
-                if (!(errorResponse !== undefined)) return [3 /*break*/, 8];
-                _b = context;
-                return [4 /*yield*/, backend.convertResponse(context, errorResponse, true)];
-            case 7:
-                _b.response = _d.sent();
-                error_2.response = context.response;
-                _d.label = 8;
-            case 8:
-                // transform array buffer responses to objs
-                if (context.response) {
-                    ApiUtils.parseResponseDataToObject(context.response);
-                }
-                return [4 /*yield*/, context.triggerEvent(RequestEvent.Error)];
-            case 9:
-                errorEventResult = _d.sent();
-                if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Respond) {
-                    return [2 /*return*/, errorEventResult.response];
-                }
-                retry = (_c = context.computedConfig) === null || _c === void 0 ? void 0 : _c.retry;
-                shouldNaturallyRetry = ApiUtils.isNetworkError(error_2) && retry && context.stats.attempt < retry;
-                shouldRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Retry ||
-                    shouldNaturallyRetry;
-                // retry request with same config
-                if (shouldRetry) {
-                    return [2 /*return*/, makeRequest(context)];
-                }
-                return [4 /*yield*/, context.triggerEvent(RequestEvent.UnrecoverableError)];
-            case 10:
-                unrecoverableErrorEventResult = _d.sent();
-                if (unrecoverableErrorEventResult) {
-                    if (unrecoverableErrorEventResult.type === EventResultType.Respond) {
-                        return [2 /*return*/, unrecoverableErrorEventResult.response];
+                code = isNetworkError(rawError) ? RequestErrorCode.REQUEST_NETWORK_ERROR : RequestErrorCode.MISC_UNKNOWN_ERROR;
+                if (errorResponse) {
+                    if (!isAcceptableStatus(errorResponse.status, context.computedConfig.acceptableStatus)) {
+                        code = RequestErrorCode.REQUEST_INVALID_STATUS;
                     }
                 }
-                throw error_2;
-            case 11: return [2 /*return*/];
+                errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
+                error = convertToRequestError(__assign({ error: rawError, response: errorResponse, code: code }, errorInfo));
+                _a.label = 5;
+            case 5: return [2 /*return*/, error];
         }
     });
 }); };

package/esm/TextDecoding.d.ts

@@ -0,0 +1 @@
+export declare const textDecode: (inputArrayOrBuffer: any, options?: any) => string;

package/esm/TextDecoding.js

@@ -0,0 +1,135 @@
+/* eslint-disable prefer-const */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+// polyfill from https://github.com/anonyco/FastestSmallestTextEncoderDecoder/blob/master/EncoderDecoderTogether.src.js
+export var textDecode = function (inputArrayOrBuffer, options) {
+    if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder("utf-8").decode(inputArrayOrBuffer);
+    }
+    var fromCharCode = String.fromCharCode;
+    var Object_prototype_toString = ({}).toString;
+    var sharedArrayBufferString = Object_prototype_toString.call(window["SharedArrayBuffer"]);
+    var undefinedObjectString = Object_prototype_toString();
+    var NativeUint8Array = window.Uint8Array;
+    var patchedU8Array = NativeUint8Array || Array;
+    var nativeArrayBuffer = NativeUint8Array ? ArrayBuffer : patchedU8Array;
+    var arrayBuffer_isView = nativeArrayBuffer.isView || function (x) {
+        return x && "length" in x;
+    };
+    var arrayBufferString = Object_prototype_toString.call(nativeArrayBuffer.prototype);
+    var tmpBufferU16 = new (NativeUint8Array ? Uint16Array : patchedU8Array)(32);
+    var inputAs8 = inputArrayOrBuffer;
+    var asObjectString;
+    if (!arrayBuffer_isView(inputAs8)) {
+        asObjectString = Object_prototype_toString.call(inputAs8);
+        if (asObjectString !== arrayBufferString && asObjectString !== sharedArrayBufferString && asObjectString !== undefinedObjectString)
+            throw TypeError("Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+        inputAs8 = NativeUint8Array ? new patchedU8Array(inputAs8) : inputAs8 || [];
+    }
+    var resultingString = "", tmpStr = "", index = 0, len = inputAs8.length | 0, lenMinus32 = len - 32 | 0, nextEnd = 0, cp0 = 0, codePoint = 0, minBits = 0, cp1 = 0, pos = 0, tmp = -1;
+    // Note that tmp represents the 2nd half of a surrogate pair incase a surrogate gets divided between blocks
+    for (; index < len;) {
+        nextEnd = index <= lenMinus32 ? 32 : len - index | 0;
+        for (; pos < nextEnd; index = index + 1 | 0, pos = pos + 1 | 0) {
+            cp0 = inputAs8[index] & 0xff;
+            switch (cp0 >> 4) {
+                case 15:
+                    cp1 = inputAs8[index = index + 1 | 0] & 0xff;
+                    if ((cp1 >> 6) !== 2 || 247 < cp0) {
+                        index = index - 1 | 0;
+                        break;
+                    }
+                    codePoint = ((cp0 & 7) << 6) | (cp1 & 63);
+                    minBits = 5; // 20 ensures it never passes -> all invalid replacements
+                    cp0 = 0x100; //  keep track of th bit size
+                // eslint-disable-next-line no-fallthrough
+                case 14:
+                    cp1 = inputAs8[index = index + 1 | 0] & 0xff;
+                    codePoint <<= 6;
+                    codePoint |= ((cp0 & 15) << 6) | (cp1 & 63);
+                    minBits = (cp1 >> 6) === 2 ? minBits + 4 | 0 : 24; // 24 ensures it never passes -> all invalid replacements
+                    cp0 = (cp0 + 0x100) & 0x300; // keep track of th bit size
+                // eslint-disable-next-line no-fallthrough
+                case 13:
+                case 12:
+                    cp1 = inputAs8[index = index + 1 | 0] & 0xff;
+                    codePoint <<= 6;
+                    codePoint |= ((cp0 & 31) << 6) | cp1 & 63;
+                    minBits = minBits + 7 | 0;
+                    // Now, process the code point
+                    if (index < len && (cp1 >> 6) === 2 && (codePoint >> minBits) && codePoint < 0x110000) {
+                        cp0 = codePoint;
+                        codePoint = codePoint - 0x10000 | 0;
+                        if (0 <= codePoint /*0xffff < codePoint*/) { // BMP code point
+                            //nextEnd = nextEnd - 1|0;
+                            tmp = (codePoint >> 10) + 0xD800 | 0; // highSurrogate
+                            cp0 = (codePoint & 0x3ff) + 0xDC00 | 0; // lowSurrogate (will be inserted later in the switch-statement)
+                            if (pos < 31) { // notice 31 instead of 32
+                                tmpBufferU16[pos] = tmp;
+                                pos = pos + 1 | 0;
+                                tmp = -1;
+                            }
+                            else { // else, we are at the end of the inputAs8 and let tmp0 be filled in later on
+                                // NOTE that cp1 is being used as a temporary variable for the swapping of tmp with cp0
+                                cp1 = tmp;
+                                tmp = cp0;
+                                cp0 = cp1;
+                            }
+                        }
+                        else
+                            nextEnd = nextEnd + 1 | 0; // because we are advancing i without advancing pos
+                    }
+                    else {
+                        // invalid code point means replacing the whole thing with null replacement characters
+                        cp0 >>= 8;
+                        index = index - cp0 - 1 | 0; // reset index  back to what it was before
+                        cp0 = 0xfffd;
+                    }
+                    // Finally, reset the variables for the next go-around
+                    minBits = 0;
+                    codePoint = 0;
+                    nextEnd = index <= lenMinus32 ? 32 : len - index | 0;
+                /*case 11:
+                case 10:
+                case 9:
+                case 8:
+                  codePoint ? codePoint = 0 : cp0 = 0xfffd; // fill with invalid replacement character
+                case 7:
+                case 6:
+                case 5:
+                case 4:
+                case 3:
+                case 2:
+                case 1:
+                case 0:
+                  tmpBufferU16[pos] = cp0;
+                  continue;*/
+                // eslint-disable-next-line no-fallthrough
+                default:
+                    tmpBufferU16[pos] = cp0; // fill with invalid replacement character
+                    continue;
+                case 11:
+                case 10:
+                case 9:
+                case 8:
+            }
+            tmpBufferU16[pos] = 0xfffd; // fill with invalid replacement character
+        }
+        tmpStr += fromCharCode(tmpBufferU16[0], tmpBufferU16[1], tmpBufferU16[2], tmpBufferU16[3], tmpBufferU16[4], tmpBufferU16[5], tmpBufferU16[6], tmpBufferU16[7], tmpBufferU16[8], tmpBufferU16[9], tmpBufferU16[10], tmpBufferU16[11], tmpBufferU16[12], tmpBufferU16[13], tmpBufferU16[14], tmpBufferU16[15], tmpBufferU16[16], tmpBufferU16[17], tmpBufferU16[18], tmpBufferU16[19], tmpBufferU16[20], tmpBufferU16[21], tmpBufferU16[22], tmpBufferU16[23], tmpBufferU16[24], tmpBufferU16[25], tmpBufferU16[26], tmpBufferU16[27], tmpBufferU16[28], tmpBufferU16[29], tmpBufferU16[30], tmpBufferU16[31]);
+        if (pos < 32)
+            tmpStr = tmpStr.slice(0, pos - 32 | 0); //-(32-pos));
+        if (index < len) {
+            //fromCharCode.apply(0, tmpBufferU16 : NativeUint8Array ?  tmpBufferU16.subarray(0,pos) : tmpBufferU16.slice(0,pos));
+            tmpBufferU16[0] = tmp;
+            pos = (~tmp) >>> 31; //tmp !== -1 ? 1 : 0;
+            tmp = -1;
+            if (tmpStr.length < resultingString.length)
+                continue;
+        }
+        else if (tmp !== -1) {
+            tmpStr += fromCharCode(tmp);
+        }
+        resultingString += tmpStr;
+        tmpStr = "";
+    }
+    return (resultingString);
+};

package/esm/Utils.d.ts

@@ -3,3 +3,12 @@ export declare const padNumber: (stringOrNumber: string | number, maxLength: num
 export declare type EnumOf<T extends Record<string, any>> = T[keyof T];
 export declare type Fetch = typeof window.fetch;
 export declare const getGlobalFetch: () => Fetch | undefined;
+export declare const noop: () => void;
+/**
+ * Just used to simulate lag, or loading times.
+ * @param value   The value you want to return after the delay
+ * @param delayMs The delay in ms
+ * @returns The `value` param as a Promise
+ */
+export declare const delayThenReturn: <T>(value: T, delayMs: number) => Promise<T>;
+export declare const randInt: (min: number, max: number) => number;

package/esm/Utils.js

@@ -30,3 +30,29 @@ export var getGlobalFetch = function () {
     }
     return window.fetch.bind(window);
 };
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export var noop = function () {
+};
+/**
+ * Just used to simulate lag, or loading times.
+ * @param value   The value you want to return after the delay
+ * @param delayMs The delay in ms
+ * @returns The `value` param as a Promise
+ */
+export var delayThenReturn = function (value, delayMs) {
+    return (new Promise(function (resolve) {
+        if (delayMs > 0) {
+            setTimeout(function () {
+                resolve(value);
+            }, delayMs);
+        }
+        else {
+            resolve(value);
+        }
+    }));
+};
+export var randInt = function (min, max) {
+    var minI = Math.ceil(min);
+    var maxI = Math.floor(max);
+    return (Math.floor(Math.random() * (maxI - minI + 1)) + minI);
+};

package/esm/backend/AxiosRequestBackend.d.ts

@@ -1,11 +1,12 @@
-import RequestBackend, { RequestOperation } from "./RequestBackend";
+import RequestBackend, { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
 import { ApiResponse } from "../ApiTypes";
-import type { AxiosError, AxiosResponse } from "axios";
+import type { AxiosError, AxiosResponse, AxiosStatic } from "axios";
 import RequestContext from "../RequestContext";
 export declare const isAxiosError: (error: Error) => error is AxiosError<any>;
 export default class AxiosRequestBackend implements RequestBackend<AxiosResponse> {
-    constructor(axiosLibrary: any);
+    constructor(axiosLibrary: AxiosStatic);
     extractResponseFromError(error: Error): Promise<AxiosResponse | null | undefined>;
     convertResponse<T>(context: RequestContext, response: AxiosResponse): Promise<ApiResponse<T>>;
     makeRequest(context: RequestContext): RequestOperation<AxiosResponse>;
+    getErrorInfo(error: Error, response: ApiResponse | undefined | null): RequestBackendErrorInfo | undefined;
 }

package/esm/backend/AxiosRequestBackend.js

@@ -79,6 +79,9 @@ var AxiosRequestBackend = /** @class */ (function () {
             canceler: function () { return canceler && canceler(); },
         };
     };
+    AxiosRequestBackend.prototype.getErrorInfo = function (error, response) {
+        return undefined;
+    };
     return AxiosRequestBackend;
 }());
 export default AxiosRequestBackend;

package/esm/backend/FetchRequestBackend.d.ts

@@ -1,4 +1,4 @@
-import RequestBackend, { RequestOperation } from "./RequestBackend";
+import RequestBackend, { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
 import { ApiResponse } from "../ApiTypes";
 import RequestContext from "../RequestContext";
 import { Fetch } from "../Utils";
@@ -12,4 +12,5 @@ export default class FetchRequestBackend implements RequestBackend<Response> {
         __text?: string;
     }, error?: boolean): Promise<ApiResponse<T>>;
     makeRequest(context: RequestContext): RequestOperation<Response>;
+    getErrorInfo(error: Error, response: ApiResponse | undefined | null): RequestBackendErrorInfo | undefined;
 }

package/esm/backend/FetchRequestBackend.js

@@ -87,7 +87,7 @@ var FetchRequestBackend = /** @class */ (function () {
     };
     FetchRequestBackend.prototype.convertResponse = function (context, response, error) {
         return __awaiter(this, void 0, void 0, function () {
-            var data, responseType, _a, error_1;
+            var data, responseType, _a, error_1, status;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -122,11 +122,13 @@ var FetchRequestBackend = /** @class */ (function () {
                         throw Object.assign(new Error("[api-def] Invalid '" + context.responseType + "' response, got: '" + response.__text + "'"), {
                             response: response,
                         });
-                    case 9: return [2 /*return*/, {
-                            data: data,
-                            status: response.status,
-                            headers: response.headers,
-                        }];
+                    case 9:
+                        status = response.status;
+                        return [2 /*return*/, {
+                                data: data,
+                                status: status,
+                                headers: response.headers,
+                            }];
                 }
             });
         });
@@ -182,7 +184,7 @@ var FetchRequestBackend = /** @class */ (function () {
                 throw error;
             }
             if (softAbort) {
-                throw new Error("Request was aborted");
+                throw new Error("[api-def] Request was aborted");
             }
             return response;
         });
@@ -196,6 +198,9 @@ var FetchRequestBackend = /** @class */ (function () {
                 },
         };
     };
+    FetchRequestBackend.prototype.getErrorInfo = function (error, response) {
+        return undefined;
+    };
     return FetchRequestBackend;
 }());
 export default FetchRequestBackend;

package/esm/backend/MockRequestBackend.d.ts

@@ -0,0 +1,10 @@
+import RequestBackend, { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
+import { ApiResponse } from "../ApiTypes";
+import RequestContext from "../RequestContext";
+export default class MockRequestBackend implements RequestBackend<ApiResponse> {
+    convertResponse<T>(context: RequestContext, response: ApiResponse, error?: boolean): Promise<ApiResponse<T>>;
+    extractResponseFromError(error: Error): Promise<ApiResponse | null | undefined>;
+    private runRequest;
+    makeRequest(context: RequestContext): RequestOperation<ApiResponse>;
+    getErrorInfo(error: Error, response: ApiResponse | undefined | null): RequestBackendErrorInfo | undefined;
+}