@midwayjs/core 3.0.0-beta.1 → 3.0.0-beta.13

package/dist/service/frameworkService.d.ts

@@ -4,6 +4,7 @@ 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;
@@ -11,14 +12,15 @@ export declare class MidwayFrameworkService {
     loggerService: MidwayLoggerService;
     aspectService: MidwayAspectService;
     decoratorService: MidwayDecoratorService;
+    applicationManager: MidwayApplicationManager;
     constructor(applicationContext: IMidwayContainer, globalOptions: any);
     private mainFramework;
-    private globalFrameworkMap;
     private globalFrameworkList;
-    init(): Promise<void>;
+    protected init(): Promise<void>;
     getMainApp(): any;
-    getMainFramework(): IMidwayFramework<any, any>;
-    getFramework(type: MidwayFrameworkType): IMidwayFramework<any, 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

@@ -18,6 +18,7 @@ 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');
@@ -25,10 +26,10 @@ let MidwayFrameworkService = class MidwayFrameworkService {
     constructor(applicationContext, globalOptions) {
         this.applicationContext = applicationContext;
         this.globalOptions = globalOptions;
-        this.globalFrameworkMap = new WeakMap();
         this.globalFrameworkList = [];
     }
     async init() {
+        var _a;
         // register base config hook
         this.decoratorService.registerPropertyHandler(decorator_1.CONFIG_KEY, (propertyName, meta) => {
             var _a;
@@ -51,7 +52,7 @@ let MidwayFrameworkService = class MidwayFrameworkService {
         let frameworks = (0, decorator_1.listModule)(decorator_1.FRAMEWORK_KEY);
         // filter proto
         frameworks = filterProtoFramework(frameworks);
-        debug(`[core:framework]: Found Framework length = ${frameworks.length}`);
+        debug(`[core]: Found Framework length = ${frameworks.length}`);
         if (frameworks.length) {
             for (const frameworkClz of frameworks) {
                 const frameworkInstance = await this.applicationContext.getAsync(frameworkClz, [this.applicationContext]);
@@ -62,24 +63,24 @@ let MidwayFrameworkService = class MidwayFrameworkService {
                         applicationContext: this.applicationContext,
                         ...this.globalOptions,
                     });
-                    debug(`[core:framework]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
                 }
                 else {
-                    debug(`[core:framework]: Found Framework "${frameworkInstance.getFrameworkName()}" and delay initialize.`);
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and delay initialize.`);
                 }
                 // app init
-                this.globalFrameworkMap.set(frameworkInstance.getFrameworkType(), frameworkInstance);
+                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) {
-                    if (this.globalFrameworkMap.has(mete.type)) {
-                        return this.globalFrameworkMap.get(mete.type).getApplication();
-                    }
-                    else {
+                    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();
@@ -107,8 +108,18 @@ let MidwayFrameworkService = class MidwayFrameworkService {
     getMainFramework() {
         return this.mainFramework;
     }
-    getFramework(type) {
-        return this.globalFrameworkMap.get(type);
+    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 => {
@@ -132,6 +143,10 @@ __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),

package/dist/service/lifeCycleService.js

@@ -23,7 +23,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
     async init() {
         // run lifecycle
         const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
-        debug(`[core:lifecycle]: Found Configuration length = ${cycles.length}`);
+        debug(`[core]: Found Configuration length = ${cycles.length}`);
         const lifecycleInstanceList = [];
         for (const cycle of cycles) {
             if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
@@ -32,7 +32,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
             }
             else {
                 // 普通类写法
-                debug(`[core:lifecycle]: run ${cycle.target.name} init`);
+                debug(`[core]: run ${cycle.target.name} init`);
                 cycle.instance = await this.applicationContext.getAsync(cycle.target);
             }
             cycle.instance && lifecycleInstanceList.push(cycle);
@@ -54,6 +54,8 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         });
         // exec onReady()
         await this.runContainerLifeCycle(lifecycleInstanceList, 'onReady');
+        // exec framework.run()
+        await this.frameworkService.runFramework();
         // exec onServerReady()
         await this.runContainerLifeCycle(lifecycleInstanceList, 'onServerReady');
     }
@@ -78,7 +80,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         if (Array.isArray(lifecycleInstanceOrList)) {
             for (const cycle of lifecycleInstanceOrList) {
                 if (typeof cycle.instance[lifecycle] === 'function') {
-                    debug(`[core:lifecycle]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                    debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
                     const result = await cycle.instance[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
                     if (resultHandler) {
                         resultHandler(result);
@@ -88,7 +90,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
         }
         else {
             if (typeof lifecycleInstanceOrList[lifecycle] === 'function') {
-                debug(`[core:lifecycle]: run ${lifecycleInstanceOrList.constructor.name} ${lifecycle}`);
+                debug(`[core]: run ${lifecycleInstanceOrList.constructor.name} ${lifecycle}`);
                 const result = await lifecycleInstanceOrList[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
                 if (resultHandler) {
                     resultHandler(result);
@@ -99,7 +101,7 @@ let MidwayLifeCycleService = class MidwayLifeCycleService {
     async runObjectLifeCycle(lifecycleInstanceList, lifecycle) {
         for (const cycle of lifecycleInstanceList) {
             if (typeof cycle.instance[lifecycle] === 'function') {
-                debug(`[core:lifecycle]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
                 return this.applicationContext[lifecycle](cycle.instance[lifecycle].bind(cycle.instance));
             }
         }

package/dist/service/loggerService.d.ts

@@ -1,5 +1,5 @@
 import { MidwayConfigService } from './configService';
-import { ServiceFactory } from '../util/serviceFactory';
+import { ServiceFactory } from '../common/serviceFactory';
 import { ILogger } from '@midwayjs/logger';
 import { IMidwayContainer } from '../interface';
 export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
@@ -15,7 +15,6 @@ export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     };
     protected createClient(config: any, name?: string): Promise<void>;
     getName(): string;
-    destroy(): Promise<void>;
     createLogger(name: any, config: any): ILogger;
     getLogger(name: string): ILogger;
     transformEggLogger(options: any): {

package/dist/service/loggerService.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayLoggerService = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const configService_1 = require("./configService");
-const serviceFactory_1 = require("../util/serviceFactory");
+const serviceFactory_1 = require("../common/serviceFactory");
 const logger_1 = require("@midwayjs/logger");
 const levelTransform = level => {
     if (!level) {
@@ -73,9 +73,6 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
     getName() {
         return 'logger';
     }
-    async destroy() {
-        logger_1.loggers.close();
-    }
     createLogger(name, config) {
         return logger_1.loggers.createLogger(name, config);
     }
@@ -119,12 +116,6 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], MidwayLoggerService.prototype, "init", null);
-__decorate([
-    (0, decorator_1.Destroy)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], MidwayLoggerService.prototype, "destroy", null);
 MidwayLoggerService = __decorate([
     (0, decorator_1.Provide)(),
     (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),

package/dist/service/middlewareService.d.ts

@@ -1,11 +1,10 @@
-import { CommonMiddleware, IMidwayContainer } from '../interface';
-export declare class MidwayMiddlewareService<T> {
+import { CommonMiddleware, IMidwayContainer, IMidwayApplication } from '../interface';
+export declare class MidwayMiddlewareService<T, R, N = unknown> {
     readonly applicationContext: IMidwayContainer;
     constructor(applicationContext: IMidwayContainer);
-    compose(middleware: Array<CommonMiddleware<T> | string>, name?: string): Promise<{
+    compose(middleware: Array<CommonMiddleware<T, R, N> | string>, app: IMidwayApplication, name?: string): Promise<{
         (context: any, next?: any): Promise<any>;
         _name: string;
     }>;
 }
-export declare function pathMatching(options: any): (ctx?: any) => any;
 //# sourceMappingURL=middlewareService.d.ts.map

package/dist/service/middlewareService.js

@@ -9,15 +9,15 @@ 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.pathMatching = exports.MidwayMiddlewareService = void 0;
+exports.MidwayMiddlewareService = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const pathToRegexp_1 = require("../util/pathToRegexp");
 const error_1 = require("../error");
+const util_1 = require("../util");
 let MidwayMiddlewareService = class MidwayMiddlewareService {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
     }
-    async compose(middleware, name) {
+    async compose(middleware, app, name) {
         if (!Array.isArray(middleware)) {
             throw new error_1.MidwayParameterError('Middleware stack must be an array');
         }
@@ -30,16 +30,18 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                 }
                 const classMiddleware = await this.applicationContext.getAsync(fn);
                 if (classMiddleware) {
-                    fn = classMiddleware.resolve();
+                    fn = classMiddleware.resolve(app);
                     if (!classMiddleware.match && !classMiddleware.ignore) {
-                        fn._name = classMiddleware.constructor.name;
+                        if (!fn.name) {
+                            fn._name = classMiddleware.constructor.name;
+                        }
                         // just got fn
                         newMiddlewareArr.push(fn);
                     }
                     else {
                         // wrap ignore and match
                         const mw = fn;
-                        const match = pathMatching({
+                        const match = (0, util_1.pathMatching)({
                             match: classMiddleware.match,
                             ignore: classMiddleware.ignore,
                         });
@@ -67,6 +69,7 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
          * @api public
          */
         const composeFn = (context, next) => {
+            const supportBody = (0, util_1.isIncludeProperty)(context, 'body');
             // last called middleware #
             let index = -1;
             return dispatch(0);
@@ -80,9 +83,25 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                 if (!fn)
                     return Promise.resolve();
                 try {
-                    return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
-                        index,
-                    }));
+                    if (supportBody) {
+                        return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
+                            index,
+                        })).then(result => {
+                            // need to set body
+                            if (context.body && !result) {
+                                result = context.body;
+                            }
+                            else if (result && context.body !== result) {
+                                context.body = result;
+                            }
+                            return result;
+                        });
+                    }
+                    else {
+                        return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
+                            index,
+                        }));
+                    }
                 }
                 catch (err) {
                     return Promise.reject(err);
@@ -101,41 +120,4 @@ MidwayMiddlewareService = __decorate([
     __metadata("design:paramtypes", [Object])
 ], MidwayMiddlewareService);
 exports.MidwayMiddlewareService = MidwayMiddlewareService;
-function pathMatching(options) {
-    options = options || {};
-    if (options.match && options.ignore)
-        throw new error_1.MidwayCommonError('options.match and options.ignore can not both present');
-    if (!options.match && !options.ignore)
-        return () => true;
-    const matchFn = options.match
-        ? toPathMatch(options.match)
-        : toPathMatch(options.ignore);
-    return function pathMatch(ctx) {
-        const matched = matchFn(ctx);
-        return options.match ? matched : !matched;
-    };
-}
-exports.pathMatching = pathMatching;
-function toPathMatch(pattern) {
-    if (typeof pattern === 'string') {
-        const reg = (0, pathToRegexp_1.pathToRegexp)(pattern, [], { end: false });
-        if (reg.global)
-            reg.lastIndex = 0;
-        return ctx => reg.test(ctx.path);
-    }
-    if (pattern instanceof RegExp) {
-        return ctx => {
-            if (pattern.global)
-                pattern.lastIndex = 0;
-            return pattern.test(ctx.path);
-        };
-    }
-    if (typeof pattern === 'function')
-        return pattern;
-    if (Array.isArray(pattern)) {
-        const matchs = pattern.map(item => toPathMatch(item));
-        return ctx => matchs.some(match => match(ctx));
-    }
-    throw new error_1.MidwayCommonError('match/ignore pattern must be RegExp, Array or String, but got ' + pattern);
-}
 //# sourceMappingURL=middlewareService.js.map

package/dist/setup.js

@@ -6,6 +6,7 @@ const config_default_1 = require("./config/config.default");
 const decorator_1 = require("@midwayjs/decorator");
 const util = require("util");
 const path_1 = require("path");
+const logger_1 = require("@midwayjs/logger");
 const debug = util.debuglog('midway:debug');
 async function initializeGlobalApplicationContext(globalOptions) {
     var _a, _b, _c, _d;
@@ -21,7 +22,7 @@ async function initializeGlobalApplicationContext(globalOptions) {
     // register baseDir and appDir
     applicationContext.registerObject('baseDir', baseDir);
     applicationContext.registerObject('appDir', appDir);
-    if (globalOptions.moduleDirector !== false) {
+    if (globalOptions.moduleDetector !== false) {
         if (globalOptions.moduleDetector === undefined ||
             globalOptions.moduleDetector === 'file') {
             applicationContext.setFileDetector(new _1.DirectoryFileDetector({
@@ -43,6 +44,7 @@ async function initializeGlobalApplicationContext(globalOptions) {
     applicationContext.bindClass(_1.MidwayFrameworkService);
     applicationContext.bindClass(_1.MidwayMiddlewareService);
     applicationContext.bindClass(_1.MidwayLifeCycleService);
+    applicationContext.bindClass(_1.MidwayApplicationManager);
     // bind preload module
     if (globalOptions.preloadModules && globalOptions.preloadModules.length) {
         for (const preloadModule of globalOptions.preloadModules) {
@@ -74,7 +76,12 @@ async function initializeGlobalApplicationContext(globalOptions) {
     // bind user code module
     await applicationContext.ready();
     if (globalOptions.globalConfig) {
-        configService.add([globalOptions.globalConfig]);
+        if (Array.isArray(globalOptions.globalConfig)) {
+            configService.add(globalOptions.globalConfig);
+        }
+        else {
+            configService.addObject(globalOptions.globalConfig);
+        }
     }
     // merge config
     await configService.load();
@@ -104,6 +111,7 @@ async function destroyGlobalApplicationContext(applicationContext) {
     // stop container
     await applicationContext.stop();
     (0, decorator_1.clearBindContainer)();
+    logger_1.loggers.close();
     global['MIDWAY_APPLICATION_CONTEXT'] = undefined;
     global['MIDWAY_MAIN_FRAMEWORK'] = undefined;
 }

package/dist/util/contextUtil.d.ts

@@ -1,5 +1,5 @@
 import { IConfigurationOptions, IMidwayContainer, IMidwayFramework } from '../interface';
 export declare const getCurrentApplicationContext: () => IMidwayContainer;
-export declare const getCurrentMainFramework: <APP extends import("../interface").IMidwayBaseApplication<import("../interface").Context>, T extends IConfigurationOptions>() => IMidwayFramework<APP, T>;
+export declare const getCurrentMainFramework: <APP extends import("../interface").IMidwayBaseApplication<CTX>, CTX extends import("../interface").Context, CONFIG extends IConfigurationOptions>() => IMidwayFramework<APP, CTX, CONFIG, unknown, unknown>;
 export declare const getCurrentMainApp: <APP extends import("../interface").IMidwayBaseApplication<import("../interface").Context>>() => APP;
 //# sourceMappingURL=contextUtil.d.ts.map

package/dist/util/index.d.ts

@@ -1,5 +1,18 @@
+import { FunctionMiddleware } from '../interface';
+/**
+ * @since 2.0.0
+ * @param env
+ */
 export declare const isDevelopmentEnvironment: (env: any) => boolean;
+/**
+ * @since 2.0.0
+ */
 export declare const getCurrentEnvironment: () => string;
+/**
+ * @param p
+ * @param enabledCache
+ * @since 2.0.0
+ */
 export declare const safeRequire: (p: any, enabledCache?: boolean) => any;
 /**
  *  safelyGet(['a','b'],{a: {b: 2}})  // => 2
@@ -8,11 +21,13 @@ export declare const safeRequire: (p: any, enabledCache?: boolean) => any;
  *  safelyGet(['a','1'],{a: {b: 2}})  // => undefined
  *  safelyGet('a.b',{a: {b: 2}})  // => 2
  *  safelyGet('a.b',{c: {b: 2}})  // => undefined
+ *  @since 2.0.0
  */
 export declare function safelyGet(list: string | string[], obj?: Record<string, unknown>): any;
 /**
  * 剔除 @ 符号
  * @param provideId provideId
+ * @since 2.0.0
  */
 export declare function parsePrefix(provideId: string): string;
 export declare function getUserHome(): string;
@@ -21,19 +36,50 @@ export declare function joinURLPath(...strArray: any[]): string;
  * 代理目标所有的原型方法，不包括构造器和内部隐藏方法
  * @param derivedCtor
  * @param constructors
+ * @since 2.0.0
  */
 export declare function delegateTargetPrototypeMethod(derivedCtor: any, constructors: any[]): void;
 /**
  * 代理目标原型上的特定方法
  * @param derivedCtor
  * @param methods
+ * @since 2.0.0
  */
 export declare function delegateTargetMethod(derivedCtor: any, methods: string[]): void;
 /**
  * 代理目标原型属性
  * @param derivedCtor
  * @param properties
+ * @since 2.0.0
  */
 export declare function delegateTargetProperties(derivedCtor: any, properties: string[]): void;
+/**
+ * 代理目标原型属性
+ * @since 2.0.0
+ * @param timestamp
+ */
 export declare const getCurrentDateString: (timestamp?: number) => string;
+/**
+ *
+ * @param message
+ * @since 3.0.0
+ */
+export declare const deprecatedOutput: (message: string) => void;
+/**
+ * transform request object to definition type
+ *
+ * @param originValue
+ * @param targetType
+ * @since 3.0.0
+ */
+export declare const transformRequestObjectByType: (originValue: any, targetType?: any) => any;
+export declare function toPathMatch(pattern: any): any;
+export declare function pathMatching(options: any): (ctx?: any) => any;
+/**
+ * wrap function middleware with match and ignore
+ * @param mw
+ * @param 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;
 //# sourceMappingURL=index.d.ts.map