wrapper-fns 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Uladzimir Kasacheuski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/contract/index.d.ts

@@ -0,0 +1,3 @@
+export { withBottleneck } from '../logic/withBottleneck';
+export { withRetry } from '../logic/withRetry';
+export { withTimeout } from '../logic/withTimeout';

package/dist/contract/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = exports.withRetry = exports.withBottleneck = void 0;
+var withBottleneck_1 = require("../logic/withBottleneck");
+Object.defineProperty(exports, "withBottleneck", { enumerable: true, get: function () { return withBottleneck_1.withBottleneck; } });
+var withRetry_1 = require("../logic/withRetry");
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return withRetry_1.withRetry; } });
+var withTimeout_1 = require("../logic/withTimeout");
+Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return withTimeout_1.withTimeout; } });
+//# sourceMappingURL=index.js.map

package/dist/contract/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contract/index.ts"],"names":[],"mappings":";;;AAAA,0DAAyD;AAAhD,gHAAA,cAAc,OAAA;AACvB,gDAA+C;AAAtC,sGAAA,SAAS,OAAA;AAClB,oDAAmD;AAA1C,0GAAA,WAAW,OAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/logic/withBottleneck.d.ts

@@ -0,0 +1,4 @@
+import Bottleneck from 'bottleneck';
+export declare const withBottleneck: <I extends any[], O extends Promise<any>, T extends (...args: I) => O>(logic: T, options?: {
+    bottleneck: Bottleneck;
+}) => T;

package/dist/logic/withBottleneck.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withBottleneck = void 0;
+const bottleneck_1 = __importDefault(require("bottleneck"));
+const machineWideDefaultBottleneck = new bottleneck_1.default({ maxConcurrent: 1 });
+const withBottleneck = (logic, options = { bottleneck: machineWideDefaultBottleneck }) => {
+    const wrapped = (...args) => options.bottleneck.schedule(() => logic(...args));
+    return wrapped;
+};
+exports.withBottleneck = withBottleneck;
+//# sourceMappingURL=withBottleneck.js.map

package/dist/logic/withBottleneck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withBottleneck.js","sourceRoot":"","sources":["../../src/logic/withBottleneck.ts"],"names":[],"mappings":";;;;;;AAAA,4DAAoC;AAEpC,MAAM,4BAA4B,GAAG,IAAI,oBAAU,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;AAEnE,MAAM,cAAc,GAAG,CAK5B,KAAQ,EACR,UAEI,EAAE,UAAU,EAAE,4BAA4B,EAAE,EAC7C,EAAE;IACL,MAAM,OAAO,GAAG,CAAC,GAAG,IAAO,EAAE,EAAE,CAC7B,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAI,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACvD,OAAO,OAAY,CAAC;AACtB,CAAC,CAAC;AAbW,QAAA,cAAc,kBAazB"}

package/dist/logic/withRetry.d.ts

@@ -0,0 +1,4 @@
+import { Procedure, VisualogicContext } from 'visualogic';
+export declare function withRetry<TInput, TContext extends VisualogicContext, TOutput>(logic: () => TOutput): typeof logic;
+export declare function withRetry<TInput, TContext extends VisualogicContext, TOutput>(logic: (input: TInput) => TOutput): typeof logic;
+export declare function withRetry<TInput, TContext extends VisualogicContext, TOutput>(logic: Procedure<TInput, TContext, TOutput>): typeof logic;

package/dist/logic/withRetry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetry = void 0;
+/**
+ * function which calls the wrapped function and runs it again one time if an error is caught
+ */
+function withRetry(logic) {
+    return (async (input, context) => {
+        try {
+            return await logic(input, context);
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            context.log.warn('withRetry.progress: caught an error, will retry', {
+                error: {
+                    message: error.message,
+                    stack: error.stack,
+                },
+            });
+            return await logic(input, context);
+        }
+    });
+}
+exports.withRetry = withRetry;
+//# sourceMappingURL=withRetry.js.map

package/dist/logic/withRetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRetry.js","sourceRoot":"","sources":["../../src/logic/withRetry.ts"],"names":[],"mappings":";;;AAkBA;;GAEG;AACH,SAAgB,SAAS,CACvB,KAA2C;IAE3C,OAAO,CAAC,KAAK,EACX,KAAmC,EACnC,OAAuC,EACC,EAAE;QAC1C,IAAI,CAAC;YACH,OAAO,MAAM,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC;gBAAE,MAAM,KAAK,CAAC;YAC3C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,iDAAiD,EAAE;gBAClE,KAAK,EAAE;oBACL,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,KAAK,EAAE,KAAK,CAAC,KAAK;iBACnB;aACF,CAAC,CAAC;YACH,OAAO,MAAM,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACrC,CAAC;IACH,CAAC,CAAiB,CAAC;AACrB,CAAC;AApBD,8BAoBC"}

package/dist/logic/withTimeout.d.ts

@@ -0,0 +1,9 @@
+import { UniDuration } from '@ehmpathy/uni-time';
+import { Procedure } from 'visualogic';
+export declare function withTimeout<TInput, TContext, TOutput>(logic: () => TOutput, // empty inputs override
+options: {
+    threshold: UniDuration;
+}): typeof logic;
+export declare function withTimeout<TInput, TContext, TOutput>(logic: Procedure<TInput, TContext, TOutput>, options: {
+    threshold: UniDuration;
+}): typeof logic;

package/dist/logic/withTimeout.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = void 0;
+const uni_time_1 = require("@ehmpathy/uni-time");
+/**
+ * returns a new function which calls the input function and "races" the result against a promise that throws an error on timeout.
+ *
+ * the result is:
+ * - if your async fn takes longer than timeout ms, then an error will be thrown
+ * - if your async fn executes faster than timeout ms, you'll get the normal response of the fn
+ *
+ * ### usage
+ * ```ts
+ * const result = await withTimeout(() => doSomethingAsync(...args), 3000);
+ * ```
+ * or
+ * ```ts
+ * const result = await withTimeout(doSomethingAsync, 3000)(...args);
+ * ```
+ * or even
+ * ```ts
+ * const doSomethingAsyncWithTimeout = withTimeout(doSomethingAsync, 3000);
+ * const result = await doSomethingAsyncWithTimeout(...args);
+ * ```
+ */
+function withTimeout(logic, options) {
+    const thresholdMs = (0, uni_time_1.toMilliseconds)(options.threshold);
+    return (input, context) => {
+        // create a promise that rejects in <ms> milliseconds; https://italonascimento.github.io/applying-a-timeout-to-your-promises/
+        const timeout = new Promise((resolve, reject) => {
+            const id = setTimeout(() => {
+                clearTimeout(id);
+                reject(new Error(`promise was timed out in ${thresholdMs} ms, by withTimeout`));
+            }, thresholdMs); // tslint:disable-line align
+        });
+        // returns a "race" between our timeout and the function executed with the input params
+        return Promise.race([
+            logic(input, context), // the wrapped fn, executed w/ the input params
+            timeout, // the timeout
+        ]);
+    };
+}
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=withTimeout.js.map

package/dist/logic/withTimeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTimeout.js","sourceRoot":"","sources":["../../src/logic/withTimeout.ts"],"names":[],"mappings":";;;AAAA,iDAAiE;AAiBjE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,WAAW,CACzB,KAA2C,EAC3C,OAAmC;IAEnC,MAAM,WAAW,GAAG,IAAA,yBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACtD,OAAO,CACL,KAAmC,EACnC,OAAuC,EACR,EAAE;QACjC,6HAA6H;QAC7H,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,EAAE;gBACzB,YAAY,CAAC,EAAE,CAAC,CAAC;gBACjB,MAAM,CACJ,IAAI,KAAK,CACP,4BAA4B,WAAW,qBAAqB,CAC7D,CACF,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,4BAA4B;QAC/C,CAAC,CAAC,CAAC;QAEH,uFAAuF;QACvF,OAAO,OAAO,CAAC,IAAI,CAAC;YAClB,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,+CAA+C;YACtE,OAAO,EAAE,cAAc;SACxB,CAAkC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AA3BD,kCA2BC"}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "wrapper-fns",
+  "author": "ehmpathy",
+  "description": "Use wrappers for simpler, safer, and more readable code",
+  "version": "1.0.0",
+  "repository": "ehmpathy/wrapper-fns",
+  "homepage": "https://github.com/ehmpathy/wrapper-fns",
+  "keywords": [
+    "wrapper",
+    "retry",
+    "bottleneck",
+    "timeout"
+  ],
+  "bugs": "https://github.com/ehmpathy/wrapper-fns/issues",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "build:ts": "tsc -p ./tsconfig.build.json",
+    "commit:with-cli": "npx cz",
+    "fix:format:prettier": "prettier --write '**/*.ts' --config ./prettier.config.js",
+    "fix:format": "npm run fix:format:prettier",
+    "fix:lint": "eslint -c ./.eslintrc.js src/**/*.ts --fix",
+    "build:clean": "rm dist/ -rf",
+    "build:compile": "tsc -p ./tsconfig.build.json",
+    "build": "npm run build:clean && npm run build:compile",
+    "test:commits": "LAST_TAG=$(git describe --tags --abbrev=0 @^ 2> /dev/null || git rev-list --max-parents=0 HEAD) && npx commitlint --from $LAST_TAG --to HEAD --verbose",
+    "test:types": "tsc -p ./tsconfig.build.json --noEmit",
+    "test:format:prettier": "prettier --parser typescript --check 'src/**/*.ts' --config ./prettier.config.js",
+    "test:format": "npm run test:format:prettier",
+    "test:lint:deps": "npx depcheck -c ./depcheckrc.yml",
+    "test:lint:eslint": "eslint -c ./.eslintrc.js src/**/*.ts",
+    "test:lint": "npm run test:lint:eslint && npm run test:lint:deps",
+    "test:unit": "jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -z $THOROUGH ] && echo '--changedSince=main')",
+    "test:integration": "jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -z $THOROUGH ] && echo '--changedSince=main')",
+    "test:acceptance:locally": "npm run build && LOCALLY=true jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests",
+    "test": "npm run test:commits && npm run test:types && npm run test:format && npm run test:lint && npm run test:unit && npm run test:integration && npm run test:acceptance:locally",
+    "test:acceptance": "npm run build && jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests",
+    "prepush": "npm run test && npm run build",
+    "prepublish": "npm run build",
+    "preversion": "npm run prepush",
+    "postversion": "git push origin HEAD --tags --no-verify",
+    "postinstall": "[ -d .git ] && npm run prepare:husky || exit 0",
+    "prepare:husky": "npx husky install && chmod ug+x .husky/*"
+  },
+  "dependencies": {
+    "@ehmpathy/uni-time": "1.7.4",
+    "bottleneck": "2.19.5",
+    "visualogic": "1.3.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "19.3.0",
+    "@commitlint/config-conventional": "13.1.0",
+    "@trivago/prettier-plugin-sort-imports": "4.3.0",
+    "@tsconfig/node-lts-strictest": "18.12.1",
+    "@types/jest": "29.2.4",
+    "@typescript-eslint/eslint-plugin": "7.8.0",
+    "@typescript-eslint/parser": "7.8.0",
+    "core-js": "3.26.1",
+    "cz-conventional-changelog": "3.3.0",
+    "declapract": "0.12.0",
+    "declapract-typescript-ehmpathy": "0.39.5",
+    "depcheck": "1.4.3",
+    "eslint": "8.56.0",
+    "eslint-config-airbnb-typescript": "18.0.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "husky": "8.0.3",
+    "jest": "29.3.1",
+    "prettier": "2.8.1",
+    "ts-jest": "29.1.3",
+    "ts-node": "10.9.2",
+    "typescript": "5.4.5"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,58 @@
+# wrapper-fns
+
+![test](https://github.com/ehmpathy/wrapper-fns/workflows/test/badge.svg)
+![publish](https://github.com/ehmpathy/wrapper-fns/workflows/publish/badge.svg)
+
+Use wrappers for simpler, safer, and more readable code.
+
+Wrap your procedures with before and after effects to abstract away common lifecycle tasks. This library makes it simple to use wrappers and includes a standard set of primitive wrappers.
+
+
+# install
+
+```sh
+npm install wrapper-fns
+```
+
+# use
+
+### `withRetry`
+
+retries the wrapped logic execution in case of failure
+
+for example
+```ts
+const result = await withRetry(doSomethingFlakey)()
+```
+
+
+### `withBottleneck`
+
+executes the wrapped logic execution within a bottleneck
+
+for example
+```ts
+// use the global bottleneck by default
+const result = await withBottleneck(doSomethingRatelimited)()
+```
+or
+```ts
+// use a dedicated bottleneck instead
+const options = { bottleneck: new Bottleneck({ maxConcurrent: 3 }) }
+const result = await withBottleneck(doSomethingRatelimited, options)()
+```
+
+### `withTimeout`
+
+throws a timeout error if the wrapped logic takes longer than the threshold
+
+- if your async fn takes longer than timeout ms, then an error will be thrown
+- if your async fn executes faster than timeout ms, you'll get the normal response of the fn
+
+
+for example
+or
+```ts
+const options = { threshold: { seconds: 3 } }
+const result = await withTimeout(doSomethingAsync, options)(...args);
+```