api-def 0.9.1 → 0.9.2

package/esm/backend/MockRequestBackend.js

@@ -1,116 +1,116 @@
-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());
-    });
-};
-import * as Utils from "../Utils";
-import { delayThenReturn, randInt } from "../Utils";
-import { convertToRequestError, RequestErrorCode } from "../RequestError";
-export default class MockRequestBackend {
-    constructor() {
-        this.id = "mock";
-    }
-    convertResponse(context, response, error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return response;
-        });
-    }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ("response" in error) {
-                const fetchError = error;
-                return fetchError.response ? fetchError.response : null;
-            }
-            return undefined;
-        });
-    }
-    runRequest(context) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const mockingFunc = (_a = context.mocking) === null || _a === void 0 ? void 0 : _a.handler;
-            if (!mockingFunc) {
-                throw convertToRequestError({
-                    error: new Error("[api-def] Attempted to run mocked request without mocking function"),
-                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                    context,
-                });
-            }
-            const req = {
-                body: context.getParsedBody(),
-                params: (_b = context.computedConfig.params) !== null && _b !== void 0 ? _b : {},
-                query: context.computedConfig.queryObject,
-                headers: (_c = context.computedConfig.headers) !== null && _c !== void 0 ? _c : {},
-                url: context.requestUrl.toString(),
-            };
-            const res = {
-                statusCode: -1,
-                headers: {},
-                response: undefined,
-                status(statusCode) {
-                    res.statusCode = statusCode;
-                    return res;
-                },
-                send(response) {
-                    res.response = response;
-                    if (response && typeof response === "object") {
-                        res.headers["Content-Type"] = "application/json";
-                    }
-                    return res;
-                },
-            };
-            if ((_d = context.mocking) === null || _d === void 0 ? void 0 : _d.delay) {
-                const delay = context.mocking.delay;
-                let delayMs;
-                if (typeof delay === "number") {
-                    delayMs = delay;
-                }
-                else {
-                    const [min, max] = delay;
-                    if (min > max) {
-                        throw convertToRequestError({
-                            error: new Error("[api-def] Min delay cannot be greater than max delay"),
-                            code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                            context,
-                        });
-                    }
-                    delayMs = randInt(min, max);
-                }
-                yield delayThenReturn(yield mockingFunc(req, res), delayMs);
-            }
-            else {
-                yield mockingFunc(req, res);
-            }
-            if (res.response === undefined) {
-                throw convertToRequestError({
-                    error: new Error("[api-def] Mocked API did not respond"),
-                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                    context,
-                });
-            }
-            const parsedHeaders = Object.keys(res.headers).reduce((parsedHeaders, key) => {
-                parsedHeaders[key] = res.headers[key].toString();
-                return parsedHeaders;
-            }, {});
-            return {
-                url: context.requestUrl.href,
-                method: context.method,
-                headers: parsedHeaders,
-                data: res.response,
-                status: res.statusCode,
-            };
-        });
-    }
-    makeRequest(context) {
-        return {
-            canceler: Utils.noop,
-            promise: this.runRequest(context),
-        };
-    }
-    getErrorInfo(error, response) {
-        return undefined;
-    }
-}
+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());
+    });
+};
+import { RequestErrorCode, convertToRequestError } from "../RequestError";
+import * as Utils from "../Utils";
+import { delayThenReturn, randInt } from "../Utils";
+export default class MockRequestBackend {
+    constructor() {
+        this.id = "mock";
+    }
+    convertResponse(context, response, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return response;
+        });
+    }
+    extractResponseFromError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ("response" in error) {
+                const fetchError = error;
+                return fetchError.response ? fetchError.response : null;
+            }
+            return undefined;
+        });
+    }
+    runRequest(context) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const mockingFunc = (_a = context.mocking) === null || _a === void 0 ? void 0 : _a.handler;
+            if (!mockingFunc) {
+                throw convertToRequestError({
+                    error: new Error("[api-def] Attempted to run mocked request without mocking function"),
+                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                    context,
+                });
+            }
+            const req = {
+                body: context.getParsedBody(),
+                params: (_b = context.computedConfig.params) !== null && _b !== void 0 ? _b : {},
+                query: context.computedConfig.queryObject,
+                headers: (_c = context.computedConfig.headers) !== null && _c !== void 0 ? _c : {},
+                url: context.requestUrl.toString(),
+            };
+            const res = {
+                statusCode: -1,
+                headers: {},
+                response: undefined,
+                status(statusCode) {
+                    res.statusCode = statusCode;
+                    return res;
+                },
+                send(response) {
+                    res.response = response;
+                    if (response && typeof response === "object") {
+                        res.headers["Content-Type"] = "application/json";
+                    }
+                    return res;
+                },
+            };
+            if ((_d = context.mocking) === null || _d === void 0 ? void 0 : _d.delay) {
+                const delay = context.mocking.delay;
+                let delayMs;
+                if (typeof delay === "number") {
+                    delayMs = delay;
+                }
+                else {
+                    const [min, max] = delay;
+                    if (min > max) {
+                        throw convertToRequestError({
+                            error: new Error("[api-def] Min delay cannot be greater than max delay"),
+                            code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                            context,
+                        });
+                    }
+                    delayMs = randInt(min, max);
+                }
+                yield delayThenReturn(yield mockingFunc(req, res), delayMs);
+            }
+            else {
+                yield mockingFunc(req, res);
+            }
+            if (res.response === undefined) {
+                throw convertToRequestError({
+                    error: new Error("[api-def] Mocked API did not respond"),
+                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                    context,
+                });
+            }
+            const parsedHeaders = Object.keys(res.headers).reduce((parsedHeaders, key) => {
+                parsedHeaders[key] = res.headers[key].toString();
+                return parsedHeaders;
+            }, {});
+            return {
+                url: context.requestUrl.href,
+                method: context.method,
+                headers: parsedHeaders,
+                data: res.response,
+                status: res.statusCode,
+            };
+        });
+    }
+    makeRequest(context) {
+        return {
+            canceler: Utils.noop,
+            promise: this.runRequest(context),
+        };
+    }
+    getErrorInfo(error, response) {
+        return undefined;
+    }
+}

package/esm/backend/RequestBackend.d.ts

@@ -1,19 +1,19 @@
-import RequestContext from "../RequestContext";
-import { ApiResponse } from "../ApiTypes";
-export interface RequestOperation<R> {
-    promise: Promise<R>;
-    canceler: () => void;
-}
-export interface RequestBackendErrorInfo {
-    code: string;
-}
-export declare type ConvertedApiResponse<T> = ApiResponse<T> & {
-    __lowercaseHeaders?: any;
-};
-export default interface RequestBackend<R = any> {
-    readonly id: string;
-    makeRequest(context: RequestContext): RequestOperation<R>;
-    convertResponse<T>(context: RequestContext, response: R): Promise<ConvertedApiResponse<T>>;
-    extractResponseFromError(error: Error): Promise<R | null | undefined>;
-    getErrorInfo(error: Error, response: ApiResponse | undefined | null): RequestBackendErrorInfo | undefined;
-}
+import { ApiResponse } from "../ApiTypes";
+import RequestContext from "../RequestContext";
+export interface RequestOperation<R> {
+    promise: Promise<R>;
+    canceler: () => void;
+}
+export interface RequestBackendErrorInfo {
+    code: string;
+}
+export type ConvertedApiResponse<T> = ApiResponse<T> & {
+    __lowercaseHeaders?: any;
+};
+export default interface RequestBackend<R = any> {
+    readonly id: string;
+    makeRequest(context: RequestContext): RequestOperation<R>;
+    convertResponse<T>(context: RequestContext, response: R): Promise<ConvertedApiResponse<T>>;
+    extractResponseFromError(error: Error): Promise<R | null | undefined>;
+    getErrorInfo(error: Error, response: ApiResponse | undefined | null): RequestBackendErrorInfo | undefined;
+}

package/esm/backend/RequestBackend.js

@@ -1 +1 @@
-export {};
+export {};

package/esm/cache/CacheBackend.d.ts

@@ -1,6 +1,6 @@
-export interface CacheBackend {
-    removeItem(key: string): Promise<void>;
-    setItem<T>(key: string, value: T): Promise<void>;
-    getItem<T>(key: string): Promise<T | null>;
-    clear(): Promise<void>;
-}
+export interface CacheBackend {
+    removeItem(key: string): Promise<void>;
+    setItem<T>(key: string, value: T): Promise<void>;
+    getItem<T>(key: string): Promise<T | null>;
+    clear(): Promise<void>;
+}

package/esm/cache/CacheBackend.js

@@ -1 +1 @@
-export {};
+export {};

package/esm/cache/Caching.d.ts

@@ -1,10 +1,10 @@
-import { CacheBackend } from "./CacheBackend";
-export declare const setCacheBackend: (backend: CacheBackend) => void;
-export declare const DEFAULT_CACHE_EXPIRY: number;
-export declare const clearCache: () => Promise<void>;
-export interface CacheEntry {
-    data: any;
-    expiry: number | null;
-}
-export declare const setCachedItem: <T>(key: string, value: T, expiry?: number) => Promise<T>;
-export declare const getCachedItem: <T = any>(key: string) => Promise<T | undefined>;
+import { CacheBackend } from "./CacheBackend";
+export declare const setCacheBackend: (backend: CacheBackend) => void;
+export declare const DEFAULT_CACHE_EXPIRY: number;
+export declare const clearCache: () => Promise<void>;
+export interface CacheEntry {
+    data: any;
+    expiry: number | null;
+}
+export declare const setCachedItem: <T>(key: string, value: T, expiry?: number) => Promise<T>;
+export declare const getCachedItem: <T = any>(key: string) => Promise<T | undefined>;

package/esm/cache/Caching.js

@@ -1,39 +1,39 @@
-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());
-    });
-};
-import LocalStorageCacheBackend from "./LocalStorageCacheBackend";
-let cacheBackend = new LocalStorageCacheBackend();
-export const setCacheBackend = (backend) => {
-    cacheBackend = backend;
-};
-export const DEFAULT_CACHE_EXPIRY = /* 15 mins */ 60 * 1000 * 15;
-export const clearCache = () => {
-    return cacheBackend.clear();
-};
-export const setCachedItem = (key, value, expiry) => __awaiter(void 0, void 0, void 0, function* () {
-    const entry = {
-        data: value,
-        expiry: expiry === undefined || isNaN(expiry) ? null : expiry,
-    };
-    yield cacheBackend.setItem(key, entry);
-    return value;
-});
-export const getCachedItem = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    const entry = yield cacheBackend.getItem(key);
-    if (!entry) {
-        return undefined;
-    }
-    if (typeof entry.expiry === "number") {
-        if (Date.now() >= entry.expiry) {
-            yield cacheBackend.removeItem(key);
-            return undefined;
-        }
-    }
-    return entry.data;
-});
+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());
+    });
+};
+import LocalStorageCacheBackend from "./LocalStorageCacheBackend";
+let cacheBackend = new LocalStorageCacheBackend();
+export const setCacheBackend = (backend) => {
+    cacheBackend = backend;
+};
+export const DEFAULT_CACHE_EXPIRY = /* 15 mins */ 60 * 1000 * 15;
+export const clearCache = () => {
+    return cacheBackend.clear();
+};
+export const setCachedItem = (key, value, expiry) => __awaiter(void 0, void 0, void 0, function* () {
+    const entry = {
+        data: value,
+        expiry: expiry === undefined || Number.isNaN(expiry) ? null : expiry,
+    };
+    yield cacheBackend.setItem(key, entry);
+    return value;
+});
+export const getCachedItem = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const entry = yield cacheBackend.getItem(key);
+    if (!entry) {
+        return undefined;
+    }
+    if (typeof entry.expiry === "number") {
+        if (Date.now() >= entry.expiry) {
+            yield cacheBackend.removeItem(key);
+            return undefined;
+        }
+    }
+    return entry.data;
+});

package/esm/cache/LocalForageCacheBackend.d.ts

@@ -1,9 +1,9 @@
-import { CacheBackend } from "./CacheBackend";
-export default class LocalForageCacheBackend implements CacheBackend {
-    private readonly store;
-    constructor(localforage: any);
-    clear(): Promise<void>;
-    getItem<T>(key: string): Promise<T | null>;
-    removeItem(key: string): Promise<void>;
-    setItem<T>(key: string, value: T): Promise<void>;
-}
+import { CacheBackend } from "./CacheBackend";
+export default class LocalForageCacheBackend implements CacheBackend {
+    private readonly store;
+    constructor(localforage: any);
+    clear(): Promise<void>;
+    getItem<T>(key: string): Promise<T | null>;
+    removeItem(key: string): Promise<void>;
+    setItem<T>(key: string, value: T): Promise<void>;
+}

package/esm/cache/LocalForageCacheBackend.js

@@ -1,20 +1,20 @@
-export default class LocalForageCacheBackend {
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    constructor(localforage) {
-        this.store = localforage.createInstance({
-            name: "requestCache",
-        });
-    }
-    clear() {
-        return this.store.clear();
-    }
-    getItem(key) {
-        return this.store.getItem(key);
-    }
-    removeItem(key) {
-        return this.store.removeItem(key);
-    }
-    setItem(key, value) {
-        return this.store.setItem(key, value);
-    }
-}
+export default class LocalForageCacheBackend {
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    constructor(localforage) {
+        this.store = localforage.createInstance({
+            name: "requestCache",
+        });
+    }
+    clear() {
+        return this.store.clear();
+    }
+    getItem(key) {
+        return this.store.getItem(key);
+    }
+    removeItem(key) {
+        return this.store.removeItem(key);
+    }
+    setItem(key, value) {
+        return this.store.setItem(key, value);
+    }
+}

package/esm/cache/LocalStorageCacheBackend.d.ts

@@ -1,7 +1,7 @@
-import { CacheBackend } from "./CacheBackend";
-export default class LocalStorageCacheBackend implements CacheBackend {
-    clear(): Promise<void>;
-    getItem<T>(key: string): Promise<T | null>;
-    removeItem(key: string): Promise<void>;
-    setItem<T>(key: string, value: T): Promise<void>;
-}
+import { CacheBackend } from "./CacheBackend";
+export default class LocalStorageCacheBackend implements CacheBackend {
+    clear(): Promise<void>;
+    getItem<T>(key: string): Promise<T | null>;
+    removeItem(key: string): Promise<void>;
+    setItem<T>(key: string, value: T): Promise<void>;
+}

package/esm/cache/LocalStorageCacheBackend.js

@@ -1,32 +1,32 @@
-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());
-    });
-};
-export default class LocalStorageCacheBackend {
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            localStorage.clear();
-        });
-    }
-    getItem(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const value = localStorage.getItem(key);
-            return value ? JSON.parse(value) : null;
-        });
-    }
-    removeItem(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            localStorage.removeItem(key);
-        });
-    }
-    setItem(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            localStorage.setItem(key, JSON.stringify(value));
-        });
-    }
-}
+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());
+    });
+};
+export default class LocalStorageCacheBackend {
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            localStorage.clear();
+        });
+    }
+    getItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = localStorage.getItem(key);
+            return value ? JSON.parse(value) : null;
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            localStorage.removeItem(key);
+        });
+    }
+    setItem(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            localStorage.setItem(key, JSON.stringify(value));
+        });
+    }
+}

package/esm/index.d.ts

@@ -1,13 +1,13 @@
-export * from "./Api";
-export * from "./ApiTypes";
-export * from "./UtilTypes";
-export * from "./ApiConstants";
-export { isRequestError } from "./RequestError";
-export { default as Endpoint, EndpointConfig } from "./Endpoint";
-export { clearCache, setCacheBackend } from "./cache/Caching";
-export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
-export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";
-export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
-export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
-export { default as CacheMiddleware } from "./middleware/CacheMiddleware";
-export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";
+export * from "./Api";
+export * from "./ApiTypes";
+export * from "./UtilTypes";
+export * from "./ApiConstants";
+export { isRequestError } from "./RequestError";
+export { default as Endpoint, EndpointConfig } from "./Endpoint";
+export { clearCache, setCacheBackend } from "./cache/Caching";
+export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
+export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";
+export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
+export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
+export { default as CacheMiddleware } from "./middleware/CacheMiddleware";
+export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";

package/esm/index.js

@@ -1,15 +1,14 @@
-/// <reference types="typescript" />
-"use strict";
-export * from "./Api";
-export * from "./ApiTypes";
-export * from "./UtilTypes";
-export * from "./ApiConstants";
-export { isRequestError } from "./RequestError";
-export { default as Endpoint } from "./Endpoint";
-export { clearCache, setCacheBackend } from "./cache/Caching";
-export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
-export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";
-export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
-export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
-export { default as CacheMiddleware } from "./middleware/CacheMiddleware";
-export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";
+/// <reference types="typescript" />
+export * from "./Api";
+export * from "./ApiTypes";
+export * from "./UtilTypes";
+export * from "./ApiConstants";
+export { isRequestError } from "./RequestError";
+export { default as Endpoint } from "./Endpoint";
+export { clearCache, setCacheBackend } from "./cache/Caching";
+export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
+export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";
+export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
+export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
+export { default as CacheMiddleware } from "./middleware/CacheMiddleware";
+export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";

package/esm/middleware/CacheMiddleware.d.ts

@@ -1,7 +1,7 @@
-import { RequestMiddleware } from "../ApiTypes";
-export interface CacheMiddlewareOptions {
-    defaultExpiry?: number;
-    predicate?: () => boolean;
-}
-declare const CacheMiddleware: (options?: CacheMiddlewareOptions) => RequestMiddleware;
-export default CacheMiddleware;
+import { RequestMiddleware } from "../ApiTypes";
+export interface CacheMiddlewareOptions {
+    defaultExpiry?: number;
+    predicate?: () => boolean;
+}
+declare const CacheMiddleware: (options?: CacheMiddlewareOptions) => RequestMiddleware;
+export default CacheMiddleware;