bun-plugin-stx 0.2.12 → 0.2.13

package/dist/serve.d.ts

@@ -13,4 +13,35 @@ export declare interface ServeOptions {
   quiet?: boolean
   routes?: Record<string, (req: Request) => Response | Promise<Response>>
   onRequest?: (req: Request) => Response | Promise<Response> | null | undefined
+  middleware?: Record<string, MiddlewareHandler>
+  globalMiddleware?: string[]
+  middlewareGroups?: Record<string, string[]>
+  auth?: false | {
+    cookieName?: string
+    redirectTo?: string
+    home?: string
+    protectedPaths?: string[]
+  }
 }
+export declare interface MiddlewareContext {
+  path: string
+  url: URL
+  params: Record<string, string>
+  cookies: Record<string, string>
+  redirect: (to: string, status?: number) => Response
+}
+/**
+ * Middleware handler — a Laravel-style gate that either passes through
+ * (returns `void`/`null`/`undefined`) or terminates the pipeline by
+ * returning a `Response`.
+ *
+ * The third argument is the colon-separated arg list, so a page that
+ * declares `middleware: ['auth:admin']` invokes the `auth` handler
+ * with `args = ['admin']` — the same shape as Laravel's
+ * `handle($request, $next, ...$args)`.
+ */
+export type MiddlewareHandler = (
+  req: Request,
+  ctx: MiddlewareContext,
+  ...args: string[]
+) => Response | null | undefined | void | Promise<Response | null | undefined | void>;

package/dist/serve.js

@@ -5124,6 +5124,151 @@ After installing: bun add bun-plugin-stx`);
   const routes = new Map;
   let sourceFiles = null;
   let assetsInitialized = false;
+  const pageMiddlewareByPath = new Map;
+  const pageMiddlewarePatterns = [];
+  function compileRoutePattern(urlPath) {
+    const names = [];
+    const re = urlPath.split("/").map((seg) => {
+      if (!seg)
+        return "";
+      const catchAll = seg.match(/^\[\.\.\.(.+)\]$/);
+      if (catchAll) {
+        names.push(catchAll[1]);
+        return "(.+)";
+      }
+      const param = seg.match(/^\[(.+)\]$/);
+      if (param) {
+        names.push(param[1]);
+        return "([^/]+)";
+      }
+      return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }).join("/");
+    return { re: new RegExp(`^${re}/?$`), names };
+  }
+  function urlPathFromFile(file) {
+    let rel = file;
+    for (const pattern of patterns) {
+      const base = pattern.replace(/\/$/, "");
+      if (rel.startsWith(`${base}/`)) {
+        rel = rel.slice(base.length + 1);
+        break;
+      }
+    }
+    rel = rel.replace(/\.(stx|md|html)$/, "");
+    if (rel === "index" || rel.endsWith("/index"))
+      rel = rel.replace(/\/?index$/, "");
+    return rel.startsWith("/") ? rel : `/${rel}`;
+  }
+  async function detectPageMiddleware(file) {
+    try {
+      const fs = await import("fs/promises");
+      const src = await fs.readFile(file, "utf-8");
+      const meta = src.match(/definePageMeta\s*\(\s*\{[\s\S]*?\}\s*\)/);
+      if (!meta)
+        return;
+      const mw = meta[0].match(/middleware\s*:\s*(\[[^\]]*\]|['"][^'"]+['"])/);
+      if (!mw)
+        return;
+      const names = mw[1].startsWith("[") ? Array.from(mw[1].matchAll(/['"]([^'"]+)['"]/g)).map((m) => m[1]) : [mw[1].replace(/['"]/g, "")];
+      if (names.length === 0)
+        return;
+      const urlPath = urlPathFromFile(file);
+      if (urlPath.includes("[")) {
+        const { re, names: paramNames } = compileRoutePattern(urlPath);
+        pageMiddlewarePatterns.push({ re, names: paramNames, middleware: names });
+      } else {
+        pageMiddlewareByPath.set(urlPath, names);
+      }
+    } catch {}
+  }
+  function resolveRouteMiddleware(path) {
+    const exact = pageMiddlewareByPath.get(path);
+    if (exact)
+      return { names: exact, params: {} };
+    const trimmed = path.replace(/\/$/, "");
+    if (trimmed !== path) {
+      const exactTrim = pageMiddlewareByPath.get(trimmed);
+      if (exactTrim)
+        return { names: exactTrim, params: {} };
+    }
+    for (const entry of pageMiddlewarePatterns) {
+      const m = entry.re.exec(path);
+      if (m) {
+        const params = {};
+        entry.names.forEach((n, i) => {
+          params[n] = decodeURIComponent(m[i + 1] ?? "");
+        });
+        return { names: entry.middleware, params };
+      }
+    }
+    return { names: [], params: {} };
+  }
+  function parseCookies(req) {
+    const out = {};
+    const header = req.headers.get("cookie") || "";
+    if (!header)
+      return out;
+    for (const part of header.split(/;\s*/)) {
+      const eq = part.indexOf("=");
+      if (eq === -1)
+        continue;
+      const k = part.slice(0, eq);
+      if (!k)
+        continue;
+      try {
+        out[k] = decodeURIComponent(part.slice(eq + 1));
+      } catch {
+        out[k] = part.slice(eq + 1);
+      }
+    }
+    return out;
+  }
+  function redirectWithNext(target, originalPath, search = "") {
+    const sep = target.includes("?") ? "&" : "?";
+    const next = encodeURIComponent(originalPath + search);
+    return Response.redirect(`${target}${sep}next=${next}`, 302);
+  }
+  const authConfig = options.auth === false ? null : options.auth ?? {};
+  const authCookieName = authConfig?.cookieName ?? "auth-token";
+  const authRedirectTo = authConfig?.redirectTo ?? "/login";
+  const authHome = authConfig?.home ?? "/";
+  const extraProtectedPrefixes = authConfig?.protectedPaths ?? [];
+  const builtInMiddleware = authConfig === null ? {} : {
+    auth: (_req, ctx) => {
+      const tok = ctx.cookies[authCookieName];
+      if (!tok)
+        return ctx.redirect(authRedirectTo);
+      return null;
+    },
+    guest: (_req, ctx) => {
+      const tok = ctx.cookies[authCookieName];
+      if (tok)
+        return Response.redirect(authHome, 302);
+      return null;
+    }
+  };
+  const middlewareRegistry = {
+    ...builtInMiddleware,
+    ...options.middleware ?? {}
+  };
+  function expandMiddlewareNames(names) {
+    const out = [];
+    const groups = options.middlewareGroups ?? {};
+    const seen = new Set;
+    const visit = (name) => {
+      if (seen.has(name))
+        return;
+      seen.add(name);
+      const group = groups[name];
+      if (group)
+        group.forEach(visit);
+      else
+        out.push(name);
+    };
+    names.forEach(visit);
+    return out;
+  }
+  const globalMiddlewareNames = options.globalMiddleware ?? [];
   async function discoverFiles() {
     if (sourceFiles !== null)
       return sourceFiles;
@@ -5159,6 +5304,9 @@ After installing: bun add bun-plugin-stx`);
       }
     }
     sourceFiles = files;
+    pageMiddlewareByPath.clear();
+    pageMiddlewarePatterns.length = 0;
+    await Promise.all(files.map((f) => detectPageMiddleware(f)));
     try {
       const { Router } = await import("./chunk-762q71t6.js");
       const pagesDir = patterns[0]?.replace(/\/$/, "") || "pages";
@@ -5541,6 +5689,40 @@ ${output}`;
         if (customResponse)
           return customResponse;
       }
+      const route = resolveRouteMiddleware(path);
+      const extraNames = extraProtectedPrefixes.some((p) => path === p || path.startsWith(p.endsWith("/") ? p : `${p}/`)) ? ["auth"] : [];
+      const requested = [...globalMiddlewareNames, ...route.names, ...extraNames];
+      if (requested.length > 0) {
+        const expanded = expandMiddlewareNames(requested);
+        const cookies = parseCookies(req);
+        const ctx = {
+          path,
+          url,
+          params: route.params,
+          cookies,
+          redirect: (to, status = 302) => {
+            const sep = to.includes("?") ? "&" : "?";
+            const next = encodeURIComponent(path + (url.search || ""));
+            return new Response(null, {
+              status,
+              headers: { Location: `${to}${sep}next=${next}` }
+            });
+          }
+        };
+        for (const entry of expanded) {
+          const colon = entry.indexOf(":");
+          const name = colon === -1 ? entry : entry.slice(0, colon);
+          const args = colon === -1 ? [] : entry.slice(colon + 1).split(",");
+          const handler = middlewareRegistry[name];
+          if (!handler) {
+            console.warn(`[stx serve] unknown middleware "${name}" on ${path}`);
+            continue;
+          }
+          const result = await handler(req, ctx, ...args);
+          if (result instanceof Response)
+            return result;
+        }
+      }
       if (options.routes) {
         const routeHandler = options.routes[path];
         if (routeHandler) {
@@ -5864,11 +6046,11 @@ ${pageSetupScripts.join(`
             break;
           }
         }
-        let route = normalizedPath.replace(/\.(stx|md|html)$/, "");
-        if (route.startsWith("pages/")) {
-          route = route.slice(6);
+        let route2 = normalizedPath.replace(/\.(stx|md|html)$/, "");
+        if (route2.startsWith("pages/")) {
+          route2 = route2.slice(6);
         }
-        availableRoutes.push(`<li><a href="/${route}">/${route}</a></li>`);
+        availableRoutes.push(`<li><a href="/${route2}">/${route2}</a></li>`);
       }
       const routesList = availableRoutes.join(`
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -72,6 +72,6 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/stx": "0.2.12"
+    "@stacksjs/stx": "0.2.13"
   }
 }