bun-plugin-stx 0.2.278 → 0.2.279

package/dist/page-middleware.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Run stx page middleware through one public seam.
+ *
+ * Function handlers remain supported. Class-style middleware additionally
+ * contributes a priority, receives colon parameters through
+ * `request._middlewareParams`, and may throw a Response or status-carrying
+ * error to stop the chain.
+ */
+export declare function runPageMiddleware(options: RunPageMiddlewareOptions): Promise<Response | null>;
+/**
+ * Request surface shared with class-style middleware such as
+ * `@stacksjs/router`'s `Middleware` class.
+ */
+export declare interface MiddlewareRequest extends Request {
+  params?: Record<string, string>
+  _middlewareParams?: Record<string, string>
+}
+/**
+ * Structural middleware contract. A `Middleware` instance from
+ * `@stacksjs/router` satisfies this without an adapter.
+ */
+export declare interface MiddlewareDefinition {
+  readonly name: string
+  readonly priority?: number
+  readonly handle: MiddlewareDefinitionHandler
+}
+export declare interface MiddlewareContext {
+  path: string
+  url: URL
+  params: Record<string, string>
+  cookies: Record<string, string>
+  redirect: (to: string, status?: number) => Response
+}
+export declare interface RunPageMiddlewareOptions {
+  request: MiddlewareRequest
+  context: MiddlewareContext
+  entries: string[]
+  registry: Readonly<Record<string, PageMiddleware>>
+  prepareRequest?: PrepareMiddlewareRequest
+}
+/**
+ * Middleware handler compatible with the original stx page middleware API.
+ */
+export type MiddlewareHandler = (
+  req: MiddlewareRequest,
+  ctx: MiddlewareContext,
+  ...args: string[]
+) => Response | null | undefined | void | Promise<Response | null | undefined | void>;
+declare type MiddlewareDefinitionHandler = {
+  bivarianceHack: (
+    req: MiddlewareRequest,
+    ctx: MiddlewareContext,
+    ...args: string[]
+  ) => Response | null | undefined | void | Promise<Response | null | undefined | void>
+}['bivarianceHack'];
+export type PageMiddleware = MiddlewareHandler | MiddlewareDefinition;
+export type PrepareMiddlewareRequest = (
+  request: MiddlewareRequest,
+  context: MiddlewareContext,
+) => MiddlewareRequest | Promise<MiddlewareRequest>;

package/dist/serve.d.ts

@@ -1,3 +1,5 @@
+import type { MiddlewareContext, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
+export type { MiddlewareContext, MiddlewareDefinition, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
 /**
  * Extract real top-level `<script server>` elements without matching tag-like
  * text inside HTML comments or another script body. A regex over the whole
@@ -243,7 +245,8 @@ export declare interface ServeOptions {
   | null
   | undefined
   | Promise<Response | null | undefined>
-  middleware?: Record<string, MiddlewareHandler>
+  middleware?: Record<string, PageMiddleware>
+  prepareMiddlewareRequest?: PrepareMiddlewareRequest
   globalMiddleware?: string[]
   middlewareGroups?: Record<string, string[]>
   auth?: false | {
@@ -253,13 +256,6 @@ export declare interface ServeOptions {
     protectedPaths?: string[]
   }
 }
-export declare interface MiddlewareContext {
-  path: string
-  url: URL
-  params: Record<string, string>
-  cookies: Record<string, string>
-  redirect: (to: string, status?: number) => Response
-}
 /**
  * The slice of Crosswind this server calls, taken from the package's own types
  * rather than restated here.
@@ -272,18 +268,3 @@ export declare interface MiddlewareContext {
  * `cwcss-crosswind.d.ts`). `typeof import` cannot drift from the real engine.
  */
 declare type CrosswindEngine = Pick<typeof import('@cwcss/crosswind'), 'CSSGenerator' | 'config'>;
-/**
- * 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

@@ -8722,6 +8722,89 @@ import { BUILD_ID_HEADER, extractPageResponseStatus, findContainerRegion, FRAGME
 import { buildCodeFrame, locateFailureLine } from "@stacksjs/stx/build-message";
 import { clearBundleFailures, getBundleFailures } from "@stacksjs/stx/client-script-bundler";
 import { actionRedirectResponse, compressResponse, runPageAction as sharedRunPageAction } from "@stacksjs/stx";
+
+// src/page-middleware.ts
+var DEFAULT_PRIORITY = 10;
+function middlewarePriority(middleware) {
+  const raw = middleware.priority;
+  return typeof raw === "number" && Number.isFinite(raw) && raw >= 0 ? raw : DEFAULT_PRIORITY;
+}
+function parseMiddlewareEntry(entry, registry) {
+  const negated = entry.startsWith("!");
+  const bare = negated ? entry.slice(1) : entry;
+  if (Object.hasOwn(registry, bare))
+    return { args: [], name: bare, negated };
+  const colon = bare.indexOf(":");
+  if (colon === -1)
+    return { args: [], name: bare, negated };
+  const params = bare.slice(colon + 1);
+  return {
+    args: params === "" ? [] : params.split(","),
+    name: bare.slice(0, colon),
+    negated,
+    params
+  };
+}
+function statusResponse(thrown) {
+  if (thrown instanceof Response)
+    return thrown;
+  if (typeof thrown !== "object" || thrown === null)
+    return null;
+  const candidate = thrown;
+  const rawStatus = candidate.statusCode ?? candidate.status;
+  if (typeof rawStatus !== "number" || !Number.isInteger(rawStatus) || rawStatus < 100 || rawStatus > 599)
+    return null;
+  const message = typeof candidate.message === "string" ? candidate.message : "Middleware rejected the request";
+  return new Response(message, { status: rawStatus });
+}
+async function invokeMiddleware(middleware, request, context, args) {
+  try {
+    const result = typeof middleware === "function" ? await middleware(request, context, ...args) : await middleware.handle(request, context, ...args);
+    return result instanceof Response ? result : null;
+  } catch (thrown) {
+    const response = statusResponse(thrown);
+    if (response)
+      return response;
+    throw thrown;
+  }
+}
+async function runPageMiddleware(options) {
+  options.request.params = options.context.params;
+  const request = options.prepareRequest ? await options.prepareRequest(options.request, options.context) : options.request;
+  request.params = options.context.params;
+  request._middlewareParams ||= {};
+  const resolved = [];
+  for (const [index, entry] of options.entries.entries()) {
+    const parsed = parseMiddlewareEntry(entry, options.registry);
+    const middleware = options.registry[parsed.name];
+    if (!middleware) {
+      console.warn(`[stx serve] unknown middleware "${parsed.name}" on ${options.context.path}; failing closed`);
+      return new Response(`Route middleware '${parsed.name}' is not registered`, { status: 500 });
+    }
+    resolved.push({
+      ...parsed,
+      index,
+      middleware,
+      priority: middlewarePriority(middleware)
+    });
+  }
+  resolved.sort((a, b) => a.priority - b.priority || a.index - b.index);
+  for (const entry of resolved) {
+    if (entry.params !== undefined)
+      request._middlewareParams[entry.name] = entry.params;
+    const response = await invokeMiddleware(entry.middleware, request, options.context, entry.args);
+    if (entry.negated) {
+      if (response)
+        continue;
+      return new Response(`Access denied. This route requires "${entry.name}" not to apply.`, { status: 403 });
+    }
+    if (response)
+      return response;
+  }
+  return null;
+}
+
+// src/serve.ts
 var defaultStxModule = import("@stacksjs/stx");
 var REACTIVE_TEMPLATE_DIRECTIVE_RE = /@for|:for|@if|:if|@else|:else|x-for|x-if|x-else/;
 function extractServerScriptsFromTemplate(content) {
@@ -10393,19 +10476,15 @@ ${block}`;
                       });
                     }
                   };
-                  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;
-                  }
+                  const middlewareResponse = await runPageMiddleware({
+                    request: req,
+                    context: ctx,
+                    entries: expanded,
+                    registry: middlewareRegistry,
+                    prepareRequest: options.prepareMiddlewareRequest
+                  });
+                  if (middlewareResponse)
+                    return middlewareResponse;
                 }
                 if (options.routes) {
                   const routeHandler = options.routes[path];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.278",
+  "version": "0.2.279",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",