@koa/router 15.0.0 → 15.1.1

package/dist/index.js

@@ -30,13 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Router: () => Router,
-  default: () => Router
+  Router: () => RouterExport,
+  default: () => router_default
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/router.ts
-var import_debug = __toESM(require("debug"));
 var import_koa_compose = __toESM(require("koa-compose"));
 var import_http_errors = __toESM(require("http-errors"));
 
@@ -82,7 +81,7 @@ function normalizeLayerOptionsToPathToRegexp(options = {}) {
   return normalized;
 }
 
-// src/layer.ts
+// src/utils/safe-decode-uri-components.ts
 function safeDecodeURIComponent(text) {
   try {
     return decodeURIComponent(text);
@@ -90,6 +89,8 @@ function safeDecodeURIComponent(text) {
     return text;
   }
 }
+
+// src/layer.ts
 var Layer = class {
   opts;
   name;
@@ -230,9 +231,15 @@ var Layer = class {
    *
    * @param args - URL parameters (various formats supported)
    * @returns Generated URL
+   * @throws Error if route path is a RegExp (cannot generate URL from RegExp)
    * @private
    */
   url(...arguments_) {
+    if (this.path instanceof RegExp) {
+      throw new TypeError(
+        "Cannot generate URL for routes defined with RegExp paths. Use string paths with named parameters instead."
+      );
+    }
     const { params, options } = this._parseUrlArguments(arguments_);
     const cleanPath = this.path.replaceAll("(.*)", "");
     const pathCompiler = compilePath(cleanPath, {
@@ -259,20 +266,28 @@ var Layer = class {
    * @private
    */
   _parseUrlArguments(allArguments) {
-    let parameters = allArguments[0];
+    let parameters = allArguments[0] ?? {};
     let options = allArguments[1];
-    if (typeof parameters !== "object") {
+    if (typeof parameters !== "object" || parameters === null) {
       const argumentsList = [...allArguments];
       const lastArgument = argumentsList.at(-1);
-      if (typeof lastArgument === "object") {
+      if (typeof lastArgument === "object" && lastArgument !== null) {
         options = lastArgument;
         parameters = argumentsList.slice(0, -1);
       } else {
         parameters = argumentsList;
       }
-    } else if (parameters && parameters.query && !options) {
-      options = parameters;
-      parameters = {};
+    } else if (parameters && !options) {
+      const parameterKeys = Object.keys(parameters);
+      const isOnlyOptions = parameterKeys.length === 1 && parameterKeys[0] === "query";
+      if (isOnlyOptions) {
+        options = parameters;
+        parameters = {};
+      } else if ("query" in parameters && parameters.query) {
+        const { query, ...restParameters } = parameters;
+        options = { query };
+        parameters = restParameters;
+      }
     }
     return { params: parameters, options };
   }
@@ -295,7 +310,7 @@ var Layer = class {
           );
         }
       }
-    } else if (hasNamedParameters && typeof parameters === "object" && !parameters.query) {
+    } else if (hasNamedParameters && typeof parameters === "object" && !("query" in parameters)) {
       for (const [parameterName, parameterValue] of Object.entries(
         parameters
       )) {
@@ -309,14 +324,19 @@ var Layer = class {
    * @private
    */
   _addQueryString(baseUrl, query) {
-    const parsedUrl = (0, import_node_url.parse)(baseUrl);
+    const parsed = (0, import_node_url.parse)(baseUrl);
+    const urlObject = {
+      ...parsed,
+      query: parsed.query ?? void 0
+    };
     if (typeof query === "string") {
-      parsedUrl.search = query;
+      urlObject.search = query;
+      urlObject.query = void 0;
     } else {
-      parsedUrl.search = void 0;
-      parsedUrl.query = query;
+      urlObject.search = void 0;
+      urlObject.query = query;
     }
-    return (0, import_node_url.format)(parsedUrl);
+    return (0, import_node_url.format)(urlObject);
   }
   /**
    * Run validations on route named parameters.
@@ -366,7 +386,7 @@ var Layer = class {
    * @private
    */
   _createParamMiddleware(parameterName, parameterHandler) {
-    const middleware = function(context, next) {
+    const middleware = ((context, next) => {
       if (!context._matchedParams) {
         context._matchedParams = /* @__PURE__ */ new WeakMap();
       }
@@ -374,13 +394,8 @@ var Layer = class {
         return next();
       }
       context._matchedParams.set(parameterHandler, true);
-      return parameterHandler.call(
-        this,
-        context.params[parameterName],
-        context,
-        next
-      );
-    };
+      return parameterHandler(context.params[parameterName], context, next);
+    });
     middleware.param = parameterName;
     middleware._originalFn = parameterHandler;
     return middleware;
@@ -390,20 +405,26 @@ var Layer = class {
    * @private
    */
   _insertParamMiddleware(middlewareStack, parameterMiddleware, parameterNamesList, currentParameterPosition) {
-    middlewareStack.some((existingMiddleware, stackIndex) => {
+    let inserted = false;
+    for (let stackIndex = 0; stackIndex < middlewareStack.length; stackIndex++) {
+      const existingMiddleware = middlewareStack[stackIndex];
       if (!existingMiddleware.param) {
         middlewareStack.splice(stackIndex, 0, parameterMiddleware);
-        return true;
+        inserted = true;
+        break;
       }
       const existingParameterPosition = parameterNamesList.indexOf(
         existingMiddleware.param
       );
       if (existingParameterPosition > currentParameterPosition) {
         middlewareStack.splice(stackIndex, 0, parameterMiddleware);
-        return true;
+        inserted = true;
+        break;
       }
-      return false;
-    });
+    }
+    if (!inserted) {
+      middlewareStack.push(parameterMiddleware);
+    }
   }
   /**
    * Prefix route path.
@@ -434,7 +455,7 @@ var Layer = class {
     const pathIsRawRegex = this.opts.pathAsRegExp === true && typeof this.path === "string";
     if (prefixHasParameters && pathIsRawRegex) {
       const currentPath = this.path;
-      if (currentPath === String.raw`(?:\/|$)` || currentPath === String.raw`(?:\/|$)`) {
+      if (currentPath === String.raw`(?:\/|$)` || currentPath === String.raw`(?:\\\/|$)`) {
         this.path = "{/*rest}";
         this.opts.pathAsRegExp = false;
       }
@@ -461,7 +482,9 @@ var Layer = class {
       this.paramNames = keys;
       this.opts.pathAsRegExp = false;
     } else if (treatAsRegExp) {
-      this.regexp = this.path instanceof RegExp ? this.path : new RegExp(this.path);
+      const pathString = this.path;
+      const anchoredPattern = pathString.startsWith("^") ? pathString : `^${pathString}`;
+      this.regexp = this.path instanceof RegExp ? this.path : new RegExp(anchoredPattern);
     } else {
       const options = normalizeLayerOptionsToPathToRegexp(this.opts);
       const { regexp, keys } = compilePathToRegexp(
@@ -501,7 +524,9 @@ function normalizeParameterMiddleware(parameterMiddleware) {
   return [parameterMiddleware];
 }
 function applyParameterMiddlewareToRoute(route, parameterName, parameterMiddleware) {
-  const middlewareList = normalizeParameterMiddleware(parameterMiddleware);
+  const middlewareList = normalizeParameterMiddleware(
+    parameterMiddleware
+  );
   for (const middleware of middlewareList) {
     route.param(parameterName, middleware);
   }
@@ -510,7 +535,11 @@ function applyAllParameterMiddleware(route, parametersObject) {
   const parameterNames = Object.keys(parametersObject);
   for (const parameterName of parameterNames) {
     const parameterMiddleware = parametersObject[parameterName];
-    applyParameterMiddlewareToRoute(route, parameterName, parameterMiddleware);
+    applyParameterMiddlewareToRoute(
+      route,
+      parameterName,
+      parameterMiddleware
+    );
   }
 }
 
@@ -559,8 +588,11 @@ function determineMiddlewarePath(explicitPath, hasPrefixParameters) {
   };
 }
 
-// src/router.ts
+// src/utils/debug.ts
+var import_debug = __toESM(require("debug"));
 var debug = (0, import_debug.default)("koa-router");
+
+// src/router.ts
 var httpMethods = getAllHttpMethods();
 var Router = class {
   opts;
@@ -640,6 +672,11 @@ var Router = class {
     if (hasExplicitPath) {
       explicitPath = middleware.shift();
     }
+    if (middleware.length === 0) {
+      throw new Error(
+        "You must provide at least one middleware function to router.use()"
+      );
+    }
     for (const currentMiddleware of middleware) {
       if (this._isNestedRouter(currentMiddleware)) {
         this._mountNestedRouter(
@@ -657,11 +694,11 @@ var Router = class {
     return this;
   }
   /**
-   * Check if first argument is an array of paths
+   * Check if first argument is an array of paths (all elements must be strings)
    * @private
    */
   _isPathArray(firstArgument) {
-    return Array.isArray(firstArgument) && typeof firstArgument[0] === "string";
+    return Array.isArray(firstArgument) && firstArgument.length > 0 && firstArgument.every((item) => typeof item === "string");
   }
   /**
    * Check if first argument is an explicit path (string or RegExp)
@@ -676,7 +713,7 @@ var Router = class {
    * @private
    */
   _isNestedRouter(middleware) {
-    return middleware.router !== void 0;
+    return typeof middleware === "function" && "router" in middleware && middleware.router !== void 0;
   }
   /**
    * Apply middleware to multiple paths
@@ -731,14 +768,22 @@ var Router = class {
     );
   }
   /**
-   * Clone a layer instance
+   * Clone a layer instance (deep clone to avoid shared references)
    * @private
    */
   _cloneLayer(sourceLayer) {
-    return Object.assign(
+    const cloned = Object.assign(
       Object.create(Object.getPrototypeOf(sourceLayer)),
-      sourceLayer
+      sourceLayer,
+      {
+        // Deep clone arrays and objects to avoid shared references
+        stack: [...sourceLayer.stack],
+        methods: [...sourceLayer.methods],
+        paramNames: [...sourceLayer.paramNames],
+        opts: { ...sourceLayer.opts }
+      }
     );
+    return cloned;
   }
   /**
    * Apply this router's param middleware to a nested router
@@ -789,6 +834,7 @@ var Router = class {
   }
   /**
    * Set the path prefix for a Router instance that was already initialized.
+   * Note: Calling this method multiple times will replace the prefix, not stack them.
    *
    * @example
    *
@@ -801,8 +847,12 @@ var Router = class {
    */
   prefix(prefixPath) {
     const normalizedPrefix = prefixPath.replace(/\/$/, "");
+    const previousPrefix = this.opts.prefix || "";
     this.opts.prefix = normalizedPrefix;
     for (const route of this.stack) {
+      if (previousPrefix && typeof route.path === "string" && route.path.startsWith(previousPrefix)) {
+        route.path = route.path.slice(previousPrefix.length) || "/";
+      }
       route.setPrefix(normalizedPrefix);
     }
     return this;
@@ -831,7 +881,10 @@ var Router = class {
         matchedLayers,
         requestPath
       );
-      return (0, import_koa_compose.default)(middlewareChain)(context, next);
+      return (0, import_koa_compose.default)(middlewareChain)(
+        context,
+        next
+      );
     }.bind(this);
     dispatchMiddleware.router = this;
     return dispatchMiddleware;
@@ -841,17 +894,19 @@ var Router = class {
    * @private
    */
   _getRequestPath(context) {
-    return this.opts.routerPath || context.newRouterPath || context.path || context.routerPath || "";
+    const context_ = context;
+    return this.opts.routerPath || context_.newRouterPath || context_.path || context_.routerPath || "";
   }
   /**
    * Store matched routes on context
    * @private
    */
   _storeMatchedRoutes(context, matchResult) {
-    if (context.matched) {
-      context.matched.push(...matchResult.path);
+    const context_ = context;
+    if (context_.matched) {
+      context_.matched.push(...matchResult.path);
     } else {
-      context.matched = matchResult.path;
+      context_.matched = matchResult.path;
     }
   }
   /**
@@ -859,11 +914,12 @@ var Router = class {
    * @private
    */
   _setMatchedRouteInfo(context, matchedLayers) {
+    const context_ = context;
     const routeLayer = matchedLayers.toReversed().find((layer) => layer.methods.length > 0);
     if (routeLayer) {
-      context._matchedRoute = routeLayer.path;
+      context_._matchedRoute = routeLayer.path;
       if (routeLayer.name) {
-        context._matchedRouteName = routeLayer.name;
+        context_._matchedRouteName = routeLayer.name;
       }
     }
   }
@@ -950,11 +1006,11 @@ var Router = class {
         if (!this._shouldProcessAllowedMethods(routerContext)) {
           return;
         }
-        const allowedMethods = this._collectAllowedMethods(
-          routerContext.matched
-        );
+        const matchedRoutes = routerContext.matched || [];
+        const allowedMethods = this._collectAllowedMethods(matchedRoutes);
         const allowedMethodsList = Object.keys(allowedMethods);
-        if (!implementedMethods.includes(context.method)) {
+        const requestMethod = context.method.toUpperCase();
+        if (!implementedMethods.includes(requestMethod)) {
           this._handleNotImplemented(
             routerContext,
             allowedMethodsList,
@@ -962,11 +1018,11 @@ var Router = class {
           );
           return;
         }
-        if (context.method === "OPTIONS" && allowedMethodsList.length > 0) {
+        if (requestMethod === "OPTIONS" && allowedMethodsList.length > 0) {
           this._handleOptionsRequest(routerContext, allowedMethodsList);
           return;
         }
-        if (allowedMethodsList.length > 0 && !allowedMethods[context.method]) {
+        if (allowedMethodsList.length > 0 && !allowedMethods[requestMethod]) {
           this._handleMethodNotAllowed(
             routerContext,
             allowedMethodsList,
@@ -1080,12 +1136,12 @@ var Router = class {
   redirect(source, destination, code) {
     let resolvedSource = source;
     let resolvedDestination = destination;
-    if (typeof source === "symbol" || source[0] !== "/") {
+    if (typeof source === "symbol" || typeof source === "string" && source[0] !== "/") {
       const sourceUrl = this.url(source);
       if (sourceUrl instanceof Error) throw sourceUrl;
       resolvedSource = sourceUrl;
     }
-    if (typeof destination === "symbol" || destination[0] !== "/" && !destination.includes("://")) {
+    if (typeof destination === "symbol" || typeof destination === "string" && destination[0] !== "/" && !destination.includes("://")) {
       const destinationUrl = this.url(destination);
       if (destinationUrl instanceof Error) throw destinationUrl;
       resolvedDestination = destinationUrl;
@@ -1202,7 +1258,7 @@ var Router = class {
    */
   url(name, ...arguments_) {
     const route = this.route(name);
-    if (route) return route.url.apply(route, arguments_);
+    if (route) return route.url(...arguments_);
     return new Error(`No route found for name: ${String(name)}`);
   }
   /**
@@ -1219,12 +1275,13 @@ var Router = class {
       pathAndMethod: [],
       route: false
     };
+    const normalizedMethod = method.toUpperCase();
     for (const layer of this.stack) {
       debug("test %s %s", layer.path, layer.regexp);
       if (layer.match(path)) {
         matchResult.path.push(layer);
         const isMiddleware = layer.methods.length === 0;
-        const matchesMethod = layer.methods.includes(method);
+        const matchesMethod = layer.methods.includes(normalizedMethod);
         if (isMiddleware || matchesMethod) {
           matchResult.pathAndMethod.push(layer);
           if (layer.methods.length > 0) {
@@ -1350,7 +1407,10 @@ var Router = class {
     return this._registerMethod("delete", ...arguments_);
   }
   del(...arguments_) {
-    return this.delete.apply(this, arguments_);
+    return this.delete.apply(
+      this,
+      arguments_
+    );
   }
   head(...arguments_) {
     return this._registerMethod("head", ...arguments_);
@@ -1359,8 +1419,10 @@ var Router = class {
     return this._registerMethod("options", ...arguments_);
   }
 };
+var RouterExport = Router;
+var router_default = RouterExport;
 for (const httpMethod of httpMethods) {
-  const isAlreadyDefined = COMMON_HTTP_METHODS.includes(httpMethod) || Router.prototype[httpMethod];
+  const isAlreadyDefined = COMMON_HTTP_METHODS.includes(httpMethod) || httpMethod in Router.prototype;
   if (!isAlreadyDefined) {
     Object.defineProperty(Router.prototype, httpMethod, {
       value: function(...arguments_) {
@@ -1376,3 +1438,7 @@ for (const httpMethod of httpMethods) {
 0 && (module.exports = {
   Router
 });
+if (module.exports.default) {
+  Object.assign(module.exports.default, module.exports);
+  module.exports = module.exports.default;
+}