api-def 0.9.0 → 0.9.2

package/esm/middleware/CacheMiddleware.js

@@ -1,58 +1,58 @@
-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 Caching from "../cache/Caching";
-import { CacheSource, EventResultType, RequestEvent, RequestMethod } from "../ApiConstants";
-const CacheMiddleware = (options = {}) => {
-    return {
-        [RequestEvent.Success]: (context) => __awaiter(void 0, void 0, void 0, function* () {
-            if (context.method !== RequestMethod.Get)
-                return;
-            const { cache } = context.computedConfig || {};
-            const shouldCache = !options.predicate || options.predicate();
-            if (cache && shouldCache) {
-                const expiry = typeof cache === "number" ? cache : (options.defaultExpiry || Caching.DEFAULT_CACHE_EXPIRY);
-                yield Caching.setCachedItem(context.key, context.response, expiry);
-            }
-        }),
-        [RequestEvent.BeforeSend]: (context) => __awaiter(void 0, void 0, void 0, function* () {
-            if (context.method !== RequestMethod.Get)
-                return;
-            const { cache } = context.computedConfig || {};
-            const shouldCache = !options.predicate || options.predicate();
-            if (cache && shouldCache) {
-                if (cache) {
-                    const cachedValue = yield Caching.getCachedItem(context.key);
-                    if (cachedValue) {
-                        context.stats.cached = {
-                            is: true,
-                            by: CacheSource.Local,
-                        };
-                        context.cacheInfo.source = CacheSource.Local;
-                        context.cacheInfo.cached = true;
-                        return {
-                            type: EventResultType.Respond,
-                            response: cachedValue,
-                        };
-                    }
-                }
-            }
-            if (cache === false) {
-                context.updateQuery({
-                    _bust: Math.floor(Math.random() * 9000) + 1000,
-                });
-                context.updateHeaders({
-                    Pragma: "no-cache, no-store, must-revalidate",
-                    "Cache-Control": "no-cache, no-store, must-revalidate",
-                });
-            }
-        }),
-    };
-};
-export default CacheMiddleware;
+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 { CacheSource, EventResultType, RequestEvent, RequestMethod } from "../ApiConstants";
+import * as Caching from "../cache/Caching";
+const CacheMiddleware = (options = {}) => {
+    return {
+        [RequestEvent.Success]: (context) => __awaiter(void 0, void 0, void 0, function* () {
+            if (context.method !== RequestMethod.Get)
+                return;
+            const { cache } = context.computedConfig || {};
+            const shouldCache = !options.predicate || options.predicate();
+            if (cache && shouldCache) {
+                const expiry = typeof cache === "number" ? cache : options.defaultExpiry || Caching.DEFAULT_CACHE_EXPIRY;
+                yield Caching.setCachedItem(context.key, context.response, expiry);
+            }
+        }),
+        [RequestEvent.BeforeSend]: (context) => __awaiter(void 0, void 0, void 0, function* () {
+            if (context.method !== RequestMethod.Get)
+                return;
+            const { cache } = context.computedConfig || {};
+            const shouldCache = !options.predicate || options.predicate();
+            if (cache && shouldCache) {
+                if (cache) {
+                    const cachedValue = yield Caching.getCachedItem(context.key);
+                    if (cachedValue) {
+                        context.stats.cached = {
+                            is: true,
+                            by: CacheSource.Local,
+                        };
+                        context.cacheInfo.source = CacheSource.Local;
+                        context.cacheInfo.cached = true;
+                        return {
+                            type: EventResultType.Respond,
+                            response: cachedValue,
+                        };
+                    }
+                }
+            }
+            if (cache === false) {
+                context.updateQuery({
+                    _bust: Math.floor(Math.random() * 9000) + 1000,
+                });
+                context.updateHeaders({
+                    Pragma: "no-cache, no-store, must-revalidate",
+                    "Cache-Control": "no-cache, no-store, must-revalidate",
+                });
+            }
+        }),
+    };
+};
+export default CacheMiddleware;

package/esm/middleware/LoggingMiddleware.d.ts

@@ -1,6 +1,6 @@
-import { RequestMiddleware } from "../ApiTypes";
-export interface LoggingMiddlewareOptions {
-    predicate?: () => boolean;
-}
-declare const LoggingMiddleware: (config?: LoggingMiddlewareOptions) => RequestMiddleware;
-export default LoggingMiddleware;
+import { RequestMiddleware } from "../ApiTypes";
+export interface LoggingMiddlewareOptions {
+    predicate?: () => boolean;
+}
+declare const LoggingMiddleware: (config?: LoggingMiddlewareOptions) => RequestMiddleware;
+export default LoggingMiddleware;

package/esm/middleware/LoggingMiddleware.js

@@ -1,83 +1,77 @@
-import * as ApiUtils from "../ApiUtils";
-import * as Utils from "../Utils";
-import { RequestEvent } from "../ApiConstants";
-var LogType;
-(function (LogType) {
-    LogType[LogType["Info"] = 0] = "Info";
-    LogType[LogType["Success"] = 1] = "Success";
-    LogType[LogType["Error"] = 2] = "Error";
-    LogType[LogType["Warn"] = 3] = "Warn";
-})(LogType || (LogType = {}));
-const COLOR_MAP = {
-    [LogType.Error]: "#c8646c",
-    [LogType.Info]: "#85a6c7",
-    [LogType.Success]: "#a9c490",
-    [LogType.Warn]: "#d19a66",
-};
-const diagnoseError = (error) => {
-    if (!error.response) {
-        if (ApiUtils.isNetworkError(error)) {
-            return { message: "network issue", error };
-        }
-        if (ApiUtils.isCancelledError(error)) {
-            return { message: "cancelled", error };
-        }
-        return { message: "client-side error", error };
-    }
-    const { status, data } = error.response;
-    const code = data === null || data === void 0 ? void 0 : data.code;
-    return {
-        message: `responded with ${status}${code ? ` (${code})` : ""}`,
-        response: error.response,
-    };
-};
-const formatTime = (time) => {
-    return `${Utils.padNumber(time.getHours(), 2)}:${Utils.padNumber(time.getMinutes(), 2)}:${Utils.padNumber(time.getSeconds(), 2)}.${Utils.padNumber(time.getMilliseconds(), 3)}`;
-};
-const log = (context, type, message, config, objects) => {
-    if (typeof config.predicate === "function" && !config.predicate()) {
-        return;
-    }
-    const color = COLOR_MAP[type];
-    const timestamp = formatTime(new Date());
-    const args = [
-        `%cnetwork %c[${context.api.name}] ${context.method.toUpperCase()} ${context.path} %c${message} %c@ ${timestamp}`,
-        "color:gray",
-        "color:auto",
-        `color:${color}`,
-        "color:gray",
-    ];
-    /* eslint-disable-next-line no-console */
-    console.groupCollapsed(...args);
-    /* eslint-disable-next-line no-console */
-    console.log(Utils.assign({ context: context }, objects || {}));
-    /* eslint-disable-next-line no-console */
-    console.groupEnd();
-};
-const LoggingMiddleware = (config = {}) => {
-    return {
-        [RequestEvent.BeforeSend]: (context) => {
-            log(context, LogType.Info, context.stats.attempt > 1 ? "retrying" : "sending", config);
-        },
-        [RequestEvent.Success]: (context) => {
-            var _a;
-            const cacheSource = context.cacheInfo.source;
-            log(context, LogType.Success, `responded with ${(_a = context.response) === null || _a === void 0 ? void 0 : _a.status}${cacheSource ? ` (cached by ${cacheSource})` : ""}`, config);
-        },
-        [RequestEvent.Error]: (context) => {
-            if (context.error) {
-                const { error, message } = diagnoseError(context.error);
-                log(context, LogType.Warn, `error on attempt ${context.stats.attempt} - ${message}`, config, { error: error });
-            }
-        },
-        [RequestEvent.UnrecoverableError]: (context) => {
-            if (context.error) {
-                const { error, message } = diagnoseError(context.error);
-                log(context, LogType.Error, `failed - ${message}`, config, {
-                    error: error,
-                });
-            }
-        },
-    };
-};
-export default LoggingMiddleware;
+import { RequestEvent } from "../ApiConstants";
+import * as ApiUtils from "../ApiUtils";
+import * as Utils from "../Utils";
+var LogType;
+(function (LogType) {
+    LogType[LogType["Info"] = 0] = "Info";
+    LogType[LogType["Success"] = 1] = "Success";
+    LogType[LogType["Error"] = 2] = "Error";
+    LogType[LogType["Warn"] = 3] = "Warn";
+})(LogType || (LogType = {}));
+const COLOR_MAP = {
+    [LogType.Error]: "#c8646c",
+    [LogType.Info]: "#85a6c7",
+    [LogType.Success]: "#a9c490",
+    [LogType.Warn]: "#d19a66",
+};
+const diagnoseError = (error) => {
+    if (!error.response) {
+        if (ApiUtils.isNetworkError(error)) {
+            return { message: "network issue", error };
+        }
+        if (ApiUtils.isCancelledError(error)) {
+            return { message: "cancelled", error };
+        }
+        return { message: "client-side error", error };
+    }
+    const { status, data } = error.response;
+    const code = data === null || data === void 0 ? void 0 : data.code;
+    return {
+        message: `responded with ${status}${code ? ` (${code})` : ""}`,
+        response: error.response,
+    };
+};
+const formatTime = (time) => {
+    return `${Utils.padNumber(time.getHours(), 2)}:${Utils.padNumber(time.getMinutes(), 2)}:${Utils.padNumber(time.getSeconds(), 2)}.${Utils.padNumber(time.getMilliseconds(), 3)}`;
+};
+const log = (context, type, message, config, objects) => {
+    if (typeof config.predicate === "function" && !config.predicate()) {
+        return;
+    }
+    const color = COLOR_MAP[type];
+    const timestamp = formatTime(new Date());
+    const args = [`%cnetwork %c[${context.api.name}] ${context.method.toUpperCase()} ${context.path} %c${message} %c@ ${timestamp}`, "color:gray", "color:auto", `color:${color}`, "color:gray"];
+    /* eslint-disable-next-line no-console */
+    console.groupCollapsed(...args);
+    /* eslint-disable-next-line no-console */
+    console.log(Utils.assign({ context: context }, objects || {}));
+    /* eslint-disable-next-line no-console */
+    console.groupEnd();
+};
+const LoggingMiddleware = (config = {}) => {
+    return {
+        [RequestEvent.BeforeSend]: (context) => {
+            log(context, LogType.Info, context.stats.attempt > 1 ? "retrying" : "sending", config);
+        },
+        [RequestEvent.Success]: (context) => {
+            var _a;
+            const cacheSource = context.cacheInfo.source;
+            log(context, LogType.Success, `responded with ${(_a = context.response) === null || _a === void 0 ? void 0 : _a.status}${cacheSource ? ` (cached by ${cacheSource})` : ""}`, config);
+        },
+        [RequestEvent.Error]: (context) => {
+            if (context.error) {
+                const { error, message } = diagnoseError(context.error);
+                log(context, LogType.Warn, `error on attempt ${context.stats.attempt} - ${message}`, config, { error: error });
+            }
+        },
+        [RequestEvent.UnrecoverableError]: (context) => {
+            if (context.error) {
+                const { error, message } = diagnoseError(context.error);
+                log(context, LogType.Error, `failed - ${message}`, config, {
+                    error: error,
+                });
+            }
+        },
+    };
+};
+export default LoggingMiddleware;

package/esm/util/retry/index.d.ts

@@ -1,3 +1,3 @@
-import { RetryFunction, RetryOptions } from "./interfaces";
-declare const retry: <A>(fn: RetryFunction<A>, opts: RetryOptions) => Promise<A>;
-export default retry;
+import { RetryFunction, RetryOptions } from "./interfaces";
+declare const retry: <A>(fn: RetryFunction<A>, opts: RetryOptions) => Promise<A>;
+export default retry;

package/esm/util/retry/index.js

@@ -1,50 +1,50 @@
-import * as retrier from "./lib/retry";
-// Retry is just transplanted from here:
-// https://www.npmjs.com/package/retry (lib), and
-// https://www.npmjs.com/package/async-retry (RetryFunction)
-// ---
-const retry = (fn, opts) => {
-    return new Promise((resolve, reject) => {
-        const options = opts || {};
-        if (!("randomize" in options)) {
-            options.randomize = true;
-        }
-        const op = retrier.operation(options);
-        // We allow the user to abort retrying
-        // this makes sense in the cases where
-        // knowledge is obtained that retrying
-        // would be futile (e.g.: auth errors)
-        const bail = (err) => {
-            reject(err || new Error("Aborted"));
-        };
-        const onError = (err, num) => {
-            if (err.bail) {
-                bail(err);
-                return;
-            }
-            if (!op.retry(err)) {
-                reject(op.mainError());
-            }
-            else if (options.onRetry) {
-                options.onRetry(err, num);
-            }
-        };
-        const runAttempt = (num) => {
-            let val;
-            try {
-                val = fn(bail, num);
-            }
-            catch (err) {
-                onError(err, num);
-                return;
-            }
-            Promise.resolve(val)
-                .then(resolve)
-                .catch(function catchIt(err) {
-                onError(err, num);
-            });
-        };
-        op.attempt(runAttempt);
-    });
-};
-export default retry;
+import * as retrier from "./lib/retry";
+// Retry is just transplanted from here:
+// https://www.npmjs.com/package/retry (lib), and
+// https://www.npmjs.com/package/async-retry (RetryFunction)
+// ---
+const retry = (fn, opts) => {
+    return new Promise((resolve, reject) => {
+        const options = opts || {};
+        if (!("randomize" in options)) {
+            options.randomize = true;
+        }
+        const op = retrier.operation(options);
+        // We allow the user to abort retrying
+        // this makes sense in the cases where
+        // knowledge is obtained that retrying
+        // would be futile (e.g.: auth errors)
+        const bail = (err) => {
+            reject(err || new Error("Aborted"));
+        };
+        const onError = (err, num) => {
+            if (err.bail) {
+                bail(err);
+                return;
+            }
+            if (!op.retry(err)) {
+                reject(op.mainError());
+            }
+            else if (options.onRetry) {
+                options.onRetry(err, num);
+            }
+        };
+        const runAttempt = (num) => {
+            let val;
+            try {
+                val = fn(bail, num);
+            }
+            catch (err) {
+                onError(err, num);
+                return;
+            }
+            Promise.resolve(val)
+                .then(resolve)
+                .catch(function catchIt(err) {
+                onError(err, num);
+            });
+        };
+        op.attempt(runAttempt);
+    });
+};
+export default retry;

package/esm/util/retry/lib/retry.d.ts

@@ -1,3 +1,3 @@
-import { RetryOptions } from "../interfaces";
-import RetryOperation from "./retryOperation";
-export declare const operation: (options: RetryOptions) => RetryOperation;
+import { RetryOptions } from "../interfaces";
+import RetryOperation from "./retryOperation";
+export declare const operation: (options: RetryOptions) => RetryOperation;

package/esm/util/retry/lib/retry.js

@@ -1,39 +1,35 @@
-import RetryOperation from "./retryOperation";
-export const operation = (options) => {
-    const timeouts = _timeouts(options);
-    return (new RetryOperation(timeouts, {
-        forever: options && (options.forever || options.retries === Infinity),
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime,
-    }));
-};
-const _timeouts = (options) => {
-    var _a;
-    const createTimeout = (attempt, opts) => {
-        const random = (opts.randomize)
-            ? (Math.random() + 1)
-            : 1;
-        let timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
-        timeout = Math.min(timeout, opts.maxTimeout);
-        return (timeout);
-    };
-    const defaultRetries = 10;
-    const opts = Object.assign({ retries: defaultRetries, factor: 2, minTimeout: 1 * 1000, maxTimeout: Infinity, randomize: false }, options);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    if (opts.minTimeout > opts.maxTimeout) {
-        throw new Error("minTimeout is greater than maxTimeout");
-    }
-    const timeouts = [];
-    const numRetries = (_a = opts.retries) !== null && _a !== void 0 ? _a : defaultRetries;
-    for (let i = 0; i < numRetries; i++) {
-        timeouts.push(createTimeout(i, opts));
-    }
-    if (options && options.forever && !timeouts.length) {
-        timeouts.push(createTimeout(numRetries, opts));
-    }
-    // sort the array numerically ascending
-    timeouts.sort(function (a, b) {
-        return a - b;
-    });
-    return (timeouts);
-};
+import RetryOperation from "./retryOperation";
+export const operation = (options) => {
+    const timeouts = _timeouts(options);
+    return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options === null || options === void 0 ? void 0 : options.unref,
+        maxRetryTime: options === null || options === void 0 ? void 0 : options.maxRetryTime,
+    });
+};
+const _timeouts = (options) => {
+    var _a;
+    const createTimeout = (attempt, opts) => {
+        const random = opts.randomize ? Math.random() + 1 : 1;
+        let timeout = Math.round(random * Math.max(opts.minTimeout, 1) * opts.factor ** attempt);
+        timeout = Math.min(timeout, opts.maxTimeout);
+        return timeout;
+    };
+    const defaultRetries = 10;
+    const opts = Object.assign({ retries: defaultRetries, factor: 2, minTimeout: 1 * 1000, maxTimeout: Infinity, randomize: false }, options);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+    }
+    const timeouts = [];
+    const numRetries = (_a = opts.retries) !== null && _a !== void 0 ? _a : defaultRetries;
+    for (let i = 0; i < numRetries; i++) {
+        timeouts.push(createTimeout(i, opts));
+    }
+    if ((options === null || options === void 0 ? void 0 : options.forever) && !timeouts.length) {
+        timeouts.push(createTimeout(numRetries, opts));
+    }
+    // sort the array numerically ascending
+    timeouts.sort((a, b) => a - b);
+    return timeouts;
+};

package/esm/util/retry/lib/retryOperation.d.ts

@@ -1,27 +1,27 @@
-export default RetryOperation;
-declare function RetryOperation(timeouts: any, options: any): void;
-declare class RetryOperation {
-    constructor(timeouts: any, options: any);
-    _originalTimeouts: any;
-    _timeouts: any;
-    _options: any;
-    _maxRetryTime: any;
-    _fn: any;
-    _errors: any[];
-    _attempts: number;
-    _operationTimeout: any;
-    _operationTimeoutCb: any;
-    _timeout: NodeJS.Timeout | null;
-    _operationStart: number | null;
-    _timer: NodeJS.Timeout | null;
-    _cachedTimeouts: any;
-    reset(): void;
-    stop(): void;
-    retry(err: any): boolean;
-    attempt(fn: any, timeoutOps: any): void;
-    try(fn: any): void;
-    start: (fn: any) => void;
-    errors(): any[];
-    attempts(): number;
-    mainError(): any;
-}
+export default RetryOperation;
+declare function RetryOperation(timeouts: any, options: any): void;
+declare class RetryOperation {
+    constructor(timeouts: any, options: any);
+    _originalTimeouts: any;
+    _timeouts: any;
+    _options: any;
+    _maxRetryTime: any;
+    _fn: any;
+    _errors: any[];
+    _attempts: number;
+    _operationTimeout: any;
+    _operationTimeoutCb: any;
+    _timeout: NodeJS.Timeout | null;
+    _operationStart: number | null;
+    _timer: NodeJS.Timeout | null;
+    _cachedTimeouts: any;
+    reset(): void;
+    stop(): void;
+    retry(err: any): boolean;
+    attempt(fn: any, timeoutOps: any): void;
+    try(fn: any): void;
+    start: (fn: any) => void;
+    errors(): any[];
+    attempts(): number;
+    mainError(): any;
+}