api-def 0.4.1-alpha3 → 0.5.1

package/README.md

@@ -1,4 +1,4 @@
-# [api-def](https://github.com/Censkh/api-def/) · [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Censkh/api-def/blob/master/LICENSE) [![npm version](https://img.shields.io/npm/v/api-def.svg?style=flat)](https://www.npmjs.com/package/api-def)
+# [api-def](https://github.com/Censkh/api-def/) · [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Censkh/api-def/blob/master/LICENSE) [![npm version](https://img.shields.io/npm/v/api-def.svg?style=flat)](https://www.npmjs.com/package/api-def) [![build status](https://img.shields.io/github/workflow/status/censkh/api-def/Node.js%20CI)](https://github.com/Censkh/api-def/actions)
 
 Typed APIs with middleware support
 

package/cjs/Api.d.ts

@@ -1,33 +1,31 @@
-import { ApiResponse, BaseRequestConfig, ModulePossiblyDefault, RequestConfig, RequestEventHandlers, RequestMiddleware } from "./ApiTypes";
-import { EndpointMockingInfo, MockingConfig } from "./Mocking";
+import Endpoint from "./Endpoint";
+import { ApiResponse, BaseRequestConfig, RequestConfig, RequestMiddleware } from "./ApiTypes";
 import RequestBackend from "./backend/RequestBackend";
 import EndpointBuilder from "./EndpointBuilder";
-export declare let requestBackend: RequestBackend | null;
-export declare let requestBackendIsDefault: boolean;
+import { ApiMockingConfig } from "./MockingTypes";
+export declare const getRequestBackend: () => RequestBackend | null;
+export declare const isRequestBackendDefault: () => boolean;
 export declare const setRequestBackend: (backend: RequestBackend) => void;
 export interface ApiInfo {
     readonly name: string;
     readonly baseUrl: string;
     readonly middleware?: RequestMiddleware[];
     readonly config?: BaseRequestConfig | (() => BaseRequestConfig);
-    readonly mocking?: MockingConfig;
-}
-export interface ApiMocking extends MockingConfig {
-    loaderPromise: null | Promise<ModulePossiblyDefault<any>>;
-    loaded: boolean;
+    readonly mocking?: ApiMockingConfig;
 }
 export declare class Api implements ApiInfo {
     readonly baseUrl: string;
     readonly name: string;
     readonly middleware: RequestMiddleware[];
     readonly config?: BaseRequestConfig | (() => BaseRequestConfig);
-    readonly mocking: ApiMocking | undefined;
-    private readonly endpoints;
+    readonly mocking?: ApiMockingConfig;
+    protected readonly endpoints: Record<string, Endpoint>;
     constructor(info: ApiInfo);
     endpoint(): EndpointBuilder;
     getConfig(): BaseRequestConfig;
-    getEventHandlers(): RequestEventHandlers<any>;
-    get<R = unknown>(path: string, config: RequestConfig): Promise<ApiResponse<R>>;
-    post<R = unknown>(path: string, config: RequestConfig): Promise<ApiResponse<R>>;
-    getEndpointMocks(): Record<string, EndpointMockingInfo | null>;
+    private hotRequest;
+    get: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    post: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    put: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
+    delete: <R = unknown>(path: string, config: RequestConfig) => Promise<ApiResponse<R>>;
 }

package/cjs/Api.js

@@ -36,18 +36,26 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = exports.setRequestBackend = exports.requestBackendIsDefault = exports.requestBackend = void 0;
+exports.Api = exports.setRequestBackend = exports.isRequestBackendDefault = exports.getRequestBackend = void 0;
 var Requester = require("./Requester");
 var EndpointBuilder_1 = require("./EndpointBuilder");
 var Utils = require("./Utils");
 var FetchRequestBackend_1 = require("./backend/FetchRequestBackend");
 var ApiConstants_1 = require("./ApiConstants");
 // use fetch as default if it is present
-exports.requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend_1.default() : null;
-exports.requestBackendIsDefault = true;
+var requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend_1.default() : null;
+var requestBackendIsDefault = true;
+var getRequestBackend = function () {
+    return requestBackend;
+};
+exports.getRequestBackend = getRequestBackend;
+var isRequestBackendDefault = function () {
+    return requestBackendIsDefault;
+};
+exports.isRequestBackendDefault = isRequestBackendDefault;
 var setRequestBackend = function (backend) {
-    exports.requestBackendIsDefault = false;
-    exports.requestBackend = backend;
+    requestBackendIsDefault = false;
+    requestBackend = backend;
 };
 exports.setRequestBackend = setRequestBackend;
 var HotRequestHost = /** @class */ (function () {
@@ -75,18 +83,27 @@ var HotRequestHost = /** @class */ (function () {
 }());
 var Api = /** @class */ (function () {
     function Api(info) {
+        var _this = this;
+        var _a;
         this.endpoints = {};
+        this.hotRequest = function (requestMethod) { return function (path, config) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Requester.submit(new HotRequestHost(this, path, requestMethod), config, null)];
+                    case 1: return [2 /*return*/, (_a.sent())];
+                }
+            });
+        }); }; };
+        this.get = this.hotRequest(ApiConstants_1.RequestMethod.GET);
+        this.post = this.hotRequest(ApiConstants_1.RequestMethod.POST);
+        this.put = this.hotRequest(ApiConstants_1.RequestMethod.PUT);
+        this.delete = this.hotRequest(ApiConstants_1.RequestMethod.DELETE);
         this.name = info.name;
         this.baseUrl = info.baseUrl;
         this.middleware = info.middleware || [];
         this.endpoints = {};
         this.config = info.config;
-        this.mocking =
-            info.mocking &&
-                Utils.assign(info.mocking, {
-                    loaderPromise: null,
-                    loaded: false,
-                });
+        this.mocking = (_a = info.mocking) !== null && _a !== void 0 ? _a : undefined;
     }
     Api.prototype.endpoint = function () {
         return new EndpointBuilder_1.default(this);
@@ -95,36 +112,6 @@ var Api = /** @class */ (function () {
         return ((typeof this.config === "function" ? this.config() : this.config) ||
             {});
     };
-    Api.prototype.getEventHandlers = function () {
-        return {};
-    };
-    Api.prototype.get = function (path, config) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Requester.submit(new HotRequestHost(this, path, ApiConstants_1.RequestMethod.Get), config)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Api.prototype.post = function (path, config) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Requester.submit(new HotRequestHost(this, path, ApiConstants_1.RequestMethod.Post), config)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Api.prototype.getEndpointMocks = function () {
-        var _this = this;
-        return Object.keys(this.endpoints).reduce(function (mocks, key) {
-            mocks[key] = _this.endpoints[key].mocking;
-            return mocks;
-        }, {});
-    };
     return Api;
 }());
 exports.Api = Api;

package/cjs/ApiConstants.d.ts

@@ -1,29 +1,57 @@
 import { EnumOf } from "./Utils";
 export declare const RequestMethod: {
+    /** @deprecated use 'POST' */
     readonly Post: "post";
+    /** @deprecated use 'GET' */
     readonly Get: "get";
+    readonly POST: "post";
+    readonly GET: "get";
+    readonly PUT: "put";
+    readonly DELETE: "delete";
 };
 export declare type RequestMethod = EnumOf<typeof RequestMethod>;
 export declare const RequestEvent: {
+    /** @deprecated use 'BEFORE_SEND' */
     readonly BeforeSend: "beforeSend";
+    /** @deprecated use 'SUCCESS' */
     readonly Success: "success";
+    /** @deprecated use 'ERROR' */
     readonly Error: "error";
+    /** @deprecated use 'UNRECOVERABLE_ERROR' */
     readonly UnrecoverableError: "unrecoverableError";
+    readonly BEFORE_SEND: "beforeSend";
+    readonly SUCCESS: "success";
+    readonly ERROR: "error";
+    readonly UNRECOVERABLE_ERROR: "unrecoverableError";
 };
 export declare type RequestEvent = EnumOf<typeof RequestEvent>;
 export declare const EventResultType: {
+    /** @deprecated use 'RESPOND' */
     readonly Respond: "respond";
+    /** @deprecated use 'RETRY' */
     readonly Retry: "retry";
+    readonly RESPOND: "respond";
+    readonly RETRY: "retry";
 };
 export declare type EventResultType = EnumOf<typeof EventResultType>;
 export declare const CacheSource: {
+    /** @deprecated use 'API' */
     readonly Api: "api";
+    /** @deprecated use 'LOCAL' */
     readonly Local: "local";
+    readonly API: "api";
+    readonly LOCAL: "local";
 };
 export declare type CacheSource = EnumOf<typeof CacheSource>;
 export declare const ResponseType: {
+    /** @deprecated use 'JSON' */
     readonly Json: "json";
+    /** @deprecated use 'TEXT' */
     readonly Text: "text";
+    /** @deprecated use 'ARRAY_BUFFER' */
     readonly ArrayBuffer: "arraybuffer";
+    readonly JSON: "json";
+    readonly TEXT: "text";
+    readonly ARRAY_BUFFER: "arraybuffer";
 };
 export declare type ResponseType = EnumOf<typeof ResponseType>;

package/cjs/ApiConstants.js

@@ -2,25 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseType = exports.CacheSource = exports.EventResultType = exports.RequestEvent = exports.RequestMethod = void 0;
 exports.RequestMethod = {
+    /** @deprecated use 'POST' */
     Post: "post",
+    /** @deprecated use 'GET' */
     Get: "get",
+    POST: "post",
+    GET: "get",
+    PUT: "put",
+    DELETE: "delete",
 };
 exports.RequestEvent = {
+    /** @deprecated use 'BEFORE_SEND' */
     BeforeSend: "beforeSend",
+    /** @deprecated use 'SUCCESS' */
     Success: "success",
+    /** @deprecated use 'ERROR' */
     Error: "error",
+    /** @deprecated use 'UNRECOVERABLE_ERROR' */
     UnrecoverableError: "unrecoverableError",
+    BEFORE_SEND: "beforeSend",
+    SUCCESS: "success",
+    ERROR: "error",
+    UNRECOVERABLE_ERROR: "unrecoverableError",
 };
 exports.EventResultType = {
+    /** @deprecated use 'RESPOND' */
     Respond: "respond",
+    /** @deprecated use 'RETRY' */
     Retry: "retry",
+    RESPOND: "respond",
+    RETRY: "retry",
 };
 exports.CacheSource = {
+    /** @deprecated use 'API' */
     Api: "api",
+    /** @deprecated use 'LOCAL' */
     Local: "local",
+    API: "api",
+    LOCAL: "local",
 };
 exports.ResponseType = {
+    /** @deprecated use 'JSON' */
     Json: "json",
+    /** @deprecated use 'TEXT' */
     Text: "text",
+    /** @deprecated use 'ARRAY_BUFFER' */
     ArrayBuffer: "arraybuffer",
+    JSON: "json",
+    TEXT: "text",
+    ARRAY_BUFFER: "arraybuffer",
 };

package/cjs/ApiTypes.d.ts

@@ -1,9 +1,7 @@
 import RequestContext from "./RequestContext";
 import { Api } from "./Api";
 import { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
-export declare type ModulePossiblyDefault<T> = T & {
-    default?: T;
-};
+export declare type AcceptableStatus = number | [min: number, max: number];
 export declare type Headers = Record<string, string | number | boolean | null | undefined>;
 export declare type Params = string;
 export declare type Query = Record<string, string | number | boolean | undefined | null>;
@@ -18,6 +16,7 @@ export interface BaseRequestConfig {
     lock?: string | false;
     retry?: number | false;
     headers?: Readonly<Headers>;
+    acceptableStatus?: AcceptableStatus[];
 }
 export declare type RequestConfig<P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> = (P extends undefined ? {
     params?: never;
@@ -54,10 +53,6 @@ export interface RequestContextStats {
     };
     attempt: number;
 }
-export interface RequestError extends Error {
-    name: "RequestError";
-    response?: ApiResponse;
-}
 export interface RequestHost {
     readonly method: RequestMethod;
     readonly api: Api;

package/cjs/ApiUtils.d.ts

@@ -1,13 +1,5 @@
-import { ApiResponse, CancelledRequestError, RequestError } from "./ApiTypes";
-export declare class ResponseBuilder<R> {
-    private _data;
-    private _status;
-    send(data: R): ApiResponse<R>;
-    data(data: R): this;
-    status(status: number): this;
-    build(): ApiResponse<R>;
-}
+import { AcceptableStatus, ApiResponse, CancelledRequestError } from "./ApiTypes";
 export declare const isCancelledError: (error: Error) => error is CancelledRequestError;
 export declare const isNetworkError: (error: Error) => boolean;
-export declare const isRequestError: (error: Error) => error is RequestError;
 export declare const parseResponseDataToObject: (response: ApiResponse) => void;
+export declare const isAcceptableStatus: (status: number, acceptableStatus?: AcceptableStatus[] | undefined) => boolean;

package/cjs/ApiUtils.js

@@ -1,35 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseResponseDataToObject = exports.isRequestError = exports.isNetworkError = exports.isCancelledError = exports.ResponseBuilder = void 0;
-var ResponseBuilder = /** @class */ (function () {
-    function ResponseBuilder() {
-        this._status = 200;
-    }
-    ResponseBuilder.prototype.send = function (data) {
-        this.data(data);
-        return this.build();
-    };
-    ResponseBuilder.prototype.data = function (data) {
-        this._data = data;
-        return this;
-    };
-    ResponseBuilder.prototype.status = function (status) {
-        this._status = status;
-        return this;
-    };
-    ResponseBuilder.prototype.build = function () {
-        if (this._data === undefined) {
-            throw new Error("Response builder doesn't have a response");
-        }
-        return {
-            headers: {},
-            data: this._data,
-            status: this._status,
-        };
-    };
-    return ResponseBuilder;
-}());
-exports.ResponseBuilder = ResponseBuilder;
+exports.isAcceptableStatus = exports.parseResponseDataToObject = exports.isNetworkError = exports.isCancelledError = void 0;
+var TextDecoding_1 = require("./TextDecoding");
 var isCancelledError = function (error) {
     return "isCancelledRequest" in error;
 };
@@ -41,18 +13,13 @@ var isNetworkError = function (error) {
         ((_a = error.constructor) === null || _a === void 0 ? void 0 : _a.name) === "NetworkError");
 };
 exports.isNetworkError = isNetworkError;
-var isRequestError = function (error) {
-    return "response" in error;
-};
-exports.isRequestError = isRequestError;
 var parseResponseDataToObject = function (response) {
-    if (TextDecoder &&
-        response.data &&
+    if (response.data &&
         typeof response.data === "object") {
         var data = response.data;
         if (data.constructor && data.constructor.name === "ArrayBuffer") {
             try {
-                var decodedData = (response.data = new TextDecoder("utf-8").decode(data));
+                var decodedData = (response.data = TextDecoding_1.textDecode(data));
                 response.data = JSON.parse(decodedData);
             }
             catch (e) {
@@ -62,3 +29,23 @@ var parseResponseDataToObject = function (response) {
     }
 };
 exports.parseResponseDataToObject = parseResponseDataToObject;
+var DEFAULT_ACCEPTABLE_STATUS = [[200, 299], 304];
+var isAcceptableStatus = function (status, acceptableStatus) {
+    var acceptable = acceptableStatus !== null && acceptableStatus !== void 0 ? acceptableStatus : DEFAULT_ACCEPTABLE_STATUS;
+    for (var _i = 0, acceptable_1 = acceptable; _i < acceptable_1.length; _i++) {
+        var cmpStatus = acceptable_1[_i];
+        if (Array.isArray(cmpStatus)) {
+            var min = cmpStatus[0], max = cmpStatus[1];
+            if (status >= min && status <= max) {
+                return (true);
+            }
+        }
+        else if (!isNaN(cmpStatus)) {
+            if (status === cmpStatus) {
+                return (true);
+            }
+        }
+    }
+    return (false);
+};
+exports.isAcceptableStatus = isAcceptableStatus;

package/cjs/Endpoint.d.ts

@@ -1,15 +1,33 @@
 import { Api } from "./Api";
 import { ApiResponse, BaseRequestConfig, Body, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
-import { EndpointMockingInfo, MockingFunction } from "./Mocking";
+import * as Mocking from "./MockingTypes";
 import { RequestMethod, ResponseType } from "./ApiConstants";
 export interface EndpointConfig<R, P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined> {
     readonly id: string;
     readonly method: RequestMethod;
+    readonly path: string;
+    /**
+     * Name your endpoint to help with debugging and documentation
+     * @default `id` is used as the name if no name is supplied
+     */
     readonly name?: string;
+    /**
+     * Describe your endpoint to help with debugging and documentation
+     */
     readonly description?: string;
-    readonly path: string;
     readonly config?: BaseRequestConfig;
+    /**
+     * Let the backend requestor (fetch, axios, etc.) know what type of response
+     * you are expecting from this endpoint
+     * @default `application/json`
+     */
     readonly responseType?: ResponseType;
+    /**
+     * Specify mocking for your endpoint upfront to help with disconnected dev,
+     * and testing.
+     * Enable/disable mocked returns for all endpoints on your API object.
+     */
+    readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
 }
 export default class Endpoint<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> implements EndpointConfig<R, P, Q, B>, RequestHost {
     readonly api: Api;
@@ -20,12 +38,10 @@ export default class Endpoint<R = any, P extends Params | undefined = Params | u
     readonly path: string;
     readonly config?: BaseRequestConfig;
     readonly responseType: ResponseType;
-    mocking: EndpointMockingInfo<R, P, Q, B> | null;
+    readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
     constructor(api: Api, info: EndpointConfig<R, P, Q, B>);
     submit(config: RequestConfig<P, Q, B>): Promise<ApiResponse<R>>;
     computePath(path: string, request: RequestConfig): string;
-    mock(mocker: MockingFunction<R, P, Q, B>): this;
-    mockBypass(): this;
     get baseUrl(): string;
     computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): RequestConfig<P, Q, B>;
 }

package/cjs/Endpoint.js

@@ -37,12 +37,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var Requester = require("./Requester");
-var Mocking = require("./Mocking");
 var Utils = require("./Utils");
 var ApiConstants_1 = require("./ApiConstants");
 var Endpoint = /** @class */ (function () {
     function Endpoint(api, info) {
-        this.mocking = null;
         this.api = api;
         this.id = info.id;
         this.method = info.method;
@@ -51,26 +49,25 @@ var Endpoint = /** @class */ (function () {
         this.path = info.path;
         this.config = info.config;
         this.responseType = info.responseType || ApiConstants_1.ResponseType.Json;
+        this.mocking = info.mocking;
     }
     Endpoint.prototype.submit = function (config) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var apiMocking;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        apiMocking = this.api.mocking;
-                        if (!(!((_a = this.mocking) === null || _a === void 0 ? void 0 : _a.bypass) && (apiMocking === null || apiMocking === void 0 ? void 0 : apiMocking.predicate()))) return [3 /*break*/, 3];
-                        if (!((apiMocking === null || apiMocking === void 0 ? void 0 : apiMocking.loader) && !apiMocking.loaded)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, (apiMocking.loaderPromise ||
-                                (apiMocking.loaderPromise = apiMocking.loader()))];
-                    case 1:
-                        _b.sent();
-                        apiMocking.loaded = true;
-                        _b.label = 2;
-                    case 2: return [2 /*return*/, Mocking.mockRequest(this, config)];
-                    case 3: return [2 /*return*/, Requester.submit(this, config)];
+            var mock, apiMocking, mockingEnabled;
+            return __generator(this, function (_c) {
+                mock = false;
+                apiMocking = this.api.mocking;
+                if (apiMocking) {
+                    mockingEnabled = (_a = (typeof apiMocking.enabled === "function" ? apiMocking.enabled() : apiMocking.enabled)) !== null && _a !== void 0 ? _a : false;
+                    if (mockingEnabled) {
+                        if (!((_b = this.mocking) === null || _b === void 0 ? void 0 : _b.handler)) {
+                            throw new Error("[api-def] Endpoint for '" + this.path + "' has no mocking");
+                        }
+                        mock = true;
+                    }
                 }
+                return [2 /*return*/, Requester.submit(this, config, mock ? this.mocking : null)];
             });
         });
     };
@@ -84,22 +81,10 @@ var Endpoint = /** @class */ (function () {
             }
         }
         if (computedPath.includes(":")) {
-            throw new Error("Not all path params have been resolved: '" + computedPath + "'");
+            throw new Error("[api-def] Not all path params have been resolved: '" + computedPath + "'");
         }
         return computedPath;
     };
-    Endpoint.prototype.mock = function (mocker) {
-        this.mocking = {
-            func: mocker,
-        };
-        return this;
-    };
-    Endpoint.prototype.mockBypass = function () {
-        this.mocking = {
-            bypass: true,
-        };
-        return this;
-    };
     Object.defineProperty(Endpoint.prototype, "baseUrl", {
         get: function () {
             return this.api.baseUrl;

package/cjs/MockingTypes.d.ts

@@ -0,0 +1,28 @@
+import { ApiResponse, Body, Headers, Params, Query } from "./ApiTypes";
+export interface ApiMockingConfig {
+    enabled: boolean | (() => boolean);
+}
+export interface MockRequest<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> {
+    params: P extends Params ? Record<P, string> : {};
+    body: B;
+    query: Q;
+    headers: Readonly<Headers>;
+}
+export interface MockResponse<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> {
+    statusCode: number;
+    response: R | undefined;
+    status(statusCode: number): this;
+    send(response: R): this;
+}
+export declare type MockRequestError = Error & {
+    response?: ApiResponse;
+};
+export declare type EndpointMockingFunction<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> = (req: MockRequest<R, P, Q, B>, res: MockResponse<R, P, Q, B>) => Promise<MockResponse<R, P, Q, B>> | MockResponse<R, P, Q, B>;
+export interface EndpointMockingConfig<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> {
+    /**-
+     * The range supplied will be used to simulate the lag in obtaining a response
+     * your endpoint. If no values are supplied, a response will be returned immediately
+     */
+    delay?: number | [minMs: number, maxMs: number];
+    handler: EndpointMockingFunction<R, P, Q, B>;
+}

package/cjs/RequestContext.d.ts

@@ -1,6 +1,9 @@
-import { ApiResponse, Body, EventResult, Headers, Params, Query, RequestCacheInfo, RequestConfig, RequestContextStats, RequestError, RequestEventHandlers, RequestHost } from "./ApiTypes";
+import { ApiResponse, Body, EventResult, Headers, Params, Query, RequestCacheInfo, RequestConfig, RequestContextStats, RequestEventHandlers, RequestHost } from "./ApiTypes";
 import { Api } from "./Api";
 import { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
+import { EndpointMockingConfig } from "./MockingTypes";
+import { RequestError } from "./RequestError";
+import RequestBackend from "./backend/RequestBackend";
 export default class RequestContext<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> {
     readonly id: number;
     readonly key: string;
@@ -8,18 +11,20 @@ export default class RequestContext<R = any, P extends Params | undefined = Para
     readonly stats: RequestContextStats;
     private readonly host;
     readonly eventHandlers: RequestEventHandlers<R>;
+    readonly backend: RequestBackend;
     private canceler;
-    response: ApiResponse<R> | null;
+    response: ApiResponse<R> | null | undefined;
     error: RequestError | null;
     readonly cacheInfo: RequestCacheInfo;
     cancelled: boolean;
     readonly computedConfig: RequestConfig<P, Q, B>;
-    constructor(host: RequestHost, config: RequestConfig<P, Q, B>, computedPath: string);
+    readonly mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined;
+    constructor(backend: RequestBackend, host: RequestHost, config: RequestConfig<P, Q, B>, computedPath: string, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined);
     get method(): RequestMethod;
     get api(): Api;
     get baseUrl(): string;
     get responseType(): ResponseType;
-    initMiddleware(): void;
+    private initMiddleware;
     private generateKey;
     updateHeaders(newHeaders: Headers): this;
     updateQuery(newQuery: Partial<Q>): this;

package/cjs/RequestContext.js

@@ -39,12 +39,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var Utils = require("./Utils");
 var contextIdCounter = 0;
 var RequestContext = /** @class */ (function () {
-    function RequestContext(host, config, computedPath) {
+    function RequestContext(backend, host, config, computedPath, mocking) {
         this.canceler = null;
-        this.response = null;
+        this.response = undefined;
         this.error = null;
         this.cacheInfo = { cached: false, source: null };
         this.cancelled = false;
+        this.backend = backend;
         this.id = contextIdCounter++;
         this.host = host;
         this.computedConfig = config;
@@ -56,6 +57,7 @@ var RequestContext = /** @class */ (function () {
             cached: false,
         };
         this.eventHandlers = {};
+        this.mocking = mocking;
         this.initMiddleware();
     }
     Object.defineProperty(RequestContext.prototype, "method", {

package/cjs/RequestError.d.ts

@@ -0,0 +1,21 @@
+import { ApiResponse } from "./ApiTypes";
+import { EnumOf } from "./Utils";
+export declare const RequestErrorCode: {
+    readonly MISC_UNKNOWN_ERROR: "misc/unknown-error";
+    readonly REQUEST_NETWORK_ERROR: "request/network-error";
+    readonly REQUEST_INVALID_STATUS: "request/invalid-status";
+    readonly REQUEST_INVALID_CONFIG: "request/invalid-config";
+};
+export declare type RequestErrorCode = EnumOf<typeof RequestErrorCode>;
+export interface RequestError extends Error {
+    isRequestError: true;
+    response: ApiResponse | undefined | null;
+    code: string;
+}
+export declare const isRequestError: (error: Error) => error is RequestError;
+export interface RequestErrorConfig {
+    error: Error;
+    code: string;
+    response?: ApiResponse | null;
+}
+export declare const convertToRequestError: (config: RequestErrorConfig) => RequestError;