api-def 0.4.1-alpha3 → 0.5.1

package/esm/backend/MockRequestBackend.js

@@ -0,0 +1,147 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import * as Utils from "../Utils";
+import { delayThenReturn, randInt } from "../Utils";
+import { convertToRequestError, RequestErrorCode } from "../RequestError";
+var MockRequestBackend = /** @class */ (function () {
+    function MockRequestBackend() {
+    }
+    MockRequestBackend.prototype.convertResponse = function (context, response, error) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, response];
+            });
+        });
+    };
+    MockRequestBackend.prototype.extractResponseFromError = function (error) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fetchError;
+            return __generator(this, function (_a) {
+                if ("response" in error) {
+                    fetchError = error;
+                    return [2 /*return*/, fetchError.response ? fetchError.response : null];
+                }
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    MockRequestBackend.prototype.runRequest = function (context) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var mockingFunc, req, res, delay, delayMs, min, max, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        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,
+                            });
+                        }
+                        req = {
+                            body: context.computedConfig.body,
+                            params: (_b = context.computedConfig.params) !== null && _b !== void 0 ? _b : {},
+                            query: context.computedConfig.query,
+                            headers: (_c = context.computedConfig.headers) !== null && _c !== void 0 ? _c : {},
+                        };
+                        res = {
+                            statusCode: -1,
+                            response: undefined,
+                            status: function (statusCode) {
+                                res.statusCode = statusCode;
+                                return res;
+                            },
+                            send: function (response) {
+                                res.response = response;
+                                return res;
+                            },
+                        };
+                        if (!((_d = context.mocking) === null || _d === void 0 ? void 0 : _d.delay)) return [3 /*break*/, 3];
+                        delay = context.mocking.delay;
+                        delayMs = void 0;
+                        if (typeof delay === "number") {
+                            delayMs = delay;
+                        }
+                        else {
+                            min = delay[0], max = delay[1];
+                            if (min > max) {
+                                throw convertToRequestError({
+                                    error: new Error("[api-def] Min delay cannot be greater than max delay"),
+                                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                                });
+                            }
+                            delayMs = randInt(min, max);
+                        }
+                        _e = delayThenReturn;
+                        return [4 /*yield*/, mockingFunc(req, res)];
+                    case 1: return [4 /*yield*/, _e.apply(void 0, [_f.sent(), delayMs])];
+                    case 2:
+                        _f.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, mockingFunc(req, res)];
+                    case 4:
+                        _f.sent();
+                        _f.label = 5;
+                    case 5:
+                        if (res.response === undefined) {
+                            throw convertToRequestError({
+                                error: new Error("[api-def] Mocked API did not respond"),
+                                code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                            });
+                        }
+                        return [2 /*return*/, {
+                                headers: {},
+                                data: res.response,
+                                status: res.statusCode,
+                            }];
+                }
+            });
+        });
+    };
+    MockRequestBackend.prototype.makeRequest = function (context) {
+        return {
+            canceler: Utils.noop,
+            promise: this.runRequest(context),
+        };
+    };
+    MockRequestBackend.prototype.getErrorInfo = function (error, response) {
+        return undefined;
+    };
+    return MockRequestBackend;
+}());
+export default MockRequestBackend;

package/esm/backend/RequestBackend.d.ts

@@ -4,8 +4,12 @@ export interface RequestOperation<R> {
     promise: Promise<R>;
     canceler: () => void;
 }
+export interface RequestBackendErrorInfo {
+    code: string;
+}
 export default interface RequestBackend<R = any> {
     makeRequest(context: RequestContext): RequestOperation<R>;
     convertResponse<T>(context: RequestContext, response: R, error?: boolean): Promise<ApiResponse<T>>;
     extractResponseFromError(error: Error): Promise<R | null | undefined>;
+    getErrorInfo(error: Error, response: ApiResponse | undefined | null): RequestBackendErrorInfo | undefined;
 }

package/esm/cache/LocalForageCacheBackend.js

@@ -1,4 +1,5 @@
 var LocalForageCacheBackend = /** @class */ (function () {
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     function LocalForageCacheBackend(localforage) {
         this.store = localforage.createInstance({
             name: "requestCache",

package/esm/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./Api";
 export * from "./ApiTypes";
 export * from "./ApiConstants";
-export { isRequestError } from "./ApiUtils";
+export { isRequestError } from "./RequestError";
 export { clearCache, setCacheBackend } from "./cache/Caching";
 export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
 export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";

package/esm/index.js

@@ -3,7 +3,7 @@
 export * from "./Api";
 export * from "./ApiTypes";
 export * from "./ApiConstants";
-export { isRequestError } from "./ApiUtils";
+export { isRequestError } from "./RequestError";
 export { clearCache, setCacheBackend } from "./cache/Caching";
 export { default as LocalStorageCacheBackend } from "./cache/LocalStorageCacheBackend";
 export { default as LocaleForageCacheBackend } from "./cache/LocalForageCacheBackend";

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +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)
+// ---
+var retry = function (fn, opts) {
+    return new Promise(function (resolve, reject) {
+        var options = opts || {};
+        if (!("randomize" in options)) {
+            options.randomize = true;
+        }
+        var 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)
+        var bail = function (err) {
+            reject(err || new Error("Aborted"));
+        };
+        var onError = function (err, num) {
+            if (err.bail) {
+                bail(err);
+                return;
+            }
+            if (!op.retry(err)) {
+                reject(op.mainError());
+            }
+            else if (options.onRetry) {
+                options.onRetry(err, num);
+            }
+        };
+        var runAttempt = function (num) {
+            var 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

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

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

@@ -0,0 +1,50 @@
+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);
+};
+import RetryOperation from "./retryOperation";
+export var operation = function (options) {
+    var timeouts = _timeouts(options);
+    return (new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime,
+    }));
+};
+var _timeouts = function (options) {
+    var _a;
+    var createTimeout = function (attempt, opts) {
+        var random = (opts.randomize)
+            ? (Math.random() + 1)
+            : 1;
+        var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+        timeout = Math.min(timeout, opts.maxTimeout);
+        return (timeout);
+    };
+    var defaultRetries = 10;
+    var opts = __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");
+    }
+    var timeouts = [];
+    var numRetries = (_a = opts.retries) !== null && _a !== void 0 ? _a : defaultRetries;
+    for (var 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);
+};

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,132 @@
+function RetryOperation(timeouts, options) {
+    // Compatibility for the old (timeouts, retryForever) signature
+    if (typeof options === "boolean") {
+        options = { forever: options };
+    }
+    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+    this._timeouts = timeouts;
+    this._options = options || {};
+    this._maxRetryTime = options && options.maxRetryTime || Infinity;
+    this._fn = null;
+    this._errors = [];
+    this._attempts = 1;
+    this._operationTimeout = null;
+    this._operationTimeoutCb = null;
+    this._timeout = null;
+    this._operationStart = null;
+    this._timer = null;
+    if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+    }
+}
+RetryOperation.prototype.reset = function () {
+    this._attempts = 1;
+    this._timeouts = this._originalTimeouts.slice(0);
+};
+RetryOperation.prototype.stop = function () {
+    if (this._timeout) {
+        clearTimeout(this._timeout);
+    }
+    if (this._timer) {
+        clearTimeout(this._timer);
+    }
+    this._timeouts = [];
+    this._cachedTimeouts = null;
+};
+RetryOperation.prototype.retry = function (err) {
+    if (this._timeout) {
+        clearTimeout(this._timeout);
+    }
+    if (!err) {
+        return false;
+    }
+    var currentTime = new Date().getTime();
+    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+    }
+    this._errors.push(err);
+    var timeout = this._timeouts.shift();
+    if (timeout === undefined) {
+        if (this._cachedTimeouts) {
+            // retry forever, only keep last error
+            this._errors.splice(0, this._errors.length - 1);
+            timeout = this._cachedTimeouts.slice(-1);
+        }
+        else {
+            return false;
+        }
+    }
+    var self = this;
+    this._timer = setTimeout(function () {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+            self._timeout = setTimeout(function () {
+                self._operationTimeoutCb(self._attempts);
+            }, self._operationTimeout);
+            if (self._options.unref) {
+                self._timeout.unref();
+            }
+        }
+        self._fn(self._attempts);
+    }, timeout);
+    if (this._options.unref) {
+        this._timer.unref();
+    }
+    return true;
+};
+RetryOperation.prototype.attempt = function (fn, timeoutOps) {
+    this._fn = fn;
+    if (timeoutOps) {
+        if (timeoutOps.timeout) {
+            this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+            this._operationTimeoutCb = timeoutOps.cb;
+        }
+    }
+    var self = this;
+    if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function () {
+            self._operationTimeoutCb();
+        }, self._operationTimeout);
+    }
+    this._operationStart = new Date().getTime();
+    this._fn(this._attempts);
+};
+RetryOperation.prototype.try = function (fn) {
+    // console.log("Using RetryOperation.try() is deprecated");
+    this.attempt(fn);
+};
+RetryOperation.prototype.start = function (fn) {
+    // console.log("Using RetryOperation.start() is deprecated");
+    this.attempt(fn);
+};
+RetryOperation.prototype.start = RetryOperation.prototype.try;
+RetryOperation.prototype.errors = function () {
+    return this._errors;
+};
+RetryOperation.prototype.attempts = function () {
+    return this._attempts;
+};
+RetryOperation.prototype.mainError = function () {
+    if (this._errors.length === 0) {
+        return null;
+    }
+    var counts = {};
+    var mainError = null;
+    var mainErrorCount = 0;
+    for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+            mainError = error;
+            mainErrorCount = count;
+        }
+    }
+    return mainError;
+};
+export default RetryOperation;

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "api-def",
-  "version": "0.4.1-alpha3",
+  "version": "0.5.1",
   "description": "Typed API definitions with middleware support",
   "main": "cjs/index.js",
   "types": "esm/index.d.ts",
   "module": "esm/index.js",
   "sideEffects": false,
   "scripts": {
-    "lint": "eslint --ext .tsx,.ts src",
-    "lint:fix": "eslint --fix --ext .tsx,.ts src",
-    "build": "npm run build:esm && npm run build:cjs",
-    "build:esm": "tsc --module es2015 --target es5 --outDir esm",
-    "build:cjs": "tsc --module commonjs --target es5 --outDir cjs",
-    "build:watch": "npm-run-all -p \"build:esm -- -w\" \"build:cjs -- -w\"",
+    "test": "npm run test:types && npm run test:lint && npm run test:unit",
+    "test:unit": "cross-env NODE_ENV=test jest",
+    "test:lint": "npm run lint:strict",
+    "test:types": "tsc --noEmit -p .",
+    "example:start": "cd example && npm run start",
+    "lint": "esw --ext .tsx,.ts src",
+    "lint:watch": "npm run lint -- --watch",
+    "lint:fix": "npm run lint -- --fix",
+    "lint:strict": "npm run lint -- --max-warnings 0",
+    "cleanup": "rimraf esm && rimraf cjs",
+    "build": "npm run cleanup && npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc --module es2015 --target es5 --outDir esm --preserveWatchOutput",
+    "build:cjs": "tsc --module commonjs --target es5 --outDir cjs --preserveWatchOutput",
+    "build:watch": "npm-run-all -p \"build:esm -- -w\" \"build:cjs -- -w\" \"lint:watch\"",
     "website:dev": "cd website && npm run start",
     "website:deploy": "cd website && npm run deploy"
   },
@@ -38,16 +46,18 @@
   ],
   "repository": "https://github.com/Censkh/api-def",
   "devDependencies": {
-    "@types/axios": "^0.14.0",
-    "@types/node": "^14.14.22",
-    "@typescript-eslint/eslint-plugin": "^4.14.1",
-    "@typescript-eslint/parser": "^4.14.1",
-    "eslint": "^7.18.0",
-    "npm-run-all": "^4.1.5",
-    "typescript": "^4.2.3"
-  },
-  "optionalDependencies": {
-    "axios": "^0.19.0"
-  },
-  "dependencies": {}
+    "@babel/preset-env": "7.14.8",
+    "@babel/preset-typescript": "7.14.5",
+    "@types/axios": "0.14.0",
+    "@types/jest": "26.0.24",
+    "@types/node": "16.4.6",
+    "@typescript-eslint/eslint-plugin": "4.28.5",
+    "@typescript-eslint/parser": "4.28.5",
+    "cross-env": "7.0.3",
+    "eslint": "7.31.0",
+    "eslint-watch": "7.0.0",
+    "jest": "27.0.6",
+    "npm-run-all": "4.1.5",
+    "typescript": "4.3.5"
+  }
 }

package/CHANGELOG.md

@@ -1,39 +0,0 @@
-# 0.4.1
-
-- add better error handling on parse
-
-# 0.4.0
-
-## Breaking Changes
-
-- Move config values from options object up one layer
-- In config `retries` -> `retry`
-- `defaults` -> `config`
-
-## Changes
-
-- Remove need for enum imports
-- Make `name` and `description` optional in endpoint definition 
-
-# 0.3.11
-
-## Changes
-
-- Make fetch backend default if fetch is present
-- Fix fetch backends text response type support
-
-# 0.3.0
-
-## Features
-
-- allow defaults to be a function on api
-- add content type header in fetch backend to match axios backend
-- remove `flatted`
-- polyfill object.assign for ie
-- change retry logic so that if a middleware event responds with Retry we always attempt a retry
-
-# 0.2.5
-
-## Changes
-
-- Remove `window` usages to allow node support

package/cjs/Mocking.d.ts

@@ -1,23 +0,0 @@
-import { ApiResponse, Body, ModulePossiblyDefault, Params, Query, RequestConfig } from "./ApiTypes";
-import Endpoint from "./Endpoint";
-export interface MockingConfig {
-    loader?: () => Promise<ModulePossiblyDefault<any>>;
-    predicate: () => boolean;
-}
-export interface EndpointMockingInfo<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> {
-    func?: MockingFunction<R, P, Q, B>;
-    bypass?: 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;
-}
-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 MockingFunction<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>) => void;
-export declare const mockRequest: <R = any, P extends string | undefined = string | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined>(endpoint: Endpoint<R, P, Q, B>, config: RequestConfig<P, Q, B>) => Promise<ApiResponse<R>>;