@midwayjs/core 3.4.0-beta.8 → 3.4.0-beta.9

package/dist/baseFramework.d.ts

@@ -20,6 +20,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected composeMiddleware: any;
+    protected bootstrapOptions: IMidwayBootstrapOptions;
     loggerService: MidwayLoggerService;
     environmentService: MidwayEnvironmentService;
     configService: MidwayConfigService;

package/dist/baseFramework.js

@@ -22,6 +22,7 @@ const middlewareService_1 = require("./service/middlewareService");
 const filterManager_1 = require("./common/filterManager");
 const mockService_1 = require("./service/mockService");
 const util = require("util");
+const asyncContextManager_1 = require("./common/asyncContextManager");
 const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
@@ -45,6 +46,7 @@ class BaseFramework {
         return true;
     }
     async initialize(options) {
+        this.bootstrapOptions = options;
         await this.beforeContainerInitialize(options);
         await this.containerInitialize(options);
         await this.afterContainerInitialize(options);
@@ -231,21 +233,34 @@ class BaseFramework {
      */
     async afterContainerReady(options) { }
     async applyMiddleware(lastMiddleware) {
+        var _a;
+        const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
+            false;
+        const contextManager = asyncContextManagerEnabled
+            ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.contextManager) || new asyncContextManager_1.NoopContextManager()
+            : new asyncContextManager_1.NoopContextManager();
+        if (asyncContextManagerEnabled) {
+            contextManager.enable();
+        }
         if (!this.composeMiddleware) {
             this.middlewareManager.insertFirst((async (ctx, next) => {
-                this.mockService.applyContextMocks(this.app, ctx);
-                let returnResult = undefined;
-                try {
-                    const result = await next();
-                    returnResult = await this.filterManager.runResultFilter(result, ctx);
-                }
-                catch (err) {
-                    returnResult = await this.filterManager.runErrorFilter(err, ctx);
-                }
-                if (returnResult.error) {
-                    throw returnResult.error;
-                }
-                return returnResult.result;
+                // warp with context manager
+                const rootContext = asyncContextManager_1.ASYNC_ROOT_CONTEXT.setValue(interface_1.ASYNC_CONTEXT_KEY, ctx);
+                return await contextManager.with(rootContext, async () => {
+                    this.mockService.applyContextMocks(this.app, ctx);
+                    let returnResult = undefined;
+                    try {
+                        const result = await next();
+                        returnResult = await this.filterManager.runResultFilter(result, ctx);
+                    }
+                    catch (err) {
+                        returnResult = await this.filterManager.runErrorFilter(err, ctx);
+                    }
+                    if (returnResult.error) {
+                        throw returnResult.error;
+                    }
+                    return returnResult.result;
+                });
             }));
             debug(`[core]: Compose middleware = [${this.middlewareManager.getNames()}]`);
             this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager, this.app);

package/dist/common/asyncContextManager.d.ts

@@ -0,0 +1,61 @@
+export interface AsyncContext {
+    /**
+     * Get a value from the context.
+     *
+     * @param key key which identifies a context value
+     */
+    getValue(key: symbol): unknown;
+    /**
+     * Create a new context which inherits from this context and has
+     * the given key set to the given value.
+     *
+     * @param key context key for which to set the value
+     * @param value value to set for the given key
+     */
+    setValue(key: symbol, value: unknown): AsyncContext;
+    /**
+     * Return a new context which inherits from this context but does
+     * not contain a value for the given key.
+     *
+     * @param key context key for which to clear a value
+     */
+    deleteValue(key: symbol): AsyncContext;
+}
+export interface AsyncContextManager {
+    /**
+     * Get the current active context
+     */
+    active(): AsyncContext;
+    /**
+     * Run the fn callback with object set as the current active context
+     * @param context Any object to set as the current active context
+     * @param fn A callback to be immediately run within a specific context
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    /**
+     * Bind an object as the current context (or a specific one)
+     * @param [context] Optionally specify the context which you want to assign
+     * @param target Any object to which a context need to be set
+     */
+    bind<T>(context: AsyncContext, target: T): T;
+    /**
+     * Enable context management
+     */
+    enable(): this;
+    /**
+     * Disable context management
+     */
+    disable(): this;
+}
+/** The root context is used as the default parent context when there is no active context */
+export declare const ASYNC_ROOT_CONTEXT: AsyncContext;
+export declare class NoopContextManager implements AsyncContextManager {
+    active(): AsyncContext;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(_context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    bind<T>(_context: AsyncContext, target: T): T;
+    enable(): this;
+    disable(): this;
+}
+//# sourceMappingURL=asyncContextManager.d.ts.map

package/dist/common/asyncContextManager.js

@@ -0,0 +1,63 @@
+"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.NoopContextManager = exports.ASYNC_ROOT_CONTEXT = void 0;
+class AsyncBaseContext {
+    /**
+     * Construct a new context which inherits values from an optional parent context.
+     *
+     * @param parentContext a context from which to inherit values
+     */
+    constructor(parentContext) {
+        // for minification
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : new Map();
+        self.getValue = (key) => self._currentContext.get(key);
+        self.setValue = (key, value) => {
+            const context = new AsyncBaseContext(self._currentContext);
+            context._currentContext.set(key, value);
+            return context;
+        };
+        self.deleteValue = (key) => {
+            const context = new AsyncBaseContext(self._currentContext);
+            context._currentContext.delete(key);
+            return context;
+        };
+    }
+}
+/** The root context is used as the default parent context when there is no active context */
+exports.ASYNC_ROOT_CONTEXT = new AsyncBaseContext();
+class NoopContextManager {
+    active() {
+        return exports.ASYNC_ROOT_CONTEXT;
+    }
+    with(_context, fn, thisArg, ...args) {
+        return fn.call(thisArg, ...args);
+    }
+    bind(_context, target) {
+        return target;
+    }
+    enable() {
+        return this;
+    }
+    disable() {
+        return this;
+    }
+}
+exports.NoopContextManager = NoopContextManager;
+//# sourceMappingURL=asyncContextManager.js.map

package/dist/config/config.default.d.ts

@@ -5,6 +5,9 @@ declare const _default: (appInfo: MidwayAppInfo) => {
     debug?: {
         recordConfigMergeOrder?: boolean;
     };
+    asyncContextManager: {
+        enable: boolean;
+    };
 };
 export default _default;
 //# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -8,6 +8,9 @@ exports.default = (appInfo) => {
     const isDevelopment = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
     const logRoot = (_a = process.env[interface_1.MIDWAY_LOGGER_WRITEABLE_DIR]) !== null && _a !== void 0 ? _a : appInfo.root;
     return {
+        asyncContextManager: {
+            enable: false,
+        },
         midwayLogger: {
             default: {
                 dir: (0, path_1.join)(logRoot, 'logs', appInfo.name),

package/dist/index.d.ts

@@ -35,6 +35,7 @@ export * from './common/filterManager';
 export * from './common/applicationManager';
 export * from './setup';
 export * from './error';
+export { AsyncContextManager, ASYNC_ROOT_CONTEXT, AsyncContext, } from './common/asyncContextManager';
 /**
  * proxy
  */

package/dist/index.js

@@ -14,7 +14,7 @@ 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.MidwayFrameworkType = exports.DataSourceManager = exports.WebRouterCollector = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.createConfiguration = exports.extend = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.safeRequire = exports.safelyGet = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
+exports.MidwayFrameworkType = exports.ASYNC_ROOT_CONTEXT = exports.DataSourceManager = exports.WebRouterCollector = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.createConfiguration = exports.extend = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.safeRequire = exports.safelyGet = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
 __exportStar(require("./interface"), exports);
 __exportStar(require("./context/container"), exports);
 var requestContainer_1 = require("./context/requestContainer");
@@ -81,6 +81,8 @@ __exportStar(require("./common/filterManager"), exports);
 __exportStar(require("./common/applicationManager"), exports);
 __exportStar(require("./setup"), exports);
 __exportStar(require("./error"), exports);
+var asyncContextManager_1 = require("./common/asyncContextManager");
+Object.defineProperty(exports, "ASYNC_ROOT_CONTEXT", { enumerable: true, get: function () { return asyncContextManager_1.ASYNC_ROOT_CONTEXT; } });
 /**
  * proxy
  */

package/dist/interface.d.ts

@@ -4,6 +4,7 @@ import { ILogger, LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import { ContextMiddlewareManager } from './common/middlewareManager';
 import _default from './config/config.default';
+import { AsyncContextManager } from './common/asyncContextManager';
 export declare type PowerPartial<T> = {
     [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
 };
@@ -432,6 +433,7 @@ export interface IMidwayBootstrapOptions {
     globalConfig?: Array<{
         [environmentName: string]: Record<string, any>;
     }> | Record<string, any>;
+    asyncContextManager?: AsyncContextManager;
 }
 export interface IConfigurationOptions {
     logger?: ILogger;
@@ -479,5 +481,6 @@ export interface MidwayAppInfo {
 export interface MidwayConfig extends FileConfigOption<typeof _default> {
     [customConfigKey: string]: unknown;
 }
+export declare const ASYNC_CONTEXT_KEY: unique symbol;
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.MidwayProcessTypeEnum = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.ObjectLifeCycleEvent = void 0;
+exports.ASYNC_CONTEXT_KEY = exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.MidwayProcessTypeEnum = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.ObjectLifeCycleEvent = void 0;
 var ObjectLifeCycleEvent;
 (function (ObjectLifeCycleEvent) {
     ObjectLifeCycleEvent["BEFORE_BIND"] = "beforeBind";
@@ -19,4 +19,5 @@ var MidwayProcessTypeEnum;
     MidwayProcessTypeEnum["AGENT"] = "AGENT";
 })(MidwayProcessTypeEnum = exports.MidwayProcessTypeEnum || (exports.MidwayProcessTypeEnum = {}));
 exports.MIDWAY_LOGGER_WRITEABLE_DIR = 'MIDWAY_LOGGER_WRITEABLE_DIR';
+exports.ASYNC_CONTEXT_KEY = Symbol('ASYNC_CONTEXT_KEY');
 //# sourceMappingURL=interface.js.map

package/dist/service/middlewareService.js

@@ -32,6 +32,10 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                 const classMiddleware = await this.applicationContext.getAsync(fn);
                 if (classMiddleware) {
                     fn = await classMiddleware.resolve(app);
+                    if (!fn) {
+                        // for middleware enabled
+                        continue;
+                    }
                     if (!classMiddleware.match && !classMiddleware.ignore) {
                         if (!fn.name) {
                             fn._name = classMiddleware.constructor.name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.4.0-beta.8",
+  "version": "3.4.0-beta.9",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,7 +21,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.4.0-beta.8",
+    "@midwayjs/decorator": "^3.4.0-beta.9",
     "koa": "2.13.4",
     "midway-test-component": "*",
     "mm": "3.2.0",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "9e4ed69eca31022e4dc93ed52ac503fe25ae383e"
+  "gitHead": "41e82a0fba386c6ec42c2eefd1dff4795a81b389"
 }