bun-plugin-stx 0.2.410 → 0.2.411

package/dist/domain-routes.d.ts

@@ -14,12 +14,23 @@ export declare function matchDomain(host: string, route: DomainRoute): Record<st
  * the root).
  */
 export declare function resolveDomainRoute(host: string, pathname: string, routes: DomainRoute[]): string | null;
+/**
+ * Where a request for another page on a routed host belongs, or null to
+ * answer it in place.
+ *
+ * Only for a route that names `elsewhere`, only for a host that matches it,
+ * only for paths other than the root, and only for page requests: `isAsset`
+ * is the server's own test for scripts, styles, `/api` and `public/` files,
+ * which stay where the page at the root can load them.
+ */
+export declare function resolveDomainElsewhere(host: string, pathname: string, search: string, routes: DomainRoute[], isAsset: (pathname: string) => boolean): string | null;
 /** One line for boot output: `{username}.example.com/ → /{username}`. */
 export declare function describeDomainRoutes(routes: DomainRoute[]): string;
 export declare interface DomainRoute {
   pattern: string
   labels: Label[]
   to: string
+  elsewhere?: string
   literals: number
 }
 /**
@@ -45,6 +56,21 @@ export declare interface DomainRoute {
  * site's own, answered as it would be on the main domain, so one page can be
  * given a domain without the rest of the site breaking under it.
  *
+ * Unless the route says where the rest of the site lives:
+ *
+ * ```ts
+ * domains: {
+ *   '{username}.example.com': { to: '/{username}', elsewhere: 'https://example.com' },
+ * }
+ * ```
+ *
+ * Then a request for any other PAGE on that host is redirected there
+ * (`chris.example.com/pricing` → `example.com/pricing`), while its assets,
+ * `/api` and `public/` files are still answered in place, because the page
+ * at its root needs them. A browser keeps a session per origin: without
+ * this, signing in from a profile's own domain signs in to that domain, and
+ * the visitor ends up using the whole app under someone else's name.
+ *
  * A pattern is a hostname whose labels are either literal or `{name}`, which
  * matches exactly one DNS label (`{username}.example.com` matches
  * `chris.example.com`, not `a.b.example.com` and not the bare apex). Literal
@@ -59,4 +85,4 @@ export declare interface DomainRoute {
  */
 /** One label of a compiled pattern. */
 declare type Label = { literal: string } | { param: string }
-export type DomainRoutesOption = Record<string, string>;
+export type DomainRoutesOption = Record<string, string | { to: string, elsewhere?: string }>;

package/dist/serve.d.ts

@@ -1,5 +1,5 @@
 import { serve as bunServe } from 'bun';
-import { compileDomainRoutes, describeDomainRoutes, requestHost, resolveDomainRoute } from './domain-routes';
+import { compileDomainRoutes, describeDomainRoutes, requestHost, resolveDomainElsewhere, resolveDomainRoute } from './domain-routes';
 import type { DomainRoutesOption } from './domain-routes';
 import type { MiddlewareContext, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
 export type { DomainRoute, DomainRoutesOption } from './domain-routes';
@@ -392,4 +392,4 @@ export declare interface ServeOptions {
 declare type CssEngine = Pick<typeof import('@stacksjs/ts-css/engine'), 'CSSGenerator' | 'config'>;
 /** The Bun server `serve()` started - handed to `onRequest` beside each request. */
 export type ServeServer = ReturnType<typeof bunServe>;
-export { compileDomainRoutes, describeDomainRoutes, matchDomain, requestHost, resolveDomainRoute } from './domain-routes';
+export { compileDomainRoutes, describeDomainRoutes, matchDomain, requestHost, resolveDomainElsewhere, resolveDomainRoute } from './domain-routes';

package/dist/serve.js

@@ -8728,9 +8728,22 @@ var LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 var PARAM = /^\{([A-Za-z_]\w*)\}$/;
 function compileDomainRoutes(input, warn = () => {}) {
   const routes = [];
-  for (const [rawPattern, rawTo] of Object.entries(input ?? {})) {
+  for (const [rawPattern, target] of Object.entries(input ?? {})) {
     const pattern = String(rawPattern).trim().toLowerCase().replace(/\.$/, "");
+    const rawTo = typeof target === "object" && target ? target.to : target;
     const to = String(rawTo ?? "").trim();
+    let elsewhere;
+    if (typeof target === "object" && target?.elsewhere) {
+      try {
+        const url = new URL(String(target.elsewhere));
+        if (url.protocol === "https:" || url.protocol === "http:")
+          elsewhere = url.origin;
+      } catch {}
+      if (!elsewhere) {
+        warn(`[stx] domain route "${rawPattern}" ignored: elsewhere "${target.elsewhere}" is not an http(s) origin`);
+        continue;
+      }
+    }
     const parts = pattern.split(".");
     if (parts.length < 2 || !to.startsWith("/")) {
       warn(`[stx] domain route "${rawPattern}" -> "${rawTo}" ignored: a route is a hostname with a dot and a path starting with "/"`);
@@ -8755,7 +8768,7 @@ function compileDomainRoutes(input, warn = () => {}) {
       warn(`[stx] domain route "${rawPattern}" -> "${rawTo}" ignored: ${!valid ? "a label is neither a hostname label nor {name}" : `the path uses {${missing.join("}, {")}} which the hostname does not capture`}`);
       continue;
     }
-    routes.push({ pattern, labels, to, literals: labels.filter((label) => ("literal" in label)).length });
+    routes.push({ pattern, labels, to, ...elsewhere ? { elsewhere } : {}, literals: labels.filter((label) => ("literal" in label)).length });
   }
   return routes.sort((a, b) => b.literals - a.literals || b.labels.length - a.labels.length);
 }
@@ -8796,8 +8809,20 @@ function resolveDomainRoute(host, pathname, routes) {
   }
   return null;
 }
+function resolveDomainElsewhere(host, pathname, search, routes, isAsset) {
+  if (!routes.length || pathname === "/" || pathname === "" || pathname === "/index")
+    return null;
+  for (const route of routes) {
+    if (!matchDomain(host, route))
+      continue;
+    if (!route.elsewhere || isAsset(pathname))
+      return null;
+    return `${route.elsewhere}${pathname}${search}`;
+  }
+  return null;
+}
 function describeDomainRoutes(routes) {
-  return routes.map((route) => `${route.pattern}/ \u2192 ${route.to}`).join(", ");
+  return routes.map((route) => `${route.pattern}/ \u2192 ${route.to}${route.elsewhere ? ` (other pages: ${route.elsewhere})` : ""}`).join(", ");
 }
 // src/page-middleware.ts
 var DEFAULT_PRIORITY = 10;
@@ -10577,6 +10602,10 @@ ${block}`;
                 const headers = new Headers(req.headers);
                 headers.set("x-stx-domain-route", requestHost(req));
                 req = new Request(original, { headers, method: req.method, body: req.body, redirect: req.redirect, duplex: "half" });
+              } else if (req.method === "GET" || req.method === "HEAD") {
+                const location = resolveDomainElsewhere(requestHost(req), original.pathname, original.search, domainRoutes, (pathname) => pathname.startsWith("/api/") || pathname.startsWith("/_stx/") || pathname.startsWith("/.well-known/") || isStaticAssetPath(pathname) || publicFileExists(pathname, publicDir));
+                if (location)
+                  return new Response(null, { status: 301, headers: { Location: location } });
               }
             }
             const url = new URL(req.url);
@@ -11468,6 +11497,7 @@ export {
   resolveServeOpenUrl,
   resolveImageWarmupBindBudget,
   resolveDomainRoute,
+  resolveDomainElsewhere,
   requestHost,
   render404Page,
   publicFileExists,

package/package.json

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