@midwayjs/core 3.4.0-beta.4 → 3.4.0-beta.7

package/dist/common/webGenerator.js

@@ -101,6 +101,7 @@ class WebControllerGenerator {
                     methodMiddlewares.push(routeMiddlewareFn);
                 }
                 if (this.app.getFrameworkType() === decorator_1.MidwayFrameworkType.WEB_KOA) {
+                    // egg use path-to-regexp v1 but koa use v6
                     if (typeof routeInfo.url === 'string' && /\*$/.test(routeInfo.url)) {
                         routeInfo.url = routeInfo.url.replace('*', '(.*)');
                     }
@@ -115,7 +116,7 @@ class WebControllerGenerator {
                 debug(`[core]: Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
                 // apply controller from request context
                 // eslint-disable-next-line prefer-spread
-                newRouter[routeInfo.requestMethod].apply(newRouter, routerArgs);
+                newRouter[routeInfo.requestMethod.toLowerCase()].apply(newRouter, routerArgs);
             }
             routerHandler && routerHandler(newRouter);
         }

package/dist/service/configService.js

@@ -184,9 +184,6 @@ let MidwayConfigService = class MidwayConfigService {
                 exports = exports.default;
             }
         }
-        else {
-            console.log(exports);
-        }
         return exports;
     }
     clearAllConfig() {

package/dist/service/slsFunctionService.js

@@ -133,20 +133,22 @@ let MidwayServerlessFunctionService = class MidwayServerlessFunctionService exte
         }
     }
     async getFunctionList() {
-        return this.getFlattenRouterTable();
+        return this.getFlattenRouterTable({
+            compileUrlPattern: true,
+        });
     }
     addServerlessFunction(func, triggerOptions, functionOptions = {}) {
         var _a, _b;
-        const prefix = '/';
+        const prefix = '';
         if (!this.routes.has(prefix)) {
             this.routes.set(prefix, []);
             this.routesPriority.push({
                 prefix,
-                priority: -999,
+                priority: 0,
                 middleware: [],
                 routerOptions: {},
                 controllerId: undefined,
-                routerModule: module,
+                routerModule: undefined,
             });
         }
         const functionName = (_a = triggerOptions.functionName) !== null && _a !== void 0 ? _a : functionOptions.functionName;

package/dist/service/webRouterService.d.ts

@@ -28,6 +28,9 @@ export interface RouterInfo {
      * router description
      */
     description?: string;
+    /**
+     * @deprecated
+     */
     summary?: string;
     /**
      * router handler function key，for IoC container load
@@ -73,8 +76,20 @@ export interface RouterInfo {
      * serverless function metadata
      */
     functionMetadata?: any;
+    /**
+     * url with prefix
+     */
+    fullUrl?: string;
+    /**
+     * pattern after path-regexp compile
+     */
+    fullUrlCompiledRegexp?: RegExp;
+    /**
+     * url after wildcard and can be path-to-regexp by path-to-regexp v6
+     */
+    fullUrlFlattenString?: string;
 }
-export declare type DynamicRouterInfo = Omit<RouterInfo, 'id' | 'url' | 'prefix' | 'method' | 'controllerId' | 'controllerMiddleware' | 'responseMetadata'>;
+export declare type DynamicRouterInfo = Omit<RouterInfo, 'id' | 'method' | 'controllerId' | 'controllerMiddleware' | 'responseMetadata'>;
 export interface RouterPriority {
     prefix: string;
     priority: number;
@@ -95,6 +110,8 @@ export declare class MidwayWebRouterService {
     private isReady;
     protected routes: Map<string, RouterInfo[]>;
     protected routesPriority: RouterPriority[];
+    private cachedFlattenRouteList;
+    private includeCompileUrlPattern;
     constructor(options?: RouterCollectorOptions);
     protected analyze(): Promise<void>;
     protected analyzeController(): void;
@@ -112,7 +129,7 @@ export declare class MidwayWebRouterService {
      * @param routerFunction
      * @param routerInfoOption
      */
-    addRouter(routerPath: string | RegExp, routerFunction: (...args: any[]) => void, routerInfoOption: DynamicRouterInfo): void;
+    addRouter(routerFunction: (...args: any[]) => void, routerInfoOption: DynamicRouterInfo): void;
     sortRouter(urlMatchList: RouterInfo[]): {
         _pureRouter: string;
         _level: number;
@@ -147,6 +164,9 @@ export declare class MidwayWebRouterService {
          * router description
          */
         description?: string;
+        /**
+         * @deprecated
+         */
         summary?: string;
         /**
          * router handler function key，for IoC container load
@@ -192,10 +212,26 @@ export declare class MidwayWebRouterService {
          * serverless function metadata
          */
         functionMetadata?: any;
+        /**
+         * url with prefix
+         */
+        fullUrl?: string;
+        /**
+         * pattern after path-regexp compile
+         */
+        fullUrlCompiledRegexp?: RegExp;
+        /**
+         * url after wildcard and can be path-to-regexp by path-to-regexp v6
+         */
+        fullUrlFlattenString?: string;
     }[];
     getRoutePriorityList(): Promise<RouterPriority[]>;
     getRouterTable(): Promise<Map<string, RouterInfo[]>>;
-    getFlattenRouterTable(): Promise<RouterInfo[]>;
+    getFlattenRouterTable(options?: {
+        compileUrlPattern?: boolean;
+        noCache?: boolean;
+    }): Promise<RouterInfo[]>;
+    getMatchedRouterInfo(routerUrl: string, method: string): Promise<RouterInfo | undefined>;
     protected checkDuplicateAndPush(prefix: any, routerInfo: RouterInfo): void;
 }
 //# sourceMappingURL=webRouterService.d.ts.map

package/dist/service/webRouterService.js

@@ -14,6 +14,7 @@ const decorator_1 = require("@midwayjs/decorator");
 const util_1 = require("../util");
 const error_1 = require("../error");
 const util = require("util");
+const pathToRegexp_1 = require("../util/pathToRegexp");
 const debug = util.debuglog('midway:debug');
 let MidwayWebRouterService = class MidwayWebRouterService {
     constructor(options = {}) {
@@ -21,6 +22,7 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         this.isReady = false;
         this.routes = new Map();
         this.routesPriority = [];
+        this.includeCompileUrlPattern = false;
     }
     async analyze() {
         this.analyzeController();
@@ -156,10 +158,22 @@ let MidwayWebRouterService = class MidwayWebRouterService {
      * @param routerFunction
      * @param routerInfoOption
      */
-    addRouter(routerPath, routerFunction, routerInfoOption) {
-        this.checkDuplicateAndPush('/', Object.assign(routerInfoOption, {
+    addRouter(routerFunction, routerInfoOption) {
+        const prefix = routerInfoOption.prefix || '';
+        routerInfoOption.requestMethod = (routerInfoOption.requestMethod || 'GET').toUpperCase();
+        if (!this.routes.has(prefix)) {
+            this.routes.set(prefix, []);
+            this.routesPriority.push({
+                prefix,
+                priority: 0,
+                middleware: [],
+                routerOptions: {},
+                controllerId: undefined,
+                routerModule: undefined,
+            });
+        }
+        this.checkDuplicateAndPush(prefix, Object.assign(routerInfoOption, {
             method: routerFunction,
-            url: routerPath,
         }));
     }
     sortRouter(urlMatchList) {
@@ -238,7 +252,19 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         }
         return this.routes;
     }
-    async getFlattenRouterTable() {
+    async getFlattenRouterTable(options = {}) {
+        if (this.cachedFlattenRouteList && !options.noCache) {
+            if (options.compileUrlPattern && !this.includeCompileUrlPattern) {
+                this.includeCompileUrlPattern = true;
+                // attach match pattern function
+                for (const item of this.cachedFlattenRouteList) {
+                    if (item.fullUrlFlattenString) {
+                        item.fullUrlCompiledRegexp = pathToRegexp_1.PathToRegexpUtil.toRegexp(item.fullUrlFlattenString);
+                    }
+                }
+            }
+            return this.cachedFlattenRouteList;
+        }
         if (!this.isReady) {
             await this.analyze();
             this.isReady = true;
@@ -247,8 +273,34 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         for (const routerPriority of this.routesPriority) {
             routeArr = routeArr.concat(this.routes.get(routerPriority.prefix));
         }
+        if (options.compileUrlPattern) {
+            this.includeCompileUrlPattern = true;
+            // attach match pattern function
+            for (const item of routeArr) {
+                if (item.fullUrlFlattenString) {
+                    item.fullUrlCompiledRegexp = pathToRegexp_1.PathToRegexpUtil.toRegexp(item.fullUrlFlattenString);
+                }
+            }
+        }
+        this.cachedFlattenRouteList = routeArr;
         return routeArr;
     }
+    async getMatchedRouterInfo(routerUrl, method) {
+        const routes = await this.getFlattenRouterTable({
+            compileUrlPattern: true,
+        });
+        let matchedRouterInfo;
+        for (const item of routes) {
+            if (item.fullUrlCompiledRegexp) {
+                if (method.toUpperCase() === item['requestMethod'].toUpperCase() &&
+                    item.fullUrlCompiledRegexp.test(routerUrl)) {
+                    matchedRouterInfo = item;
+                    break;
+                }
+            }
+        }
+        return matchedRouterInfo;
+    }
     checkDuplicateAndPush(prefix, routerInfo) {
         const prefixList = this.routes.get(prefix);
         const matched = prefixList.filter(item => {
@@ -260,6 +312,18 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         if (matched && matched.length) {
             throw new error_1.MidwayDuplicateRouteError(`${routerInfo.requestMethod} ${routerInfo.url}`, `${matched[0].handlerName}`, `${routerInfo.handlerName}`);
         }
+        // format url
+        if (!routerInfo.fullUrlFlattenString &&
+            routerInfo.url &&
+            typeof routerInfo.url === 'string') {
+            routerInfo.fullUrl = (0, util_1.joinURLPath)(prefix, routerInfo.url);
+            if (/\*$/.test(routerInfo.fullUrl)) {
+                routerInfo.fullUrlFlattenString = routerInfo.fullUrl.replace('*', '(.*)');
+            }
+            else {
+                routerInfo.fullUrlFlattenString = routerInfo.fullUrl;
+            }
+        }
         prefixList.push(routerInfo);
     }
 };

package/dist/util/index.js

@@ -238,7 +238,7 @@ function toPathMatch(pattern) {
         return ctx => pattern;
     }
     if (typeof pattern === 'string') {
-        const reg = (0, pathToRegexp_1.pathToRegexp)(pattern, [], { end: false });
+        const reg = pathToRegexp_1.PathToRegexpUtil.toRegexp(pattern.replace('*', '(.*)'));
         if (reg.global)
             reg.lastIndex = 0;
         return ctx => reg.test(ctx.path);

package/dist/util/pathToRegexp.d.ts

@@ -1,17 +1,123 @@
+interface ParseOptions {
+    /**
+     * Set the default delimiter for repeat parameters. (default: `'/'`)
+     */
+    delimiter?: string;
+    /**
+     * List of characters to automatically consider prefixes when parsing.
+     */
+    prefixes?: string;
+}
 /**
- * this file fork from path-to-regexp package v1.8.0
+ * Parse a string for the raw tokens.
  */
+declare function parse(str: string, options?: ParseOptions): Token[];
+interface TokensToFunctionOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * Function for encoding input strings for output.
+     */
+    encode?: (value: string, token: Key) => string;
+    /**
+     * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
+     */
+    validate?: boolean;
+}
+/**
+ * Compile a string to a template function for the path.
+ */
+declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
+declare type PathFunction<P extends object = object> = (data?: P) => string;
+interface RegexpToFunctionOptions {
+    /**
+     * Function for decoding strings for params.
+     */
+    decode?: (value: string, token: Key) => string;
+}
+/**
+ * A match result contains data about the path match.
+ */
+interface MatchResult<P extends object = object> {
+    path: string;
+    index: number;
+    params: P;
+}
+/**
+ * A match is either `false` (no match) or a match result.
+ */
+declare type Match<P extends object = object> = false | MatchResult<P>;
+/**
+ * The match function takes a string and returns whether it matched the path.
+ */
+declare type MatchFunction<P extends object = object> = (path: string) => Match<P>;
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+declare function match<P extends object = object>(str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions): MatchFunction<P>;
+/**
+ * Metadata about a key.
+ */
+interface Key {
+    name: string | number;
+    prefix: string;
+    suffix: string;
+    pattern: string;
+    modifier: string;
+}
+/**
+ * A token is a string (nothing special) or key metadata (capture group).
+ */
+declare type Token = string | Key;
+interface TokensToRegexpOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
+     */
+    strict?: boolean;
+    /**
+     * When `true` the regexp will match to the end of the string. (default: `true`)
+     */
+    end?: boolean;
+    /**
+     * When `true` the regexp will match from the beginning of the string. (default: `true`)
+     */
+    start?: boolean;
+    /**
+     * Sets the final character for non-ending optimistic matches. (default: `/`)
+     */
+    delimiter?: string;
+    /**
+     * List of characters that can also be "end" characters.
+     */
+    endsWith?: string;
+    /**
+     * Encode path tokens for use in the `RegExp`.
+     */
+    encode?: (value: string) => string;
+}
+/**
+ * Supported `path-to-regexp` input types.
+ */
+declare type Path = string | RegExp | Array<string | RegExp>;
 /**
  * Normalize the given path string, returning a regular expression.
  *
  * An empty array can be passed in for the keys, which will hold the
  * placeholder key descriptions. For example, using `/user/:id`, `keys` will
  * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
- *
- * @param  {(string|RegExp|Array)} path
- * @param  {(Array|Object)=}       keys
- * @param  {Object=}               options
- * @return {!RegExp}
  */
-export declare function pathToRegexp(path: any, keys: any, options: any): any;
+declare function toRegexp(path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp;
+export declare const PathToRegexpUtil: {
+    toRegexp: typeof toRegexp;
+    compile: typeof compile;
+    parse: typeof parse;
+    match: typeof match;
+};
+export {};
 //# sourceMappingURL=pathToRegexp.d.ts.map

package/dist/util/pathToRegexp.js

@@ -1,250 +1,382 @@
 "use strict";
-/**
- * this file fork from path-to-regexp package v1.8.0
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pathToRegexp = void 0;
+exports.PathToRegexpUtil = void 0;
 /**
- * The main path matching regexp utility.
- *
- * @type {RegExp}
+ * Tokenize input string.
  */
-const PATH_REGEXP = new RegExp([
-    // Match escaped characters that would otherwise appear in future matches.
-    // This allows the user to escape special characters that won't transform.
-    '(\\\\.)',
-    // Match Express-style parameters and un-named parameters with a prefix
-    // and optional suffixes. Matches appear as:
-    //
-    // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
-    // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
-    // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
-    '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))',
-].join('|'), 'g');
+function lexer(str) {
+    const tokens = [];
+    let i = 0;
+    while (i < str.length) {
+        const char = str[i];
+        if (char === '*' || char === '+' || char === '?') {
+            tokens.push({ type: 'MODIFIER', index: i, value: str[i++] });
+            continue;
+        }
+        if (char === '\\') {
+            tokens.push({ type: 'ESCAPED_CHAR', index: i++, value: str[i++] });
+            continue;
+        }
+        if (char === '{') {
+            tokens.push({ type: 'OPEN', index: i, value: str[i++] });
+            continue;
+        }
+        if (char === '}') {
+            tokens.push({ type: 'CLOSE', index: i, value: str[i++] });
+            continue;
+        }
+        if (char === ':') {
+            let name = '';
+            let j = i + 1;
+            while (j < str.length) {
+                const code = str.charCodeAt(j);
+                if (
+                // `0-9`
+                (code >= 48 && code <= 57) ||
+                    // `A-Z`
+                    (code >= 65 && code <= 90) ||
+                    // `a-z`
+                    (code >= 97 && code <= 122) ||
+                    // `_`
+                    code === 95) {
+                    name += str[j++];
+                    continue;
+                }
+                break;
+            }
+            if (!name)
+                throw new TypeError(`Missing parameter name at ${i}`);
+            tokens.push({ type: 'NAME', index: i, value: name });
+            i = j;
+            continue;
+        }
+        if (char === '(') {
+            let count = 1;
+            let pattern = '';
+            let j = i + 1;
+            if (str[j] === '?') {
+                throw new TypeError(`Pattern cannot start with "?" at ${j}`);
+            }
+            while (j < str.length) {
+                if (str[j] === '\\') {
+                    pattern += str[j++] + str[j++];
+                    continue;
+                }
+                if (str[j] === ')') {
+                    count--;
+                    if (count === 0) {
+                        j++;
+                        break;
+                    }
+                }
+                else if (str[j] === '(') {
+                    count++;
+                    if (str[j + 1] !== '?') {
+                        throw new TypeError(`Capturing groups are not allowed at ${j}`);
+                    }
+                }
+                pattern += str[j++];
+            }
+            if (count)
+                throw new TypeError(`Unbalanced pattern at ${i}`);
+            if (!pattern)
+                throw new TypeError(`Missing pattern at ${i}`);
+            tokens.push({ type: 'PATTERN', index: i, value: pattern });
+            i = j;
+            continue;
+        }
+        tokens.push({ type: 'CHAR', index: i, value: str[i++] });
+    }
+    tokens.push({ type: 'END', index: i, value: '' });
+    return tokens;
+}
 /**
  * Parse a string for the raw tokens.
- *
- * @param  {string}  str
- * @param  {Object=} options
- * @return {!Array}
  */
-function parse(str, options) {
-    const tokens = [];
+function parse(str, options = {}) {
+    const tokens = lexer(str);
+    const { prefixes = './' } = options;
+    const defaultPattern = `[^${escapeString(options.delimiter || '/#?')}]+?`;
+    const result = [];
     let key = 0;
-    let index = 0;
+    let i = 0;
     let path = '';
-    const defaultDelimiter = (options && options.delimiter) || '/';
-    let res;
-    while ((res = PATH_REGEXP.exec(str)) != null) {
-        const m = res[0];
-        const escaped = res[1];
-        const offset = res.index;
-        path += str.slice(index, offset);
-        index = offset + m.length;
-        // Ignore already escaped sequences.
-        if (escaped) {
-            path += escaped[1];
+    const tryConsume = (type) => {
+        if (i < tokens.length && tokens[i].type === type)
+            return tokens[i++].value;
+    };
+    const mustConsume = (type) => {
+        const value = tryConsume(type);
+        if (value !== undefined)
+            return value;
+        const { type: nextType, index } = tokens[i];
+        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}`);
+    };
+    const consumeText = () => {
+        let result = '';
+        let value;
+        while ((value = tryConsume('CHAR') || tryConsume('ESCAPED_CHAR'))) {
+            result += value;
+        }
+        return result;
+    };
+    while (i < tokens.length) {
+        const char = tryConsume('CHAR');
+        const name = tryConsume('NAME');
+        const pattern = tryConsume('PATTERN');
+        if (name || pattern) {
+            let prefix = char || '';
+            if (prefixes.indexOf(prefix) === -1) {
+                path += prefix;
+                prefix = '';
+            }
+            if (path) {
+                result.push(path);
+                path = '';
+            }
+            result.push({
+                name: name || key++,
+                prefix,
+                suffix: '',
+                pattern: pattern || defaultPattern,
+                modifier: tryConsume('MODIFIER') || '',
+            });
+            continue;
+        }
+        const value = char || tryConsume('ESCAPED_CHAR');
+        if (value) {
+            path += value;
             continue;
         }
-        const next = str[index];
-        const prefix = res[2];
-        const name = res[3];
-        const capture = res[4];
-        const group = res[5];
-        const modifier = res[6];
-        const asterisk = res[7];
-        // Push the current path onto the tokens.
         if (path) {
-            tokens.push(path);
+            result.push(path);
             path = '';
         }
-        const partial = prefix != null && next != null && next !== prefix;
-        const repeat = modifier === '+' || modifier === '*';
-        const optional = modifier === '?' || modifier === '*';
-        const delimiter = res[2] || defaultDelimiter;
-        const pattern = capture || group;
-        tokens.push({
-            name: name || key++,
-            prefix: prefix || '',
-            delimiter: delimiter,
-            optional: optional,
-            repeat: repeat,
-            partial: partial,
-            asterisk: !!asterisk,
-            pattern: pattern
-                ? escapeGroup(pattern)
-                : asterisk
-                    ? '.*'
-                    : '[^' + escapeString(delimiter) + ']+?',
-        });
-    }
-    // Match any characters still remaining.
-    if (index < str.length) {
-        path += str.slice(index);
-    }
-    // If the path exists, push it onto the end.
-    if (path) {
-        tokens.push(path);
+        const open = tryConsume('OPEN');
+        if (open) {
+            const prefix = consumeText();
+            const name = tryConsume('NAME') || '';
+            const pattern = tryConsume('PATTERN') || '';
+            const suffix = consumeText();
+            mustConsume('CLOSE');
+            result.push({
+                name: name || (pattern ? key++ : ''),
+                pattern: name && !pattern ? defaultPattern : pattern,
+                prefix,
+                suffix,
+                modifier: tryConsume('MODIFIER') || '',
+            });
+            continue;
+        }
+        mustConsume('END');
     }
-    return tokens;
+    return result;
 }
 /**
- * Escape a regular expression string.
- *
- * @param  {string} str
- * @return {string}
+ * Compile a string to a template function for the path.
  */
-function escapeString(str) {
-    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+function compile(str, options) {
+    return tokensToFunction(parse(str, options), options);
 }
 /**
- * Escape the capturing group by escaping special characters and meaning.
- *
- * @param  {string} group
- * @return {string}
+ * Expose a method for transforming tokens into the path function.
+ */
+function tokensToFunction(tokens, options = {}) {
+    const reFlags = flags(options);
+    const { encode = (x) => x, validate = true } = options;
+    // Compile all the tokens into regexps.
+    const matches = tokens.map(token => {
+        if (typeof token === 'object') {
+            return new RegExp(`^(?:${token.pattern})$`, reFlags);
+        }
+    });
+    return (data) => {
+        let path = '';
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (typeof token === 'string') {
+                path += token;
+                continue;
+            }
+            const value = data ? data[token.name] : undefined;
+            const optional = token.modifier === '?' || token.modifier === '*';
+            const repeat = token.modifier === '*' || token.modifier === '+';
+            if (Array.isArray(value)) {
+                if (!repeat) {
+                    throw new TypeError(`Expected "${token.name}" to not repeat, but got an array`);
+                }
+                if (value.length === 0) {
+                    if (optional)
+                        continue;
+                    throw new TypeError(`Expected "${token.name}" to not be empty`);
+                }
+                for (let j = 0; j < value.length; j++) {
+                    const segment = encode(value[j], token);
+                    if (validate && !matches[i].test(segment)) {
+                        throw new TypeError(`Expected all "${token.name}" to match "${token.pattern}", but got "${segment}"`);
+                    }
+                    path += token.prefix + segment + token.suffix;
+                }
+                continue;
+            }
+            if (typeof value === 'string' || typeof value === 'number') {
+                const segment = encode(String(value), token);
+                if (validate && !matches[i].test(segment)) {
+                    throw new TypeError(`Expected "${token.name}" to match "${token.pattern}", but got "${segment}"`);
+                }
+                path += token.prefix + segment + token.suffix;
+                continue;
+            }
+            if (optional)
+                continue;
+            const typeOfMessage = repeat ? 'an array' : 'a string';
+            throw new TypeError(`Expected "${token.name}" to be ${typeOfMessage}`);
+        }
+        return path;
+    };
+}
+/**
+ * Create path match function from `path-to-regexp` spec.
  */
-function escapeGroup(group) {
-    return group.replace(/([=!:$/()])/g, '\\$1');
+function match(str, options) {
+    const keys = [];
+    const re = toRegexp(str, keys, options);
+    return regexpToFunction(re, keys, options);
 }
 /**
- * Attach the keys as a property of the regexp.
- *
- * @param  {!RegExp} re
- * @param  {Array}   keys
- * @return {!RegExp}
+ * Create a path match function from `path-to-regexp` output.
+ */
+function regexpToFunction(re, keys, options = {}) {
+    const { decode = (x) => x } = options;
+    return function (pathname) {
+        const m = re.exec(pathname);
+        if (!m)
+            return false;
+        const { 0: path, index } = m;
+        const params = Object.create(null);
+        for (let i = 1; i < m.length; i++) {
+            if (m[i] === undefined)
+                continue;
+            const key = keys[i - 1];
+            if (key.modifier === '*' || key.modifier === '+') {
+                params[key.name] = m[i].split(key.prefix + key.suffix).map(value => {
+                    return decode(value, key);
+                });
+            }
+            else {
+                params[key.name] = decode(m[i], key);
+            }
+        }
+        return { path, index, params };
+    };
+}
+/**
+ * Escape a regular expression string.
  */
-function attachKeys(re, keys) {
-    re.keys = keys;
-    return re;
+function escapeString(str) {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
 }
 /**
  * Get the flags for a regexp from the options.
- *
- * @param  {Object} options
- * @return {string}
  */
 function flags(options) {
     return options && options.sensitive ? '' : 'i';
 }
 /**
  * Pull out keys from a regexp.
- *
- * @param  {!RegExp} path
- * @param  {!Array}  keys
- * @return {!RegExp}
  */
 function regexpToRegexp(path, keys) {
-    // Use a negative lookahead to match only capturing groups.
-    const groups = path.source.match(/\((?!\?)/g);
-    if (groups) {
-        for (let i = 0; i < groups.length; i++) {
-            keys.push({
-                name: i,
-                prefix: null,
-                delimiter: null,
-                optional: false,
-                repeat: false,
-                partial: false,
-                asterisk: false,
-                pattern: null,
-            });
-        }
+    if (!keys)
+        return path;
+    const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+    let index = 0;
+    let execResult = groupsRegex.exec(path.source);
+    while (execResult) {
+        keys.push({
+            // Use parenthesized substring match if available, index otherwise
+            name: execResult[1] || index++,
+            prefix: '',
+            suffix: '',
+            modifier: '',
+            pattern: '',
+        });
+        execResult = groupsRegex.exec(path.source);
     }
-    return attachKeys(path, keys);
+    return path;
 }
 /**
  * Transform an array into a regexp.
- *
- * @param  {!Array}  path
- * @param  {Array}   keys
- * @param  {!Object} options
- * @return {!RegExp}
  */
-function arrayToRegexp(path, keys, options) {
-    const parts = [];
-    for (let i = 0; i < path.length; i++) {
-        parts.push(pathToRegexp(path[i], keys, options).source);
-    }
-    const regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
-    return attachKeys(regexp, keys);
+function arrayToRegexp(paths, keys, options) {
+    const parts = paths.map(path => toRegexp(path, keys, options).source);
+    return new RegExp(`(?:${parts.join('|')})`, flags(options));
 }
 /**
  * Create a path regexp from string input.
- *
- * @param  {string}  path
- * @param  {!Array}  keys
- * @param  {!Object} options
- * @return {!RegExp}
  */
 function stringToRegexp(path, keys, options) {
-    return tokensToRegExp(parse(path, options), keys, options);
+    return tokensToRegexp(parse(path, options), keys, options);
 }
 /**
  * Expose a function for taking tokens and returning a RegExp.
- *
- * @param  {!Array}          tokens
- * @param  {(Array|Object)=} keys
- * @param  {Object=}         options
- * @return {!RegExp}
  */
-function tokensToRegExp(tokens, keys, options) {
-    if (!Array.isArray(keys)) {
-        options = /** @type {!Object} */ keys || options;
-        keys = [];
-    }
-    options = options || {};
-    const strict = options.strict;
-    const end = options.end !== false;
-    let route = '';
+function tokensToRegexp(tokens, keys, options = {}) {
+    const { strict = false, start = true, end = true, encode = (x) => x, delimiter = '/#?', endsWith = '', } = options;
+    const endsWithRe = `[${escapeString(endsWith)}]|$`;
+    const delimiterRe = `[${escapeString(delimiter)}]`;
+    let route = start ? '^' : '';
     // Iterate over the tokens and create our regexp string.
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
+    for (const token of tokens) {
         if (typeof token === 'string') {
-            route += escapeString(token);
+            route += escapeString(encode(token));
         }
         else {
-            const prefix = escapeString(token.prefix);
-            let capture = '(?:' + token.pattern + ')';
-            keys.push(token);
-            if (token.repeat) {
-                capture += '(?:' + prefix + capture + ')*';
-            }
-            if (token.optional) {
-                if (!token.partial) {
-                    capture = '(?:' + prefix + '(' + capture + '))?';
+            const prefix = escapeString(encode(token.prefix));
+            const suffix = escapeString(encode(token.suffix));
+            if (token.pattern) {
+                if (keys)
+                    keys.push(token);
+                if (prefix || suffix) {
+                    if (token.modifier === '+' || token.modifier === '*') {
+                        const mod = token.modifier === '*' ? '?' : '';
+                        route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;
+                    }
+                    else {
+                        route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+                    }
                 }
                 else {
-                    capture = prefix + '(' + capture + ')?';
+                    if (token.modifier === '+' || token.modifier === '*') {
+                        route += `((?:${token.pattern})${token.modifier})`;
+                    }
+                    else {
+                        route += `(${token.pattern})${token.modifier}`;
+                    }
                 }
             }
             else {
-                capture = prefix + '(' + capture + ')';
+                route += `(?:${prefix}${suffix})${token.modifier}`;
             }
-            route += capture;
         }
     }
-    const delimiter = escapeString(options.delimiter || '/');
-    const endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
-    // In non-strict mode we allow a slash at the end of match. If the path to
-    // match already ends with a slash, we remove it for consistency. The slash
-    // is valid at the end of a path match, not in the middle. This is important
-    // in non-ending mode, where "/test/" shouldn't match "/test//route".
-    if (!strict) {
-        route =
-            (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) +
-                '(?:' +
-                delimiter +
-                '(?=$))?';
-    }
     if (end) {
-        route += '$';
+        if (!strict)
+            route += `${delimiterRe}?`;
+        route += !options.endsWith ? '$' : `(?=${endsWithRe})`;
     }
     else {
-        // In non-ending mode, we need the capturing groups to match as much as
-        // possible by using a positive lookahead to the end or next path segment.
-        route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
+        const endToken = tokens[tokens.length - 1];
+        const isEndDelimited = typeof endToken === 'string'
+            ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1
+            : endToken === undefined;
+        if (!strict) {
+            route += `(?:${delimiterRe}(?=${endsWithRe}))?`;
+        }
+        if (!isEndDelimited) {
+            route += `(?=${delimiterRe}|${endsWithRe})`;
+        }
     }
-    return attachKeys(new RegExp('^' + route, flags(options)), keys);
+    return new RegExp(route, flags(options));
 }
 /**
  * Normalize the given path string, returning a regular expression.
@@ -252,29 +384,18 @@ function tokensToRegExp(tokens, keys, options) {
  * An empty array can be passed in for the keys, which will hold the
  * placeholder key descriptions. For example, using `/user/:id`, `keys` will
  * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
- *
- * @param  {(string|RegExp|Array)} path
- * @param  {(Array|Object)=}       keys
- * @param  {Object=}               options
- * @return {!RegExp}
  */
-function pathToRegexp(path, keys, options) {
-    if (!Array.isArray(keys)) {
-        options = /** @type {!Object} */ keys || options;
-        keys = [];
-    }
-    options = options || {};
-    if (path instanceof RegExp) {
-        return regexpToRegexp(path, /** @type {!Array} */ keys);
-    }
-    if (Array.isArray(path)) {
-        return arrayToRegexp(
-        /** @type {!Array} */ path, 
-        /** @type {!Array} */ keys, options);
-    }
-    return stringToRegexp(
-    /** @type {string} */ path, 
-    /** @type {!Array} */ keys, options);
+function toRegexp(path, keys, options) {
+    if (path instanceof RegExp)
+        return regexpToRegexp(path, keys);
+    if (Array.isArray(path))
+        return arrayToRegexp(path, keys, options);
+    return stringToRegexp(path, keys, options);
 }
-exports.pathToRegexp = pathToRegexp;
+exports.PathToRegexpUtil = {
+    toRegexp,
+    compile,
+    parse,
+    match,
+};
 //# sourceMappingURL=pathToRegexp.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.4.0-beta.4",
+  "version": "3.4.0-beta.7",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,7 +21,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.4.0-beta.4",
+    "@midwayjs/decorator": "^3.4.0-beta.7",
     "koa": "2.13.4",
     "midway-test-component": "*",
     "mm": "3.2.0",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "3b686101f7802f87d47b8c9d25561339d556e573"
+  "gitHead": "4d5cc59a7a33e49beeaf20fcfaf766438649959c"
 }