@midwayjs/core 3.19.0-beta.2 → 4.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 - Now midwayjs
+
+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/baseFramework.d.ts

@@ -1,4 +1,4 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion, ILogger, MidwayLoggerOptions } from './interface';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion, ILogger, MidwayLoggerOptions, IMidwayGlobalContainer } from './interface';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
 import { MidwayInformationService } from './service/informationService';
@@ -10,7 +10,7 @@ import { MidwayMockService } from './service/mockService';
 import { AsyncContextManager } from './common/asyncContextManager';
 import { GuardManager } from './common/guardManager';
 export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next> {
-    readonly applicationContext: IMidwayContainer;
+    readonly applicationContext: IMidwayGlobalContainer;
     app: APP;
     configurationOptions: OPT;
     protected logger: ILogger;
@@ -31,51 +31,23 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     informationService: MidwayInformationService;
     middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
     mockService: MidwayMockService;
-    constructor(applicationContext: IMidwayContainer);
+    constructor(applicationContext: IMidwayGlobalContainer);
     init(): Promise<this>;
-    abstract configure(options?: OPT): any;
+    abstract configure(options?: OPT): OPT;
+    abstract applicationInitialize(options: IMidwayBootstrapOptions): void | Promise<void>;
+    abstract run(): Promise<void>;
     isEnable(): boolean;
     initialize(options?: IMidwayBootstrapOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected containerInitialize(options: IMidwayBootstrapOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected containerDirectoryLoad(options: IMidwayBootstrapOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected containerReady(options: IMidwayBootstrapOptions): Promise<void>;
-    getApplicationContext(): IMidwayContainer;
+    getApplicationContext(): IMidwayGlobalContainer;
     getConfiguration(key?: string): any;
     getCurrentEnvironment(): string;
     getApplication(): APP;
-    abstract applicationInitialize(options: IMidwayBootstrapOptions): any;
-    abstract run(): Promise<void>;
     protected createContextLogger(ctx: CTX, name?: string): ILogger;
     stop(): Promise<void>;
     getAppDir(): string;
     getBaseDir(): string;
     protected defineApplicationProperties(applicationProperties?: {}, whiteList?: string[]): void;
     protected beforeStop(): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected beforeContainerInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected afterContainerInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected afterContainerDirectoryLoad(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
     applyMiddleware<R, N>(lastMiddleware?: CommonMiddlewareUnion<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): any;
     getCoreLogger(): ILogger;

package/dist/baseFramework.js

@@ -36,10 +36,9 @@ class BaseFramework {
         this.composeMiddleware = null;
     }
     async init() {
-        var _a, _b;
-        this.configurationOptions = (_a = this.configure()) !== null && _a !== void 0 ? _a : {};
+        this.configurationOptions = this.configure() ?? {};
         this.contextLoggerApplyLogger =
-            (_b = this.configurationOptions.contextLoggerApplyLogger) !== null && _b !== void 0 ? _b : 'appLogger';
+            this.configurationOptions.contextLoggerApplyLogger ?? 'appLogger';
         this.contextLoggerFormat = this.configurationOptions.contextLoggerFormat;
         this.logger = this.loggerService.getLogger('coreLogger');
         this.appLogger = this.loggerService.getLogger('appLogger');
@@ -50,34 +49,17 @@ class BaseFramework {
     }
     async initialize(options) {
         this.bootstrapOptions = options;
-        await this.beforeContainerInitialize(options);
-        await this.containerInitialize(options);
-        await this.afterContainerInitialize(options);
-        await this.containerDirectoryLoad(options);
-        await this.afterContainerDirectoryLoad(options);
         /**
          * Third party application initialization
          */
         await this.applicationInitialize(options);
-        await this.containerReady(options);
-        await this.afterContainerReady(options);
-        await this.mockService.runSimulatorAppSetup(this.app);
-    }
-    /**
-     * @deprecated
-     */
-    async containerInitialize(options) { }
-    /**
-     * @deprecated
-     */
-    async containerDirectoryLoad(options) { }
-    /**
-     * @deprecated
-     */
-    async containerReady(options) {
+        /**
+         * define application properties if not exists
+         */
         if (!this.app.getApplicationContext) {
             this.defineApplicationProperties();
         }
+        await this.mockService.runSimulatorAppSetup(this.app);
     }
     getApplicationContext() {
         return this.applicationContext;
@@ -109,7 +91,7 @@ class BaseFramework {
             return ctxLogger;
         }
         else {
-            const appLogger = this.getLogger(name !== null && name !== void 0 ? name : this.contextLoggerApplyLogger);
+            const appLogger = this.getLogger(name ?? this.contextLoggerApplyLogger);
             // avoid maximum call stack size exceeded
             if (ctx['_logger']) {
                 return ctx['_logger'];
@@ -147,11 +129,6 @@ class BaseFramework {
             getConfig: (key) => {
                 return this.getConfiguration(key);
             },
-            getFrameworkType: () => {
-                if (this['getFrameworkType']) {
-                    return this['getFrameworkType']();
-                }
-            },
             getProcessType: () => {
                 return interface_1.MidwayProcessTypeEnum.APPLICATION;
             },
@@ -180,7 +157,6 @@ class BaseFramework {
                 }
                 if (!ctx.requestContext) {
                     ctx.requestContext = new requestContainer_1.MidwayRequestContainer(ctx, this.getApplicationContext());
-                    ctx.requestContext.ready();
                 }
                 if (!ctx.getLogger) {
                     ctx.getLogger = name => {
@@ -229,30 +205,13 @@ class BaseFramework {
         Object.assign(this.app, defaultApplicationProperties, applicationProperties);
     }
     async beforeStop() { }
-    /**
-     * @deprecated
-     */
-    async beforeContainerInitialize(options) { }
-    /**
-     * @deprecated
-     */
-    async afterContainerInitialize(options) { }
-    /**
-     * @deprecated
-     */
-    async afterContainerDirectoryLoad(options) { }
-    /**
-     * @deprecated
-     */
-    async afterContainerReady(options) { }
     async applyMiddleware(lastMiddleware) {
-        var _a;
         if (!this.composeMiddleware) {
             if (!this.applicationContext.hasObject(constants_1.ASYNC_CONTEXT_MANAGER_KEY)) {
                 const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
                     false;
                 const contextManager = asyncContextManagerEnabled
-                    ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.asyncContextManager) ||
+                    ? this.bootstrapOptions?.asyncContextManager ||
                         new asyncContextManager_1.NoopContextManager()
                     : new asyncContextManager_1.NoopContextManager();
                 if (asyncContextManagerEnabled) {
@@ -299,8 +258,7 @@ class BaseFramework {
         return this.composeMiddleware;
     }
     getLogger(name) {
-        var _a;
-        return (_a = this.loggerService.getLogger(name)) !== null && _a !== void 0 ? _a : this.appLogger;
+        return this.loggerService.getLogger(name) ?? this.appLogger;
     }
     getCoreLogger() {
         return this.logger;
@@ -345,6 +303,7 @@ class BaseFramework {
         return this.namespace;
     }
 }
+exports.BaseFramework = BaseFramework;
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", loggerService_1.MidwayLoggerService)
@@ -375,5 +334,4 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], BaseFramework.prototype, "init", null);
-exports.BaseFramework = BaseFramework;
 //# sourceMappingURL=baseFramework.js.map

package/dist/common/applicationManager.d.ts

@@ -1,10 +1,10 @@
-import { IMidwayApplication, IMidwayFramework, FrameworkType } from '../interface';
+import { IMidwayApplication, IMidwayFramework } from '../interface';
 export declare class MidwayApplicationManager {
     private globalFrameworkMap;
-    private globalFrameworkTypeMap;
-    addFramework(namespace: any, framework: IMidwayFramework<any, any, any>): void;
-    getFramework(namespaceOrFrameworkType: string | FrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
-    getApplication(namespaceOrFrameworkType: string | FrameworkType): IMidwayApplication;
-    getApplications(namespaces?: Array<string | FrameworkType>): IMidwayApplication[];
+    addFramework(frameworkNameOrNamespace: string, framework: IMidwayFramework<any, any, any>): void;
+    hasFramework(frameworkNameOrNamespace: string): boolean;
+    getFramework(frameworkNameOrNamespace: string): IMidwayFramework<any, any, any, unknown, unknown>;
+    getApplication(frameworkNameOrNamespace: string): IMidwayApplication;
+    getApplications(frameworkNameOrNamespace?: Array<string>): IMidwayApplication[];
 }
 //# sourceMappingURL=applicationManager.d.ts.map

package/dist/common/applicationManager.js

@@ -12,50 +12,33 @@ const decorator_1 = require("../decorator");
 let MidwayApplicationManager = class MidwayApplicationManager {
     constructor() {
         this.globalFrameworkMap = new Map();
-        this.globalFrameworkTypeMap = new WeakMap();
     }
-    addFramework(namespace, framework) {
-        this.globalFrameworkMap.set(namespace, framework);
-        if (framework['getFrameworkType']) {
-            this.globalFrameworkTypeMap.set(framework['getFrameworkType'](), framework);
-        }
+    addFramework(frameworkNameOrNamespace, framework) {
+        this.globalFrameworkMap.set(frameworkNameOrNamespace, framework);
     }
-    getFramework(namespaceOrFrameworkType) {
-        if (typeof namespaceOrFrameworkType === 'string') {
-            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkMap.get(namespaceOrFrameworkType);
-            }
-        }
-        else {
-            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkTypeMap.get(namespaceOrFrameworkType);
-            }
-        }
+    hasFramework(frameworkNameOrNamespace) {
+        return this.globalFrameworkMap.has(frameworkNameOrNamespace);
     }
-    getApplication(namespaceOrFrameworkType) {
-        if (typeof namespaceOrFrameworkType === 'string') {
-            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkMap
-                    .get(namespaceOrFrameworkType)
-                    .getApplication();
-            }
+    getFramework(frameworkNameOrNamespace) {
+        if (this.globalFrameworkMap.has(frameworkNameOrNamespace)) {
+            return this.globalFrameworkMap.get(frameworkNameOrNamespace);
         }
-        else {
-            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkTypeMap
-                    .get(namespaceOrFrameworkType)
-                    .getApplication();
-            }
+    }
+    getApplication(frameworkNameOrNamespace) {
+        if (this.globalFrameworkMap.has(frameworkNameOrNamespace)) {
+            return this.globalFrameworkMap
+                .get(frameworkNameOrNamespace)
+                .getApplication();
         }
     }
-    getApplications(namespaces) {
-        if (!namespaces) {
+    getApplications(frameworkNameOrNamespace) {
+        if (!frameworkNameOrNamespace) {
             return Array.from(this.globalFrameworkMap.values()).map(framework => {
                 return framework.getApplication();
             });
         }
         else {
-            return namespaces
+            return frameworkNameOrNamespace
                 .map(namespace => {
                 return this.getApplication(namespace);
             })
@@ -65,9 +48,9 @@ let MidwayApplicationManager = class MidwayApplicationManager {
         }
     }
 };
-MidwayApplicationManager = __decorate([
+exports.MidwayApplicationManager = MidwayApplicationManager;
+exports.MidwayApplicationManager = MidwayApplicationManager = __decorate([
     (0, decorator_1.Provide)(),
     (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
 ], MidwayApplicationManager);
-exports.MidwayApplicationManager = MidwayApplicationManager;
 //# sourceMappingURL=applicationManager.js.map

package/dist/common/asyncContextManager.d.ts

@@ -58,4 +58,19 @@ export declare class NoopContextManager implements AsyncContextManager {
     enable(): this;
     disable(): this;
 }
+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=asyncContextManager.d.ts.map

package/dist/common/asyncContextManager.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLocalStorageContextManager = exports.NoopContextManager = exports.ASYNC_ROOT_CONTEXT = void 0;
 /*
  * Copyright The OpenTelemetry Authors
  *
@@ -14,8 +16,7 @@
  * 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;
+const async_hooks_1 = require("async_hooks");
 class AsyncBaseContext {
     /**
      * Construct a new context which inherits values from an optional parent context.
@@ -60,4 +61,52 @@ class NoopContextManager {
     }
 }
 exports.NoopContextManager = NoopContextManager;
+class AsyncLocalStorageContextManager {
+    constructor() {
+        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    active() {
+        return this._asyncLocalStorage.getStore() ?? exports.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=asyncContextManager.js.map

package/dist/common/dataListener.js

@@ -27,6 +27,7 @@ class DataListener {
     }
     async destroyListener() { }
 }
+exports.DataListener = DataListener;
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
@@ -39,5 +40,4 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], DataListener.prototype, "stop", null);
-exports.DataListener = DataListener;
 //# sourceMappingURL=dataListener.js.map

package/dist/common/dataSourceManager.d.ts

@@ -44,6 +44,9 @@ export declare abstract class DataSourceManager<T, ConnectionOpts extends Record
     protected abstract createDataSource(config: any, dataSourceName: string): Promise<T | void> | (T | void);
     protected abstract checkConnected(dataSource: T): Promise<boolean>;
     protected abstract destroyDataSource(dataSource: T): Promise<void>;
+    /**
+     * Call destroyDataSource() on all data sources
+     */
     stop(): Promise<void>;
     getDefaultDataSourceName(): string;
     getDataSourcePriority(name: string): string;

package/dist/common/dataSourceManager.js

@@ -33,7 +33,6 @@ class DataSourceManager {
         this.dataSourcePriority = {};
     }
     async initDataSource(dataSourceConfig, baseDirOrOptions) {
-        var _a;
         this.options = dataSourceConfig;
         if (!this.options.dataSource) {
             throw new error_1.MidwayParameterError('[DataSourceManager] must set options.dataSource.');
@@ -53,7 +52,7 @@ class DataSourceManager {
                 for (const entity of userEntities) {
                     if (typeof entity === 'string') {
                         // string will be glob file
-                        const models = await globModels(entity, baseDirOrOptions.baseDir, (_a = this.environmentService) === null || _a === void 0 ? void 0 : _a.getModuleLoadType());
+                        const models = await globModels(entity, baseDirOrOptions.baseDir, this.environmentService?.getModuleLoadType());
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
@@ -71,7 +70,7 @@ class DataSourceManager {
             }
             // create data source
             const opts = {
-                cacheInstance: dataSourceConfig.cacheInstance,
+                cacheInstance: dataSourceConfig.cacheInstance, // will default true
                 validateConnection: dataSourceConfig.validateConnection,
             };
             await this.createInstance(dataSourceOptions, dataSourceName, opts);
@@ -134,6 +133,9 @@ class DataSourceManager {
     getDataSourceNameByModel(modelOrRepository) {
         return this.modelMapping.get(modelOrRepository);
     }
+    /**
+     * Call destroyDataSource() on all data sources
+     */
     async stop() {
         const arr = Array.from(this.dataSource.values());
         await Promise.all(arr.map(dbh => {
@@ -170,6 +172,7 @@ class DataSourceManager {
         return this.priorityManager.isLowPriority(this.dataSourcePriority[name]);
     }
 }
+exports.DataSourceManager = DataSourceManager;
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", String)
@@ -182,7 +185,6 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", priorityManager_1.MidwayPriorityManager)
 ], DataSourceManager.prototype, "priorityManager", void 0);
-exports.DataSourceManager = DataSourceManager;
 function formatGlobString(globString) {
     let pattern;
     if (!/^\*/.test(globString)) {

package/dist/common/fileDetector.d.ts

@@ -1,10 +1,9 @@
-import { IFileDetector, IMidwayContainer } from '../interface';
+import { IFileDetector, IMidwayGlobalContainer } from '../interface';
 export declare abstract class AbstractFileDetector<T> implements IFileDetector {
     options: T;
-    extraDetectorOptions: T;
     constructor(options?: T);
-    abstract run(container: IMidwayContainer): void | Promise<void>;
-    setExtraDetectorOptions(detectorOptions: T): void;
+    abstract run(container: IMidwayGlobalContainer, namespace: string): Promise<void>;
+    abstract runSync(container: IMidwayGlobalContainer, namespace: string): void;
 }
 /**
  * CommonJS module loader
@@ -13,14 +12,14 @@ export declare class CommonJSFileDetector extends AbstractFileDetector<{
     loadDir?: string | string[];
     pattern?: string | string[];
     ignore?: string | string[];
-    namespace?: string;
     conflictCheck?: boolean;
 }> {
     private duplicateModuleCheckSet;
-    run(container: any): void | Promise<void>;
-    loadSync(container: any): void;
-    loadAsync(container: any): Promise<void>;
+    run(container: IMidwayGlobalContainer, namespace: string): Promise<void>;
+    loadSync(container: IMidwayGlobalContainer, namespace: string): void;
+    loadAsync(container: IMidwayGlobalContainer, namespace: string): Promise<void>;
     getType(): 'commonjs' | 'module';
+    runSync(container: IMidwayGlobalContainer, namespace: string): void;
 }
 /**
  * ES module loader
@@ -32,6 +31,7 @@ export declare class CustomModuleDetector extends AbstractFileDetector<{
     modules?: any[];
     namespace?: string;
 }> {
-    run(container: any): Promise<void>;
+    run(container: IMidwayGlobalContainer): Promise<void>;
+    runSync(container: IMidwayGlobalContainer, namespace: string): void;
 }
 //# sourceMappingURL=fileDetector.d.ts.map

package/dist/common/fileDetector.js

@@ -5,15 +5,13 @@ const types_1 = require("../util/types");
 const glob_1 = require("@midwayjs/glob");
 const error_1 = require("../error");
 const constants_1 = require("../constants");
-const decorator_1 = require("../decorator");
 const util_1 = require("../util");
+const decorator_1 = require("../decorator");
+const util_2 = require("util");
+const debug = (0, util_2.debuglog)('midway:debug');
 class AbstractFileDetector {
     constructor(options) {
         this.options = options;
-        this.extraDetectorOptions = {};
-    }
-    setExtraDetectorOptions(detectorOptions) {
-        this.extraDetectorOptions = detectorOptions;
     }
 }
 exports.AbstractFileDetector = AbstractFileDetector;
@@ -38,29 +36,27 @@ class CommonJSFileDetector extends AbstractFileDetector {
         super(...arguments);
         this.duplicateModuleCheckSet = new Map();
     }
-    run(container) {
+    async run(container, namespace) {
         if (this.getType() === 'commonjs') {
-            return this.loadSync(container);
+            return this.loadSync(container, namespace);
         }
         else {
-            return this.loadAsync(container);
+            return this.loadAsync(container, namespace);
         }
     }
-    loadSync(container) {
-        var _a;
+    loadSync(container, namespace) {
         this.options = this.options || {};
-        const loadDirs = [].concat((_a = this.options.loadDir) !== null && _a !== void 0 ? _a : container.get('baseDir'));
+        const loadDirs = [].concat(this.options.loadDir ?? container.get('baseDir'));
         for (const dir of loadDirs) {
-            const fileResults = (0, glob_1.run)(DEFAULT_GLOB_PATTERN.concat(this.options.pattern || []).concat(this.extraDetectorOptions.pattern || []), {
+            const fileResults = (0, glob_1.run)(DEFAULT_GLOB_PATTERN.concat(this.options.pattern || []), {
                 cwd: dir,
-                ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []).concat(this.extraDetectorOptions.ignore || []),
+                ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []),
             });
+            debug(`[core]: load file from ${dir}, files: ${fileResults}`);
             // 检查重复模块
             const checkDuplicatedHandler = (module, options) => {
-                if ((this.options.conflictCheck ||
-                    this.extraDetectorOptions.conflictCheck) &&
-                    types_1.Types.isClass(module)) {
-                    const name = (0, decorator_1.getProviderName)(module);
+                if (this.options.conflictCheck && types_1.Types.isClass(module)) {
+                    const name = decorator_1.DecoratorManager.getProviderName(module);
                     if (name) {
                         if (this.duplicateModuleCheckSet.has(name)) {
                             throw new error_1.MidwayDuplicateClassNameError(name, options.srcPath, this.duplicateModuleCheckSet.get(name));
@@ -75,7 +71,7 @@ class CommonJSFileDetector extends AbstractFileDetector {
                 const exports = require(file);
                 // add module to set
                 container.bindClass(exports, {
-                    namespace: this.options.namespace,
+                    namespace,
                     srcPath: file,
                     createFrom: 'file',
                     bindHook: checkDuplicatedHandler,
@@ -85,21 +81,19 @@ class CommonJSFileDetector extends AbstractFileDetector {
         // check end
         this.duplicateModuleCheckSet.clear();
     }
-    async loadAsync(container) {
-        var _a;
+    async loadAsync(container, namespace) {
         this.options = this.options || {};
-        const loadDirs = [].concat((_a = this.options.loadDir) !== null && _a !== void 0 ? _a : container.get('baseDir'));
+        const loadDirs = [].concat(this.options.loadDir ?? container.get('baseDir'));
         for (const dir of loadDirs) {
-            const fileResults = (0, glob_1.run)(DEFAULT_GLOB_PATTERN.concat(this.options.pattern || []).concat(this.extraDetectorOptions.pattern || []), {
+            const fileResults = (0, glob_1.run)(DEFAULT_GLOB_PATTERN.concat(this.options.pattern || []), {
                 cwd: dir,
-                ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []).concat(this.extraDetectorOptions.ignore || []),
+                ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []),
             });
+            debug(`[core]: load file from ${dir}, files: ${fileResults}`);
             // 检查重复模块
             const checkDuplicatedHandler = (module, options) => {
-                if ((this.options.conflictCheck ||
-                    this.extraDetectorOptions.conflictCheck) &&
-                    types_1.Types.isClass(module)) {
-                    const name = (0, decorator_1.getProviderName)(module);
+                if (this.options.conflictCheck && types_1.Types.isClass(module)) {
+                    const name = decorator_1.DecoratorManager.getProviderName(module);
                     if (name) {
                         if (this.duplicateModuleCheckSet.has(name)) {
                             throw new error_1.MidwayDuplicateClassNameError(name, options.srcPath, this.duplicateModuleCheckSet.get(name));
@@ -116,7 +110,7 @@ class CommonJSFileDetector extends AbstractFileDetector {
                 });
                 // add module to set
                 container.bindClass(exports, {
-                    namespace: this.options.namespace,
+                    namespace,
                     srcPath: file,
                     createFrom: 'file',
                     bindHook: checkDuplicatedHandler,
@@ -129,6 +123,11 @@ class CommonJSFileDetector extends AbstractFileDetector {
     getType() {
         return 'commonjs';
     }
+    runSync(container, namespace) {
+        if (this.getType() === 'commonjs') {
+            return this.loadSync(container, namespace);
+        }
+    }
 }
 exports.CommonJSFileDetector = CommonJSFileDetector;
 /**
@@ -142,6 +141,9 @@ class ESModuleFileDetector extends CommonJSFileDetector {
 exports.ESModuleFileDetector = ESModuleFileDetector;
 class CustomModuleDetector extends AbstractFileDetector {
     async run(container) {
+        this.runSync(container, this.options.namespace);
+    }
+    runSync(container, namespace) {
         for (const module of this.options.modules) {
             container.bindClass(module, {
                 namespace: this.options.namespace,