@midwayjs/async-hooks-context-manager 3.4.0-beta.8

package/README.md

@@ -0,0 +1,9 @@
+# midway-async-hooks-context-manager
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/asyncHooksContextManager.d.ts

@@ -0,0 +1,49 @@
+import { AsyncContext, AsyncContextManager } from '@midwayjs/core';
+export declare class AsyncHooksContextManager implements AsyncContextManager {
+    private _asyncHook;
+    private _contexts;
+    private _stack;
+    constructor();
+    active(): AsyncContext;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    enable(): this;
+    disable(): this;
+    /**
+     * Init hook will be called when userland create a async context, setting the
+     * context as the current one if it exist.
+     * @param uid id of the async context
+     * @param type the resource type
+     */
+    private _init;
+    /**
+     * Destroy hook will be called when a given context is no longer used so we can
+     * remove its attached context.
+     * @param uid uid of the async context
+     */
+    private _destroy;
+    /**
+     * Before hook is called just before executing a async context.
+     * @param uid uid of the async context
+     */
+    private _before;
+    /**
+     * After hook is called just after completing the execution of a async context.
+     */
+    private _after;
+    /**
+     * Set the given context as active
+     */
+    private _enterContext;
+    /**
+     * Remove the context at the root of the stack
+     */
+    private _exitContext;
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind<T>(context: AsyncContext, target: T): T;
+}
+//# sourceMappingURL=asyncHooksContextManager.d.ts.map

package/dist/asyncHooksContextManager.js

@@ -0,0 +1,140 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncHooksContextManager = void 0;
+const core_1 = require("@midwayjs/core");
+const asyncHooks = require("async_hooks");
+class AsyncHooksContextManager {
+    constructor() {
+        this._contexts = new Map();
+        this._stack = [];
+        this._asyncHook = asyncHooks.createHook({
+            init: this._init.bind(this),
+            before: this._before.bind(this),
+            after: this._after.bind(this),
+            destroy: this._destroy.bind(this),
+            promiseResolve: this._destroy.bind(this),
+        });
+    }
+    active() {
+        var _a;
+        return (_a = this._stack[this._stack.length - 1]) !== null && _a !== void 0 ? _a : core_1.ASYNC_ROOT_CONTEXT;
+    }
+    with(context, fn, thisArg, ...args) {
+        this._enterContext(context);
+        try {
+            return fn.call(thisArg, ...args);
+        }
+        finally {
+            this._exitContext();
+        }
+    }
+    enable() {
+        this._asyncHook.enable();
+        return this;
+    }
+    disable() {
+        this._asyncHook.disable();
+        this._contexts.clear();
+        this._stack = [];
+        return this;
+    }
+    /**
+     * Init hook will be called when userland create a async context, setting the
+     * context as the current one if it exist.
+     * @param uid id of the async context
+     * @param type the resource type
+     */
+    _init(uid, type) {
+        // ignore TIMERWRAP as they combine timers with same timeout which can lead to
+        // false context propagation. TIMERWRAP has been removed in node 11
+        // every timer has it's own `Timeout` resource anyway which is used to propagete
+        // context.
+        if (type === 'TIMERWRAP')
+            return;
+        const context = this._stack[this._stack.length - 1];
+        if (context !== undefined) {
+            this._contexts.set(uid, context);
+        }
+    }
+    /**
+     * Destroy hook will be called when a given context is no longer used so we can
+     * remove its attached context.
+     * @param uid uid of the async context
+     */
+    _destroy(uid) {
+        this._contexts.delete(uid);
+    }
+    /**
+     * Before hook is called just before executing a async context.
+     * @param uid uid of the async context
+     */
+    _before(uid) {
+        const context = this._contexts.get(uid);
+        if (context !== undefined) {
+            this._enterContext(context);
+        }
+    }
+    /**
+     * After hook is called just after completing the execution of a async context.
+     */
+    _after() {
+        this._exitContext();
+    }
+    /**
+     * Set the given context as active
+     */
+    _enterContext(context) {
+        this._stack.push(context);
+    }
+    /**
+     * Remove the context at the root of the stack
+     */
+    _exitContext() {
+        this._stack.pop();
+    }
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind(context, target) {
+        if (typeof target === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const manager = this;
+            const contextWrapper = function (...args) {
+                return manager.with(context, () => target.apply(this, args));
+            };
+            Object.defineProperty(contextWrapper, 'length', {
+                enumerable: false,
+                configurable: true,
+                writable: false,
+                value: target.length,
+            });
+            /**
+             * It isn't possible to tell Typescript that contextWrapper is the same as T
+             * so we forced to cast as any here.
+             */
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return contextWrapper;
+        }
+        return target;
+    }
+}
+exports.AsyncHooksContextManager = AsyncHooksContextManager;
+//# sourceMappingURL=asyncHooksContextManager.js.map

package/dist/asyncLocalStorageContextManager.d.ts

@@ -0,0 +1,17 @@
+import { AsyncContext, AsyncContextManager } from '@midwayjs/core';
+export declare class AsyncLocalStorageContextManager implements AsyncContextManager {
+    private _asyncLocalStorage;
+    constructor();
+    active(): AsyncContext;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    enable(): this;
+    disable(): this;
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind<T>(context: AsyncContext, target: T): T;
+}
+//# sourceMappingURL=asyncLocalStorageContextManager.d.ts.map

package/dist/asyncLocalStorageContextManager.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLocalStorageContextManager = void 0;
+const core_1 = require("@midwayjs/core");
+const async_hooks_1 = require("async_hooks");
+class AsyncLocalStorageContextManager {
+    constructor() {
+        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    active() {
+        var _a;
+        return (_a = this._asyncLocalStorage.getStore()) !== null && _a !== void 0 ? _a : core_1.ASYNC_ROOT_CONTEXT;
+    }
+    with(context, fn, thisArg, ...args) {
+        const cb = thisArg == null ? fn : fn.bind(thisArg);
+        return this._asyncLocalStorage.run(context, cb, ...args);
+    }
+    enable() {
+        return this;
+    }
+    disable() {
+        this._asyncLocalStorage.disable();
+        return this;
+    }
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind(context, target) {
+        if (typeof target === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const manager = this;
+            const contextWrapper = function (...args) {
+                return manager.with(context, () => target.apply(this, args));
+            };
+            Object.defineProperty(contextWrapper, 'length', {
+                enumerable: false,
+                configurable: true,
+                writable: false,
+                value: target.length,
+            });
+            /**
+             * It isn't possible to tell Typescript that contextWrapper is the same as T
+             * so we forced to cast as any here.
+             */
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return contextWrapper;
+        }
+        return target;
+    }
+}
+exports.AsyncLocalStorageContextManager = AsyncLocalStorageContextManager;
+//# sourceMappingURL=asyncLocalStorageContextManager.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './asyncHooksContextManager';
+export * from './asyncLocalStorageContextManager';
+export { isSemverGreaterThanOrEqualTo, createContextManager } from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextManager = exports.isSemverGreaterThanOrEqualTo = void 0;
+__exportStar(require("./asyncHooksContextManager"), exports);
+__exportStar(require("./asyncLocalStorageContextManager"), exports);
+var util_1 = require("./util");
+Object.defineProperty(exports, "isSemverGreaterThanOrEqualTo", { enumerable: true, get: function () { return util_1.isSemverGreaterThanOrEqualTo; } });
+Object.defineProperty(exports, "createContextManager", { enumerable: true, get: function () { return util_1.createContextManager; } });
+//# sourceMappingURL=index.js.map

package/dist/util.d.ts

@@ -0,0 +1,5 @@
+import { AsyncLocalStorageContextManager } from './asyncLocalStorageContextManager';
+import { AsyncHooksContextManager } from './asyncHooksContextManager';
+export declare function isSemverGreaterThanOrEqualTo(currentVersion: string, targetVersion: string): boolean;
+export declare function createContextManager(): AsyncHooksContextManager | AsyncLocalStorageContextManager;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextManager = exports.isSemverGreaterThanOrEqualTo = void 0;
+const asyncLocalStorageContextManager_1 = require("./asyncLocalStorageContextManager");
+const asyncHooksContextManager_1 = require("./asyncHooksContextManager");
+const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?)?)?$/i;
+// 判断 semver 大于等于 v14.8.0
+function isSemverGreaterThanOrEqualTo(currentVersion, targetVersion) {
+    const v = semver.exec(currentVersion);
+    const t = semver.exec(targetVersion);
+    if (v && t) {
+        if (v[1] === t[1] && v[2] === t[2] && v[3] === t[3] && v[4] === t[4]) {
+            return true;
+        }
+        return (gteString(v[1], t[1]) ||
+            (v[1] === t[1] && gteString(v[2], t[2])) ||
+            (v[1] === t[1] && v[2] === t[2] && gteString(v[3], t[3])) ||
+            (v[1] === t[1] && v[2] === t[2] && v[3] === t[3] && gteString(v[4], t[4])));
+    }
+    return false;
+}
+exports.isSemverGreaterThanOrEqualTo = isSemverGreaterThanOrEqualTo;
+function gteString(v1, v2) {
+    // compare string with parseInt
+    const v1Int = parseInt(v1, 10);
+    const v2Int = parseInt(v2, 10);
+    return v1Int > v2Int;
+}
+function createContextManager() {
+    const ContextManager = isSemverGreaterThanOrEqualTo(process.version, '14.8.0')
+        ? asyncLocalStorageContextManager_1.AsyncLocalStorageContextManager
+        : asyncHooksContextManager_1.AsyncHooksContextManager;
+    return new ContextManager();
+}
+exports.createContextManager = createContextManager;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@midwayjs/async-hooks-context-manager",
+  "version": "3.4.0-beta.8",
+  "description": "midway async hooks context manager",
+  "main": "dist/index",
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit"
+  },
+  "keywords": [
+    "midway",
+    "async",
+    "context manager"
+  ],
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@midwayjs/core": "^3.4.0-beta.8"
+  },
+  "author": "Harry Chen <czy88840616@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/midwayjs/midway.git"
+  },
+  "engines": {
+    "node": ">=12.17.0"
+  },
+  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
+}