@midwayjs/core 3.4.0-beta.6 → 3.4.0-beta.9

package/dist/baseFramework.d.ts

@@ -20,6 +20,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected composeMiddleware: any;
+    protected bootstrapOptions: IMidwayBootstrapOptions;
     loggerService: MidwayLoggerService;
     environmentService: MidwayEnvironmentService;
     configService: MidwayConfigService;

package/dist/baseFramework.js

@@ -22,6 +22,7 @@ const middlewareService_1 = require("./service/middlewareService");
 const filterManager_1 = require("./common/filterManager");
 const mockService_1 = require("./service/mockService");
 const util = require("util");
+const asyncContextManager_1 = require("./common/asyncContextManager");
 const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
@@ -45,6 +46,7 @@ class BaseFramework {
         return true;
     }
     async initialize(options) {
+        this.bootstrapOptions = options;
         await this.beforeContainerInitialize(options);
         await this.containerInitialize(options);
         await this.afterContainerInitialize(options);
@@ -231,21 +233,34 @@ class BaseFramework {
      */
     async afterContainerReady(options) { }
     async applyMiddleware(lastMiddleware) {
+        var _a;
+        const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
+            false;
+        const contextManager = asyncContextManagerEnabled
+            ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.contextManager) || new asyncContextManager_1.NoopContextManager()
+            : new asyncContextManager_1.NoopContextManager();
+        if (asyncContextManagerEnabled) {
+            contextManager.enable();
+        }
         if (!this.composeMiddleware) {
             this.middlewareManager.insertFirst((async (ctx, next) => {
-                this.mockService.applyContextMocks(this.app, ctx);
-                let returnResult = undefined;
-                try {
-                    const result = await next();
-                    returnResult = await this.filterManager.runResultFilter(result, ctx);
-                }
-                catch (err) {
-                    returnResult = await this.filterManager.runErrorFilter(err, ctx);
-                }
-                if (returnResult.error) {
-                    throw returnResult.error;
-                }
-                return returnResult.result;
+                // warp with context manager
+                const rootContext = asyncContextManager_1.ASYNC_ROOT_CONTEXT.setValue(interface_1.ASYNC_CONTEXT_KEY, ctx);
+                return await contextManager.with(rootContext, async () => {
+                    this.mockService.applyContextMocks(this.app, ctx);
+                    let returnResult = undefined;
+                    try {
+                        const result = await next();
+                        returnResult = await this.filterManager.runResultFilter(result, ctx);
+                    }
+                    catch (err) {
+                        returnResult = await this.filterManager.runErrorFilter(err, ctx);
+                    }
+                    if (returnResult.error) {
+                        throw returnResult.error;
+                    }
+                    return returnResult.result;
+                });
             }));
             debug(`[core]: Compose middleware = [${this.middlewareManager.getNames()}]`);
             this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager, this.app);

package/dist/common/asyncContextManager.d.ts

@@ -0,0 +1,61 @@
+export interface AsyncContext {
+    /**
+     * Get a value from the context.
+     *
+     * @param key key which identifies a context value
+     */
+    getValue(key: symbol): unknown;
+    /**
+     * Create a new context which inherits from this context and has
+     * the given key set to the given value.
+     *
+     * @param key context key for which to set the value
+     * @param value value to set for the given key
+     */
+    setValue(key: symbol, value: unknown): AsyncContext;
+    /**
+     * Return a new context which inherits from this context but does
+     * not contain a value for the given key.
+     *
+     * @param key context key for which to clear a value
+     */
+    deleteValue(key: symbol): AsyncContext;
+}
+export interface AsyncContextManager {
+    /**
+     * Get the current active context
+     */
+    active(): AsyncContext;
+    /**
+     * Run the fn callback with object set as the current active context
+     * @param context Any object to set as the current active context
+     * @param fn A callback to be immediately run within a specific context
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    /**
+     * Bind an object as the current context (or a specific one)
+     * @param [context] Optionally specify the context which you want to assign
+     * @param target Any object to which a context need to be set
+     */
+    bind<T>(context: AsyncContext, target: T): T;
+    /**
+     * Enable context management
+     */
+    enable(): this;
+    /**
+     * Disable context management
+     */
+    disable(): this;
+}
+/** The root context is used as the default parent context when there is no active context */
+export declare const ASYNC_ROOT_CONTEXT: AsyncContext;
+export declare class NoopContextManager implements AsyncContextManager {
+    active(): AsyncContext;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(_context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    bind<T>(_context: AsyncContext, target: T): T;
+    enable(): this;
+    disable(): this;
+}
+//# sourceMappingURL=asyncContextManager.d.ts.map

package/dist/common/asyncContextManager.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopContextManager = exports.ASYNC_ROOT_CONTEXT = void 0;
+class AsyncBaseContext {
+    /**
+     * Construct a new context which inherits values from an optional parent context.
+     *
+     * @param parentContext a context from which to inherit values
+     */
+    constructor(parentContext) {
+        // for minification
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : new Map();
+        self.getValue = (key) => self._currentContext.get(key);
+        self.setValue = (key, value) => {
+            const context = new AsyncBaseContext(self._currentContext);
+            context._currentContext.set(key, value);
+            return context;
+        };
+        self.deleteValue = (key) => {
+            const context = new AsyncBaseContext(self._currentContext);
+            context._currentContext.delete(key);
+            return context;
+        };
+    }
+}
+/** The root context is used as the default parent context when there is no active context */
+exports.ASYNC_ROOT_CONTEXT = new AsyncBaseContext();
+class NoopContextManager {
+    active() {
+        return exports.ASYNC_ROOT_CONTEXT;
+    }
+    with(_context, fn, thisArg, ...args) {
+        return fn.call(thisArg, ...args);
+    }
+    bind(_context, target) {
+        return target;
+    }
+    enable() {
+        return this;
+    }
+    disable() {
+        return this;
+    }
+}
+exports.NoopContextManager = NoopContextManager;
+//# sourceMappingURL=asyncContextManager.js.map

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('*', '(.*)');
                     }

package/dist/config/config.default.d.ts

@@ -5,6 +5,9 @@ declare const _default: (appInfo: MidwayAppInfo) => {
     debug?: {
         recordConfigMergeOrder?: boolean;
     };
+    asyncContextManager: {
+        enable: boolean;
+    };
 };
 export default _default;
 //# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -8,6 +8,9 @@ exports.default = (appInfo) => {
     const isDevelopment = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
     const logRoot = (_a = process.env[interface_1.MIDWAY_LOGGER_WRITEABLE_DIR]) !== null && _a !== void 0 ? _a : appInfo.root;
     return {
+        asyncContextManager: {
+            enable: false,
+        },
         midwayLogger: {
             default: {
                 dir: (0, path_1.join)(logRoot, 'logs', appInfo.name),

package/dist/index.d.ts

@@ -35,6 +35,7 @@ export * from './common/filterManager';
 export * from './common/applicationManager';
 export * from './setup';
 export * from './error';
+export { AsyncContextManager, ASYNC_ROOT_CONTEXT, AsyncContext, } from './common/asyncContextManager';
 /**
  * proxy
  */

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MidwayFrameworkType = exports.DataSourceManager = exports.WebRouterCollector = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.createConfiguration = exports.extend = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.safeRequire = exports.safelyGet = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
+exports.MidwayFrameworkType = exports.ASYNC_ROOT_CONTEXT = exports.DataSourceManager = exports.WebRouterCollector = exports.MidwayServerlessFunctionService = exports.MidwayWebRouterService = exports.MidwayMockService = exports.MidwayDecoratorService = exports.MidwayMiddlewareService = exports.MidwayLifeCycleService = exports.MidwayAspectService = exports.MidwayFrameworkService = exports.MidwayLoggerService = exports.MidwayInformationService = exports.MidwayEnvironmentService = exports.MidwayConfigService = exports.createConfiguration = exports.extend = exports.wrapAsync = exports.wrapMiddleware = exports.pathMatching = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.safeRequire = exports.safelyGet = exports.BaseFramework = exports.MidwayRequestContainer = void 0;
 __exportStar(require("./interface"), exports);
 __exportStar(require("./context/container"), exports);
 var requestContainer_1 = require("./context/requestContainer");
@@ -81,6 +81,8 @@ __exportStar(require("./common/filterManager"), exports);
 __exportStar(require("./common/applicationManager"), exports);
 __exportStar(require("./setup"), exports);
 __exportStar(require("./error"), exports);
+var asyncContextManager_1 = require("./common/asyncContextManager");
+Object.defineProperty(exports, "ASYNC_ROOT_CONTEXT", { enumerable: true, get: function () { return asyncContextManager_1.ASYNC_ROOT_CONTEXT; } });
 /**
  * proxy
  */

package/dist/interface.d.ts

@@ -4,6 +4,7 @@ import { ILogger, LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import { ContextMiddlewareManager } from './common/middlewareManager';
 import _default from './config/config.default';
+import { AsyncContextManager } from './common/asyncContextManager';
 export declare type PowerPartial<T> = {
     [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
 };
@@ -432,6 +433,7 @@ export interface IMidwayBootstrapOptions {
     globalConfig?: Array<{
         [environmentName: string]: Record<string, any>;
     }> | Record<string, any>;
+    asyncContextManager?: AsyncContextManager;
 }
 export interface IConfigurationOptions {
     logger?: ILogger;
@@ -479,5 +481,6 @@ export interface MidwayAppInfo {
 export interface MidwayConfig extends FileConfigOption<typeof _default> {
     [customConfigKey: string]: unknown;
 }
+export declare const ASYNC_CONTEXT_KEY: unique symbol;
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.MidwayProcessTypeEnum = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.ObjectLifeCycleEvent = void 0;
+exports.ASYNC_CONTEXT_KEY = exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.MidwayProcessTypeEnum = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.ObjectLifeCycleEvent = void 0;
 var ObjectLifeCycleEvent;
 (function (ObjectLifeCycleEvent) {
     ObjectLifeCycleEvent["BEFORE_BIND"] = "beforeBind";
@@ -19,4 +19,5 @@ var MidwayProcessTypeEnum;
     MidwayProcessTypeEnum["AGENT"] = "AGENT";
 })(MidwayProcessTypeEnum = exports.MidwayProcessTypeEnum || (exports.MidwayProcessTypeEnum = {}));
 exports.MIDWAY_LOGGER_WRITEABLE_DIR = 'MIDWAY_LOGGER_WRITEABLE_DIR';
+exports.ASYNC_CONTEXT_KEY = Symbol('ASYNC_CONTEXT_KEY');
 //# sourceMappingURL=interface.js.map

package/dist/service/middlewareService.js

@@ -32,6 +32,10 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                 const classMiddleware = await this.applicationContext.getAsync(fn);
                 if (classMiddleware) {
                     fn = await classMiddleware.resolve(app);
+                    if (!fn) {
+                        // for middleware enabled
+                        continue;
+                    }
                     if (!classMiddleware.match && !classMiddleware.ignore) {
                         if (!fn.name) {
                             fn._name = classMiddleware.constructor.name;

package/dist/service/slsFunctionService.js

@@ -144,7 +144,7 @@ let MidwayServerlessFunctionService = class MidwayServerlessFunctionService exte
             this.routes.set(prefix, []);
             this.routesPriority.push({
                 prefix,
-                priority: -999,
+                priority: 0,
                 middleware: [],
                 routerOptions: {},
                 controllerId: undefined,

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,10 +76,18 @@ export interface RouterInfo {
      * serverless function metadata
      */
     functionMetadata?: any;
+    /**
+     * url with prefix
+     */
+    fullUrl?: string;
     /**
      * pattern after path-regexp compile
      */
-    urlCompiledPattern?: RegExp;
+    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' | 'method' | 'controllerId' | 'controllerMiddleware' | 'responseMetadata'>;
 export interface RouterPriority {
@@ -153,6 +164,9 @@ export declare class MidwayWebRouterService {
          * router description
          */
         description?: string;
+        /**
+         * @deprecated
+         */
         summary?: string;
         /**
          * router handler function key，for IoC container load
@@ -198,10 +212,18 @@ export declare class MidwayWebRouterService {
          * serverless function metadata
          */
         functionMetadata?: any;
+        /**
+         * url with prefix
+         */
+        fullUrl?: string;
         /**
          * pattern after path-regexp compile
          */
-        urlCompiledPattern?: RegExp;
+        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[]>>;

package/dist/service/webRouterService.js

@@ -160,11 +160,12 @@ let MidwayWebRouterService = class MidwayWebRouterService {
      */
     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: -999,
+                priority: 0,
                 middleware: [],
                 routerOptions: {},
                 controllerId: undefined,
@@ -257,10 +258,8 @@ let MidwayWebRouterService = class MidwayWebRouterService {
                 this.includeCompileUrlPattern = true;
                 // attach match pattern function
                 for (const item of this.cachedFlattenRouteList) {
-                    if (item.url) {
-                        item.urlCompiledPattern = (0, pathToRegexp_1.pathToRegexp)(item.url, [], {
-                            end: false,
-                        });
+                    if (item.fullUrlFlattenString) {
+                        item.fullUrlCompiledRegexp = pathToRegexp_1.PathToRegexpUtil.toRegexp(item.fullUrlFlattenString);
                     }
                 }
             }
@@ -278,9 +277,9 @@ let MidwayWebRouterService = class MidwayWebRouterService {
             this.includeCompileUrlPattern = true;
             // attach match pattern function
             for (const item of routeArr) {
-                item.urlCompiledPattern = (0, pathToRegexp_1.pathToRegexp)(item.url, [], {
-                    end: false,
-                });
+                if (item.fullUrlFlattenString) {
+                    item.fullUrlCompiledRegexp = pathToRegexp_1.PathToRegexpUtil.toRegexp(item.fullUrlFlattenString);
+                }
             }
         }
         this.cachedFlattenRouteList = routeArr;
@@ -292,9 +291,9 @@ let MidwayWebRouterService = class MidwayWebRouterService {
         });
         let matchedRouterInfo;
         for (const item of routes) {
-            if (item.urlCompiledPattern) {
+            if (item.fullUrlCompiledRegexp) {
                 if (method.toUpperCase() === item['requestMethod'].toUpperCase() &&
-                    item.urlCompiledPattern.test(routerUrl)) {
+                    item.fullUrlCompiledRegexp.test(routerUrl)) {
                     matchedRouterInfo = item;
                     break;
                 }
@@ -313,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,24 +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.
  */
-export interface PathToRegexpOptions {
-    end?: boolean;
+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;
-    sensitive?: boolean;
+    /**
+     * 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: string | RegExp | Array<string>, options?: PathToRegexpOptions): RegExp;
-export declare function pathToRegexp(path: string | RegExp | Array<string>, keys: Array<string>, options?: PathToRegexpOptions): RegExp;
+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,268 +1,401 @@
 "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 escapeGroup(group) {
-    return group.replace(/([=!:$/()])/g, '\\$1');
+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;
+    };
 }
 /**
- * Attach the keys as a property of the regexp.
- *
- * @param  {!RegExp} re
- * @param  {Array}   keys
- * @return {!RegExp}
+ * Create path match function from `path-to-regexp` spec.
  */
-function attachKeys(re, keys) {
-    re.keys = keys;
-    return re;
+function match(str, options) {
+    const keys = [];
+    const re = toRegexp(str, keys, options);
+    return regexpToFunction(re, keys, options);
+}
+/**
+ * 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 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));
 }
-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);
+/**
+ * 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 }]`.
+ */
+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.6",
+  "version": "3.4.0-beta.9",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,7 +21,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.4.0-beta.6",
+    "@midwayjs/decorator": "^3.4.0-beta.9",
     "koa": "2.13.4",
     "midway-test-component": "*",
     "mm": "3.2.0",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "8e187c4593d4832de32b6745af3e195f6b90816c"
+  "gitHead": "41e82a0fba386c6ec42c2eefd1dff4795a81b389"
 }