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

package/dist/interface.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import type { AsyncContextManager } from './common/asyncContextManager';
 import type { LoggerFactory } from './common/loggerFactory';
 import type { ManagedResolverFactory } from './context/managedResolverFactory';
@@ -382,6 +383,10 @@ export interface MidwayCoreDefaultConfig {
     };
     core?: {
         healthCheckTimeout?: number;
+        configLoadTimeout?: number;
+        readyTimeout?: number;
+        serverReadyTimeout?: number;
+        stopTimeout?: number;
     };
 }
 export type ServiceFactoryConfigOption<OPTIONS> = {
@@ -397,38 +402,44 @@ export type ServiceFactoryConfigOption<OPTIONS> = {
 };
 export type CreateDataSourceInstanceOptions = {
     /**
-     * @default false
+     * @deprecated
      */
     validateConnection?: boolean;
     /**
-     * @default true
+     * @deprecated
      */
     cacheInstance?: boolean | undefined;
 };
-export type DataSourceManagerConfigOption<OPTIONS, ENTITY_CONFIG_KEY extends string = 'entities'> = {
-    default?: OPTIONS;
+export type BaseDataSourceManagerConfigOption<OPTIONS extends Record<string, any>, ENTITY_CONFIG_KEY extends string = 'entities'> = OPTIONS & {
+    validateConnection?: boolean;
+    customDataSourceClass?: any;
+} & {
+    [key in ENTITY_CONFIG_KEY]?: any[];
+};
+export interface DataSourceManagerConfigOption<OPTIONS extends Record<string, any>, ENTITY_CONFIG_KEY extends string = 'entities'> extends CreateDataSourceInstanceOptions {
+    default?: BaseDataSourceManagerConfigOption<OPTIONS, ENTITY_CONFIG_KEY>;
     defaultDataSourceName?: string;
-    dataSource?: {
-        [key: string]: PowerPartial<{
-            [keyName in ENTITY_CONFIG_KEY]: any[];
-        }> & OPTIONS;
-    };
-} & CreateDataSourceInstanceOptions;
+    dataSource?: BaseDataSourceManagerConfigOption<OPTIONS, ENTITY_CONFIG_KEY>;
+}
 type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<ReturnType<T>>> : Writable<PowerPartial<T>>;
 /**
  * Get definition from config
  */
 export type FileConfigOption<T, K = unknown> = K extends keyof ConfigType<T> ? Pick<ConfigType<T>, K> : ConfigType<T>;
+export interface LifeCycleInvokeOptions {
+    abortController: AbortController;
+    timeout: number;
+}
 /**
  * Lifecycle Definition
  * 生命周期定义
  */
 export interface ILifeCycle extends Partial<IObjectLifeCycle> {
-    onConfigLoad?(container: IMidwayContainer, mainApp?: IMidwayApplication): Promise<any>;
-    onReady?(container: IMidwayContainer, mainApp?: IMidwayApplication): Promise<void>;
-    onServerReady?(container: IMidwayContainer, mainApp?: IMidwayApplication): Promise<void>;
-    onHealthCheck?(container: IMidwayContainer): Promise<HealthResult>;
-    onStop?(container: IMidwayContainer, mainApp?: IMidwayApplication): Promise<void>;
+    onConfigLoad?(container: IMidwayContainer, mainApp: IMidwayApplication, options: LifeCycleInvokeOptions): Promise<any>;
+    onReady?(container: IMidwayContainer, mainApp: IMidwayApplication, options: LifeCycleInvokeOptions): Promise<void>;
+    onServerReady?(container: IMidwayContainer, mainApp: IMidwayApplication, options: LifeCycleInvokeOptions): Promise<void>;
+    onHealthCheck?(container: IMidwayContainer, mainApp: IMidwayApplication, options: LifeCycleInvokeOptions): Promise<HealthResult>;
+    onStop?(container: IMidwayContainer, mainApp: IMidwayApplication, options: LifeCycleInvokeOptions): Promise<void>;
 }
 /**
  * Abstract Object Factory
@@ -544,6 +555,7 @@ export interface IObjectDefinitionRegistry {
     clearAll(): void;
     hasObject(identifier: ObjectIdentifier): boolean;
     registerObject(identifier: ObjectIdentifier, target: any): any;
+    removeObject(identifier: ObjectIdentifier): void;
     getObject(identifier: ObjectIdentifier): any;
     getIdentifierRelation(): IIdentifierRelationShip;
     setIdentifierRelation(identifierRelation: IIdentifierRelationShip): any;
@@ -581,8 +593,8 @@ export interface IMidwayGlobalContainer extends IMidwayContainer, WithFn<IObject
     objectCreateEventTarget: EventEmitter;
     getNamespaceList(): string[];
     addNamespace(namespace: string): void;
-    bind<T>(target: T, options?: Partial<IObjectDefinition>): void;
-    bind<T>(identifier: ObjectIdentifier, target: T, options?: Partial<IObjectDefinition>): void;
+    bind<T>(target: T, options?: Partial<IObjectDefinition>): IObjectDefinition | undefined;
+    bind<T>(identifier: ObjectIdentifier, target: T, options?: Partial<IObjectDefinition>): IObjectDefinition | undefined;
     bindClass(exports: any, options?: Partial<IObjectDefinition>): void;
     stop(): Promise<void>;
     getManagedResolverFactory(): ManagedResolverFactory;
@@ -597,6 +609,7 @@ export interface IMidwayContainer extends IObjectFactory {
     getDefinition(identifier: ObjectIdentifier): IObjectDefinition;
     hasObject(identifier: ObjectIdentifier): boolean;
     getObject<T>(identifier: ObjectIdentifier): T;
+    removeObject(identifier: ObjectIdentifier): void;
     /**
      * Set value to app attribute map
      * @param key
@@ -759,7 +772,7 @@ export interface IMidwayBaseApplication<CTX extends IMidwayContext> {
      * Get all configuration values or get the specified configuration through parameters
      * @param key config key
      */
-    getConfig(key?: string): any;
+    getConfig<T = any>(key?: string): T;
     /**
      * Get default logger object or get the specified logger through parameters
      * @param name
@@ -832,7 +845,6 @@ export interface IMidwayBaseApplication<CTX extends IMidwayContext> {
 export type IMidwayApplication<T extends IMidwayContext = IMidwayContext, FrameworkApplication = unknown> = IMidwayBaseApplication<T> & FrameworkApplication;
 export type ModuleLoadType = 'commonjs' | 'esm';
 export interface IMidwayBootstrapOptions {
-    [customPropertyKey: string]: any;
     baseDir?: string;
     appDir?: string;
     applicationContext?: IMidwayGlobalContainer;
@@ -857,7 +869,7 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     configurationOptions: CONFIG;
     configure(options?: CONFIG): CONFIG;
     isEnable(): boolean;
-    initialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
+    initialize(options: IMidwayBootstrapOptions): Promise<void>;
     run(): Promise<void>;
     stop(): Promise<void>;
     getApplication(): APP;
@@ -878,6 +890,7 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     useGuard(guard: CommonGuardUnion<CTX>): void;
     runGuard(ctx: CTX, supplierClz: new (...args: any[]) => any, methodName: string): Promise<boolean>;
     getNamespace(): string;
+    setFrameworkLoggerName(name: string): void;
 }
 export interface MidwayAppInfo {
     pkg: Record<string, any>;
@@ -908,6 +921,20 @@ export interface IServiceFactory<Client> {
     isMediumPriority(clientName: string): boolean;
     isLowPriority(clientName: string): boolean;
 }
+export interface IDataSourceManager<DataSource, DataSourceConfig> {
+    createInstance(config: DataSourceConfig): Promise<DataSource | void>;
+    getDataSource(dataSourceName: string): DataSource;
+    getDataSourceNames(): string[];
+    getAllDataSources(): Map<string, DataSource>;
+    hasDataSource(dataSourceName: string): boolean;
+    isConnected(dataSourceName: string): Promise<boolean>;
+    getDefaultDataSourceName(): string;
+    stop(): Promise<void>;
+    getDataSourcePriority(dataSourceName: string): string;
+    isHighPriority(dataSourceName: string): boolean;
+    isMediumPriority(dataSourceName: string): boolean;
+    isLowPriority(dataSourceName: string): boolean;
+}
 export interface ISimulation {
     setup?(): Promise<void>;
     tearDown?(): Promise<void>;
@@ -978,5 +1005,138 @@ export interface InjectionConfigurationOptions {
     detector?: IFileDetector | false;
 }
 export type FunctionalConfigurationOptions = InjectionConfigurationOptions & ILifeCycle;
+/**
+ * 负载均衡策略类型
+ */
+export declare const LoadBalancerType: {
+    readonly RANDOM: "random";
+    readonly ROUND_ROBIN: "roundRobin";
+};
+export type LoadBalancerType = typeof LoadBalancerType[keyof typeof LoadBalancerType];
+export declare const ServiceDiscoveryHealthCheckType: {
+    readonly SELF: "self";
+    readonly TTL: "ttl";
+    readonly HTTP: "http";
+    readonly TCP: "tcp";
+    readonly CUSTOM: "custom";
+};
+export type ServiceDiscoveryHealthCheckType = typeof ServiceDiscoveryHealthCheckType[keyof typeof ServiceDiscoveryHealthCheckType];
+/**
+ * 基础健康检查配置
+ */
+export interface BaseServiceDiscoveryHealthCheckOptions {
+    /**
+     * 检查间隔（毫秒）
+     */
+    interval?: number;
+    /**
+     * 检查超时时间（毫秒）
+     */
+    timeout?: number;
+    /**
+     * 最大重试次数
+     */
+    maxRetries?: number;
+    /**
+     * 重试间隔（毫秒）
+     */
+    retryInterval?: number;
+}
+/**
+ * TTL 健康检查配置
+ */
+export interface TTLServiceDiscoveryHealthCheckOptions extends BaseServiceDiscoveryHealthCheckOptions {
+    /**
+     * TTL 时间（秒）
+     */
+    ttl: number;
+}
+/**
+ * HTTP 健康检查配置
+ */
+export interface HTTPServiceDiscoveryHealthCheckOptions extends BaseServiceDiscoveryHealthCheckOptions {
+    /**
+     * 健康检查 URL
+     */
+    url: string;
+    /**
+     * HTTP 方法
+     */
+    method?: string;
+    /**
+     * HTTP 请求头
+     */
+    headers?: Record<string, string>;
+    /**
+     * 期望的 HTTP 状态码
+     */
+    expectedStatus?: number;
+}
+/**
+ * TCP 健康检查配置
+ */
+export interface TCPServiceDiscoveryHealthCheckOptions extends BaseServiceDiscoveryHealthCheckOptions {
+    /**
+     * 主机地址
+     */
+    host: string;
+    /**
+     * 端口号
+     */
+    port: number;
+}
+/**
+ * 健康检查配置联合类型
+ */
+export type ServiceDiscoveryHealthCheckOptions = TTLServiceDiscoveryHealthCheckOptions | HTTPServiceDiscoveryHealthCheckOptions | TCPServiceDiscoveryHealthCheckOptions;
+export interface ServiceDiscoveryBaseInstance {
+}
+export interface DefaultInstanceMetadata {
+    id: string;
+    serviceName: string;
+    host: string;
+    port: number;
+    metadata: Record<string, any>;
+}
+/**
+ * 健康检查结果
+ */
+export interface ServiceDiscoveryHealthCheckResult {
+    status: 'passing' | 'warning' | 'critical' | 'unknown';
+    message?: string;
+    timestamp: number;
+}
+export interface IServiceDiscoveryHealthCheck<ServiceInstance> {
+    check(instance: ServiceInstance): Promise<ServiceDiscoveryHealthCheckResult>;
+}
+export interface ServiceDiscoveryOptions<ServiceInstance, serviceOptions = Record<string, any>> {
+    serviceDiscoveryClient?: string;
+    serviceOptions?: serviceOptions;
+    loadBalancer?: LoadBalancerType | ILoadBalancer<ServiceInstance>;
+}
+/**
+ * 负载均衡策略接口
+ */
+export interface ILoadBalancer<ServiceInstance> {
+    /**
+     * 从服务实例列表中选择一个实例
+     * @param instances 服务实例列表
+     */
+    select(instances: ServiceInstance[]): ServiceInstance;
+}
+export interface IServiceDiscoveryClient<ServiceInstance> {
+    /**
+     * 注册服务实例
+     */
+    register(instance: unknown): Promise<void>;
+    /**
+     * 上线服务实例
+     */
+    online(): Promise<void>;
+    /**
+     * 下线服务实例
+     */
+    offline(): Promise<void>;
+}
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayProcessTypeEnum = exports.ObjectLifeCycleEvent = exports.ServerlessTriggerType = exports.MSListenerType = exports.MSProviderType = exports.InjectModeEnum = exports.ScopeEnum = void 0;
+exports.ServiceDiscoveryHealthCheckType = exports.LoadBalancerType = exports.MidwayProcessTypeEnum = exports.ObjectLifeCycleEvent = exports.ServerlessTriggerType = exports.MSListenerType = exports.MSProviderType = exports.InjectModeEnum = exports.ScopeEnum = void 0;
 var ScopeEnum;
 (function (ScopeEnum) {
     ScopeEnum["Singleton"] = "Singleton";
@@ -53,4 +53,18 @@ var MidwayProcessTypeEnum;
     MidwayProcessTypeEnum["APPLICATION"] = "APPLICATION";
     MidwayProcessTypeEnum["AGENT"] = "AGENT";
 })(MidwayProcessTypeEnum || (exports.MidwayProcessTypeEnum = MidwayProcessTypeEnum = {}));
+/**
+ * 负载均衡策略类型
+ */
+exports.LoadBalancerType = {
+    RANDOM: 'random',
+    ROUND_ROBIN: 'roundRobin',
+};
+exports.ServiceDiscoveryHealthCheckType = {
+    SELF: 'self',
+    TTL: 'ttl',
+    HTTP: 'http',
+    TCP: 'tcp',
+    CUSTOM: 'custom'
+};
 //# sourceMappingURL=interface.js.map

package/dist/service/configService.d.ts

@@ -23,7 +23,7 @@ export declare class MidwayConfigService implements IConfigService {
     private getEnvSet;
     private getConfigEnv;
     load(): void;
-    getConfiguration(configKey?: string): any;
+    getConfiguration<T = any>(configKey?: string, defaultValue?: any): T;
     getConfigMergeOrder(): Array<ConfigMergeInfo>;
     private loadConfig;
     clearAllConfig(): void;

package/dist/service/configService.js

@@ -179,9 +179,10 @@ let MidwayConfigService = class MidwayConfigService {
         this.configuration = target;
         this.isReady = true;
     }
-    getConfiguration(configKey) {
+    getConfiguration(configKey, defaultValue) {
         if (configKey) {
-            return (0, util_1.safelyGet)(configKey, this.configuration);
+            const res = (0, util_1.safelyGet)(configKey, this.configuration);
+            return res === undefined ? defaultValue : res;
         }
         return this.configuration;
     }

package/dist/service/healthService.d.ts

@@ -1,7 +1,9 @@
 import { HealthResults, IMidwayContainer } from '../interface';
 import { MidwayConfigService } from './configService';
+import { MidwayFrameworkService } from './frameworkService';
 export declare class MidwayHealthService {
     protected configService: MidwayConfigService;
+    protected frameworkService: MidwayFrameworkService;
     protected applicationContext: IMidwayContainer;
     private healthCheckTimeout;
     private healthCheckMethods;

package/dist/service/healthService.js

@@ -13,7 +13,8 @@ exports.MidwayHealthService = void 0;
 const decorator_1 = require("../decorator");
 const interface_1 = require("../interface");
 const configService_1 = require("./configService");
-const util_1 = require("../util");
+const timeout_1 = require("../util/timeout");
+const frameworkService_1 = require("./frameworkService");
 let MidwayHealthService = class MidwayHealthService {
     constructor() {
         this.healthCheckTimeout = 1000;
@@ -35,14 +36,20 @@ let MidwayHealthService = class MidwayHealthService {
         }
     }
     async getStatus() {
-        const checkResult = await (0, util_1.createPromiseTimeoutInvokeChain)({
+        const checkResult = await (0, timeout_1.createPromiseTimeoutInvokeChain)({
             promiseItems: this.healthCheckMethods.map(item => {
                 return {
-                    item: item.item(this.applicationContext),
+                    item: ab => {
+                        return item.item(this.applicationContext, this.frameworkService.getMainApp(), {
+                            abortController: ab,
+                            timeout: this.healthCheckTimeout,
+                        });
+                    },
                     meta: item.meta,
+                    itemName: item.meta.namespace,
                 };
             }),
-            timeout: this.healthCheckTimeout,
+            itemTimeout: this.healthCheckTimeout,
             methodName: 'configuration.onHealthCheck',
             onSuccess: (result, meta) => {
                 if (result['status'] !== undefined) {
@@ -84,6 +91,10 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", configService_1.MidwayConfigService)
 ], MidwayHealthService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", frameworkService_1.MidwayFrameworkService)
+], MidwayHealthService.prototype, "frameworkService", void 0);
 __decorate([
     (0, decorator_1.ApplicationContext)(),
     __metadata("design:type", Object)

package/dist/service/informationService.d.ts

@@ -10,5 +10,8 @@ export declare class MidwayInformationService implements IInformationService {
     getPkg(): any;
     getProjectName(): string;
     getRoot(): string;
+    getHostname(): string;
+    getIpv4Address(): string;
+    getIpv6Address(): string;
 }
 //# sourceMappingURL=informationService.d.ts.map

package/dist/service/informationService.js

@@ -15,6 +15,7 @@ const util_1 = require("../util");
 const path_1 = require("path");
 const decorator_1 = require("../decorator");
 const fs_1 = require("fs");
+const network_1 = require("../util/network");
 let MidwayInformationService = class MidwayInformationService {
     init() {
         if (this.baseDir) {
@@ -55,6 +56,15 @@ let MidwayInformationService = class MidwayInformationService {
         const isDevelopmentEnv = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
         return isDevelopmentEnv ? this.getAppDir() : this.getHome();
     }
+    getHostname() {
+        return network_1.NetworkUtils.getHostname();
+    }
+    getIpv4Address() {
+        return network_1.NetworkUtils.getIpv4Address();
+    }
+    getIpv6Address() {
+        return network_1.NetworkUtils.getIpv6Address();
+    }
 };
 exports.MidwayInformationService = MidwayInformationService;
 __decorate([

package/dist/service/lifeCycleService.d.ts

@@ -3,6 +3,11 @@ import { MidwayFrameworkService } from './frameworkService';
 import { MidwayConfigService } from './configService';
 import { MidwayMockService } from './mockService';
 import { MidwayHealthService } from './healthService';
+type LifecycleInstanceItem = {
+    target: any;
+    namespace: string;
+    instance?: any;
+};
 export declare class MidwayLifeCycleService {
     readonly applicationContext: IMidwayContainer;
     protected frameworkService: MidwayFrameworkService;
@@ -17,19 +22,20 @@ export declare class MidwayLifeCycleService {
      * run some lifecycle in configuration
      * @param lifecycleInstanceOrList
      * @param lifecycle
-     * @param resultHandler
+     * @param runOptions
      */
-    private runContainerLifeCycle;
+    protected runContainerLifeCycle(lifecycleInstanceOrList: LifecycleInstanceItem[], lifecycle: string, runOptions?: {
+        resultHandler?: (result: any) => void;
+        timeout?: number;
+    }): Promise<void>;
+    private runLifeCycle;
     /**
      * run object lifecycle
      * @param lifecycleInstanceList
      * @param lifecycle
      */
     private runObjectLifeCycle;
-    getLifecycleInstanceList(): {
-        target: any;
-        namespace: string;
-        instance?: any;
-    }[];
+    getLifecycleInstanceList(): LifecycleInstanceItem[];
 }
+export {};
 //# sourceMappingURL=lifeCycleService.d.ts.map

package/dist/service/lifeCycleService.js

@@ -19,6 +19,7 @@ const mockService_1 = require("./mockService");
 const healthService_1 = require("./healthService");
 const metadataManager_1 = require("../decorator/metadataManager");
 const performanceManager_1 = require("../common/performanceManager");
+const timeout_1 = require("../util/timeout");
 const debug = (0, util_1.debuglog)('midway:debug');
 let MidwayLifeCycleService = class MidwayLifeCycleService {
     constructor(applicationContext) {
@@ -55,18 +56,25 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         // bind framework lifecycle
         // onAppError
         // exec onConfigLoad()
-        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onConfigLoad', configData => {
-            if (configData) {
-                this.configService.addObject(configData);
-            }
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onConfigLoad', {
+            resultHandler: configData => {
+                if (configData) {
+                    this.configService.addObject(configData);
+                }
+            },
+            timeout: this.configService.getConfiguration('core.configLoadTimeout'),
         });
         await this.mockService.runSimulatorSetup();
         // exec onReady()
-        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onReady');
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onReady', {
+            timeout: this.configService.getConfiguration('core.readyTimeout'),
+        });
         // exec framework.run()
         await this.frameworkService.runFramework();
         // exec onServerReady()
-        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onServerReady');
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onServerReady', {
+            timeout: this.configService.getConfiguration('core.serverReadyTimeout'),
+        });
         // clear config merge cache
         if (!this.configService.getConfiguration('debug.recordConfigMergeOrder')) {
             this.configService.clearConfigMergeOrder();
@@ -75,7 +83,9 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
     async stop() {
         await this.mockService.runSimulatorTearDown();
         // stop lifecycle
-        await this.runContainerLifeCycle(this.lifecycleInstanceList.reverse(), 'onStop');
+        await this.runContainerLifeCycle(this.lifecycleInstanceList.reverse(), 'onStop', {
+            timeout: this.configService.getConfiguration('core.stopTimeout'),
+        });
         // stop framework
         await this.frameworkService.stopFramework();
     }
@@ -83,33 +93,40 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
      * run some lifecycle in configuration
      * @param lifecycleInstanceOrList
      * @param lifecycle
-     * @param resultHandler
+     * @param runOptions
      */
-    async runContainerLifeCycle(lifecycleInstanceOrList, lifecycle, resultHandler) {
-        if (Array.isArray(lifecycleInstanceOrList)) {
-            for (const cycle of lifecycleInstanceOrList) {
-                if (typeof cycle.instance[lifecycle] === 'function') {
-                    debug(`[core]: Lifecycle run ${cycle.instance.constructor.name} ${lifecycle}`);
-                    performanceManager_1.MidwayInitializerPerformanceManager.lifecycleStart(cycle.namespace, lifecycle);
-                    const result = await cycle.instance[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
-                    if (resultHandler) {
-                        resultHandler(result);
-                    }
-                    performanceManager_1.MidwayInitializerPerformanceManager.lifecycleEnd(cycle.namespace, lifecycle);
-                }
-            }
-        }
-        else {
-            if (typeof lifecycleInstanceOrList[lifecycle] === 'function') {
-                const name = lifecycleInstanceOrList.constructor.name;
-                debug(`[core]: Lifecycle run ${name} ${lifecycle}`);
-                performanceManager_1.MidwayInitializerPerformanceManager.lifecycleStart(name, lifecycle);
-                const result = await lifecycleInstanceOrList[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
-                if (resultHandler) {
-                    resultHandler(result);
-                }
-                performanceManager_1.MidwayInitializerPerformanceManager.lifecycleEnd(name, lifecycle);
+    async runContainerLifeCycle(lifecycleInstanceOrList, lifecycle, runOptions) {
+        await (0, timeout_1.createPromiseTimeoutInvokeChain)({
+            promiseItems: lifecycleInstanceOrList.map(cycle => {
+                return {
+                    item: async (ab) => {
+                        return this.runLifeCycle(cycle, lifecycle, {
+                            ...runOptions,
+                            abortController: ab,
+                        });
+                    },
+                    meta: { namespace: cycle.namespace },
+                    itemName: cycle.namespace,
+                };
+            }),
+            itemTimeout: runOptions?.timeout,
+            isConcurrent: false,
+            methodName: `configuration.${lifecycle}`,
+        });
+    }
+    async runLifeCycle(cycle, lifecycle, runOptions) {
+        if (typeof cycle.instance[lifecycle] === 'function') {
+            debug(`[core]: Lifecycle run ${cycle.instance.constructor.name} ${lifecycle}`);
+            performanceManager_1.MidwayInitializerPerformanceManager.lifecycleStart(cycle.namespace, lifecycle);
+            const result = await cycle.instance[lifecycle](this.applicationContext, this.frameworkService.getMainApp(), {
+                timeout: runOptions.timeout,
+                abortController: runOptions.abortController,
+            });
+            if (runOptions?.resultHandler) {
+                runOptions.resultHandler(result);
             }
+            performanceManager_1.MidwayInitializerPerformanceManager.lifecycleEnd(cycle.namespace, lifecycle);
+            return result;
         }
     }
     /**

package/dist/setup.js

@@ -12,8 +12,9 @@ const asyncContextManager_1 = require("./common/asyncContextManager");
 const performanceManager_1 = require("./common/performanceManager");
 const debug = util.debuglog('midway:debug');
 let stepIdx = 1;
+let projectIdx = 1;
 function printStepDebugInfo(stepInfo) {
-    debug(`\n\nStep ${stepIdx++}: ${stepInfo}\n`);
+    debug(`\n\nProject ${projectIdx} - Step ${stepIdx++}: ${stepInfo}\n`);
 }
 /**
  * midway framework main entry, this method bootstrap all service and framework.
@@ -67,19 +68,25 @@ async function initializeGlobalApplicationContext(globalOptions) {
 }
 exports.initializeGlobalApplicationContext = initializeGlobalApplicationContext;
 async function destroyGlobalApplicationContext(applicationContext) {
+    printStepDebugInfo('Ready to destroy applicationContext');
     const loggerService = await applicationContext.getAsync(_1.MidwayLoggerService);
     const loggerFactory = loggerService.getCurrentLoggerFactory();
+    printStepDebugInfo('Stopping lifecycle');
     // stop lifecycle
     const lifecycleService = await applicationContext.getAsync(_1.MidwayLifeCycleService);
     await lifecycleService.stop();
+    printStepDebugInfo('Stopping applicationContext');
     // stop container
     await applicationContext.stop();
+    printStepDebugInfo('Closing loggerFactory');
     loggerFactory.close();
+    printStepDebugInfo('Cleaning performance manager');
     performanceManager_1.MidwayPerformanceManager.cleanAll();
     global['MIDWAY_APPLICATION_CONTEXT'] = undefined;
     global['MIDWAY_MAIN_FRAMEWORK'] = undefined;
     // reset counter
     stepIdx = 1;
+    projectIdx++;
 }
 exports.destroyGlobalApplicationContext = destroyGlobalApplicationContext;
 /**

package/dist/util/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { FunctionMiddleware, IgnoreMatcher } from '../interface';
 import { camelCase, pascalCase } from './camelCase';
 import { randomUUID } from './uuid';
@@ -121,7 +122,7 @@ export declare function pathMatching(options: {
 export declare function wrapMiddleware(mw: FunctionMiddleware<any, any>, options: any): (context: any, next: any, options?: any) => any;
 export declare function isIncludeProperty(obj: any, prop: string): boolean;
 export declare function wrapAsync(handler: any): (...args: any[]) => any;
-export declare function sleep(sleepTime?: number): Promise<void>;
+export declare function sleep(sleepTime?: number, abortController?: AbortController): Promise<void>;
 /**
  * get parameter name from function
  * @param func
@@ -134,22 +135,6 @@ export declare function generateRandomId(): string;
 export declare function merge(target: any, src: any): any;
 export declare function toAsyncFunction<T extends (...args: any[]) => any>(method: T): (...args: Parameters<T>) => Promise<ReturnType<T>>;
 export declare function isTypeScriptEnvironment(): boolean;
-/**
- * Create a Promise that resolves after the specified time
- * @param options
- */
-export declare function createPromiseTimeoutInvokeChain<Result>(options: {
-    promiseItems: Array<Promise<any> | {
-        item: Promise<any>;
-        meta?: any;
-        timeout?: number;
-    }>;
-    timeout: number;
-    methodName: string;
-    onSuccess?: (result: any, meta: any) => Result | Promise<Result>;
-    onFail: (err: Error, meta: any) => Result | Promise<Result>;
-    isConcurrent?: boolean;
-}): Promise<Result[]>;
 export declare function isConfigurationExport(exports: any): boolean;
 export declare function findProjectEntryFile(appDir: string, baseDir: string, loadMode: 'commonjs' | 'esm'): Promise<any>;
 export declare function findProjectEntryFileSync(appDir: string, baseDir: string): any;