@midwayjs/core 3.12.3 → 3.13.0

package/dist/baseFramework.d.ts

@@ -1,5 +1,4 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion } from './interface';
-import { ILogger, LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion, ILogger, MidwayLoggerOptions } from './interface';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
 import { MidwayInformationService } from './service/informationService';
@@ -18,7 +17,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected appLogger: ILogger;
     protected defaultContext: {};
     protected contextLoggerApplyLogger: string;
-    protected contextLoggerFormat: LoggerContextFormat;
+    protected contextLoggerFormat: any;
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected guardManager: GuardManager<CTX>;
@@ -80,7 +79,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     applyMiddleware<R, N>(lastMiddleware?: CommonMiddlewareUnion<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): any;
     getCoreLogger(): ILogger;
-    createLogger(name: string, option?: LoggerOptions): any;
+    createLogger(name: string, option?: MidwayLoggerOptions): any;
     getProjectName(): string;
     getFrameworkName(): string;
     useMiddleware(middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;

package/dist/baseFramework.js

@@ -107,7 +107,7 @@ class BaseFramework {
                 return ctxLoggerCache.get(name);
             }
             // create new context logger
-            const ctxLogger = appLogger.createContextLogger(ctx, {
+            const ctxLogger = this.loggerService.createContextLogger(ctx, appLogger, {
                 contextFormat: this.contextLoggerFormat,
             });
             ctxLoggerCache.set(name, ctxLogger);
@@ -118,7 +118,7 @@ class BaseFramework {
             if (ctx['_logger']) {
                 return ctx['_logger'];
             }
-            ctx['_logger'] = appLogger.createContextLogger(ctx, {
+            ctx['_logger'] = this.loggerService.createContextLogger(ctx, appLogger, {
                 contextFormat: this.contextLoggerFormat,
             });
             return ctx['_logger'];

package/dist/common/loggerFactory.d.ts

@@ -1,8 +1,32 @@
-import { ILogger } from '../interface';
+import { ILogger, MidwayAppInfo } from '../interface';
 export declare abstract class LoggerFactory<Logger extends ILogger, LoggerOptions> {
     abstract createLogger(name: string, options: LoggerOptions): Logger;
     abstract getLogger(loggerName: string): Logger;
     abstract close(loggerName?: string): any;
     abstract removeLogger(loggerName: string): any;
+    abstract getDefaultMidwayLoggerConfig(appInfo: MidwayAppInfo): {
+        midwayLogger: {
+            default?: LoggerOptions;
+            clients?: {
+                [loggerName: string]: LoggerOptions;
+            };
+        };
+    };
+    abstract createContextLogger(ctx: any, appLogger: ILogger, contextOptions?: any): ILogger;
+}
+export declare class DefaultConsoleLoggerFactory implements LoggerFactory<ILogger, any> {
+    createLogger(name: string, options: any): ILogger;
+    getLogger(loggerName: string): ILogger;
+    close(loggerName?: string): void;
+    removeLogger(loggerName: string): void;
+    getDefaultMidwayLoggerConfig(): {
+        midwayLogger: {
+            default?: any;
+            clients?: {
+                [p: string]: any;
+            };
+        };
+    };
+    createContextLogger(ctx: any, appLogger: ILogger): ILogger;
 }
 //# sourceMappingURL=loggerFactory.d.ts.map

package/dist/common/loggerFactory.js

@@ -1,7 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerFactory = void 0;
+exports.DefaultConsoleLoggerFactory = exports.LoggerFactory = void 0;
 class LoggerFactory {
 }
 exports.LoggerFactory = LoggerFactory;
+class DefaultConsoleLoggerFactory {
+    createLogger(name, options) {
+        return console;
+    }
+    getLogger(loggerName) {
+        return console;
+    }
+    close(loggerName) { }
+    removeLogger(loggerName) { }
+    getDefaultMidwayLoggerConfig() {
+        return {
+            midwayLogger: {
+                default: {},
+                clients: {
+                    coreLogger: {},
+                    appLogger: {},
+                },
+            },
+        };
+    }
+    createContextLogger(ctx, appLogger) {
+        return appLogger;
+    }
+}
+exports.DefaultConsoleLoggerFactory = DefaultConsoleLoggerFactory;
 //# sourceMappingURL=loggerFactory.js.map

package/dist/config/config.default.js

@@ -1,30 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const util_1 = require("../util/");
-const path_1 = require("path");
-const constants_1 = require("../constants");
 exports.default = (appInfo) => {
-    var _a;
     const isDevelopment = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
-    const logRoot = (_a = process.env[constants_1.MIDWAY_LOGGER_WRITEABLE_DIR]) !== null && _a !== void 0 ? _a : appInfo.root;
     return {
+        core: {
+            healthCheckTimeout: 1000,
+        },
         asyncContextManager: {
             enable: false,
         },
         midwayLogger: {
             default: {
-                dir: (0, path_1.join)(logRoot, 'logs', appInfo.name),
                 level: 'info',
-                consoleLevel: isDevelopment ? 'info' : 'warn',
-                auditFileDir: '.audit',
             },
             clients: {
                 coreLogger: {
                     level: isDevelopment ? 'info' : 'warn',
-                    fileLogName: 'midway-core.log',
                 },
                 appLogger: {
-                    fileLogName: 'midway-app.log',
                     aliasName: 'logger',
                 },
             },

package/dist/error/framework.d.ts

@@ -20,6 +20,7 @@ export declare const FrameworkErrorEnum: {
     readonly DUPLICATE_CONTROLLER_PREFIX_OPTIONS: "MIDWAY_10016";
     readonly RETRY_OVER_MAX_TIME: "MIDWAY_10017";
     readonly INVOKE_METHOD_FORBIDDEN: "MIDWAY_10018";
+    readonly CODE_INVOKE_TIMEOUT: "MIDWAY_10019";
 };
 export declare class MidwayCommonError extends MidwayError {
     constructor(message: string);
@@ -78,4 +79,7 @@ export declare class MidwayRetryExceededMaxTimesError extends MidwayError {
 export declare class MidwayInvokeForbiddenError extends MidwayError {
     constructor(methodName: string, module?: any);
 }
+export declare class MidwayCodeInvokeTimeoutError extends MidwayError {
+    constructor(methodName: string, timeout: number);
+}
 //# sourceMappingURL=framework.d.ts.map

package/dist/error/framework.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayInvokeForbiddenError = exports.MidwayRetryExceededMaxTimesError = exports.MidwayDuplicateControllerOptionsError = exports.MidwayDuplicateClassNameError = exports.MidwayInconsistentVersionError = exports.MidwayUtilHttpClientTimeoutError = exports.MidwayMissingImportComponentError = exports.MidwaySingletonInjectRequestError = exports.MidwayUseWrongMethodError = exports.MidwayDuplicateRouteError = exports.MidwayResolverMissingError = exports.MidwayInvalidConfigError = exports.MidwayConfigMissingError = exports.MidwayFeatureNotImplementedError = exports.MidwayFeatureNoLongerSupportedError = exports.MidwayDefinitionNotFoundError = exports.MidwayParameterError = exports.MidwayCommonError = exports.FrameworkErrorEnum = void 0;
+exports.MidwayCodeInvokeTimeoutError = exports.MidwayInvokeForbiddenError = exports.MidwayRetryExceededMaxTimesError = exports.MidwayDuplicateControllerOptionsError = exports.MidwayDuplicateClassNameError = exports.MidwayInconsistentVersionError = exports.MidwayUtilHttpClientTimeoutError = exports.MidwayMissingImportComponentError = exports.MidwaySingletonInjectRequestError = exports.MidwayUseWrongMethodError = exports.MidwayDuplicateRouteError = exports.MidwayResolverMissingError = exports.MidwayInvalidConfigError = exports.MidwayConfigMissingError = exports.MidwayFeatureNotImplementedError = exports.MidwayFeatureNoLongerSupportedError = exports.MidwayDefinitionNotFoundError = exports.MidwayParameterError = exports.MidwayCommonError = exports.FrameworkErrorEnum = void 0;
 const base_1 = require("./base");
 exports.FrameworkErrorEnum = (0, base_1.registerErrorCode)('midway', {
     UNKNOWN: 10000,
@@ -22,6 +22,7 @@ exports.FrameworkErrorEnum = (0, base_1.registerErrorCode)('midway', {
     DUPLICATE_CONTROLLER_PREFIX_OPTIONS: 10016,
     RETRY_OVER_MAX_TIME: 10017,
     INVOKE_METHOD_FORBIDDEN: 10018,
+    CODE_INVOKE_TIMEOUT: 10019,
 });
 class MidwayCommonError extends base_1.MidwayError {
     constructor(message) {
@@ -152,4 +153,10 @@ class MidwayInvokeForbiddenError extends base_1.MidwayError {
     }
 }
 exports.MidwayInvokeForbiddenError = MidwayInvokeForbiddenError;
+class MidwayCodeInvokeTimeoutError extends base_1.MidwayError {
+    constructor(methodName, timeout) {
+        super(`Invoke "${methodName}" running timeout(${timeout}ms)`, exports.FrameworkErrorEnum.CODE_INVOKE_TIMEOUT);
+    }
+}
+exports.MidwayCodeInvokeTimeoutError = MidwayCodeInvokeTimeoutError;
 //# sourceMappingURL=framework.js.map

package/dist/index.d.ts

@@ -33,17 +33,15 @@ export { AsyncContextManager, ASYNC_ROOT_CONTEXT, AsyncContext, } from './common
 export * from './decorator';
 export * from './decorator/decoratorManager';
 export * from './decorator/constant';
-export { safelyGet, safeRequire, loadModule, delegateTargetPrototypeMethod, delegateTargetMethod, delegateTargetProperties, delegateTargetAllPrototypeMethod, deprecatedOutput, transformRequestObjectByType, pathMatching, wrapMiddleware, wrapAsync, isTypeScriptEnvironment, } from './util/';
+export { safelyGet, safeRequire, loadModule, delegateTargetPrototypeMethod, delegateTargetMethod, delegateTargetProperties, delegateTargetAllPrototypeMethod, deprecatedOutput, transformRequestObjectByType, pathMatching, wrapMiddleware, wrapAsync, isTypeScriptEnvironment, sleep, Utils, } from './util/';
 export { extend } from './util/extend';
 export * from './util/webRouterParam';
 export * from './util/contextUtil';
 export * from './util/pathToRegexp';
 export * from './util/httpclient';
 export { retryWithAsync, retryWith } from './util/retry';
-export { sleep, Utils } from './util/index';
 export { Types } from './util/types';
 export { PathFileUtil } from './util/pathFileUtil';
 export { FileUtils } from './util/fs';
 export { FORMAT } from './util/format';
-export type { ILogger, IMidwayLogger } from '@midwayjs/logger';
 //# sourceMappingURL=index.d.ts.map

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.FORMAT = exports.FileUtils = exports.PathFileUtil = exports.Types = exports.Utils = exports.sleep = exports.retryWith = exports.retryWithAsync = exports.extend = exports.isTypeScriptEnvironment = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.loadModule = exports.safeRequire = exports.safelyGet = 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.FunctionalConfiguration = exports.createConfiguration = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
+exports.FORMAT = exports.FileUtils = exports.PathFileUtil = exports.Types = exports.retryWith = exports.retryWithAsync = exports.extend = exports.Utils = exports.sleep = exports.isTypeScriptEnvironment = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.loadModule = exports.safeRequire = exports.safelyGet = 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.FunctionalConfiguration = exports.createConfiguration = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
 __exportStar(require("./interface"), exports);
 __exportStar(require("./context/container"), exports);
 var requestContainer_1 = require("./context/requestContainer");
@@ -85,6 +85,8 @@ Object.defineProperty(exports, "pathMatching", { enumerable: true, get: function
 Object.defineProperty(exports, "wrapMiddleware", { enumerable: true, get: function () { return util_1.wrapMiddleware; } });
 Object.defineProperty(exports, "wrapAsync", { enumerable: true, get: function () { return util_1.wrapAsync; } });
 Object.defineProperty(exports, "isTypeScriptEnvironment", { enumerable: true, get: function () { return util_1.isTypeScriptEnvironment; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return util_1.sleep; } });
+Object.defineProperty(exports, "Utils", { enumerable: true, get: function () { return util_1.Utils; } });
 var extend_1 = require("./util/extend");
 Object.defineProperty(exports, "extend", { enumerable: true, get: function () { return extend_1.extend; } });
 __exportStar(require("./util/webRouterParam"), exports);
@@ -94,9 +96,6 @@ __exportStar(require("./util/httpclient"), exports);
 var retry_1 = require("./util/retry");
 Object.defineProperty(exports, "retryWithAsync", { enumerable: true, get: function () { return retry_1.retryWithAsync; } });
 Object.defineProperty(exports, "retryWith", { enumerable: true, get: function () { return retry_1.retryWith; } });
-var index_1 = require("./util/index");
-Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return index_1.sleep; } });
-Object.defineProperty(exports, "Utils", { enumerable: true, get: function () { return index_1.Utils; } });
 var types_1 = require("./util/types");
 Object.defineProperty(exports, "Types", { enumerable: true, get: function () { return types_1.Types; } });
 var pathFileUtil_1 = require("./util/pathFileUtil");

package/dist/interface.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-import type { LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import type { AsyncContextManager } from './common/asyncContextManager';
 import type { LoggerFactory } from './common/loggerFactory';
@@ -343,21 +342,61 @@ export interface ParamDecoratorOptions {
     throwError?: boolean;
     pipes?: PipeUnionTransform<any, any>[];
 }
+/**
+ * Logger Options for midway, you can merge this interface in package
+ * @example
+ * ```typescript
+ *
+ * import { IMidwayLogger } from '@midwayjs/logger';
+ *
+ * declare module '@midwayjs/core/dist/interface' {
+ *   interface ILogger extends IMidwayLogger {
+ *   }
+ * }
+ *
+ * ```
+ */
 export interface ILogger {
     info(msg: any, ...args: any[]): void;
     debug(msg: any, ...args: any[]): void;
     error(msg: any, ...args: any[]): void;
     warn(msg: any, ...args: any[]): void;
 }
+/**
+ * @deprecated
+ */
+export type IMidwayLogger = ILogger;
+/**
+ * Logger Options for midway, you can merge this interface in package
+ * @example
+ * ```typescript
+ *
+ * import { LoggerOptions } from '@midwayjs/logger';
+ *
+ * declare module '@midwayjs/core/dist/interface' {
+ *   interface MidwayLoggerOptions extends LoggerOptions {
+ *     logDir?: string;
+ *     level?: string;
+ *   }
+ * }
+ *
+ * ```
+ */
+export interface MidwayLoggerOptions {
+    lazyLoad?: boolean;
+    aliasName?: string;
+    [key: string]: any;
+}
 export interface MidwayCoreDefaultConfig {
-    midwayLogger?: ServiceFactoryConfigOption<LoggerOptions & {
-        lazyLoad?: boolean;
-    }>;
+    midwayLogger?: ServiceFactoryConfigOption<MidwayLoggerOptions>;
     debug?: {
         recordConfigMergeOrder?: boolean;
     };
-    asyncContextManager: {
-        enable: boolean;
+    asyncContextManager?: {
+        enable?: boolean;
+    };
+    core?: {
+        healthCheckTimeout?: number;
     };
 }
 export type ServiceFactoryConfigOption<OPTIONS> = {
@@ -400,6 +439,7 @@ 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>;
 }
 export type ObjectContext = {
@@ -762,7 +802,7 @@ export interface IMidwayBaseApplication<CTX extends IMidwayContext> {
      * @param name
      * @param options
      */
-    createLogger(name: string, options: LoggerOptions): ILogger;
+    createLogger(name: string, options: MidwayLoggerOptions): ILogger;
     /**
      * Get project name, just package.json name
      */
@@ -847,7 +887,7 @@ export interface IConfigurationOptions {
     logger?: ILogger;
     appLogger?: ILogger;
     contextLoggerApplyLogger?: string;
-    contextLoggerFormat?: LoggerContextFormat;
+    contextLoggerFormat?: any;
 }
 export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, CONFIG extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> {
     app: APP;
@@ -866,7 +906,7 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     getBaseDir(): string;
     getLogger(name?: string): ILogger;
     getCoreLogger(): ILogger;
-    createLogger(name: string, options: LoggerOptions): ILogger;
+    createLogger(name: string, options: MidwayLoggerOptions): ILogger;
     getProjectName(): string;
     useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
     getMiddleware(): IMiddlewareManager<CTX, ResOrNext, Next>;
@@ -909,5 +949,34 @@ export interface ISimulation {
     appTearDown?(app: IMidwayApplication): Promise<void>;
     enableCondition(): boolean | Promise<boolean>;
 }
+export interface HealthResult {
+    /**
+     * health status
+     */
+    status: boolean;
+    /**
+     * failed reason
+     */
+    reason?: string;
+}
+export interface HealthResults {
+    /**
+     * health status
+     */
+    status: boolean;
+    /**
+     * first failed namespace
+     */
+    namespace: string;
+    /**
+     * first failed reason
+     */
+    reason?: string;
+    results?: Array<{
+        namespace: string;
+        status: boolean;
+        reason?: string;
+    }>;
+}
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/service/configService.d.ts

@@ -34,6 +34,7 @@ export declare class MidwayConfigService implements IConfigService {
      */
     addFilter(filter: (config: Record<string, any>) => Record<string, any>): void;
     protected runWithFilter(config: Record<string, any>): Record<string, any>;
+    getAppInfo(): MidwayAppInfo;
 }
 export {};
 //# sourceMappingURL=configService.d.ts.map

package/dist/service/configService.js

@@ -224,6 +224,9 @@ let MidwayConfigService = class MidwayConfigService {
         }
         return config;
     }
+    getAppInfo() {
+        return this.appInfo;
+    }
 };
 __decorate([
     (0, decorator_1.Inject)(),

package/dist/service/frameworkService.js

@@ -131,6 +131,7 @@ let MidwayFrameworkService = class MidwayFrameworkService {
             }
             global['MIDWAY_MAIN_FRAMEWORK'] = this.mainFramework =
                 (_b = this.applicationManager.getFramework(mainNs)) !== null && _b !== void 0 ? _b : this.globalFrameworkList[0];
+            debug(`[core]: Current main Framework is "${mainNs}".`);
         }
         // init aspect module
         await this.aspectService.loadAspect();
@@ -146,6 +147,12 @@ let MidwayFrameworkService = class MidwayFrameworkService {
         return this.applicationManager.getFramework(namespaceOrFrameworkType);
     }
     async runFramework() {
+        const namespaceList = this.applicationContext.getNamespaceList();
+        // globalFrameworkList 需要基于 namespaceList 进行排序，不然会出现顺序问题
+        this.globalFrameworkList = this.globalFrameworkList.sort((a, b) => {
+            return (namespaceList.indexOf(a.getNamespace()) -
+                namespaceList.indexOf(b.getNamespace()));
+        });
         for (const frameworkInstance of this.globalFrameworkList) {
             // if enable, just init framework
             if (frameworkInstance.isEnable()) {

package/dist/service/healthService.d.ts

@@ -0,0 +1,14 @@
+import { HealthResults, IMidwayContainer } from '../interface';
+import { MidwayConfigService } from './configService';
+import { MidwayLifeCycleService } from './lifeCycleService';
+export declare class MidwayHealthService {
+    protected configService: MidwayConfigService;
+    protected lifeCycleService: MidwayLifeCycleService;
+    protected applicationContext: IMidwayContainer;
+    private healthCheckTimeout;
+    private healthCheckMethods;
+    protected init(): Promise<void>;
+    getStatus(): Promise<HealthResults>;
+    setCheckTimeout(timeout: number): void;
+}
+//# sourceMappingURL=healthService.d.ts.map

package/dist/service/healthService.js

@@ -0,0 +1,106 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.MidwayHealthService = void 0;
+const decorator_1 = require("../decorator");
+const interface_1 = require("../interface");
+const configService_1 = require("./configService");
+const lifeCycleService_1 = require("./lifeCycleService");
+const util_1 = require("../util");
+let MidwayHealthService = class MidwayHealthService {
+    constructor() {
+        this.healthCheckTimeout = 1000;
+        this.healthCheckMethods = [];
+    }
+    async init() {
+        const healthCheckTimeout = this.configService.getConfiguration('core.healthCheckTimeout') || 1000;
+        this.setCheckTimeout(healthCheckTimeout);
+        for (const lifecycleInstance of this.lifeCycleService.getLifecycleInstanceList()) {
+            if (lifecycleInstance.instance &&
+                lifecycleInstance.instance['onHealthCheck']) {
+                this.healthCheckMethods.push({
+                    item: lifecycleInstance.instance['onHealthCheck'],
+                    meta: {
+                        namespace: lifecycleInstance.namespace,
+                    },
+                });
+            }
+        }
+    }
+    async getStatus() {
+        const checkResult = await (0, util_1.createPromiseTimeoutInvokeChain)({
+            promiseItems: this.healthCheckMethods.map(item => {
+                return {
+                    item: item.item(this.applicationContext),
+                    meta: item.meta,
+                };
+            }),
+            timeout: this.healthCheckTimeout,
+            methodName: 'configuration.onHealthCheck',
+            onSuccess: (result, meta) => {
+                if (result['status'] !== undefined) {
+                    return {
+                        namespace: meta.namespace,
+                        ...result,
+                    };
+                }
+                else {
+                    return {
+                        status: false,
+                        namespace: meta.namespace,
+                        reason: 'configuration.onHealthCheck return value must be object and contain status field',
+                    };
+                }
+            },
+            onFail: (err, meta) => {
+                return {
+                    status: false,
+                    namespace: meta.namespace,
+                    reason: err.message,
+                };
+            },
+        });
+        const failedResult = checkResult.find(item => !item.status);
+        return {
+            status: !failedResult,
+            namespace: failedResult === null || failedResult === void 0 ? void 0 : failedResult.namespace,
+            reason: failedResult === null || failedResult === void 0 ? void 0 : failedResult.reason,
+            results: checkResult,
+        };
+    }
+    setCheckTimeout(timeout) {
+        this.healthCheckTimeout = timeout;
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayHealthService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", lifeCycleService_1.MidwayLifeCycleService)
+], MidwayHealthService.prototype, "lifeCycleService", void 0);
+__decorate([
+    (0, decorator_1.ApplicationContext)(),
+    __metadata("design:type", Object)
+], MidwayHealthService.prototype, "applicationContext", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayHealthService.prototype, "init", null);
+MidwayHealthService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
+], MidwayHealthService);
+exports.MidwayHealthService = MidwayHealthService;
+//# sourceMappingURL=healthService.js.map

package/dist/service/lifeCycleService.d.ts

@@ -7,10 +7,27 @@ export declare class MidwayLifeCycleService {
     protected frameworkService: MidwayFrameworkService;
     protected configService: MidwayConfigService;
     protected mockService: MidwayMockService;
+    private lifecycleInstanceList;
     constructor(applicationContext: IMidwayContainer);
     protected init(): Promise<void>;
     stop(): Promise<void>;
+    /**
+     * run some lifecycle in configuration
+     * @param lifecycleInstanceOrList
+     * @param lifecycle
+     * @param resultHandler
+     */
     private runContainerLifeCycle;
+    /**
+     * run object lifecycle
+     * @param lifecycleInstanceList
+     * @param lifecycle
+     */
     private runObjectLifeCycle;
+    getLifecycleInstanceList(): {
+        target: any;
+        namespace: string;
+        instance?: any;
+    }[];
 }
 //# sourceMappingURL=lifeCycleService.d.ts.map

package/dist/service/lifeCycleService.js

@@ -21,6 +21,7 @@ const debug = (0, util_1.debuglog)('midway:debug');
 let MidwayLifeCycleService = class MidwayLifeCycleService {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
+        this.lifecycleInstanceList = [];
     }
     async init() {
         // exec simulator init
@@ -28,7 +29,6 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         // run lifecycle
         const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
         debug(`[core]: Found Configuration length = ${cycles.length}`);
-        const lifecycleInstanceList = [];
         for (const cycle of cycles) {
             if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
                 // 函数式写法
@@ -39,30 +39,30 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
                 debug(`[core]: Lifecycle run ${cycle.namespace} init`);
                 cycle.instance = await this.applicationContext.getAsync(cycle.target);
             }
-            cycle.instance && lifecycleInstanceList.push(cycle);
+            cycle.instance && this.lifecycleInstanceList.push(cycle);
         }
         // bind object lifecycle
         await Promise.all([
-            this.runObjectLifeCycle(lifecycleInstanceList, 'onBeforeObjectCreated'),
-            this.runObjectLifeCycle(lifecycleInstanceList, 'onObjectCreated'),
-            this.runObjectLifeCycle(lifecycleInstanceList, 'onObjectInit'),
-            this.runObjectLifeCycle(lifecycleInstanceList, 'onBeforeObjectDestroy'),
+            this.runObjectLifeCycle(this.lifecycleInstanceList, 'onBeforeObjectCreated'),
+            this.runObjectLifeCycle(this.lifecycleInstanceList, 'onObjectCreated'),
+            this.runObjectLifeCycle(this.lifecycleInstanceList, 'onObjectInit'),
+            this.runObjectLifeCycle(this.lifecycleInstanceList, 'onBeforeObjectDestroy'),
         ]);
         // bind framework lifecycle
         // onAppError
         // exec onConfigLoad()
-        await this.runContainerLifeCycle(lifecycleInstanceList, 'onConfigLoad', configData => {
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onConfigLoad', configData => {
             if (configData) {
                 this.configService.addObject(configData);
             }
         });
         await this.mockService.runSimulatorSetup();
         // exec onReady()
-        await this.runContainerLifeCycle(lifecycleInstanceList, 'onReady');
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onReady');
         // exec framework.run()
         await this.frameworkService.runFramework();
         // exec onServerReady()
-        await this.runContainerLifeCycle(lifecycleInstanceList, 'onServerReady');
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onServerReady');
         // clear config merge cache
         if (!this.configService.getConfiguration('debug.recordConfigMergeOrder')) {
             this.configService.clearConfigMergeOrder();
@@ -86,6 +86,12 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         // stop framework
         await this.frameworkService.stopFramework();
     }
+    /**
+     * run some lifecycle in configuration
+     * @param lifecycleInstanceOrList
+     * @param lifecycle
+     * @param resultHandler
+     */
     async runContainerLifeCycle(lifecycleInstanceOrList, lifecycle, resultHandler) {
         if (Array.isArray(lifecycleInstanceOrList)) {
             for (const cycle of lifecycleInstanceOrList) {
@@ -108,6 +114,11 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
             }
         }
     }
+    /**
+     * run object lifecycle
+     * @param lifecycleInstanceList
+     * @param lifecycle
+     */
     async runObjectLifeCycle(lifecycleInstanceList, lifecycle) {
         for (const cycle of lifecycleInstanceList) {
             if (typeof cycle.instance[lifecycle] === 'function') {
@@ -116,6 +127,9 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
             }
         }
     }
+    getLifecycleInstanceList() {
+        return this.lifecycleInstanceList;
+    }
 };
 __decorate([
     (0, decorator_1.Inject)(),

package/dist/service/loggerService.d.ts

@@ -1,6 +1,6 @@
 import { MidwayConfigService } from './configService';
 import { ServiceFactory } from '../common/serviceFactory';
-import { ILogger, IMidwayContainer } from '../interface';
+import { ILogger, IMidwayContainer, IMidwayContext, MidwayLoggerOptions } from '../interface';
 import { LoggerFactory } from '../common/loggerFactory';
 export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     readonly applicationContext: IMidwayContainer;
@@ -8,12 +8,14 @@ export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     configService: MidwayConfigService;
     private loggerFactory;
     private lazyLoggerConfigMap;
+    private aliasLoggerMap;
     constructor(applicationContext: IMidwayContainer, globalOptions?: {});
     protected init(): void;
     protected createClient(config: any, name?: string): void;
     getName(): string;
-    createLogger(name: any, config: any): any;
+    createLogger(name: string, config: MidwayLoggerOptions): any;
     getLogger(name: string): any;
     getCurrentLoggerFactory(): LoggerFactory<any, any>;
+    createContextLogger(ctx: IMidwayContext, appLogger: ILogger, contextOptions?: any): ILogger;
 }
 //# sourceMappingURL=loggerService.d.ts.map

package/dist/service/loggerService.js

@@ -14,22 +14,41 @@ const decorator_1 = require("../decorator");
 const configService_1 = require("./configService");
 const serviceFactory_1 = require("../common/serviceFactory");
 const interface_1 = require("../interface");
-const logger_1 = require("@midwayjs/logger");
+const loggerFactory_1 = require("../common/loggerFactory");
+const error_1 = require("../error");
 let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.ServiceFactory {
     constructor(applicationContext, globalOptions = {}) {
         super();
         this.applicationContext = applicationContext;
         this.globalOptions = globalOptions;
         this.lazyLoggerConfigMap = new Map();
+        this.aliasLoggerMap = new Map();
     }
     init() {
         var _a;
-        this.loggerFactory = this.globalOptions['loggerFactory'] || logger_1.loggers;
+        const loggerFactory = this.configService.getConfiguration('loggerFactory');
+        // load logger factory from user config first
+        this.loggerFactory =
+            loggerFactory ||
+                this.globalOptions['loggerFactory'] ||
+                new loggerFactory_1.DefaultConsoleLoggerFactory();
+        // check
+        if (!this.loggerFactory.getDefaultMidwayLoggerConfig) {
+            throw new error_1.MidwayFeatureNoLongerSupportedError('please upgrade your @midwayjs/logger to latest version');
+        }
+        const defaultLoggerConfig = this.loggerFactory.getDefaultMidwayLoggerConfig(this.configService.getAppInfo());
+        // merge to user config
+        this.configService.addObject(defaultLoggerConfig, true);
+        // init logger
         this.initClients(this.configService.getConfiguration('midwayLogger'));
         // alias inject logger
         (_a = this.applicationContext) === null || _a === void 0 ? void 0 : _a.registerObject('logger', this.getLogger('appLogger'));
     }
     createClient(config, name) {
+        if (config.aliasName) {
+            // mapping alias logger name to real logger name
+            this.aliasLoggerMap.set(config.aliasName, name);
+        }
         if (!config.lazyLoad) {
             this.loggerFactory.createLogger(name, config);
         }
@@ -42,9 +61,14 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
         return 'logger';
     }
     createLogger(name, config) {
+        delete config['aliasName'];
         return this.loggerFactory.createLogger(name, config);
     }
     getLogger(name) {
+        if (this.aliasLoggerMap.has(name)) {
+            // get real logger name
+            name = this.aliasLoggerMap.get(name);
+        }
         const logger = this.loggerFactory.getLogger(name);
         if (logger) {
             return logger;
@@ -59,6 +83,9 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
     getCurrentLoggerFactory() {
         return this.loggerFactory;
     }
+    createContextLogger(ctx, appLogger, contextOptions) {
+        return this.loggerFactory.createContextLogger(ctx, appLogger, contextOptions);
+    }
 };
 __decorate([
     (0, decorator_1.Inject)(),

package/dist/setup.js

@@ -7,6 +7,7 @@ const decorator_1 = require("./decorator");
 const util = require("util");
 const slsFunctionService_1 = require("./service/slsFunctionService");
 const path_1 = require("path");
+const healthService_1 = require("./service/healthService");
 const debug = util.debuglog('midway:debug');
 let stepIdx = 1;
 function printStepDebugInfo(stepInfo) {
@@ -134,6 +135,7 @@ async function prepareGlobalApplicationContextAsync(globalOptions) {
     applicationContext.bindClass(_1.MidwayMockService);
     applicationContext.bindClass(_1.MidwayWebRouterService);
     applicationContext.bindClass(slsFunctionService_1.MidwayServerlessFunctionService);
+    applicationContext.bindClass(healthService_1.MidwayHealthService);
     printStepDebugInfo('Binding preload module');
     // bind preload module
     if (globalOptions.preloadModules && globalOptions.preloadModules.length) {
@@ -227,6 +229,7 @@ function prepareGlobalApplicationContext(globalOptions) {
     applicationContext.bindClass(_1.MidwayMockService);
     applicationContext.bindClass(_1.MidwayWebRouterService);
     applicationContext.bindClass(slsFunctionService_1.MidwayServerlessFunctionService);
+    applicationContext.bindClass(healthService_1.MidwayHealthService);
     printStepDebugInfo('Binding preload module');
     // bind preload module
     if (globalOptions.preloadModules && globalOptions.preloadModules.length) {

package/dist/util/index.d.ts

@@ -123,6 +123,22 @@ 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 const Utils: {
     sleep: typeof sleep;
     getParamNames: typeof getParamNames;

package/dist/util/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Utils = exports.isTypeScriptEnvironment = exports.toAsyncFunction = exports.merge = exports.generateRandomId = exports.getParamNames = exports.sleep = exports.wrapAsync = exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.loadModule = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
+exports.Utils = exports.createPromiseTimeoutInvokeChain = exports.isTypeScriptEnvironment = exports.toAsyncFunction = exports.merge = exports.generateRandomId = exports.getParamNames = exports.sleep = exports.wrapAsync = exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.loadModule = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
 const path_1 = require("path");
 const fs_1 = require("fs");
 const util_1 = require("util");
@@ -496,6 +496,79 @@ function isTypeScriptEnvironment() {
     return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
 }
 exports.isTypeScriptEnvironment = isTypeScriptEnvironment;
+/**
+ * Create a Promise that resolves after the specified time
+ * @param options
+ */
+async function createPromiseTimeoutInvokeChain(options) {
+    var _a;
+    if (!options.onSuccess) {
+        options.onSuccess = async (result) => {
+            return result;
+        };
+    }
+    options.isConcurrent = (_a = options.isConcurrent) !== null && _a !== void 0 ? _a : true;
+    options.promiseItems = options.promiseItems.map(item => {
+        if (item instanceof Promise) {
+            return { item };
+        }
+        else {
+            return item;
+        }
+    });
+    // filter promise
+    options.promiseItems = options.promiseItems.filter(item => {
+        return item['item'] instanceof Promise;
+    });
+    if (options.isConcurrent) {
+        // For each check item, we create a timeout Promise
+        const checkPromises = options.promiseItems.map(item => {
+            const timeoutPromise = new Promise((_, reject) => {
+                var _a;
+                // The timeout Promise fails after the specified time
+                setTimeout(() => {
+                    var _a;
+                    return reject(new error_1.MidwayCodeInvokeTimeoutError(options.methodName, (_a = item['timeout']) !== null && _a !== void 0 ? _a : options.timeout));
+                }, (_a = item['timeout']) !== null && _a !== void 0 ? _a : options.timeout);
+            });
+            // We use Promise.race to wait for either the check item or the timeout Promise
+            return (Promise.race([item['item'], timeoutPromise])
+                // If the check item Promise resolves, we set the result to success
+                .then(re => {
+                return options.onSuccess(re, item['meta']);
+            })
+                // If the timeout Promise resolves (i.e., the check item Promise did not resolve in time), we set the result to failure
+                .catch(err => {
+                return options.onFail(err, item['meta']);
+            }));
+        });
+        return Promise.all(checkPromises);
+    }
+    else {
+        const results = [];
+        for (const item of options.promiseItems) {
+            const timeoutPromise = new Promise((_, reject) => {
+                var _a;
+                setTimeout(() => {
+                    var _a;
+                    return reject(new error_1.MidwayCodeInvokeTimeoutError(options.methodName, (_a = item['timeout']) !== null && _a !== void 0 ? _a : options.timeout));
+                }, (_a = item['timeout']) !== null && _a !== void 0 ? _a : options.timeout);
+            });
+            try {
+                const result = await Promise.race([item['item'], timeoutPromise]).then(re => {
+                    return options.onSuccess(re, item['meta']);
+                });
+                results.push(result);
+            }
+            catch (error) {
+                results.push(options.onFail(error, item['meta']));
+                break;
+            }
+        }
+        return results;
+    }
+}
+exports.createPromiseTimeoutInvokeChain = createPromiseTimeoutInvokeChain;
 exports.Utils = {
     sleep,
     getParamNames,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.12.3",
+  "version": "3.13.0",
   "description": "midway core",
-  "main": "dist/index",
+  "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
@@ -22,14 +22,14 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "koa": "2.14.1",
+    "@midwayjs/logger": "^3.0.0",
+    "koa": "2.14.2",
     "mm": "3.3.0",
     "raw-body": "2.5.2",
     "sinon": "15.2.0"
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
-    "@midwayjs/logger": "^2.15.0",
     "class-transformer": "0.5.1",
     "picomatch": "2.3.1",
     "reflect-metadata": "0.1.13"
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "0b6638726c4722d5a6ee8075fea0a0b68378452c"
+  "gitHead": "9f55734afa5b08dcf46bc89493ec8edaa8c6202b"
 }