@stacksjs/bun-router 0.0.2 → 0.0.3

package/dist/index.js

@@ -4,22 +4,27 @@ import {
   Cors,
   Csrf,
   DDoSProtection,
+  DatabaseSessionStore,
   FileSecurity,
+  FileSessionStore,
   FileUpload,
   Helmet,
   InMemoryNonceStore,
   InputValidation,
   JsonBody,
+  MemorySessionStore,
   PerformanceAlerting,
   PerformanceDashboard,
   PerformanceMonitor,
   RateLimit,
+  RedisSessionStore,
   RequestId,
   RequestSigning,
   RequestTracer,
   Security,
   SecuritySuite,
   Session,
+  SessionManager,
   SignatureError,
   __export,
   __require,
@@ -30,6 +35,7 @@ import {
   config,
   contentSecurityPolicy,
   cors,
+  createSessionStore,
   csrf,
   ddosProtection,
   defaultConfig,
@@ -38,6 +44,7 @@ import {
   extractBasicAuth,
   extractBearerToken,
   fileUpload,
+  generateSessionId,
   getConfig,
   imageUpload,
   inputValidation,
@@ -59,7 +66,7 @@ import {
   signRequest,
   singleFileUpload,
   verifySignature
-} from "./chunk-r15a48wc.js";
+} from "./chunk-cjdekj87.js";
 
 // src/auth.ts
 function base64UrlEncode(str) {
@@ -3337,7 +3344,7 @@ var MiddlewareFactory = {
     };
   },
   cors: (options = {}) => {
-    return async (req, next) => {
+    return async (_req, next) => {
       const response2 = await next();
       if (response2) {
         const headers = new Headers(response2.headers);
@@ -3369,9 +3376,147 @@ var MiddlewareFactory = {
 };
 var globalMiddlewarePipeline = new MiddlewarePipeline;
 
+// src/router/api-routes.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, extname, join, resolve } from "path";
+var ROUTE_EXTENSIONS = [".ts", ".js"];
+var ROUTES_DIRS = ["routes", "src/routes"];
+var ROOT_ROUTE_FILES = ["web", "index"];
+function detectRoutesDirectory() {
+  const cwd = process.cwd();
+  for (const dir of ROUTES_DIRS) {
+    const fullPath = resolve(cwd, dir);
+    if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function discoverRouteFiles(dir, baseDir) {
+  const results = [];
+  if (!existsSync(dir))
+    return results;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+      continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...discoverRouteFiles(fullPath, baseDir));
+    } else if (ROUTE_EXTENSIONS.includes(extname(entry.name))) {
+      const relDir = dir === baseDir ? "" : dir.slice(baseDir.length);
+      const name = basename(entry.name, extname(entry.name));
+      const prefix = ROOT_ROUTE_FILES.includes(name) ? relDir || "" : `${relDir}/${name}`;
+      results.push({ filePath: fullPath, prefix });
+    }
+  }
+  return results;
+}
+async function loadRouteFile(router, filePath, prefix, verbose) {
+  try {
+    const mod = await import(filePath);
+    let count = 0;
+    const routesBefore = router.routes?.length || 0;
+    if (typeof mod.default === "function") {
+      const prefixedRouter = createPrefixedProxy(router, prefix);
+      await mod.default(prefixedRouter);
+      count = (router.routes?.length || 0) - routesBefore;
+    } else if (Array.isArray(mod.routes)) {
+      for (const route of mod.routes) {
+        const method = (route.method || "GET").toLowerCase();
+        const path = `${prefix}${route.path}`;
+        if (typeof router[method] === "function") {
+          await router[method](path, route.handler);
+          count++;
+        }
+      }
+    }
+    if (verbose && count > 0) {
+      console.log(`  ${prefix || "/"} \u2192 ${basename(filePath)} (${count} routes)`);
+    }
+    return count;
+  } catch (error) {
+    console.error(`[bun-router] Failed to load route file ${filePath}:`, error);
+    return 0;
+  }
+}
+function createPrefixedProxy(router, prefix) {
+  if (!prefix)
+    return router;
+  const methods = ["get", "post", "put", "patch", "delete", "options", "any"];
+  return new Proxy(router, {
+    get(target, prop) {
+      if (methods.includes(prop)) {
+        return async (path, ...args) => {
+          return target[prop](`${prefix}${path}`, ...args);
+        };
+      }
+      if (prop === "group") {
+        return async (options, callback) => {
+          const nestedPrefix = options.prefix ? `${prefix}${options.prefix}` : prefix;
+          return target.group({ ...options, prefix: nestedPrefix }, callback);
+        };
+      }
+      return target[prop];
+    }
+  });
+}
+function registerApiRoutes(RouterClass) {
+  Object.defineProperties(RouterClass.prototype, {
+    _routesDir: {
+      value: null,
+      writable: true,
+      configurable: true
+    },
+    _apiRoutesInitialized: {
+      value: false,
+      writable: true,
+      configurable: true
+    },
+    _initApiRoutes: {
+      async value() {
+        if (this._apiRoutesInitialized)
+          return;
+        const routesDir = this._routesDir || detectRoutesDirectory();
+        if (!routesDir) {
+          this._apiRoutesInitialized = true;
+          return;
+        }
+        const verbose = this.config?.verbose || false;
+        const files = discoverRouteFiles(routesDir, routesDir);
+        if (files.length === 0) {
+          this._apiRoutesInitialized = true;
+          return;
+        }
+        if (verbose) {
+          console.log(`[bun-router] Auto-discovering API routes from ${routesDir}:`);
+        }
+        let totalRoutes = 0;
+        for (const { filePath, prefix } of files) {
+          totalRoutes += await loadRouteFile(this, filePath, prefix, verbose);
+        }
+        if (totalRoutes > 0 && verbose) {
+          console.log(`[bun-router] Registered ${totalRoutes} API routes`);
+        }
+        this._apiRoutesInitialized = true;
+      },
+      writable: true,
+      configurable: true
+    },
+    routesFrom: {
+      value(dir) {
+        this._routesDir = resolve(dir);
+        return this;
+      },
+      writable: true,
+      configurable: true
+    }
+  });
+}
+
 // src/router/file-based-routing.ts
-import { join, relative, resolve, dirname } from "path";
-import { readdirSync, statSync, existsSync } from "fs";
+import { join as join2, relative, resolve as resolve2, dirname } from "path";
+import { readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync2 } from "fs";
 
 // src/utils/query-preservation.ts
 var defaultQueryPreservationConfig = {
@@ -3403,11 +3548,13 @@ function generateQueryPreservationScript(config2) {
           if (pattern.endsWith('*')) {
             return path.startsWith(pattern.slice(0, -1));
           }
+          // eslint-disable-next-line prefer-template
           return path === pattern || path.startsWith(pattern + '/');
         });
       }
       return true;
-    } catch (e) { return false; }
+    }
+catch (e) { return false; }
   }
 
   function getPreservedParams() {
@@ -3518,18 +3665,18 @@ var DEFAULT_EXCLUDES = [
 var DEFAULT_EXTENSIONS = [".stx", ".html"];
 function detectViewsDirectory(cwd = process.cwd()) {
   for (const dir of DEFAULT_VIEW_DIRECTORIES) {
-    const fullPath = resolve(cwd, dir);
-    if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
+    const fullPath = resolve2(cwd, dir);
+    if (existsSync2(fullPath) && statSync2(fullPath).isDirectory()) {
       return fullPath;
     }
   }
   return null;
 }
 function hasRoutableFiles(dir, extensions, exclude) {
-  if (!existsSync(dir))
+  if (!existsSync2(dir))
     return false;
   try {
-    const entries = readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (exclude.some((pattern) => entry.name.startsWith(pattern) || entry.name === pattern)) {
         continue;
@@ -3538,7 +3685,7 @@ function hasRoutableFiles(dir, extensions, exclude) {
         return true;
       }
       if (entry.isDirectory()) {
-        const subDir = join(dir, entry.name);
+        const subDir = join2(dir, entry.name);
         if (hasRoutableFiles(subDir, extensions, exclude)) {
           return true;
         }
@@ -3569,7 +3716,7 @@ function filePathToRoutePath(filePath, viewsDir, extensions) {
     return `{${param}}`;
   });
   if (!routePath.startsWith("/")) {
-    routePath = "/" + routePath;
+    routePath = `/${routePath}`;
   }
   if (routePath === "/") {
     return { routePath: "/", params };
@@ -3578,12 +3725,12 @@ function filePathToRoutePath(filePath, viewsDir, extensions) {
 }
 function discoverRoutes(dir, viewsDir, extensions, exclude) {
   const routes = [];
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     return routes;
   }
-  const entries = readdirSync(dir, { withFileTypes: true });
+  const entries = readdirSync2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (exclude.some((pattern) => entry.name.startsWith(pattern) || entry.name === pattern)) {
       continue;
     }
@@ -3631,18 +3778,18 @@ function discoverRoutes(dir, viewsDir, extensions, exclude) {
 function findPrebuiltView(stxFilePath, viewsDir) {
   const relativePath = relative(viewsDir, stxFilePath);
   const prebuiltLocations = [
-    resolve(process.cwd(), "dist/views", relativePath.replace(/\.stx$/, ".html")),
-    resolve(process.cwd(), "views", relativePath.replace(/\.stx$/, ".html")),
-    resolve("/var/task/views", relativePath.replace(/\.stx$/, ".html"))
+    resolve2(process.cwd(), "dist/views", relativePath.replace(/\.stx$/, ".html")),
+    resolve2(process.cwd(), "views", relativePath.replace(/\.stx$/, ".html")),
+    resolve2("/var/task/views", relativePath.replace(/\.stx$/, ".html"))
   ];
   for (const location of prebuiltLocations) {
-    if (existsSync(location)) {
+    if (existsSync2(location)) {
       return location;
     }
   }
   return null;
 }
-async function renderStxFile(filePath, viewsDir, data) {
+async function renderStxFile(filePath, viewsDir, data, routingConfig) {
   const stxModule = "@stacksjs/stx";
   const stx = await import(stxModule);
   if (!stx.processDirectives || !stx.extractVariables) {
@@ -3662,15 +3809,18 @@ async function renderStxFile(filePath, viewsDir, data) {
   if (scriptContent) {
     await stx.extractVariables(scriptContent, context, filePath);
   }
+  const resolvedComponentsDir = routingConfig?.componentsDir ? resolve2(routingConfig.componentsDir) : join2(viewsDir, "components");
+  const resolvedLayoutsDir = routingConfig?.layoutsDir ? resolve2(routingConfig.layoutsDir) : join2(viewsDir, "layouts");
+  const resolvedPartialsDir = routingConfig?.partialsDir ? resolve2(routingConfig.partialsDir) : join2(viewsDir, "partials");
   const config2 = {
     ...stx.defaultConfig,
-    componentsDir: join(viewsDir, "components"),
-    layoutsDir: join(viewsDir, "layouts"),
-    partialsDir: join(viewsDir, "partials")
+    componentsDir: resolvedComponentsDir,
+    layoutsDir: resolvedLayoutsDir,
+    partialsDir: resolvedPartialsDir
   };
   return stx.processDirectives(templateContent, context, filePath, config2, new Set);
 }
-function createViewHandler(filePath, viewsDir, _config, queryPreservationConfig) {
+function createViewHandler(filePath, viewsDir, config2, queryPreservationConfig) {
   return async (req) => {
     const url = new URL(req.url);
     const data = {
@@ -3698,7 +3848,7 @@ function createViewHandler(filePath, viewsDir, _config, queryPreservationConfig)
         });
       }
       if (filePath.endsWith(".stx")) {
-        let html = await renderStxFile(filePath, viewsDir, data);
+        let html = await renderStxFile(filePath, viewsDir, data, config2);
         html = applyQueryPreservation(html);
         return new Response(html, {
           status: 200,
@@ -3767,7 +3917,7 @@ function registerFileBasedRouting(RouterClass) {
           const handler = createViewHandler(route.filePath, viewsDir, config2, this.config.queryPreservation);
           const existingRoute = this.routes.find((r) => r.path === route.routePath && r.method === "GET");
           if (!existingRoute) {
-            await this.get(route.routePath, handler, "web");
+            this.get(route.routePath, handler, "web");
             this._fileBasedRoutes.push(route);
           }
         }
@@ -3779,11 +3929,11 @@ function registerFileBasedRouting(RouterClass) {
     views: {
       value(config2) {
         if (typeof config2 === "string") {
-          this._viewsDir = resolve(config2);
+          this._viewsDir = resolve2(config2);
           this._fileRoutingConfig = {};
         } else {
           if (config2.viewsPath) {
-            this._viewsDir = resolve(config2.viewsPath);
+            this._viewsDir = resolve2(config2.viewsPath);
           }
           this._fileRoutingConfig = config2;
         }
@@ -3810,7 +3960,7 @@ function registerFileBasedRouting(RouterClass) {
     fileRoutes: {
       async value(viewsPath, options) {
         if (viewsPath) {
-          this._viewsDir = resolve(viewsPath);
+          this._viewsDir = resolve2(viewsPath);
         }
         if (options) {
           this._fileRoutingConfig = { ...this._fileRoutingConfig, ...options };
@@ -4136,10 +4286,10 @@ function registerFileStreaming(RouterClass) {
       configurable: true
     },
     health: {
-      async value() {
+      value() {
         const path = "/health";
         const fullPath = this.config.apiPrefix ? `${this.config.apiPrefix}${path}` : path;
-        await this.get(fullPath, () => {
+        this.get(fullPath, () => {
           return new Response("OK", {
             headers: {
               "Content-Type": "text/plain"
@@ -4395,7 +4545,7 @@ class ModelBindingRegistry {
   }
 }
 var modelRegistry = new ModelBindingRegistry;
-async function resolveModel(paramName, value, modelWrapper, customKey, _context = {}) {
+async function resolveModel(_paramName, value, modelWrapper, customKey, _context = {}) {
   if (customKey) {
     return await modelWrapper.resolveRouteBinding(value, customKey);
   }
@@ -5917,7 +6067,7 @@ var RouterUtils = {
 var router = new FluentRouter;
 
 // src/utils.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function normalizePath(path) {
   let normalizedPath = path.replace(/\/+/g, "/");
   if (!normalizedPath.startsWith("/")) {
@@ -6031,14 +6181,14 @@ async function fileExists(path) {
 }
 async function resolveViewPath(viewName, viewsPath, extensions) {
   if (extensions.some((ext) => viewName.endsWith(ext))) {
-    const fullPath = normalizePath(join2(viewsPath, viewName));
+    const fullPath = normalizePath(join3(viewsPath, viewName));
     if (await fileExists(fullPath)) {
       return fullPath;
     }
     return null;
   }
   for (const ext of extensions) {
-    const fullPath = normalizePath(join2(viewsPath, `${viewName}${ext}`));
+    const fullPath = normalizePath(join3(viewsPath, `${viewName}${ext}`));
     if (await fileExists(fullPath)) {
       return fullPath;
     }
@@ -6056,19 +6206,19 @@ function processHtmlTemplate(template, data) {
   return result;
 }
 function processConditionals(template, data) {
-  return template.replace(/\{\{#if ([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (match, condition, content, alternative = "") => {
+  return template.replace(/\{\{#if ([^}]+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (_match, condition, content, alternative = "") => {
     const conditionTrimmed = condition.trim();
     const value = getNestedValue(data, conditionTrimmed);
     return value ? content : alternative;
   });
 }
 function processLoops(template, data) {
-  return template.replace(/\{\{#each ([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g, (match, arrayKey, content) => {
+  return template.replace(/\{\{#each ([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g, (_match, arrayKey, content) => {
     const array = getNestedValue(data, arrayKey.trim());
     if (!Array.isArray(array))
       return "";
     return array.map((item) => {
-      return content.replace(/\{\{@index\}\}/g, String(array.indexOf(item))).replace(/\{\{this\}\}/g, String(item)).replace(/\{\{this\.([^}]+)\}\}/g, (matchStr, prop) => {
+      return content.replace(/\{\{@index\}\}/g, String(array.indexOf(item))).replace(/\{\{this\}\}/g, String(item)).replace(/\{\{this\.([^}]+)\}\}/g, (_matchStr, prop) => {
         const value = item[prop.trim()];
         return value !== undefined ? String(value) : "";
       });
@@ -6085,7 +6235,7 @@ function getNestedValue(obj, path) {
 function registerGroupOrganization(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     group: {
-      async value(options, callback) {
+      value(options, callback) {
         const previousGroup = this.currentGroup;
         const newGroup = { ...previousGroup };
         if (options.prefix && previousGroup?.prefix) {
@@ -6108,7 +6258,7 @@ function registerGroupOrganization(RouterClass) {
       configurable: true
     },
     name: {
-      async value(prefix, callback) {
+      value(prefix, callback) {
         const previousGroup = this.currentGroup || {};
         const newGroup = { ...previousGroup };
         this.currentGroup = newGroup;
@@ -6127,7 +6277,7 @@ function registerGroupOrganization(RouterClass) {
       configurable: true
     },
     controller: {
-      async value(controller, callback) {
+      value(controller, callback) {
         const previousGroup = this.currentGroup || {};
         const newGroup = { ...previousGroup, controller };
         this.currentGroup = newGroup;
@@ -6139,7 +6289,7 @@ function registerGroupOrganization(RouterClass) {
       configurable: true
     },
     domain: {
-      async value(domain, callback) {
+      value(domain, callback) {
         const previousDomain = this.currentDomain;
         this.currentDomain = domain;
         callback();
@@ -6150,14 +6300,14 @@ function registerGroupOrganization(RouterClass) {
       configurable: true
     },
     prefix: {
-      async value(prefix, callback) {
+      value(prefix, callback) {
         return this.group({ prefix }, callback);
       },
       writable: true,
       configurable: true
     },
     resource: {
-      async value(name, handler, type = "api") {
+      value(name, handler, type = "api") {
         const pluralName = name.endsWith("s") ? name : `${name}s`;
         const singularName = name.endsWith("s") ? name.slice(0, -1) : name;
         const routes = [
@@ -6169,7 +6319,7 @@ function registerGroupOrganization(RouterClass) {
           { name: "update", method: "PUT", path: `/${pluralName}/{id}`, action: "update" },
           { name: "destroy", method: "DELETE", path: `/${pluralName}/{id}`, action: "destroy" }
         ];
-        await this.name(singularName, async () => {
+        this.name(singularName, () => {
           for (const route of routes) {
             let routeHandler;
             if (typeof handler === "string") {
@@ -6183,16 +6333,16 @@ function registerGroupOrganization(RouterClass) {
             }
             switch (route.method) {
               case "GET":
-                await this.get(route.path, routeHandler, type, route.name);
+                this.get(route.path, routeHandler, type, route.name);
                 break;
               case "POST":
-                await this.post(route.path, routeHandler, type, route.name);
+                this.post(route.path, routeHandler, type, route.name);
                 break;
               case "PUT":
-                await this.put(route.path, routeHandler, type, route.name);
+                this.put(route.path, routeHandler, type, route.name);
                 break;
               case "DELETE":
-                await this.delete(route.path, routeHandler, type, route.name);
+                this.delete(route.path, routeHandler, type, route.name);
                 break;
             }
           }
@@ -6209,7 +6359,7 @@ function registerGroupOrganization(RouterClass) {
 function registerHttpMethods(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     addRoute: {
-      async value(method, path, handler, type, name, middleware2) {
+      value(method, path, handler, type, name, middleware2) {
         let routePath = path;
         let routeMiddleware = [];
         const routeType = type || "web";
@@ -6223,7 +6373,7 @@ function registerHttpMethods(RouterClass) {
         }
         if (middleware2 && middleware2.length > 0) {
           for (const middlewareItem of middleware2) {
-            const resolved = await this.resolveMiddleware(middlewareItem);
+            const resolved = this.resolveMiddleware(middlewareItem);
             if (resolved) {
               routeMiddleware.push(resolved);
             }
@@ -6272,6 +6422,9 @@ function registerHttpMethods(RouterClass) {
             };
           }
         };
+        if (handler instanceof Response) {
+          this.staticResponses.set(routePath, handler);
+        }
         if (domain) {
           if (!this.domains[domain]) {
             this.domains[domain] = [];
@@ -6284,7 +6437,10 @@ function registerHttpMethods(RouterClass) {
           if (!this.staticRoutes.has(method.toUpperCase())) {
             this.staticRoutes.set(method.toUpperCase(), new Map);
           }
-          this.staticRoutes.get(method.toUpperCase()).set(routePath, route);
+          const methodMap = this.staticRoutes.get(method.toUpperCase());
+          if (!methodMap.has(routePath)) {
+            methodMap.set(routePath, route);
+          }
         }
         if (name) {
           route.name = name;
@@ -6300,51 +6456,51 @@ function registerHttpMethods(RouterClass) {
       configurable: true
     },
     get: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         return this.addRoute("GET", path, handler, type, name, middleware2);
       },
       writable: true,
       configurable: true
     },
     post: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         return this.addRoute("POST", path, handler, type, name, middleware2);
       },
       writable: true,
       configurable: true
     },
     put: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         return this.addRoute("PUT", path, handler, type, name, middleware2);
       },
       writable: true,
       configurable: true
     },
     patch: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         return this.addRoute("PATCH", path, handler, type, name, middleware2);
       },
       writable: true,
       configurable: true
     },
     delete: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         return this.addRoute("DELETE", path, handler, type, name, middleware2);
       },
       writable: true,
       configurable: true
     },
     options: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         return this.addRoute("OPTIONS", path, handler, type, name, middleware2);
       },
       writable: true,
       configurable: true
     },
     match: {
-      async value(methods, path, handler, type, name, middleware2) {
+      value(methods, path, handler, type, name, middleware2) {
         for (const method of methods) {
-          await this.addRoute(method, path, handler, type, name, middleware2);
+          this.addRoute(method, path, handler, type, name, middleware2);
         }
         return this;
       },
@@ -6352,7 +6508,7 @@ function registerHttpMethods(RouterClass) {
       configurable: true
     },
     any: {
-      async value(path, handler, type, name, middleware2) {
+      value(path, handler, type, name, middleware2) {
         const methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
         return this.match(methods, path, handler, type, name, middleware2);
       },
@@ -6415,8 +6571,8 @@ function registerRedirectMethods(RouterClass) {
       configurable: true
     },
     redirectRoute: {
-      async value(from, to, status = 302) {
-        await this.get(from, (_req) => {
+      value(from, to, status = 302) {
+        this.get(from, (_req) => {
           return this.redirect(to, status);
         });
         return this;
@@ -6425,7 +6581,7 @@ function registerRedirectMethods(RouterClass) {
       configurable: true
     },
     permanentRedirectRoute: {
-      async value(from, to) {
+      value(from, to) {
         return this.redirectRoute(from, to, 301);
       },
       writable: true,
@@ -6501,6 +6657,9 @@ function isCallableHandler(handler) {
   return typeof handler === "function" && !handler.prototype?.handle;
 }
 async function resolveHandler(handler, req, config2) {
+  if (handler instanceof Response) {
+    return handler.clone();
+  }
   if (isCallableHandler(handler)) {
     const result = await handler(req);
     return wrapResponse(result);
@@ -6590,9 +6749,9 @@ function createHandlerResolver(config2) {
 function registerMiddlewareHandling(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     use: {
-      async value(...middleware2) {
+      value(...middleware2) {
         for (const mw of middleware2) {
-          const resolvedMiddleware = await this.resolveMiddleware(mw);
+          const resolvedMiddleware = this.resolveMiddleware(mw);
           if (resolvedMiddleware) {
             this.globalMiddleware.push(resolvedMiddleware);
           }
@@ -6603,24 +6762,41 @@ function registerMiddlewareHandling(RouterClass) {
       configurable: true
     },
     resolveMiddleware: {
-      async value(middleware2) {
+      value(middleware2) {
         if (typeof middleware2 === "function") {
           return middleware2;
         }
+        if (typeof middleware2 === "object" && middleware2 !== null && "handle" in middleware2 && typeof middleware2.handle === "function") {
+          return (req, next) => {
+            return middleware2.handle(req, next);
+          };
+        }
         if (typeof middleware2 === "string") {
-          try {
-            const importedMiddleware = await import(`../middleware/${middleware2}.ts`);
-            if (importedMiddleware.default && typeof importedMiddleware.default === "function") {
-              return importedMiddleware.default;
+          const [name, params] = middleware2.split(":");
+          const factory = this.namedMiddleware?.get(name);
+          if (factory) {
+            return factory(params);
+          }
+          let cached = null;
+          const middlewareName = middleware2;
+          return async (req, next) => {
+            if (!cached) {
+              try {
+                const importedMiddleware = await import(`../middleware/${middlewareName}.ts`);
+                if (importedMiddleware.default && typeof importedMiddleware.default === "function") {
+                  cached = importedMiddleware.default;
+                } else if (importedMiddleware.default && typeof importedMiddleware.default.handle === "function") {
+                  cached = (r, n) => importedMiddleware.default.handle(r, n);
+                }
+              } catch (error) {
+                console.error(`Failed to load middleware "${middlewareName}":`, error);
+              }
             }
-            if (importedMiddleware.default && typeof importedMiddleware.default.handle === "function") {
-              return (req, next) => {
-                return importedMiddleware.default.handle(req, next);
-              };
+            if (cached) {
+              return cached(req, next);
             }
-          } catch (error) {
-            console.error(`Failed to load middleware "${middleware2}":`, error);
-          }
+            return next();
+          };
         }
         return null;
       },
@@ -6694,9 +6870,9 @@ function registerMiddlewareHandling(RouterClass) {
       configurable: true
     },
     applyMiddlewareToRoute: {
-      async value(route, middleware2) {
+      value(route, middleware2) {
         for (const mw of middleware2) {
-          const resolvedMiddleware = await this.resolveMiddleware(mw);
+          const resolvedMiddleware = this.resolveMiddleware(mw);
           if (resolvedMiddleware) {
             route.middleware.push(resolvedMiddleware);
           }
@@ -6718,7 +6894,7 @@ function registerMiddlewareHandling(RouterClass) {
       configurable: true
     },
     onError: {
-      async value(handler) {
+      value(handler) {
         this.errorHandler = handler;
         return this;
       },
@@ -7124,7 +7300,7 @@ class RouteTrie {
           optional: paramPart.endsWith("?")
         });
       } else if (part.includes("{")) {
-        const regex = part.replace(/\{([^}:]+)(?::([^}]+))?\}/g, (match, name, pattern) => {
+        const regex = part.replace(/\{([^}:]+)(?::([^}]+))?\}/g, (_match, _name, pattern) => {
           return pattern ? `(${pattern})` : "([^/]+)";
         });
         const paramNames = Array.from(part.matchAll(/\{([^}:]+)(?::([^}]+))?\}/g)).map((match) => match[1].replace("?", ""));
@@ -7401,7 +7577,8 @@ class RouteCompiler {
     }
   }
   convertToURLPattern(path, constraints) {
-    let regexPattern = path.replace(/\{([^}:]+)(?::([^}]+))?\}/g, (match, name, pattern) => {
+    let regexPattern = path.replace(/\{([^}:]+)(?::([^}]+))?\}/g, (_match, name, ..._args) => {
+      const pattern = _args[0];
       if (constraints && constraints[name]) {
         return `(?<${name}>${constraints[name]})`;
       } else if (pattern) {
@@ -7947,7 +8124,7 @@ function registerRouteBuilding(RouterClass) {
               const apiRoutes = await import(this.config.apiRoutesPath);
               if (apiRoutes.default && Array.isArray(apiRoutes.default)) {
                 for (const route of apiRoutes.default) {
-                  await this.registerRoute(route, "api");
+                  this.registerRoute(route, "api");
                 }
               }
             } catch (error) {
@@ -7961,7 +8138,7 @@ function registerRouteBuilding(RouterClass) {
               const webRoutes = await import(this.config.webRoutesPath);
               if (webRoutes.default && Array.isArray(webRoutes.default)) {
                 for (const route of webRoutes.default) {
-                  await this.registerRoute(route, "web");
+                  this.registerRoute(route, "web");
                 }
               }
             } catch (error) {
@@ -7978,26 +8155,26 @@ function registerRouteBuilding(RouterClass) {
       configurable: true
     },
     registerRoute: {
-      async value(route, type) {
+      value(route, type) {
         const { path, method, handler, middleware: middleware2 = [], name } = route;
         switch (method) {
           case "GET":
-            await this.get(path, handler, type, name, middleware2);
+            this.get(path, handler, type, name, middleware2);
             break;
           case "POST":
-            await this.post(path, handler, type, name, middleware2);
+            this.post(path, handler, type, name, middleware2);
             break;
           case "PUT":
-            await this.put(path, handler, type, name, middleware2);
+            this.put(path, handler, type, name, middleware2);
             break;
           case "DELETE":
-            await this.delete(path, handler, type, name, middleware2);
+            this.delete(path, handler, type, name, middleware2);
             break;
           case "PATCH":
-            await this.patch(path, handler, type, name, middleware2);
+            this.patch(path, handler, type, name, middleware2);
             break;
           case "OPTIONS":
-            await this.options(path, handler, type, name, middleware2);
+            this.options(path, handler, type, name, middleware2);
             break;
           default:
             console.warn(`Unsupported HTTP method: ${method}`);
@@ -8260,6 +8437,7 @@ class Router {
   templateCache = new Map;
   routeCache = new Map;
   staticRoutes = new Map;
+  staticResponses = new Map;
   precompiledPatterns = new Map;
   domainPatternCache = new Map;
   routeCompiler = null;
@@ -8351,10 +8529,24 @@ class Router {
     }
     return this;
   }
+  async register(routePath, options) {
+    const callback = async () => {
+      await import(routePath);
+    };
+    if (options?.prefix || options?.middleware && options.middleware.length > 0) {
+      await this.group({
+        prefix: options.prefix,
+        middleware: options.middleware
+      }, callback);
+    } else {
+      await callback();
+    }
+    return this;
+  }
   invalidateCache() {
     this.routeCache.clear();
   }
-  async registerRoute(method, path, handler, type, name, middleware2) {
+  registerRoute(method, path, handler, type, name, middleware2) {
     let routePath = path;
     let routeMiddleware = [];
     const routeType = type || "web";
@@ -8368,7 +8560,7 @@ class Router {
     }
     if (middleware2 && middleware2.length > 0) {
       for (const middlewareItem of middleware2) {
-        const resolved = await this.resolveMiddleware(middlewareItem);
+        const resolved = this.resolveMiddleware(middlewareItem);
         if (resolved) {
           routeMiddleware.push(resolved);
         }
@@ -8438,7 +8630,7 @@ class Router {
     this.routeCache.clear();
     return this;
   }
-  async resolveMiddleware(middleware2) {
+  resolveMiddleware(middleware2) {
     if (typeof middleware2 === "function") {
       return middleware2;
     }
@@ -8449,31 +8641,31 @@ class Router {
     }
     return null;
   }
-  async get(path, handler, type, name, middleware2) {
+  get(path, handler, type, name, middleware2) {
     return this.registerRoute("GET", path, handler, type, name, middleware2);
   }
-  async post(path, handler, type, name, middleware2) {
+  post(path, handler, type, name, middleware2) {
     return this.registerRoute("POST", path, handler, type, name, middleware2);
   }
-  async put(path, handler, type, name, middleware2) {
+  put(path, handler, type, name, middleware2) {
     return this.registerRoute("PUT", path, handler, type, name, middleware2);
   }
-  async patch(path, handler, type, name, middleware2) {
+  patch(path, handler, type, name, middleware2) {
     return this.registerRoute("PATCH", path, handler, type, name, middleware2);
   }
-  async delete(path, handler, type, name, middleware2) {
+  delete(path, handler, type, name, middleware2) {
     return this.registerRoute("DELETE", path, handler, type, name, middleware2);
   }
-  async options(path, handler, type, name, middleware2) {
+  options(path, handler, type, name, middleware2) {
     return this.registerRoute("OPTIONS", path, handler, type, name, middleware2);
   }
-  async match(methods, path, handler, type, name, middleware2) {
+  match(methods, path, handler, type, name, middleware2) {
     for (const method of methods) {
-      await this.registerRoute(method, path, handler, type, name, middleware2);
+      this.registerRoute(method, path, handler, type, name, middleware2);
     }
     return this;
   }
-  async any(path, handler, type, name, middleware2) {
+  any(path, handler, type, name, middleware2) {
     const methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
     return this.match(methods, path, handler, type, name, middleware2);
   }
@@ -8508,8 +8700,8 @@ class Router {
   permanentRedirect(url) {
     return this.redirect(url, 301);
   }
-  async redirectRoute(from, to, status = 302) {
-    await this.get(from, (_req) => {
+  redirectRoute(from, to, status = 302) {
+    this.get(from, (_req) => {
       return this.redirect(to, status);
     });
     return this;
@@ -9082,9 +9274,9 @@ class Router {
     }
     throw new Error(`Invalid action handler: ${typeof handler}`);
   }
-  async use(...middleware2) {
+  use(...middleware2) {
     for (const mw of middleware2) {
-      const resolvedMiddleware = await this.resolveMiddleware(mw);
+      const resolvedMiddleware = this.resolveMiddleware(mw);
       if (resolvedMiddleware) {
         this.globalMiddleware.push(resolvedMiddleware);
       }
@@ -9238,12 +9430,30 @@ function registerServerHandling(RouterClass) {
         if (this._initFileRoutes) {
           await this._initFileRoutes();
         }
+        if (this._initApiRoutes) {
+          await this._initApiRoutes();
+        }
         this.invalidateCache();
         const serverOptions = {
           idleTimeout: 255,
           ...options,
           fetch: this.handleRequest.bind(this)
         };
+        const staticRouteMap = {};
+        if (this.staticResponses && this.staticResponses.size > 0) {
+          for (const [path, response2] of this.staticResponses) {
+            staticRouteMap[path] = response2;
+          }
+        }
+        if (options.static) {
+          Object.assign(staticRouteMap, options.static);
+        }
+        if (Object.keys(staticRouteMap).length > 0) {
+          serverOptions.static = staticRouteMap;
+        }
+        if (options.development !== undefined) {
+          serverOptions.development = options.development;
+        }
         if (this.wsConfig) {
           serverOptions.websocket = this.wsConfig;
         }
@@ -9483,7 +9693,7 @@ function registerServerHandling(RouterClass) {
 }
 
 // src/router/view-rendering.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function registerViewRendering(RouterClass) {
   Object.defineProperties(RouterClass.prototype, {
     renderView: {
@@ -9505,7 +9715,7 @@ function registerViewRendering(RouterClass) {
         let viewContent = await Bun.file(viewPath).text();
         const layoutName = options.layout || viewsConfig.defaultLayout;
         if (layoutName) {
-          const layoutPath = await resolveViewPath(join3("layouts", layoutName), viewsConfig.viewsPath, viewsConfig.extensions);
+          const layoutPath = await resolveViewPath(join4("layouts", layoutName), viewsConfig.viewsPath, viewsConfig.extensions);
           if (!layoutPath) {
             throw new Error(`Layout '${layoutName}' not found`);
           }
@@ -9546,7 +9756,7 @@ function registerViewRendering(RouterClass) {
       configurable: true
     },
     view: {
-      async value(path, viewOrData, dataOrOptions = {}, optionsOrType = {}, typeOrName = "web", name) {
+      value(path, viewOrData, dataOrOptions = {}, optionsOrType = {}, typeOrName = "web", name) {
         let view;
         let data = {};
         let options = {};
@@ -9614,7 +9824,7 @@ function registerViewRendering(RouterClass) {
             headers
           });
         };
-        await this.get(path, handler, type, routeName);
+        this.get(path, handler, type, routeName);
         return this;
       },
       writable: true,
@@ -10790,6 +11000,120 @@ registerServerHandling(Router);
 registerRouteBuilding(Router);
 registerModelBinding(Router);
 registerFileBasedRouting(Router);
+registerApiRoutes(Router);
+// src/router/middleware-groups.ts
+class MiddlewareGroupRegistry {
+  groups = new Map;
+  globalMiddleware = [];
+  middlewarePriority = new Map;
+  define(name, middleware2) {
+    this.groups.set(name, [...middleware2]);
+    return this;
+  }
+  extend(name, middleware2) {
+    const existing = this.groups.get(name) || [];
+    this.groups.set(name, [...existing, ...middleware2]);
+    return this;
+  }
+  prepend(name, middleware2) {
+    const existing = this.groups.get(name) || [];
+    this.groups.set(name, [...middleware2, ...existing]);
+    return this;
+  }
+  get(name) {
+    return this.groups.get(name) || [];
+  }
+  has(name) {
+    return this.groups.has(name);
+  }
+  remove(name) {
+    this.groups.delete(name);
+    return this;
+  }
+  resolve(middleware2) {
+    if (typeof middleware2 === "function") {
+      return [middleware2];
+    }
+    if (this.groups.has(middleware2)) {
+      return this.get(middleware2);
+    }
+    return [middleware2];
+  }
+  resolveAll(middleware2) {
+    const resolved = [];
+    for (const mw of middleware2) {
+      resolved.push(...this.resolve(mw));
+    }
+    return resolved;
+  }
+  pushGlobal(...middleware2) {
+    this.globalMiddleware.push(...middleware2);
+    return this;
+  }
+  prependGlobal(...middleware2) {
+    this.globalMiddleware.unshift(...middleware2);
+    return this;
+  }
+  removeGlobal(middleware2) {
+    this.globalMiddleware = this.globalMiddleware.filter((mw) => typeof mw === "string" ? mw !== middleware2 : true);
+    return this;
+  }
+  getGlobal() {
+    return [...this.globalMiddleware];
+  }
+  setPriority(name, priority) {
+    this.middlewarePriority.set(name, priority);
+    return this;
+  }
+  sortByPriority(middleware2) {
+    return [...middleware2].sort((a, b) => {
+      const nameA = typeof a === "string" ? a.split(":")[0] : "";
+      const nameB = typeof b === "string" ? b.split(":")[0] : "";
+      const priorityA = this.middlewarePriority.get(nameA) ?? 100;
+      const priorityB = this.middlewarePriority.get(nameB) ?? 100;
+      return priorityA - priorityB;
+    });
+  }
+  filter(middleware2, options) {
+    if (options.only && options.only.length > 0) {
+      return middleware2.filter((mw) => {
+        if (typeof mw === "string") {
+          const name = mw.split(":")[0];
+          return options.only.includes(name);
+        }
+        return false;
+      });
+    }
+    if (options.except && options.except.length > 0) {
+      return middleware2.filter((mw) => {
+        if (typeof mw === "string") {
+          const name = mw.split(":")[0];
+          return !options.except.includes(name);
+        }
+        return true;
+      });
+    }
+    return middleware2;
+  }
+  flush() {
+    this.groups.clear();
+    this.globalMiddleware = [];
+    this.middlewarePriority.clear();
+  }
+}
+var middlewareGroups = new MiddlewareGroupRegistry;
+middlewareGroups.define("web", ["session", "csrf", "cors"]);
+middlewareGroups.define("api", ["throttle:60,1", "cors"]);
+middlewareGroups.setPriority("session", 10);
+middlewareGroups.setPriority("cors", 20);
+middlewareGroups.setPriority("csrf", 30);
+middlewareGroups.setPriority("auth", 40);
+middlewareGroups.setPriority("throttle", 50);
+middlewareGroups.setPriority("role", 60);
+middlewareGroups.setPriority("permission", 60);
+middlewareGroups.setPriority("can", 70);
+middlewareGroups.setPriority("abilities", 70);
+middlewareGroups.setPriority("verified", 80);
 // src/testing/auth-testing.ts
 import { mock } from "bun:test";
 
@@ -11029,14 +11353,16 @@ class AuthTester {
     return this;
   }
   withApiKey(apiKey, headerName = "X-API-Key") {
-    this.request.headers = this.request.headers || new Headers;
-    this.request.headers.set(headerName, apiKey);
+    const headers = new Headers(this.request.headers);
+    headers.set(headerName, apiKey);
+    this.request = { ...this.request, headers };
     return this;
   }
   withBasicAuth(username, password) {
     const credentials = btoa(`${username}:${password}`);
-    this.request.headers = this.request.headers || new Headers;
-    this.request.headers.set("Authorization", `Basic ${credentials}`);
+    const headers = new Headers(this.request.headers);
+    headers.set("Authorization", `Basic ${credentials}`);
+    this.request = { ...this.request, headers };
     return this;
   }
   withAuthCookies(cookies) {
@@ -11667,13 +11993,13 @@ var mockMiddleware = {
       return new Response("Unauthorized", { status: 401 });
     }
   }),
-  rateLimit: (shouldLimit = false) => mock3(async (req, next) => {
+  rateLimit: (shouldLimit = false) => mock3(async (_req, next) => {
     if (shouldLimit) {
       return new Response("Too Many Requests", { status: 429 });
     }
     return await next();
   }),
-  cors: (origin = "*") => mock3(async (req, next) => {
+  cors: (origin = "*") => mock3(async (_req, next) => {
     const response2 = await next();
     if (response2) {
       response2.headers.set("Access-Control-Allow-Origin", origin);
@@ -11722,7 +12048,7 @@ function spyOnMiddleware(middleware2) {
   return spyOn(middleware2, "call");
 }
 function createMiddlewareSpy() {
-  const spy = mock3(async (req, next) => {
+  const spy = mock3(async (_req, next) => {
     return await next();
   });
   return {
@@ -12218,7 +12544,7 @@ class LoadTester {
       requestPromises.push(requestPromise);
       if (this.config.requestsPerSecond) {
         const delay = 1000 / this.config.requestsPerSecond;
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
       }
       if (requestPromises.length >= this.config.concurrency) {
         await Promise.race(requestPromises);
@@ -13276,6 +13602,7 @@ export {
   multipleFileUpload,
   modelMocks,
   mockMiddleware,
+  middlewareGroups,
   middleware,
   memoryTests,
   matchPath,
@@ -13289,6 +13616,7 @@ export {
   imageUpload,
   globalMiddlewarePipeline,
   getConfig,
+  generateSessionId,
   generateQueryPreservationScript,
   fileUploadScenarios,
   fileUploadMocks,
@@ -13309,6 +13637,7 @@ export {
   createTestClient,
   createSubdomainMiddleware,
   createSessionTester,
+  createSessionStore,
   createRouteCacheMiddleware,
   createRateLimitMiddleware,
   createPerformanceTester,
@@ -13351,6 +13680,7 @@ export {
   SkipConditions,
   SignatureError,
   SessionTester,
+  SessionManager,
   Session,
   SecuritySuite,
   Security,
@@ -13367,6 +13697,7 @@ export {
   RequestTracer,
   RequestSigning,
   RequestId,
+  RedisSessionStore,
   RateLimiter,
   RateLimitUtils,
   RateLimitRegistry,
@@ -13384,8 +13715,10 @@ export {
   MiddlewareTester,
   MiddlewarePipeline,
   MiddlewareHelpers,
+  MiddlewareGroupRegistry,
   MiddlewareFactory,
   MiddlewareChainTester,
+  MemorySessionStore,
   LoadTester,
   JsonBody,
   JWTTester,
@@ -13399,6 +13732,7 @@ export {
   FileValidationTester,
   FileUploadTester,
   FileUpload,
+  FileSessionStore,
   FileSecurity,
   exports_errors as Errors,
   EnhancementPresets,
@@ -13406,6 +13740,7 @@ export {
   DomainGroupBuilder,
   DomainGroup,
   Dependencies,
+  DatabaseSessionStore,
   DDoSProtection,
   Csrf,
   Cors,