@midwayjs/web 3.0.14-beta.1 → 3.0.14-beta.2

package/dist/base.js

@@ -8,6 +8,8 @@ const fs_1 = require("fs");
 const logger_1 = require("./logger");
 const router_1 = require("@eggjs/router");
 const util_1 = require("util");
+const lifecycle_1 = require("./framework/lifecycle");
+const web_1 = require("./framework/web");
 const ROUTER = Symbol('EggCore#router');
 const EGG_LOADER = Symbol.for('egg#loader');
 const EGG_PATH = Symbol.for('egg#eggPath');
@@ -111,6 +113,7 @@ const createAppWorkerLoader = () => {
                 this.app.beforeStart(async () => {
                     debug('[egg]: start "initialize framework service with lazy in app.load"');
                     const applicationContext = (0, core_1.getCurrentApplicationContext)();
+                    applicationContext.bind(lifecycle_1.MidwayWebLifeCycleService);
                     /**
                      * 这里 logger service 已经被 get loggers() 初始化过了，就不需要在这里初始化了
                      */
@@ -121,10 +124,17 @@ const createAppWorkerLoader = () => {
                             application: this.app,
                         },
                     ]);
-                    // lifecycle support
-                    await applicationContext.getAsync(core_1.MidwayLifeCycleService, [
-                        applicationContext,
-                    ]);
+                    this.app.once('server', async (server) => {
+                        this.framework.setServer(server);
+                        // register httpServer to applicationContext
+                        applicationContext.registerObject(core_1.HTTP_SERVER_KEY, server);
+                        await this.lifecycleService.afterInit();
+                    });
+                    // 这里生命周期走到 onReady
+                    this.lifecycleService = await applicationContext.getAsync(lifecycle_1.MidwayWebLifeCycleService, [applicationContext]);
+                    // 执行加载路由
+                    this.framework = await applicationContext.getAsync(web_1.MidwayWebFramework);
+                    await this.framework.loadMidwayController();
                 });
             }
         }

package/dist/configuration.d.ts

@@ -1,15 +1,13 @@
 import { IMidwayWebApplication } from './interface';
 import { MidwayDecoratorService } from '@midwayjs/core';
-import { MidwayWebFramework } from './framework/web';
 export declare class EggConfiguration {
     baseDir: any;
     appDir: any;
     app: IMidwayWebApplication;
     decoratorService: MidwayDecoratorService;
-    framework: MidwayWebFramework;
     init(): void;
     onReady(): Promise<void>;
-    onServerReady(container: any): Promise<void>;
+    onServerReady(): Promise<void>;
     onStop(): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -13,7 +13,6 @@ exports.EggConfiguration = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const core_1 = require("@midwayjs/core");
 const path_1 = require("path");
-const web_1 = require("./framework/web");
 let EggConfiguration = class EggConfiguration {
     init() {
         this.decoratorService.registerParameterHandler(decorator_1.WEB_ROUTER_PARAM_KEY, options => {
@@ -28,16 +27,9 @@ let EggConfiguration = class EggConfiguration {
                 ? this.app.middleware.slice()
                 : [];
     }
-    async onServerReady(container) {
+    async onServerReady() {
         // trigger server didReady
         this.app.messenger.emit('egg-ready');
-        if (process.env['EGG_CLUSTER_MODE'] === 'true') {
-            this.app.once('server', server => {
-                this.framework.setServer(server);
-                // register httpServer to applicationContext
-                container.registerObject(core_1.HTTP_SERVER_KEY, server);
-            });
-        }
     }
     async onStop() {
         // TODO flush egg logger and close it
@@ -59,10 +51,6 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", core_1.MidwayDecoratorService)
 ], EggConfiguration.prototype, "decoratorService", void 0);
-__decorate([
-    (0, decorator_1.Inject)(),
-    __metadata("design:type", web_1.MidwayWebFramework)
-], EggConfiguration.prototype, "framework", void 0);
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),

package/dist/framework/lifecycle.d.ts

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

package/dist/framework/lifecycle.js

@@ -0,0 +1,137 @@
+"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.MidwayWebLifeCycleService = void 0;
+const core_1 = require("@midwayjs/core");
+const decorator_1 = require("@midwayjs/decorator");
+const configuration_1 = require("@midwayjs/core/dist/functional/configuration");
+const util_1 = require("util");
+const debug = (0, util_1.debuglog)('midway:debug');
+let MidwayWebLifeCycleService = class MidwayWebLifeCycleService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+        this.lifecycleInstanceList = [];
+    }
+    async init() {
+        // run lifecycle
+        const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
+        debug(`[core]: Found Configuration length = ${cycles.length}`);
+        for (const cycle of cycles) {
+            if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
+                // 函数式写法
+                cycle.instance = cycle.target;
+            }
+            else {
+                // 普通类写法
+                debug(`[core]: Lifecycle run ${cycle.target.name} init`);
+                cycle.instance = await this.applicationContext.getAsync(cycle.target);
+            }
+            if (cycle.instance) {
+                this.lifecycleInstanceList.push(cycle);
+            }
+        }
+        // bind object lifecycle
+        await Promise.all([
+            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(this.lifecycleInstanceList, 'onConfigLoad', configData => {
+            if (configData) {
+                this.configService.addObject(configData);
+            }
+        });
+        // exec onReady()
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onReady');
+    }
+    async afterInit() {
+        // exec framework.run()
+        await this.frameworkService.runFramework();
+        // exec onServerReady()
+        await this.runContainerLifeCycle(this.lifecycleInstanceList, 'onServerReady');
+        // clear config merge cache
+        if (!this.configService.getConfiguration('debug.recordConfigMergeOrder')) {
+            this.configService.clearConfigMergeOrder();
+        }
+    }
+    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]: Lifecycle 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]: Lifecycle 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]: Lifecycle run ${cycle.instance.constructor.name} ${lifecycle}`);
+                return this.applicationContext[lifecycle](cycle.instance[lifecycle].bind(cycle.instance));
+            }
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayFrameworkService)
+], MidwayWebLifeCycleService.prototype, "frameworkService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayConfigService)
+], MidwayWebLifeCycleService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayWebLifeCycleService.prototype, "init", null);
+MidwayWebLifeCycleService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayWebLifeCycleService);
+exports.MidwayWebLifeCycleService = MidwayWebLifeCycleService;
+//# sourceMappingURL=lifecycle.js.map

package/dist/framework/web.js

@@ -147,26 +147,27 @@ let MidwayWebFramework = class MidwayWebFramework extends core_1.BaseFramework {
         this.setContextLoggerClass();
     }
     async loadMidwayController() {
+        // move egg router to last
+        this.app.getMiddleware().findAndInsertLast('eggRouterMiddleware');
         await this.generator.loadMidwayController(this.configurationOptions.globalPrefix, newRouter => {
             var _a;
             const dispatchFn = newRouter.middleware();
             dispatchFn._name = `midwayController(${((_a = newRouter === null || newRouter === void 0 ? void 0 : newRouter.opts) === null || _a === void 0 ? void 0 : _a.prefix) || '/'})`;
             this.app.useMiddleware(dispatchFn);
         });
+        // restore use method
+        this.app.use = this.app.originUse;
+        debug(`[egg]: current middleware = ${this.middlewareManager.getNames()}`);
     }
     getFrameworkType() {
         return decorator_1.MidwayFrameworkType.WEB;
     }
     async run() {
         var _a;
-        // move egg router to last
-        this.app.getMiddleware().findAndInsertLast('eggRouterMiddleware');
-        // load controller
-        await this.loadMidwayController();
-        // restore use method
-        this.app.use = this.app.originUse;
-        debug(`[egg]: current middleware = ${this.middlewareManager.getNames()}`);
+        // cluster 模式加载路由需在 run 之前，因为 run 需要在拿到 server 之后执行
         if (!this.isClusterMode) {
+            // load controller
+            await this.loadMidwayController();
             // https config
             if (this.configurationOptions.key && this.configurationOptions.cert) {
                 this.configurationOptions.key = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.key);

package/dist/interface.d.ts

@@ -86,7 +86,7 @@ export interface IWebMiddleware {
     resolve(): MidwayWebMiddleware;
 }
 declare module '@midwayjs/core/dist/interface' {
-    interface MidwayConfig extends EggAppConfig {
+    interface MidwayConfig extends Partial<EggAppConfig> {
         egg?: IMidwayWebConfigurationOptions;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/web",
-  "version": "3.0.14-beta.1",
+  "version": "3.0.14-beta.2",
   "description": "Midway Web Framework for Egg.js",
   "main": "dist/index",
   "typings": "dist/index.d.ts",