@midwayjs/core 3.0.0-beta.2 → 3.0.0-beta.6

package/CHANGELOG.md

@@ -3,6 +3,58 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.0.0-beta.6](https://github.com/midwayjs/midway/compare/v3.0.0-beta.5...v3.0.0-beta.6) (2021-11-26)
+
+
+### Bug Fixes
+
+* class transformer method missing ([#1387](https://github.com/midwayjs/midway/issues/1387)) ([074e839](https://github.com/midwayjs/midway/commit/074e8393598dc95e2742f735df75a2191c5fe25d))
+
+
+
+
+
+# [3.0.0-beta.5](https://github.com/midwayjs/midway/compare/v3.0.0-beta.4...v3.0.0-beta.5) (2021-11-25)
+
+
+### Bug Fixes
+
+* [@match](https://github.com/match) empty args ([#1384](https://github.com/midwayjs/midway/issues/1384)) ([6f90fc9](https://github.com/midwayjs/midway/commit/6f90fc993ff01e078288ff664833c61c02dede51))
+* router sort ([#1383](https://github.com/midwayjs/midway/issues/1383)) ([f253887](https://github.com/midwayjs/midway/commit/f2538876d3eaf7dec55173d86b5b9caeeeb7be64))
+
+
+
+
+
+# [3.0.0-beta.4](https://github.com/midwayjs/midway/compare/v3.0.0-beta.3...v3.0.0-beta.4) (2021-11-24)
+
+
+### Bug Fixes
+
+* logger close before bootstrap close ([#1370](https://github.com/midwayjs/midway/issues/1370)) ([6cc2720](https://github.com/midwayjs/midway/commit/6cc2720ed3445e8ffccc96d124b80ed7e2517f08))
+
+
+### Features
+
+* add i18n ([#1375](https://github.com/midwayjs/midway/issues/1375)) ([bffefe0](https://github.com/midwayjs/midway/commit/bffefe07afe45777d49b5a76b9ab17fc2b9d9a55))
+* auto transform args to type ([#1372](https://github.com/midwayjs/midway/issues/1372)) ([bb3f7d2](https://github.com/midwayjs/midway/commit/bb3f7d2028a034e1926d9df554849332354c3762))
+* support global prefix url ([#1371](https://github.com/midwayjs/midway/issues/1371)) ([cc5fe44](https://github.com/midwayjs/midway/commit/cc5fe44e1d221590562dc71e1f33ae96093e0da7))
+
+
+
+
+
+# [3.0.0-beta.3](https://github.com/midwayjs/midway/compare/v3.0.0-beta.2...v3.0.0-beta.3) (2021-11-18)
+
+
+### Features
+
+* add component and framework config definition ([#1367](https://github.com/midwayjs/midway/issues/1367)) ([b2fe615](https://github.com/midwayjs/midway/commit/b2fe6157f99659471ff1333eca0b86bb889f61a3))
+
+
+
+
+
 # [3.0.0-beta.2](https://github.com/midwayjs/midway/compare/v3.0.0-beta.1...v3.0.0-beta.2) (2021-11-16)
 
 **Note:** Version bump only for package @midwayjs/core

package/dist/baseFramework.d.ts

@@ -1,14 +1,14 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonExceptionFilterUnion, CommonMiddleware, MiddlewareRespond } from './interface';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, CommonMiddleware, MiddlewareRespond } from './interface';
 import { FrameworkType } from '@midwayjs/decorator';
 import { ILogger, LoggerOptions } from '@midwayjs/logger';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
 import { MidwayInformationService } from './service/informationService';
 import { MidwayLoggerService } from './service/loggerService';
-import { ContextMiddlewareManager } from './util/middlewareManager';
+import { ContextMiddlewareManager } from './common/middlewareManager';
 import { MidwayMiddlewareService } from './service/middlewareService';
-import { ExceptionFilterManager } from './util/exceptionFilterManager';
-export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions> implements IMidwayFramework<APP, OPT> {
+import { FilterManager } from './common/filterManager';
+export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next> {
     readonly applicationContext: IMidwayContainer;
     app: APP;
     configurationOptions: OPT;
@@ -17,14 +17,14 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected defaultContext: {};
     protected BaseContextLoggerClass: any;
     protected ContextLoggerApplyLogger: string;
-    protected middlewareManager: ContextMiddlewareManager<CTX, any, any>;
-    protected exceptionFilterManager: ExceptionFilterManager<CTX, any, any>;
+    protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
+    protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected composeMiddleware: any;
     loggerService: MidwayLoggerService;
     environmentService: MidwayEnvironmentService;
     configService: MidwayConfigService;
     informationService: MidwayInformationService;
-    middlewareService: MidwayMiddlewareService<CTX>;
+    middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
     constructor(applicationContext: IMidwayContainer);
     init(): Promise<this>;
     abstract configure(options?: OPT): any;
@@ -79,7 +79,9 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     getProjectName(): string;
     getFrameworkName(): string;
     getDefaultContextLoggerClass(): any;
-    useMiddleware(Middleware: CommonMiddlewareUnion<CTX>): void;
-    useFilter(Filter: CommonExceptionFilterUnion<CTX>): void;
+    useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
+    useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>): void;
+    protected createMiddlewareManager(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
+    protected createFilterManager(): FilterManager<CTX, ResOrNext, Next>;
 }
 //# sourceMappingURL=baseFramework.d.ts.map

package/dist/baseFramework.js

@@ -18,15 +18,15 @@ const environmentService_1 = require("./service/environmentService");
 const configService_1 = require("./service/configService");
 const informationService_1 = require("./service/informationService");
 const loggerService_1 = require("./service/loggerService");
-const middlewareManager_1 = require("./util/middlewareManager");
+const middlewareManager_1 = require("./common/middlewareManager");
 const middlewareService_1 = require("./service/middlewareService");
-const exceptionFilterManager_1 = require("./util/exceptionFilterManager");
+const filterManager_1 = require("./common/filterManager");
 class BaseFramework {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
         this.defaultContext = {};
-        this.middlewareManager = new middlewareManager_1.ContextMiddlewareManager();
-        this.exceptionFilterManager = new exceptionFilterManager_1.ExceptionFilterManager();
+        this.middlewareManager = this.createMiddlewareManager();
+        this.filterManager = this.createFilterManager();
         this.composeMiddleware = null;
     }
     async init() {
@@ -179,7 +179,7 @@ class BaseFramework {
                 return this.middlewareManager;
             },
             useFilter: (Filter) => {
-                this.exceptionFilterManager.useFilter(Filter);
+                this.filterManager.useFilter(Filter);
             },
         };
         for (const method of whiteList) {
@@ -206,22 +206,19 @@ class BaseFramework {
     async afterContainerReady(options) { }
     async getMiddleware(lastMiddleware) {
         if (!this.composeMiddleware) {
-            this.middlewareManager.insertFirst(async (ctx, next) => {
+            this.middlewareManager.insertFirst((async (ctx, next) => {
                 let returnResult = undefined;
                 try {
                     const result = await next();
-                    returnResult = {
-                        result,
-                        error: undefined,
-                    };
+                    returnResult = await this.filterManager.runResultFilter(result, ctx);
                 }
                 catch (err) {
-                    returnResult = await this.exceptionFilterManager.run(err, ctx);
+                    returnResult = await this.filterManager.runErrorFilter(err, ctx);
                 }
                 return returnResult;
-            });
+            }));
             this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager);
-            await this.exceptionFilterManager.init(this.applicationContext);
+            await this.filterManager.init(this.applicationContext);
         }
         if (lastMiddleware) {
             return await this.middlewareService.compose([
@@ -256,7 +253,13 @@ class BaseFramework {
         this.middlewareManager.insertLast(Middleware);
     }
     useFilter(Filter) {
-        this.exceptionFilterManager.useFilter(Filter);
+        this.filterManager.useFilter(Filter);
+    }
+    createMiddlewareManager() {
+        return new middlewareManager_1.ContextMiddlewareManager();
+    }
+    createFilterManager() {
+        return new filterManager_1.FilterManager();
     }
 }
 __decorate([

package/dist/common/filterManager.d.ts

@@ -0,0 +1,19 @@
+import { CommonFilterUnion, IMidwayContainer, IMidwayContext } from '../interface';
+export declare class FilterManager<CTX extends IMidwayContext = IMidwayContext, R = any, N = any> {
+    private errFilterList;
+    private successFilterList;
+    private exceptionMap;
+    private defaultErrFilter;
+    private matchFnList;
+    useFilter(Filters: CommonFilterUnion<CTX, R, N>): void;
+    init(applicationContext: IMidwayContainer): Promise<void>;
+    runErrorFilter(err: Error, ctx: CTX, res?: R, next?: N): Promise<{
+        result: any;
+        error: any;
+    }>;
+    runResultFilter(result: any, ctx: CTX, res?: R, next?: N): Promise<{
+        result: any;
+        error: any;
+    }>;
+}
+//# sourceMappingURL=filterManager.d.ts.map

package/dist/common/filterManager.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const util_1 = require("../util");
+class FilterManager {
+    constructor() {
+        this.errFilterList = [];
+        this.successFilterList = [];
+        this.exceptionMap = new WeakMap();
+        this.defaultErrFilter = undefined;
+        this.matchFnList = [];
+    }
+    useFilter(Filters) {
+        if (!Array.isArray(Filters)) {
+            Filters = [Filters];
+        }
+        for (const Filter of Filters) {
+            if ((0, decorator_1.getClassMetadata)(decorator_1.CATCH_KEY, Filter)) {
+                this.errFilterList.push(Filter);
+            }
+            if ((0, decorator_1.getClassMetadata)(decorator_1.MATCH_KEY, Filter)) {
+                this.successFilterList.push(Filter);
+            }
+        }
+    }
+    async init(applicationContext) {
+        // for catch exception
+        for (const FilterClass of this.errFilterList) {
+            const filter = await applicationContext.getAsync(FilterClass);
+            const exceptionMetadata = (0, decorator_1.getClassMetadata)(decorator_1.CATCH_KEY, FilterClass);
+            if (exceptionMetadata && exceptionMetadata.catchTargets) {
+                for (const Exception of exceptionMetadata.catchTargets) {
+                    this.exceptionMap.set(Exception, filter);
+                }
+            }
+            else {
+                // default filter
+                this.defaultErrFilter = filter;
+            }
+        }
+        // for success return
+        for (const FilterClass of this.successFilterList) {
+            const filter = await applicationContext.getAsync(FilterClass);
+            const matchMetadata = (0, decorator_1.getClassMetadata)(decorator_1.MATCH_KEY, FilterClass);
+            if (matchMetadata && matchMetadata.matchPattern) {
+                this.matchFnList.push({
+                    matchFn: (0, util_1.toPathMatch)(matchMetadata.matchPattern),
+                    target: filter,
+                });
+            }
+        }
+    }
+    async runErrorFilter(err, ctx, res, next) {
+        let result, error;
+        if (this.exceptionMap.has(err.constructor)) {
+            const filter = this.exceptionMap.get(err.constructor);
+            result = await filter.catch(err, ctx, res, next);
+        }
+        else if (this.defaultErrFilter) {
+            result = await this.defaultErrFilter.catch(err, ctx, res, next);
+        }
+        else {
+            error = err;
+        }
+        return {
+            result,
+            error,
+        };
+    }
+    async runResultFilter(result, ctx, res, next) {
+        let returnValue = result;
+        for (const matchData of this.matchFnList) {
+            if (matchData.matchFn(ctx, res)) {
+                returnValue = await matchData.target.match(returnValue, ctx, res, next);
+            }
+        }
+        return {
+            result: returnValue,
+            error: undefined,
+        };
+    }
+}
+exports.FilterManager = FilterManager;
+//# sourceMappingURL=filterManager.js.map

package/dist/common/middlewareManager.d.ts

@@ -0,0 +1,11 @@
+import { CommonMiddleware, CommonMiddlewareUnion, IMidwayContext } from '../interface';
+export declare class ContextMiddlewareManager<CTX extends IMidwayContext, R, N> extends Array<CommonMiddleware<CTX, R, N>> {
+    insertFirst(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
+    insertBefore(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrBeforeMiddleware: number): any;
+    insertBefore(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrBeforeMiddleware: CommonMiddlewareUnion<CTX, R, N>): any;
+    insertAfter(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrAfterMiddleware: number): any;
+    insertAfter(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrAfterMiddleware: CommonMiddlewareUnion<CTX, R, N>): any;
+    insertLast(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
+    private findItemIndex;
+}
+//# sourceMappingURL=middlewareManager.d.ts.map

package/dist/{util → common}/webGenerator.d.ts

@@ -4,8 +4,8 @@
  * @param routeArgsInfo
  * @param routerResponseData
  */
-import { MidwayFrameworkType, RouterParamValue } from '@midwayjs/decorator';
-import { IMidwayContainer } from '../';
+import { MidwayFrameworkType } from '@midwayjs/decorator';
+import { IMidwayContainer, RouterInfo } from '../index';
 import { ILogger } from '@midwayjs/logger';
 export declare abstract class WebControllerGenerator<Router extends {
     use: (...args: any[]) => void;
@@ -13,18 +13,15 @@ export declare abstract class WebControllerGenerator<Router extends {
     readonly applicationContext: IMidwayContainer;
     readonly frameworkType: MidwayFrameworkType;
     readonly logger?: ILogger;
-    private controllerIds;
     protected constructor(applicationContext: IMidwayContainer, frameworkType: MidwayFrameworkType, logger?: ILogger);
     /**
      * wrap controller string to middleware function
-     * @param controllerMapping like FooController.index
-     * @param routeArgsInfo
-     * @param routerResponseData
+     * @param routeInfo
      */
-    generateKoaController(controllerMapping: string, routeArgsInfo?: RouterParamValue[], routerResponseData?: any[]): (ctx: any, next: any) => Promise<void>;
-    loadMidwayController(routerHandler?: (newRouter: Router) => void): Promise<void>;
+    generateKoaController(routeInfo: RouterInfo): (ctx: any, next: any) => Promise<void>;
+    loadMidwayController(globalPrefix: string, routerHandler?: (newRouter: Router) => void): Promise<void>;
     abstract createRouter(routerOptions: any): Router;
-    abstract generateController(controllerMapping: string, routeArgsInfo?: RouterParamValue[], routerResponseData?: any[]): any;
+    abstract generateController(routeInfo: RouterInfo): any;
     protected handlerWebMiddleware(middlewares: any[], handlerCallback: (middlewareImpl: any) => void): Promise<void>;
 }
 //# sourceMappingURL=webGenerator.d.ts.map

package/dist/{util → common}/webGenerator.js

@@ -8,27 +8,23 @@ exports.WebControllerGenerator = void 0;
  * @param routerResponseData
  */
 const decorator_1 = require("@midwayjs/decorator");
-const __1 = require("../");
+const index_1 = require("../index");
 class WebControllerGenerator {
     constructor(applicationContext, frameworkType, logger) {
         this.applicationContext = applicationContext;
         this.frameworkType = frameworkType;
         this.logger = logger;
-        this.controllerIds = [];
     }
     /**
      * wrap controller string to middleware function
-     * @param controllerMapping like FooController.index
-     * @param routeArgsInfo
-     * @param routerResponseData
+     * @param routeInfo
      */
-    generateKoaController(controllerMapping, routeArgsInfo, routerResponseData) {
-        const [controllerId, methodName] = controllerMapping.split('.');
+    generateKoaController(routeInfo) {
         return async (ctx, next) => {
             const args = [ctx, next];
-            const controller = await ctx.requestContext.getAsync(controllerId);
+            const controller = await ctx.requestContext.getAsync(routeInfo.id);
             // eslint-disable-next-line prefer-spread
-            const result = await controller[methodName].apply(controller, args);
+            const result = await controller[routeInfo.method].apply(controller, args);
             if (result !== undefined) {
                 ctx.body = result;
             }
@@ -36,8 +32,9 @@ class WebControllerGenerator {
                 ctx.body = undefined;
             }
             // implement response decorator
-            if (Array.isArray(routerResponseData) && routerResponseData.length) {
-                for (const routerRes of routerResponseData) {
+            if (Array.isArray(routeInfo.responseMetadata) &&
+                routeInfo.responseMetadata.length) {
+                for (const routerRes of routeInfo.responseMetadata) {
                     switch (routerRes.type) {
                         case decorator_1.WEB_RESPONSE_HTTP_CODE:
                             ctx.status = routerRes.code;
@@ -59,21 +56,17 @@ class WebControllerGenerator {
             }
         };
     }
-    async loadMidwayController(routerHandler) {
+    async loadMidwayController(globalPrefix, routerHandler) {
         var _a, _b;
-        const collector = new __1.WebRouterCollector();
+        const collector = new index_1.WebRouterCollector('', {
+            globalPrefix,
+        });
         const routerTable = await collector.getRouterTable();
         const routerList = await collector.getRoutePriorityList();
         for (const routerInfo of routerList) {
             // bind controller first
             this.applicationContext.bindClass(routerInfo.routerModule);
-            const providerId = routerInfo.controllerId;
-            // controller id check
-            if (this.controllerIds.indexOf(providerId) > -1) {
-                throw new Error(`Controller identifier [${providerId}] already exists!`);
-            }
-            this.controllerIds.push(providerId);
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`Load Controller "${providerId}", prefix=${routerInfo.prefix}`);
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
             // new router
             const newRouter = this.createRouter({
                 prefix: routerInfo.prefix,
@@ -101,7 +94,7 @@ class WebControllerGenerator {
                     routeInfo.routerName,
                     routeInfo.url,
                     ...methodMiddlewares,
-                    this.generateController(routeInfo.handlerName, routeInfo.requestMetadata, routeInfo.responseMetadata),
+                    this.generateController(routeInfo),
                 ];
                 (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
                 // apply controller from request context

package/dist/{util → common}/webRouterCollector.d.ts

@@ -4,7 +4,7 @@ export interface RouterInfo {
      */
     id: string;
     /**
-     * router prefix
+     * router prefix from controller
      */
     prefix: string;
     /**
@@ -23,6 +23,9 @@ export interface RouterInfo {
      * invoke function method
      */
     method: string;
+    /**
+     * router description
+     */
     description: string;
     summary: string;
     /**
@@ -83,12 +86,12 @@ export interface RouterPriority {
 }
 export interface RouterCollectorOptions {
     includeFunctionRouter?: boolean;
+    globalPrefix?: string;
 }
 export declare class WebRouterCollector {
     protected readonly baseDir: string;
     private isReady;
     protected routes: Map<string, RouterInfo[]>;
-    protected routerModules: Set<unknown>;
     private routesPriority;
     protected options: RouterCollectorOptions;
     constructor(baseDir?: string, options?: RouterCollectorOptions);
@@ -106,7 +109,7 @@ export declare class WebRouterCollector {
          */
         id: string;
         /**
-         * router prefix
+         * router prefix from controller
          */
         prefix: string;
         /**
@@ -125,6 +128,9 @@ export declare class WebRouterCollector {
          * invoke function method
          */
         method: string;
+        /**
+         * router description
+         */
         description: string;
         summary: string;
         /**
@@ -175,7 +181,6 @@ export declare class WebRouterCollector {
     getRoutePriorityList(): Promise<RouterPriority[]>;
     getRouterTable(): Promise<Map<string, RouterInfo[]>>;
     getFlattenRouterTable(): Promise<RouterInfo[]>;
-    getRouterModules(): Promise<any[]>;
     private checkDuplicateAndPush;
 }
 //# sourceMappingURL=webRouterCollector.d.ts.map