feat: add i18n (#1375)

packages/core/src/baseFramework.ts

@@ -7,7 +7,7 @@ import {
   IMidwayContext,
   IMidwayFramework,
   MidwayProcessTypeEnum,
-  CommonExceptionFilterUnion,
+  CommonFilterUnion,
   CommonMiddleware,
   MiddlewareRespond,
 } from './interface';
@@ -18,15 +18,17 @@ 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';
+import { FilterManager } from './common/filterManager';
 
 export abstract class BaseFramework<
   APP extends IMidwayApplication<CTX>,
   CTX extends IMidwayContext,
-  OPT extends IConfigurationOptions
-> implements IMidwayFramework<APP, OPT>
+  OPT extends IConfigurationOptions,
+  ResOrNext = unknown,
+  Next = unknown
+> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next>
 {
   public app: APP;
   public configurationOptions: OPT;
@@ -35,8 +37,8 @@ export abstract class BaseFramework<
   protected defaultContext = {};
   protected BaseContextLoggerClass: any;
   protected ContextLoggerApplyLogger: string;
-  protected middlewareManager = new ContextMiddlewareManager<CTX>();
-  protected exceptionFilterManager = new ExceptionFilterManager<CTX>();
+  protected middlewareManager = this.createMiddlewareManager();
+  protected filterManager = this.createFilterManager();
   protected composeMiddleware = null;
 
   @Inject()
@@ -52,7 +54,7 @@ export abstract class BaseFramework<
   informationService: MidwayInformationService;
 
   @Inject()
-  middlewareService: MidwayMiddlewareService<CTX>;
+  middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
 
   constructor(readonly applicationContext: IMidwayContainer) {}
 
@@ -244,14 +246,16 @@ export abstract class BaseFramework<
       getAttr: <T>(key: string): T => {
         return this.getApplicationContext().getAttr(key);
       },
-      useMiddleware: (middleware: CommonMiddlewareUnion<CTX>) => {
+      useMiddleware: (
+        middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>
+      ) => {
         this.middlewareManager.insertLast(middleware);
       },
-      getMiddleware: (): ContextMiddlewareManager<CTX> => {
+      getMiddleware: (): ContextMiddlewareManager<CTX, ResOrNext, Next> => {
         return this.middlewareManager;
       },
-      useFilter: (Filter: CommonExceptionFilterUnion<CTX>) => {
-        this.exceptionFilterManager.useFilter(Filter);
+      useFilter: (Filter: CommonFilterUnion<CTX, ResOrNext, Next>) => {
+        this.filterManager.useFilter(Filter);
       },
     };
     for (const method of whiteList) {
@@ -294,23 +298,20 @@ export abstract class BaseFramework<
     lastMiddleware?: CommonMiddleware<CTX, R, N>
   ): Promise<MiddlewareRespond<CTX, R, N>> {
     if (!this.composeMiddleware) {
-      this.middlewareManager.insertFirst(async (ctx, next) => {
+      this.middlewareManager.insertFirst((async (ctx: any, next: any) => {
         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;
-      });
+      }) as any);
       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([
@@ -346,11 +347,21 @@ export abstract class BaseFramework<
     return MidwayContextLogger;
   }
 
-  public useMiddleware(Middleware: CommonMiddlewareUnion<CTX>) {
+  public useMiddleware(
+    Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>
+  ) {
     this.middlewareManager.insertLast(Middleware);
   }
 
-  public useFilter(Filter: CommonExceptionFilterUnion<CTX>) {
-    this.exceptionFilterManager.useFilter(Filter);
+  public useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>) {
+    this.filterManager.useFilter(Filter);
+  }
+
+  protected createMiddlewareManager() {
+    return new ContextMiddlewareManager<CTX, ResOrNext, Next>();
+  }
+
+  protected createFilterManager() {
+    return new FilterManager<CTX, ResOrNext, Next>();
   }
 }

packages/core/src/common/filterManager.ts

@@ -0,0 +1,116 @@
+import {
+  CATCH_KEY,
+  getClassMetadata,
+  MATCH_KEY,
+  MatchPattern,
+} from '@midwayjs/decorator';
+import {
+  CommonFilterUnion,
+  IFilter,
+  IMidwayContainer,
+  IMidwayContext,
+} from '../interface';
+import { toPathMatch } from '../util';
+
+export class FilterManager<
+  CTX extends IMidwayContext = IMidwayContext,
+  R = any,
+  N = any
+> {
+  private errFilterList: Array<new (...args) => IFilter<CTX, R, N>> = [];
+  private successFilterList: Array<new (...args) => IFilter<CTX, R, N>> = [];
+  private exceptionMap: WeakMap<Error, IFilter<CTX, R, N>> = new WeakMap();
+  private defaultErrFilter = undefined;
+  private matchFnList = [];
+
+  public useFilter(Filters: CommonFilterUnion<CTX, R, N>) {
+    if (!Array.isArray(Filters)) {
+      Filters = [Filters];
+    }
+    for (const Filter of Filters) {
+      if (getClassMetadata(CATCH_KEY, Filter)) {
+        this.errFilterList.push(Filter);
+      }
+      if (getClassMetadata(MATCH_KEY, Filter)) {
+        this.successFilterList.push(Filter);
+      }
+    }
+  }
+
+  public async init(applicationContext: IMidwayContainer) {
+    // for catch exception
+    for (const FilterClass of this.errFilterList) {
+      const filter = await applicationContext.getAsync(FilterClass);
+      const exceptionMetadata = getClassMetadata(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: {
+        matchPattern?: MatchPattern<CTX>;
+      } = getClassMetadata(MATCH_KEY, FilterClass);
+      if (matchMetadata && matchMetadata.matchPattern) {
+        this.matchFnList.push({
+          matchFn: toPathMatch(matchMetadata.matchPattern),
+          target: filter,
+        });
+      }
+    }
+  }
+
+  public async runErrorFilter(
+    err: Error,
+    ctx: CTX,
+    res?: R,
+    next?: N
+  ): Promise<{
+    result: any;
+    error: any;
+  }> {
+    let result, error;
+    if (this.exceptionMap.has((err as any).constructor)) {
+      const filter = this.exceptionMap.get((err as any).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,
+    };
+  }
+
+  public async runResultFilter(
+    result: any,
+    ctx: CTX,
+    res?: R,
+    next?: N
+  ): Promise<{
+    result: any;
+    error: any;
+  }> {
+    let returnValue = result;
+
+    for (const matchData of this.matchFnList) {
+      if (matchData.matchFn(ctx)) {
+        returnValue = await matchData.target.match(returnValue, ctx, res, next);
+      }
+    }
+
+    return {
+      result: returnValue,
+      error: undefined,
+    };
+  }
+}

packages/core/src/util/middlewareManager.ts → packages/core/src/common/middlewareManager.ts

@@ -5,11 +5,11 @@ import {
 } from '../interface';
 
 export class ContextMiddlewareManager<
-  T extends IMidwayContext = IMidwayContext,
-  R = any,
-  N = any
-> extends Array<CommonMiddleware<T, R, N>> {
-  public insertFirst(middleware: CommonMiddlewareUnion<T, R, N>) {
+  CTX extends IMidwayContext,
+  R,
+  N
+> extends Array<CommonMiddleware<CTX, R, N>> {
+  public insertFirst(middleware: CommonMiddlewareUnion<CTX, R, N>) {
     if (Array.isArray(middleware)) {
       this.unshift(...middleware);
     } else {
@@ -18,15 +18,15 @@ export class ContextMiddlewareManager<
   }
 
   public insertBefore(
-    middleware: CommonMiddlewareUnion<T, R, N>,
+    middleware: CommonMiddlewareUnion<CTX, R, N>,
     idxOrBeforeMiddleware: number
   );
   public insertBefore(
-    middleware: CommonMiddlewareUnion<T, R, N>,
-    idxOrBeforeMiddleware: CommonMiddlewareUnion<T, R, N>
+    middleware: CommonMiddlewareUnion<CTX, R, N>,
+    idxOrBeforeMiddleware: CommonMiddlewareUnion<CTX, R, N>
   );
   public insertBefore(
-    middleware: CommonMiddlewareUnion<T, R, N>,
+    middleware: CommonMiddlewareUnion<CTX, R, N>,
     idxOrBeforeMiddleware: any
   ) {
     if (typeof idxOrBeforeMiddleware !== 'number') {
@@ -40,15 +40,15 @@ export class ContextMiddlewareManager<
   }
 
   public insertAfter(
-    middleware: CommonMiddlewareUnion<T, R, N>,
+    middleware: CommonMiddlewareUnion<CTX, R, N>,
     idxOrAfterMiddleware: number
   );
   public insertAfter(
-    middleware: CommonMiddlewareUnion<T, R, N>,
-    idxOrAfterMiddleware: CommonMiddlewareUnion<T, R, N>
+    middleware: CommonMiddlewareUnion<CTX, R, N>,
+    idxOrAfterMiddleware: CommonMiddlewareUnion<CTX, R, N>
   );
   public insertAfter(
-    middleware: CommonMiddlewareUnion<T, R, N>,
+    middleware: CommonMiddlewareUnion<CTX, R, N>,
     idxOrAfterMiddleware: any
   ) {
     if (typeof idxOrAfterMiddleware !== 'number') {
@@ -61,15 +61,15 @@ export class ContextMiddlewareManager<
     }
   }
 
-  public insertLast(middleware: CommonMiddlewareUnion<T, R, N>) {
+  public insertLast(middleware: CommonMiddlewareUnion<CTX, R, N>) {
     if (Array.isArray(middleware)) {
       this.push(...middleware);
     } else {
       this.push(middleware);
     }
   }
 
-  private findItemIndex(middleware: CommonMiddleware<T, R, N>): number {
+  private findItemIndex(middleware: CommonMiddleware<CTX, R, N>): number {
     return this.findIndex(item => item === middleware);
   }
 }

packages/core/src/util/webGenerator.ts → packages/core/src/common/webGenerator.ts

@@ -11,7 +11,7 @@ import {
   WEB_RESPONSE_HTTP_CODE,
   WEB_RESPONSE_REDIRECT,
 } from '@midwayjs/decorator';
-import { WebRouterCollector, IMidwayContainer, RouterInfo } from '../';
+import { WebRouterCollector, IMidwayContainer, RouterInfo } from '../index';
 import { ILogger } from '@midwayjs/logger';
 
 export abstract class WebControllerGenerator<

packages/core/src/util/webRouterCollector.ts → packages/core/src/common/webRouterCollector.ts

@@ -17,7 +17,7 @@ import {
   WEB_ROUTER_KEY,
   WEB_ROUTER_PARAM_KEY,
 } from '@midwayjs/decorator';
-import { joinURLPath } from './index';
+import { joinURLPath } from '../util';
 import { MidwayContainer } from '../context/container';
 import { DirectoryFileDetector } from './fileDetector';
 import * as util from 'util';

packages/core/src/error/base.ts

@@ -1,11 +1,13 @@
 import { FrameworkErrorEnum } from './code';
 
 interface ErrorOption {
-  cause: Error;
+  cause?: Error;
+  status?: number;
 }
 
 export class MidwayError extends Error {
   code: number;
+  status: number;
   cause: Error;
 
   constructor(message: string, options?: ErrorOption);
@@ -19,5 +21,6 @@ export class MidwayError extends Error {
     this.name = this.constructor.name;
     this.code = code;
     this.cause = options?.cause;
+    this.status = options?.status;
   }
 }

packages/core/src/error/code.ts

@@ -55,5 +55,5 @@ export enum FrameworkErrorEnum {
   PARAM_TYPE = 10002,
   DEFINITION_NOT_FOUND = 10003,
   FEATURE_NO_LONGER_SUPPORTED = 10004,
-  NO_FRAMEWORK_FOUND = 10005,
+  VALIDATE_FAIL = 10005,
 }

packages/core/src/error/framework.ts

@@ -47,11 +47,11 @@ export class MidwayFeatureNoLongerSupportedError extends MidwayError {
   }
 }
 
-export class MidwayNoFrameworkFoundError extends MidwayError {
-  constructor() {
-    super(
-      'You must add a component that contains @Framework at least, such as @midwayjs/web, @midwayjs/koa, etc.',
-      FrameworkErrorEnum.NO_FRAMEWORK_FOUND
-    );
+export class MidwayValidationError extends MidwayError {
+  constructor(message, status, cause) {
+    super(message, FrameworkErrorEnum.VALIDATE_FAIL, {
+      status,
+      cause,
+    });
   }
 }

packages/core/src/error/http.ts

@@ -1,11 +1,11 @@
 import { HttpStatus } from './code';
+import { MidwayError } from './base';
 
-export class HttpError extends Error {
+export class HttpError extends MidwayError {
   status: number;
 
   constructor(response, status) {
-    super();
-    this.message = typeof response === 'string' ? response : response.message;
+    super(typeof response === 'string' ? response : response.message);
     this.status = status;
     this.name = this.constructor.name;
   }