@midwayjs/core 3.10.15 → 3.11.0

package/dist/interface.d.ts

@@ -619,13 +619,14 @@ export interface Context {
 }
 export type IMidwayContext<FrameworkContext = unknown> = Context & FrameworkContext;
 export type NextFunction = () => Promise<any>;
+export type IgnoreMatcher<CTX> = string | RegExp | ((ctx: CTX) => boolean);
 /**
  * Common middleware definition
  */
 export interface IMiddleware<CTX, R, N = unknown> {
     resolve: (app: IMidwayApplication) => FunctionMiddleware<CTX, R, N> | Promise<FunctionMiddleware<CTX, R, N>>;
-    match?: (ctx: CTX) => boolean;
-    ignore?: (ctx: CTX) => boolean;
+    match?: IgnoreMatcher<CTX> | IgnoreMatcher<CTX>[];
+    ignore?: IgnoreMatcher<CTX> | IgnoreMatcher<CTX>[];
 }
 export type FunctionMiddleware<CTX, R, N = unknown> = N extends true ? (req: CTX, res: R, next: N) => any : (context: CTX, next: R, options?: any) => any;
 export type ClassMiddleware<CTX, R, N> = new (...args: any[]) => IMiddleware<CTX, R, N>;

package/dist/service/middlewareService.js

@@ -20,7 +20,6 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
         this.applicationContext = applicationContext;
     }
     async compose(middleware, app, name) {
-        var _a, _b;
         if (!Array.isArray(middleware)) {
             throw new error_1.MidwayParameterError('Middleware stack must be an array');
         }
@@ -49,8 +48,9 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                         // wrap ignore and match
                         const mw = fn;
                         const match = (0, util_1.pathMatching)({
-                            match: (_a = classMiddleware.match) === null || _a === void 0 ? void 0 : _a.bind(classMiddleware),
-                            ignore: (_b = classMiddleware.ignore) === null || _b === void 0 ? void 0 : _b.bind(classMiddleware),
+                            match: classMiddleware.match,
+                            ignore: classMiddleware.ignore,
+                            thisResolver: classMiddleware,
                         });
                         fn = (ctx, next, options) => {
                             if (!match(ctx))

package/dist/util/index.d.ts

@@ -1,4 +1,4 @@
-import { FunctionMiddleware } from '../interface';
+import { FunctionMiddleware, IgnoreMatcher } from '../interface';
 import { camelCase, pascalCase } from './camelCase';
 import { randomUUID } from './uuid';
 import { safeParse, safeStringify } from './flatted';
@@ -85,7 +85,11 @@ export declare const deprecatedOutput: (message: string) => void;
  */
 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;
+export declare function pathMatching(options: {
+    match?: IgnoreMatcher<any> | IgnoreMatcher<any>[];
+    ignore?: IgnoreMatcher<any> | IgnoreMatcher<any>[];
+    thisResolver?: any;
+}): (ctx?: any) => boolean;
 /**
  * wrap function middleware with match and ignore
  * @param mw

package/dist/util/index.js

@@ -270,9 +270,32 @@ function pathMatching(options) {
         throw new error_1.MidwayCommonError('options.match and options.ignore can not both present');
     if (!options.match && !options.ignore)
         return () => true;
+    if (options.match && !Array.isArray(options.match)) {
+        options.match = [options.match];
+    }
+    if (options.ignore && !Array.isArray(options.ignore)) {
+        options.ignore = [options.ignore];
+    }
+    const createMatch = (ignoreMatcherArr) => {
+        const matchedArr = ignoreMatcherArr.map(item => {
+            if (options.thisResolver) {
+                return toPathMatch(item).bind(options.thisResolver);
+            }
+            return toPathMatch(item);
+        });
+        return ctx => {
+            for (let i = 0; i < matchedArr.length; i++) {
+                const matched = matchedArr[i](ctx);
+                if (matched) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    };
     const matchFn = options.match
-        ? toPathMatch(options.match)
-        : toPathMatch(options.ignore);
+        ? createMatch(options.match)
+        : createMatch(options.ignore);
     return function pathMatch(ctx) {
         const matched = matchFn(ctx);
         return options.match ? matched : !matched;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.10.15",
+  "version": "3.11.0",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -25,7 +25,7 @@
     "koa": "2.14.1",
     "mm": "3.2.1",
     "raw-body": "2.5.2",
-    "sinon": "15.0.1"
+    "sinon": "15.0.3"
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "8d5fd0e58156612c675821134377208e4da710ad"
+  "gitHead": "eadb977e7fddcd4287c099fc32b601cd51702514"
 }