@midwayjs/core 4.0.0-alpha.1 → 4.0.0-beta.10

package/README.md

@@ -9,4 +9,4 @@ Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 
-[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))
+[MIT](https://github.com/midwayjs/midway/blob/master/LICENSE)

package/dist/baseFramework.d.ts

@@ -14,10 +14,8 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     app: APP;
     configurationOptions: OPT;
     protected logger: ILogger;
-    protected appLogger: ILogger;
+    protected frameworkLoggerName: string;
     protected defaultContext: {};
-    protected contextLoggerApplyLogger: string;
-    protected contextLoggerFormat: any;
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected guardManager: GuardManager<CTX>;
@@ -25,14 +23,14 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected bootstrapOptions: IMidwayBootstrapOptions;
     protected asyncContextManager: AsyncContextManager;
     private namespace;
-    loggerService: MidwayLoggerService;
-    environmentService: MidwayEnvironmentService;
-    configService: MidwayConfigService;
-    informationService: MidwayInformationService;
-    middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
-    mockService: MidwayMockService;
+    protected loggerService: MidwayLoggerService;
+    protected environmentService: MidwayEnvironmentService;
+    protected configService: MidwayConfigService;
+    protected informationService: MidwayInformationService;
+    protected middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
+    protected mockService: MidwayMockService;
     constructor(applicationContext: IMidwayGlobalContainer);
-    init(): Promise<this>;
+    protected init(): Promise<this>;
     abstract configure(options?: OPT): OPT;
     abstract applicationInitialize(options: IMidwayBootstrapOptions): void | Promise<void>;
     abstract run(): Promise<void>;
@@ -64,5 +62,10 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected createGuardManager(): GuardManager<CTX>;
     setNamespace(namespace: string): void;
     getNamespace(): string;
+    /**
+     * Set the default framework logger name
+     * @since 4.0.0
+     */
+    setFrameworkLoggerName(loggerName: string): void;
 }
 //# sourceMappingURL=baseFramework.d.ts.map

package/dist/baseFramework.js

@@ -27,21 +27,31 @@ const asyncContextManager_1 = require("./common/asyncContextManager");
 const guardManager_1 = require("./common/guardManager");
 const debug = util.debuglog('midway:debug');
 class BaseFramework {
+    applicationContext;
+    app;
+    configurationOptions;
+    logger;
+    frameworkLoggerName = 'appLogger';
+    defaultContext = {};
+    middlewareManager = this.createMiddlewareManager();
+    filterManager = this.createFilterManager();
+    guardManager = this.createGuardManager();
+    composeMiddleware = null;
+    bootstrapOptions;
+    asyncContextManager;
+    namespace;
+    loggerService;
+    environmentService;
+    configService;
+    informationService;
+    middlewareService;
+    mockService;
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
-        this.defaultContext = {};
-        this.middlewareManager = this.createMiddlewareManager();
-        this.filterManager = this.createFilterManager();
-        this.guardManager = this.createGuardManager();
-        this.composeMiddleware = null;
     }
     async init() {
         this.configurationOptions = this.configure() ?? {};
-        this.contextLoggerApplyLogger =
-            this.configurationOptions.contextLoggerApplyLogger ?? 'appLogger';
-        this.contextLoggerFormat = this.configurationOptions.contextLoggerFormat;
         this.logger = this.loggerService.getLogger('coreLogger');
-        this.appLogger = this.loggerService.getLogger('appLogger');
         return this;
     }
     isEnable() {
@@ -74,7 +84,7 @@ class BaseFramework {
         return this.app;
     }
     createContextLogger(ctx, name) {
-        if (name && name !== 'appLogger') {
+        if (name && name !== this.frameworkLoggerName) {
             const appLogger = this.getLogger(name);
             let ctxLoggerCache = ctx.getAttr(constants_1.REQUEST_CTX_LOGGER_CACHE_KEY);
             if (!ctxLoggerCache) {
@@ -91,14 +101,12 @@ class BaseFramework {
             return ctxLogger;
         }
         else {
-            const appLogger = this.getLogger(name ?? this.contextLoggerApplyLogger);
             // avoid maximum call stack size exceeded
             if (ctx['_logger']) {
                 return ctx['_logger'];
             }
-            ctx['_logger'] = this.loggerService.createContextLogger(ctx, appLogger, {
-                contextFormat: this.contextLoggerFormat,
-            });
+            const appLogger = this.getLogger(name);
+            ctx['_logger'] = this.loggerService.createContextLogger(ctx, appLogger);
             return ctx['_logger'];
         }
     }
@@ -258,7 +266,7 @@ class BaseFramework {
         return this.composeMiddleware;
     }
     getLogger(name) {
-        return this.loggerService.getLogger(name) ?? this.appLogger;
+        return this.loggerService.getLogger(name ?? this.frameworkLoggerName);
     }
     getCoreLogger() {
         return this.logger;
@@ -302,6 +310,13 @@ class BaseFramework {
     getNamespace() {
         return this.namespace;
     }
+    /**
+     * Set the default framework logger name
+     * @since 4.0.0
+     */
+    setFrameworkLoggerName(loggerName) {
+        this.frameworkLoggerName = loggerName;
+    }
 }
 exports.BaseFramework = BaseFramework;
 __decorate([

package/dist/common/applicationManager.js

@@ -10,9 +10,7 @@ exports.MidwayApplicationManager = void 0;
 const interface_1 = require("../interface");
 const decorator_1 = require("../decorator");
 let MidwayApplicationManager = class MidwayApplicationManager {
-    constructor() {
-        this.globalFrameworkMap = new Map();
-    }
+    globalFrameworkMap = new Map();
     addFramework(frameworkNameOrNamespace, framework) {
         this.globalFrameworkMap.set(frameworkNameOrNamespace, framework);
     }
@@ -33,8 +31,12 @@ let MidwayApplicationManager = class MidwayApplicationManager {
     }
     getApplications(frameworkNameOrNamespace) {
         if (!frameworkNameOrNamespace) {
-            return Array.from(this.globalFrameworkMap.values()).map(framework => {
+            return Array.from(this.globalFrameworkMap.values())
+                .map(framework => {
                 return framework.getApplication();
+            })
+                .filter(app => {
+                return !!app;
             });
         }
         else {

package/dist/common/asyncContextManager.js

@@ -18,6 +18,7 @@ exports.AsyncLocalStorageContextManager = exports.NoopContextManager = exports.A
  */
 const async_hooks_1 = require("async_hooks");
 class AsyncBaseContext {
+    _currentContext;
     /**
      * Construct a new context which inherits values from an optional parent context.
      *
@@ -40,6 +41,27 @@ class AsyncBaseContext {
             return context;
         };
     }
+    /**
+     * Get a value from the context.
+     *
+     * @param key key which identifies a context value
+     */
+    getValue;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 /** The root context is used as the default parent context when there is no active context */
 exports.ASYNC_ROOT_CONTEXT = new AsyncBaseContext();
@@ -62,6 +84,7 @@ class NoopContextManager {
 }
 exports.NoopContextManager = NoopContextManager;
 class AsyncLocalStorageContextManager {
+    _asyncLocalStorage;
     constructor() {
         this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
     }

package/dist/common/dataListener.d.ts

@@ -1,10 +1,12 @@
-export declare abstract class DataListener<T> {
-    private innerData;
+export declare abstract class DataListener<T, U = T> {
+    protected innerData: T;
+    private isReady;
     protected init(): Promise<void>;
     abstract initData(): T | Promise<T>;
     abstract onData(callback: (data: T) => void): any;
     protected setData(data: T): void;
-    getData(): T;
+    getData(): U;
+    protected transformData(data: T): U;
     stop(): Promise<void>;
     protected destroyListener(): Promise<void>;
 }

package/dist/common/dataListener.js

@@ -12,15 +12,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataListener = void 0;
 const decorator_1 = require("../decorator");
 class DataListener {
+    innerData;
+    isReady = false;
     async init() {
-        this.innerData = await this.initData();
-        await this.onData(this.setData.bind(this));
+        if (!this.isReady) {
+            this.innerData = await this.initData();
+            await this.onData(this.setData.bind(this));
+            this.isReady = true;
+        }
     }
     setData(data) {
         this.innerData = data;
     }
     getData() {
-        return this.innerData;
+        return this.transformData(this.innerData);
+    }
+    transformData(data) {
+        return data;
     }
     async stop() {
         await this.destroyListener();

package/dist/common/dataSourceManager.d.ts

@@ -1,18 +1,20 @@
-import { ModuleLoadType, DataSourceManagerConfigOption } from '../interface';
+import { ModuleLoadType, DataSourceManagerConfigOption, IDataSourceManager, BaseDataSourceManagerConfigOption } from '../interface';
 import { MidwayEnvironmentService } from '../service/environmentService';
 import { MidwayPriorityManager } from './priorityManager';
-export declare abstract class DataSourceManager<T, ConnectionOpts extends Record<string, any> = Record<string, any>> {
+export declare abstract class DataSourceManager<T, ConnectionOpts extends BaseDataSourceManagerConfigOption<Record<string, any>, ENTITY_CONFIG_KEY> = BaseDataSourceManagerConfigOption<Record<string, any>, 'entities'>, ENTITY_CONFIG_KEY extends string = 'entities'> implements IDataSourceManager<T, ConnectionOpts> {
     protected dataSource: Map<string, T>;
-    protected options: DataSourceManagerConfigOption<ConnectionOpts>;
+    protected options: DataSourceManagerConfigOption<ConnectionOpts, ENTITY_CONFIG_KEY>;
     protected modelMapping: WeakMap<object, any>;
     private innerDefaultDataSourceName;
     protected dataSourcePriority: Record<string, string>;
-    protected appDir: string;
+    private creatingDataSources;
+    protected baseDir: string;
     protected environmentService: MidwayEnvironmentService;
     protected priorityManager: MidwayPriorityManager;
-    protected initDataSource(dataSourceConfig: DataSourceManagerConfigOption<ConnectionOpts>, baseDirOrOptions: {
-        baseDir: string;
+    protected initDataSource(dataSourceConfig: DataSourceManagerConfigOption<ConnectionOpts, ENTITY_CONFIG_KEY>, baseDirOrOptions: {
+        baseDir?: string;
         entitiesConfigKey?: string;
+        concurrent?: boolean;
     } | string): Promise<void>;
     /**
      * get a data source instance
@@ -31,8 +33,15 @@ export declare abstract class DataSourceManager<T, ConnectionOpts extends Record
      * @param dataSourceName
      */
     isConnected(dataSourceName: string): Promise<boolean>;
-    createInstance(config: any, clientName: any, options?: {
+    createInstance(config: ConnectionOpts): Promise<T | void>;
+    createInstance(config: ConnectionOpts, clientName: string, options?: {
+        /**
+         * @deprecated
+         */
         validateConnection?: boolean;
+        /**
+         * @deprecated
+         */
         cacheInstance?: boolean | undefined;
     }): Promise<T | void>;
     /**
@@ -53,7 +62,7 @@ export declare abstract class DataSourceManager<T, ConnectionOpts extends Record
     isHighPriority(name: string): boolean;
     isMediumPriority(name: string): boolean;
     isLowPriority(name: string): boolean;
+    static formatGlobString(globString: string): string[];
+    static globModels(globString: string, baseDir: string, loadMode?: ModuleLoadType): Promise<any[]>;
 }
-export declare function formatGlobString(globString: string): string[];
-export declare function globModels(globString: string, appDir: string, loadMode?: ModuleLoadType): Promise<any[]>;
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globModels = exports.formatGlobString = exports.DataSourceManager = void 0;
+exports.DataSourceManager = void 0;
 /**
  * 数据源管理器实现
  */
@@ -26,12 +26,16 @@ const environmentService_1 = require("../service/environmentService");
 const priorityManager_1 = require("./priorityManager");
 const debug = (0, util_1.debuglog)('midway:debug');
 class DataSourceManager {
-    constructor() {
-        this.dataSource = new Map();
-        this.options = {};
-        this.modelMapping = new WeakMap();
-        this.dataSourcePriority = {};
-    }
+    dataSource = new Map();
+    options = {};
+    modelMapping = new WeakMap();
+    innerDefaultDataSourceName;
+    dataSourcePriority = {};
+    // for multi client with initialization
+    creatingDataSources = new Map();
+    baseDir;
+    environmentService;
+    priorityManager;
     async initDataSource(dataSourceConfig, baseDirOrOptions) {
         this.options = dataSourceConfig;
         if (!this.options.dataSource) {
@@ -41,18 +45,18 @@ class DataSourceManager {
             baseDirOrOptions = {
                 baseDir: baseDirOrOptions,
                 entitiesConfigKey: 'entities',
+                concurrent: false,
             };
         }
-        for (const dataSourceName in dataSourceConfig.dataSource) {
-            const dataSourceOptions = dataSourceConfig.dataSource[dataSourceName];
-            const userEntities = dataSourceOptions[baseDirOrOptions.entitiesConfigKey];
+        const { baseDir = this.baseDir, entitiesConfigKey = 'entities', concurrent, } = baseDirOrOptions;
+        const processDataSource = async (dataSourceName, dataSourceOptions) => {
+            const userEntities = dataSourceOptions[entitiesConfigKey];
             if (userEntities) {
                 const entities = new Set();
-                // loop entities and glob files to model
-                for (const entity of userEntities) {
+                const processEntity = async (entity) => {
                     if (typeof entity === 'string') {
                         // string will be glob file
-                        const models = await globModels(entity, baseDirOrOptions.baseDir, this.environmentService?.getModuleLoadType());
+                        const models = await DataSourceManager.globModels(entity, baseDir, this.environmentService?.getModuleLoadType());
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
@@ -63,17 +67,33 @@ class DataSourceManager {
                         entities.add(entity);
                         this.modelMapping.set(entity, dataSourceName);
                     }
+                };
+                if (concurrent) {
+                    await Promise.all(userEntities.map(processEntity));
+                }
+                else {
+                    for (const entity of userEntities) {
+                        await processEntity(entity);
+                    }
                 }
-                dataSourceOptions[baseDirOrOptions.entitiesConfigKey] =
-                    Array.from(entities);
-                debug(`[core]: DataManager load ${dataSourceOptions[baseDirOrOptions.entitiesConfigKey].length} models from ${dataSourceName}.`);
+                dataSourceOptions[entitiesConfigKey] = Array.from(entities);
+                debug(`[core]: DataManager load ${dataSourceOptions[entitiesConfigKey].length} models from ${dataSourceName}.`);
             }
             // create data source
             const opts = {
-                cacheInstance: dataSourceConfig.cacheInstance, // will default true
+                cacheInstance: dataSourceConfig.cacheInstance,
                 validateConnection: dataSourceConfig.validateConnection,
             };
-            await this.createInstance(dataSourceOptions, dataSourceName, opts);
+            return this.createInstance(dataSourceOptions, dataSourceName, opts);
+        };
+        const entries = Object.entries(dataSourceConfig.dataSource);
+        if (concurrent) {
+            await Promise.all(entries.map(([name, options]) => processDataSource(name, options)));
+        }
+        else {
+            for (const [name, options] of entries) {
+                await processDataSource(name, options);
+            }
         }
     }
     /**
@@ -105,26 +125,59 @@ class DataSourceManager {
         return inst ? this.checkConnected(inst) : false;
     }
     async createInstance(config, clientName, options) {
-        const cache = options && typeof options.cacheInstance === 'boolean'
-            ? options.cacheInstance
-            : true;
-        const validateConnection = (options && options.validateConnection) || false;
-        // options.clients[id] will be merged with options.default
-        const configNow = (0, extend_1.extend)(true, {}, this.options['default'], config);
-        const client = await this.createDataSource(configNow, clientName);
-        if (cache && clientName && client) {
-            this.dataSource.set(clientName, client);
+        if (clientName && typeof clientName !== 'string') {
+            options = clientName;
+            clientName = undefined;
+        }
+        if (clientName && options && options.cacheInstance === false) {
+            // 后面就用传不传 clientName 来判断是否缓存
+            clientName = undefined;
         }
-        if (validateConnection) {
-            if (!client) {
-                throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} initialization failed.`);
+        if (clientName) {
+            if (this.dataSource.has(clientName)) {
+                return this.dataSource.get(clientName);
             }
-            const connected = await this.checkConnected(client);
-            if (!connected) {
-                throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} is not connected.`);
+            if (this.creatingDataSources.has(clientName)) {
+                return this.creatingDataSources.get(clientName);
+            }
+        }
+        const validateConnection = config.validateConnection ??
+            (options && options.validateConnection) ??
+            false;
+        // options.clients[id] will be merged with options.default
+        const configNow = (0, extend_1.extend)(true, {}, this.options['default'], config);
+        const clientCreatingPromise = this.createDataSource(configNow, clientName);
+        if (clientCreatingPromise && types_1.Types.isPromise(clientCreatingPromise)) {
+            if (clientName) {
+                this.creatingDataSources.set(clientName, clientCreatingPromise);
             }
+            return clientCreatingPromise
+                .then(async (client) => {
+                if (clientName) {
+                    this.dataSource.set(clientName, client);
+                }
+                if (validateConnection) {
+                    if (!client) {
+                        throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} initialization failed.`);
+                    }
+                    const connected = await this.checkConnected(client);
+                    if (!connected) {
+                        throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} is not connected.`);
+                    }
+                }
+                return client;
+            })
+                .finally(() => {
+                if (clientName) {
+                    this.creatingDataSources.delete(clientName);
+                }
+            });
+        }
+        // 处理同步返回的情况
+        if (clientName) {
+            this.dataSource.set(clientName, clientCreatingPromise);
         }
-        return client;
+        return clientCreatingPromise;
     }
     /**
      * get data source name by model or repository
@@ -171,12 +224,53 @@ class DataSourceManager {
     isLowPriority(name) {
         return this.priorityManager.isLowPriority(this.dataSourcePriority[name]);
     }
+    static formatGlobString(globString) {
+        let pattern;
+        if (!/^\*/.test(globString)) {
+            globString = '/' + globString;
+        }
+        const parsePattern = (0, path_1.parse)(globString);
+        if (parsePattern.base &&
+            (/\*/.test(parsePattern.base) || parsePattern.ext)) {
+            pattern = [globString];
+        }
+        else {
+            pattern = [...constants_1.DEFAULT_PATTERN.map(p => (0, path_1.join)(globString, p))];
+        }
+        return pattern;
+    }
+    static async globModels(globString, baseDir, loadMode) {
+        const pattern = this.formatGlobString(globString);
+        const models = [];
+        // string will be glob file
+        const files = (0, glob_1.run)(pattern, {
+            cwd: baseDir,
+            ignore: constants_1.IGNORE_PATTERN,
+        });
+        for (const file of files) {
+            const exports = await (0, util_2.loadModule)(file, {
+                loadMode,
+            });
+            if (types_1.Types.isClass(exports)) {
+                models.push(exports);
+            }
+            else {
+                for (const m in exports) {
+                    const module = exports[m];
+                    if (types_1.Types.isClass(module)) {
+                        models.push(module);
+                    }
+                }
+            }
+        }
+        return models;
+    }
 }
 exports.DataSourceManager = DataSourceManager;
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", String)
-], DataSourceManager.prototype, "appDir", void 0);
+], DataSourceManager.prototype, "baseDir", void 0);
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", environmentService_1.MidwayEnvironmentService)
@@ -185,46 +279,4 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", priorityManager_1.MidwayPriorityManager)
 ], DataSourceManager.prototype, "priorityManager", void 0);
-function formatGlobString(globString) {
-    let pattern;
-    if (!/^\*/.test(globString)) {
-        globString = '/' + globString;
-    }
-    const parsePattern = (0, path_1.parse)(globString);
-    if (parsePattern.base && (/\*/.test(parsePattern.base) || parsePattern.ext)) {
-        pattern = [globString];
-    }
-    else {
-        pattern = [...constants_1.DEFAULT_PATTERN.map(p => (0, path_1.join)(globString, p))];
-    }
-    return pattern;
-}
-exports.formatGlobString = formatGlobString;
-async function globModels(globString, appDir, loadMode) {
-    const pattern = formatGlobString(globString);
-    const models = [];
-    // string will be glob file
-    const files = (0, glob_1.run)(pattern, {
-        cwd: appDir,
-        ignore: constants_1.IGNORE_PATTERN,
-    });
-    for (const file of files) {
-        const exports = await (0, util_2.loadModule)(file, {
-            loadMode,
-        });
-        if (types_1.Types.isClass(exports)) {
-            models.push(exports);
-        }
-        else {
-            for (const m in exports) {
-                const module = exports[m];
-                if (types_1.Types.isClass(module)) {
-                    models.push(module);
-                }
-            }
-        }
-    }
-    return models;
-}
-exports.globModels = globModels;
 //# sourceMappingURL=dataSourceManager.js.map

package/dist/common/fileDetector.js

@@ -10,6 +10,7 @@ const decorator_1 = require("../decorator");
 const util_2 = require("util");
 const debug = (0, util_2.debuglog)('midway:debug');
 class AbstractFileDetector {
+    options;
     constructor(options) {
         this.options = options;
     }
@@ -32,10 +33,7 @@ const DEFAULT_IGNORE_PATTERN = [
  * CommonJS module loader
  */
 class CommonJSFileDetector extends AbstractFileDetector {
-    constructor() {
-        super(...arguments);
-        this.duplicateModuleCheckSet = new Map();
-    }
+    duplicateModuleCheckSet = new Map();
     async run(container, namespace) {
         if (this.getType() === 'commonjs') {
             return this.loadSync(container, namespace);

package/dist/common/filterManager.js

@@ -5,14 +5,12 @@ const decorator_1 = require("../decorator");
 const util_1 = require("../util");
 const metadataManager_1 = require("../decorator/metadataManager");
 class FilterManager {
-    constructor() {
-        this.errFilterList = [];
-        this.successFilterList = [];
-        this.exceptionMap = new WeakMap();
-        this.defaultErrFilter = undefined;
-        this.matchFnList = [];
-        this.protoMatchList = [];
-    }
+    errFilterList = [];
+    successFilterList = [];
+    exceptionMap = new WeakMap();
+    defaultErrFilter = undefined;
+    matchFnList = [];
+    protoMatchList = [];
     useFilter(Filters) {
         if (!Array.isArray(Filters)) {
             Filters = [Filters];

package/dist/common/loggerFactory.js

@@ -5,9 +5,7 @@ class LoggerFactory {
 }
 exports.LoggerFactory = LoggerFactory;
 class DefaultConsoleLoggerFactory {
-    constructor() {
-        this.instance = new Map();
-    }
+    instance = new Map();
     createLogger(name, options) {
         this.instance.set(name, console);
         return console;

package/dist/common/middlewareManager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMiddleware = exports.ContextMiddlewareManager = void 0;
+exports.ContextMiddlewareManager = void 0;
+exports.createMiddleware = createMiddleware;
 class ContextMiddlewareManager extends Array {
     /**
      * insert a middleware or middleware array to first
@@ -210,5 +211,4 @@ function createMiddleware(middleware, options, name) {
         name,
     };
 }
-exports.createMiddleware = createMiddleware;
 //# sourceMappingURL=middlewareManager.js.map

package/dist/common/performanceManager.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { PerformanceObserver, PerformanceObserverEntryList } from 'perf_hooks';
 export declare class MidwayPerformanceManager {
     private readonly group;