@midwayjs/core 3.0.0-alpha.6 → 3.0.0-beta.11

package/dist/service/decoratorService.js

@@ -0,0 +1,149 @@
+"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.MidwayDecoratorService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const aspectService_1 = require("./aspectService");
+const error_1 = require("../error");
+const util = require("util");
+const debug = util.debuglog('midway:debug');
+let MidwayDecoratorService = class MidwayDecoratorService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+        this.propertyHandlerMap = new Map();
+        this.methodDecoratorMap = new Map();
+        this.parameterDecoratorMap = new Map();
+    }
+    async init() {
+        // add custom method decorator listener
+        this.applicationContext.onBeforeBind(Clzz => {
+            // find custom method decorator metadata, include method decorator information array
+            const methodDecoratorMetadataList = (0, decorator_1.getClassMetadata)(decorator_1.INJECT_CUSTOM_METHOD, Clzz);
+            if (methodDecoratorMetadataList) {
+                // loop it, save this order for decorator run
+                for (const meta of methodDecoratorMetadataList) {
+                    const { propertyName, key, metadata } = meta;
+                    // add aspect implementation first
+                    this.aspectService.interceptPrototypeMethod(Clzz, propertyName, () => {
+                        const methodDecoratorHandler = this.methodDecoratorMap.get(key);
+                        if (!methodDecoratorHandler) {
+                            throw new error_1.MidwayCommonError(`Method Decorator "${key}" handler not found, please register first.`);
+                        }
+                        return this.methodDecoratorMap.get(key)({
+                            target: Clzz,
+                            propertyName,
+                            metadata,
+                        });
+                    });
+                }
+            }
+            // find custom param decorator metadata
+            const parameterDecoratorMetadata = (0, decorator_1.getClassMetadata)(decorator_1.INJECT_CUSTOM_PARAM, Clzz);
+            if (parameterDecoratorMetadata) {
+                // loop it, save this order for decorator run
+                for (const methodName of Object.keys(parameterDecoratorMetadata)) {
+                    // add aspect implementation first
+                    this.aspectService.interceptPrototypeMethod(Clzz, methodName, () => {
+                        return {
+                            before: async (joinPoint) => {
+                                // joinPoint.args
+                                const newArgs = [...joinPoint.args];
+                                for (const meta of parameterDecoratorMetadata[methodName]) {
+                                    const { propertyName, key, metadata, parameterIndex } = meta;
+                                    const parameterDecoratorHandler = this.parameterDecoratorMap.get(key);
+                                    if (!parameterDecoratorHandler) {
+                                        throw new error_1.MidwayCommonError(`Parameter Decorator "${key}" handler not found, please register first.`);
+                                    }
+                                    const paramTypes = (0, decorator_1.getMethodParamTypes)(Clzz, propertyName);
+                                    newArgs[parameterIndex] = await parameterDecoratorHandler({
+                                        metadata,
+                                        propertyName,
+                                        parameterIndex,
+                                        target: Clzz,
+                                        originArgs: joinPoint.args,
+                                        originParamType: paramTypes[parameterIndex],
+                                    });
+                                }
+                                joinPoint.args = newArgs;
+                            },
+                        };
+                    });
+                }
+            }
+        });
+        // add custom property decorator listener
+        this.applicationContext.onObjectCreated((instance, options) => {
+            if (this.propertyHandlerMap.size > 0 &&
+                Array.isArray(options.definition.handlerProps)) {
+                // has bind in container
+                for (const item of options.definition.handlerProps) {
+                    this.defineGetterPropertyValue(item, instance, this.getHandler(item.key));
+                }
+            }
+        });
+        // register @ApplicationContext
+        this.registerPropertyHandler(decorator_1.APPLICATION_CONTEXT_KEY, (propertyName, mete) => {
+            return this.applicationContext;
+        });
+    }
+    registerPropertyHandler(decoratorKey, fn) {
+        debug(`[core]: Register property decorator key="${decoratorKey}"`);
+        this.propertyHandlerMap.set(decoratorKey, fn);
+    }
+    registerMethodHandler(decoratorKey, fn) {
+        debug(`[core]: Register method decorator key="${decoratorKey}"`);
+        this.methodDecoratorMap.set(decoratorKey, fn);
+    }
+    registerParameterHandler(decoratorKey, fn) {
+        debug(`[core]: Register parameter decorator key="${decoratorKey}"`);
+        this.parameterDecoratorMap.set(decoratorKey, fn);
+    }
+    /**
+     * binding getter method for decorator
+     *
+     * @param prop
+     * @param instance
+     * @param getterHandler
+     */
+    defineGetterPropertyValue(prop, instance, getterHandler) {
+        if (prop && getterHandler) {
+            if (prop.propertyName) {
+                Object.defineProperty(instance, prop.propertyName, {
+                    get: () => { var _a; return getterHandler(prop.propertyName, (_a = prop.metadata) !== null && _a !== void 0 ? _a : {}, instance); },
+                    configurable: true,
+                    enumerable: true,
+                });
+            }
+        }
+    }
+    getHandler(key) {
+        if (this.propertyHandlerMap.has(key)) {
+            return this.propertyHandlerMap.get(key);
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", aspectService_1.MidwayAspectService)
+], MidwayDecoratorService.prototype, "aspectService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayDecoratorService.prototype, "init", null);
+MidwayDecoratorService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayDecoratorService);
+exports.MidwayDecoratorService = MidwayDecoratorService;
+//# sourceMappingURL=decoratorService.js.map

package/dist/service/environmentService.js

@@ -1,11 +1,18 @@
 "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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayEnvironmentService = void 0;
 const util_1 = require("../util");
-class MidwayEnvironmentService {
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayEnvironmentService = class MidwayEnvironmentService {
     getCurrentEnvironment() {
         if (!this.environment) {
-            this.environment = util_1.getCurrentEnvironment();
+            this.environment = (0, util_1.getCurrentEnvironment)();
         }
         return this.environment;
     }
@@ -13,8 +20,12 @@ class MidwayEnvironmentService {
         this.environment = environment;
     }
     isDevelopmentEnvironment() {
-        return util_1.isDevelopmentEnvironment(this.environment);
+        return (0, util_1.isDevelopmentEnvironment)(this.environment);
     }
-}
+};
+MidwayEnvironmentService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayEnvironmentService);
 exports.MidwayEnvironmentService = MidwayEnvironmentService;
 //# sourceMappingURL=environmentService.js.map

package/dist/service/frameworkService.d.ts

@@ -0,0 +1,26 @@
+import { MidwayFrameworkType } from '@midwayjs/decorator';
+import { IMidwayContainer, IMidwayFramework } from '../interface';
+import { MidwayConfigService } from './configService';
+import { MidwayLoggerService } from './loggerService';
+import { MidwayDecoratorService } from './decoratorService';
+import { MidwayAspectService } from './aspectService';
+import { MidwayApplicationManager } from '../common/applicationManager';
+export declare class MidwayFrameworkService {
+    readonly applicationContext: IMidwayContainer;
+    readonly globalOptions: any;
+    configService: MidwayConfigService;
+    loggerService: MidwayLoggerService;
+    aspectService: MidwayAspectService;
+    decoratorService: MidwayDecoratorService;
+    applicationManager: MidwayApplicationManager;
+    constructor(applicationContext: IMidwayContainer, globalOptions: any);
+    private mainFramework;
+    private globalFrameworkList;
+    protected init(): Promise<void>;
+    getMainApp(): any;
+    getMainFramework(): IMidwayFramework<any, any, any, unknown, unknown>;
+    getFramework(namespaceOrFrameworkType: string | MidwayFrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
+    runFramework(): Promise<void>;
+    stopFramework(): Promise<void>;
+}
+//# sourceMappingURL=frameworkService.d.ts.map

package/dist/service/frameworkService.js

@@ -0,0 +1,176 @@
+"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.MidwayFrameworkService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const interface_1 = require("../interface");
+const configService_1 = require("./configService");
+const loggerService_1 = require("./loggerService");
+const baseFramework_1 = require("../baseFramework");
+const pipelineService_1 = require("./pipelineService");
+const decoratorService_1 = require("./decoratorService");
+const aspectService_1 = require("./aspectService");
+const applicationManager_1 = require("../common/applicationManager");
+const util = require("util");
+const error_1 = require("../error");
+const debug = util.debuglog('midway:debug');
+let MidwayFrameworkService = class MidwayFrameworkService {
+    constructor(applicationContext, globalOptions) {
+        this.applicationContext = applicationContext;
+        this.globalOptions = globalOptions;
+        this.globalFrameworkList = [];
+    }
+    async init() {
+        var _a;
+        // register base config hook
+        this.decoratorService.registerPropertyHandler(decorator_1.CONFIG_KEY, (propertyName, meta) => {
+            var _a;
+            if (meta.identifier === decorator_1.ALL) {
+                return this.configService.getConfiguration();
+            }
+            else {
+                return this.configService.getConfiguration((_a = meta.identifier) !== null && _a !== void 0 ? _a : propertyName);
+            }
+        });
+        // register @Logger decorator handler
+        this.decoratorService.registerPropertyHandler(decorator_1.LOGGER_KEY, (propertyName, meta) => {
+            var _a;
+            return this.loggerService.getLogger((_a = meta.identifier) !== null && _a !== void 0 ? _a : propertyName);
+        });
+        this.decoratorService.registerPropertyHandler(decorator_1.PIPELINE_IDENTIFIER, (key, meta, instance) => {
+            var _a, _b;
+            return new pipelineService_1.MidwayPipelineService((_b = (_a = instance[interface_1.REQUEST_OBJ_CTX_KEY]) === null || _a === void 0 ? void 0 : _a.requestContext) !== null && _b !== void 0 ? _b : this.applicationContext, meta.valves);
+        });
+        let frameworks = (0, decorator_1.listModule)(decorator_1.FRAMEWORK_KEY);
+        // filter proto
+        frameworks = filterProtoFramework(frameworks);
+        debug(`[core]: Found Framework length = ${frameworks.length}`);
+        if (frameworks.length) {
+            for (const frameworkClz of frameworks) {
+                const frameworkInstance = await this.applicationContext.getAsync(frameworkClz, [this.applicationContext]);
+                // if enable, just init framework
+                if (frameworkInstance.isEnable()) {
+                    // app init
+                    await frameworkInstance.initialize({
+                        applicationContext: this.applicationContext,
+                        ...this.globalOptions,
+                    });
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
+                }
+                else {
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and delay initialize.`);
+                }
+                // app init
+                const definition = this.applicationContext.registry.getDefinition((0, decorator_1.getProviderUUId)(frameworkClz));
+                this.applicationManager.addFramework((_a = definition === null || definition === void 0 ? void 0 : definition.namespace) !== null && _a !== void 0 ? _a : frameworkInstance.getFrameworkName(), frameworkInstance);
+                this.globalFrameworkList.push(frameworkInstance);
+            }
+            // register @App decorator handler
+            this.decoratorService.registerPropertyHandler(decorator_1.APPLICATION_KEY, (propertyName, mete) => {
+                if (mete.type) {
+                    const framework = this.applicationManager.getApplication(mete.type);
+                    if (!framework) {
+                        throw new error_1.MidwayCommonError(`Framework ${mete.type} not Found`);
+                    }
+                    return framework;
+                }
+                else {
+                    return this.getMainApp();
+                }
+            });
+            this.decoratorService.registerPropertyHandler(decorator_1.PLUGIN_KEY, (key, target) => {
+                return this.getMainApp()[key];
+            });
+            global['MIDWAY_MAIN_FRAMEWORK'] = this.mainFramework =
+                this.globalFrameworkList[0];
+        }
+        // init aspect module
+        await this.aspectService.loadAspect();
+        // some preload module init
+        const modules = (0, decorator_1.listPreloadModule)();
+        for (const module of modules) {
+            // preload init context
+            await this.applicationContext.getAsync(module);
+        }
+    }
+    getMainApp() {
+        var _a;
+        return (_a = this.mainFramework) === null || _a === void 0 ? void 0 : _a.getApplication();
+    }
+    getMainFramework() {
+        return this.mainFramework;
+    }
+    getFramework(namespaceOrFrameworkType) {
+        return this.applicationManager.getFramework(namespaceOrFrameworkType);
+    }
+    async runFramework() {
+        for (const frameworkInstance of this.globalFrameworkList) {
+            // if enable, just init framework
+            if (frameworkInstance.isEnable()) {
+                // app init
+                await frameworkInstance.run();
+                debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and run.`);
+            }
+        }
+    }
+    async stopFramework() {
+        await Promise.all(Array.from(this.globalFrameworkList).map(frameworkInstance => {
+            return frameworkInstance.stop();
+        }));
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayFrameworkService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", loggerService_1.MidwayLoggerService)
+], MidwayFrameworkService.prototype, "loggerService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", aspectService_1.MidwayAspectService)
+], MidwayFrameworkService.prototype, "aspectService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", decoratorService_1.MidwayDecoratorService)
+], MidwayFrameworkService.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", applicationManager_1.MidwayApplicationManager)
+], MidwayFrameworkService.prototype, "applicationManager", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayFrameworkService.prototype, "init", null);
+MidwayFrameworkService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object, Object])
+], MidwayFrameworkService);
+exports.MidwayFrameworkService = MidwayFrameworkService;
+function filterProtoFramework(frameworks) {
+    const frameworkProtoArr = [];
+    // 这里把继承的框架父类都找出来，然后排除掉，只取第一层
+    for (const framework of frameworks) {
+        let proto = Object.getPrototypeOf(framework);
+        while (proto.name && proto.name !== baseFramework_1.BaseFramework.name) {
+            frameworkProtoArr.push(proto);
+            proto = Object.getPrototypeOf(proto);
+        }
+    }
+    return frameworks.filter(framework => {
+        return !frameworkProtoArr.includes(framework);
+    });
+}
+//# sourceMappingURL=frameworkService.js.map

package/dist/service/informationService.d.ts

@@ -1,12 +1,9 @@
 import { IInformationService } from '../interface';
 export declare class MidwayInformationService implements IInformationService {
-    protected pkg: Record<string, unknown>;
-    private readonly appDir;
-    private readonly baseDir;
-    constructor(options: {
-        baseDir?: string;
-        appDir?: string;
-    });
+    private pkg;
+    protected appDir: string;
+    protected baseDir: string;
+    protected init(): void;
     getAppDir(): string;
     getBaseDir(): string;
     getHome(): string;

package/dist/service/informationService.js

@@ -1,16 +1,29 @@
 "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.MidwayInformationService = void 0;
 const util_1 = require("../util");
 const path_1 = require("path");
-class MidwayInformationService {
-    constructor(options) {
-        this.baseDir = options.baseDir;
-        this.appDir = options.appDir;
-        if (!this.appDir) {
-            this.appDir = path_1.dirname(this.baseDir);
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayInformationService = class MidwayInformationService {
+    init() {
+        if (this.baseDir) {
+            if (!this.appDir) {
+                this.appDir = (0, path_1.dirname)(this.baseDir);
+            }
+            this.pkg = (0, util_1.safeRequire)((0, path_1.join)(this.appDir, 'package.json')) || {};
+        }
+        else {
+            this.pkg = {};
         }
-        this.pkg = util_1.safeRequire(path_1.join(this.appDir, 'package.json')) || {};
     }
     getAppDir() {
         return this.appDir;
@@ -19,7 +32,7 @@ class MidwayInformationService {
         return this.baseDir;
     }
     getHome() {
-        return util_1.getUserHome();
+        return (0, util_1.getUserHome)();
     }
     getPkg() {
         return this.pkg;
@@ -29,9 +42,27 @@ class MidwayInformationService {
         return ((_a = this.pkg) === null || _a === void 0 ? void 0 : _a['name']) || '';
     }
     getRoot() {
-        const isDevelopmentEnv = util_1.isDevelopmentEnvironment(util_1.getCurrentEnvironment());
+        const isDevelopmentEnv = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
         return isDevelopmentEnv ? this.getAppDir() : this.getHome();
     }
-}
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", String)
+], MidwayInformationService.prototype, "appDir", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", String)
+], MidwayInformationService.prototype, "baseDir", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], MidwayInformationService.prototype, "init", null);
+MidwayInformationService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayInformationService);
 exports.MidwayInformationService = MidwayInformationService;
 //# sourceMappingURL=informationService.js.map

package/dist/service/lifeCycleService.d.ts

@@ -0,0 +1,14 @@
+import { IMidwayContainer } from '../interface';
+import { MidwayFrameworkService } from './frameworkService';
+import { MidwayConfigService } from './configService';
+export declare class MidwayLifeCycleService {
+    readonly applicationContext: IMidwayContainer;
+    protected frameworkService: MidwayFrameworkService;
+    protected configService: MidwayConfigService;
+    constructor(applicationContext: IMidwayContainer);
+    protected init(): Promise<void>;
+    stop(): Promise<void>;
+    private runContainerLifeCycle;
+    private runObjectLifeCycle;
+}
+//# sourceMappingURL=lifeCycleService.d.ts.map

package/dist/service/lifeCycleService.js

@@ -0,0 +1,130 @@
+"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.MidwayLifeCycleService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const configuration_1 = require("../functional/configuration");
+const frameworkService_1 = require("./frameworkService");
+const configService_1 = require("./configService");
+const util_1 = require("util");
+const debug = (0, util_1.debuglog)('midway:debug');
+let MidwayLifeCycleService = class MidwayLifeCycleService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+    }
+    async init() {
+        // 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) {
+                // 函数式写法
+                cycle.instance = cycle.target;
+            }
+            else {
+                // 普通类写法
+                debug(`[core]: run ${cycle.target.name} init`);
+                cycle.instance = await this.applicationContext.getAsync(cycle.target);
+            }
+            cycle.instance && 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'),
+        ]);
+        // bind framework lifecycle
+        // onAppError
+        // exec onConfigLoad()
+        await this.runContainerLifeCycle(lifecycleInstanceList, 'onConfigLoad', configData => {
+            if (configData) {
+                this.configService.addObject(configData);
+            }
+        });
+        // exec onReady()
+        await this.runContainerLifeCycle(lifecycleInstanceList, 'onReady');
+        // exec framework.run()
+        await this.frameworkService.runFramework();
+        // exec onServerReady()
+        await this.runContainerLifeCycle(lifecycleInstanceList, 'onServerReady');
+    }
+    async stop() {
+        // stop lifecycle
+        const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
+        for (const cycle of cycles) {
+            let inst;
+            if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
+                // 函数式写法
+                inst = cycle.target;
+            }
+            else {
+                inst = await this.applicationContext.getAsync(cycle.target);
+            }
+            await this.runContainerLifeCycle(inst, 'onStop');
+        }
+        // stop framework
+        await this.frameworkService.stopFramework();
+    }
+    async runContainerLifeCycle(lifecycleInstanceOrList, lifecycle, resultHandler) {
+        if (Array.isArray(lifecycleInstanceOrList)) {
+            for (const cycle of lifecycleInstanceOrList) {
+                if (typeof cycle.instance[lifecycle] === 'function') {
+                    debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                    const result = await cycle.instance[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
+                    if (resultHandler) {
+                        resultHandler(result);
+                    }
+                }
+            }
+        }
+        else {
+            if (typeof lifecycleInstanceOrList[lifecycle] === 'function') {
+                debug(`[core]: run ${lifecycleInstanceOrList.constructor.name} ${lifecycle}`);
+                const result = await lifecycleInstanceOrList[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
+                if (resultHandler) {
+                    resultHandler(result);
+                }
+            }
+        }
+    }
+    async runObjectLifeCycle(lifecycleInstanceList, lifecycle) {
+        for (const cycle of lifecycleInstanceList) {
+            if (typeof cycle.instance[lifecycle] === 'function') {
+                debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                return this.applicationContext[lifecycle](cycle.instance[lifecycle].bind(cycle.instance));
+            }
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", frameworkService_1.MidwayFrameworkService)
+], MidwayLifeCycleService.prototype, "frameworkService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayLifeCycleService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayLifeCycleService.prototype, "init", null);
+MidwayLifeCycleService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayLifeCycleService);
+exports.MidwayLifeCycleService = MidwayLifeCycleService;
+//# sourceMappingURL=lifeCycleService.js.map

package/dist/service/loggerService.d.ts

@@ -0,0 +1,27 @@
+import { MidwayConfigService } from './configService';
+import { ServiceFactory } from '../common/serviceFactory';
+import { ILogger } from '@midwayjs/logger';
+import { IMidwayContainer } from '../interface';
+export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
+    readonly applicationContext: IMidwayContainer;
+    configService: MidwayConfigService;
+    constructor(applicationContext: IMidwayContainer);
+    protected init(): Promise<void>;
+    transformEggConfig(): {
+        midwayLogger: {
+            default: {};
+            clients: {};
+        };
+    };
+    protected createClient(config: any, name?: string): Promise<void>;
+    getName(): string;
+    createLogger(name: any, config: any): ILogger;
+    getLogger(name: string): ILogger;
+    transformEggLogger(options: any): {
+        midwayLogger: {
+            default: {};
+            clients: {};
+        };
+    };
+}
+//# sourceMappingURL=loggerService.d.ts.map