bun-plugin-stx 0.2.409 → 0.2.411

package/dist/domain-routes.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Compile `{ pattern: path }` into routes, most specific first. Invalid
+ * entries are dropped with a warning rather than thrown: a malformed domain
+ * route must not stop a site booting.
+ */
+export declare function compileDomainRoutes(input: DomainRoutesOption | undefined, warn?: (message: string) => void): DomainRoute[];
+/** The hostname a request was made to, without the port, lowercased. */
+export declare function requestHost(req: Request): string;
+/** The params a host captures for a route, or null when it does not match. */
+export declare function matchDomain(host: string, route: DomainRoute): Record<string, string> | null;
+/**
+ * The path a request to `host` at `pathname` should render, or null when no
+ * domain route applies (a host that matches nothing, or a path other than
+ * 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
+}
+/**
+ * Domain routes: a host whose home page is a page of the site.
+ *
+ * ```ts
+ * serve({
+ *   domains: {
+ *     '{username}.example.com': '/{username}',
+ *     'shop.example.com': '/store',
+ *   },
+ * })
+ * ```
+ *
+ * `chris.example.com/` then renders exactly what `example.com/chris` renders
+ * — the same file route, the same `route.params.username` — and the address
+ * bar keeps saying `chris.example.com`. It is how a profile, a team or a shop
+ * gets a domain of its own on a site that is otherwise one app, the way a
+ * GitHub Pages or a Substack subdomain works.
+ *
+ * Only the host's root is routed. Every other path on that host — scripts,
+ * styles, images, `/api`, the other pages a navigation bar links to — is the
+ * 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
+ * patterns win over parameterised ones, then the one with more literal
+ * labels, so `docs.example.com` can be carved out of `{username}.example.com`.
+ * A parameter's value is placed in the target path URL-encoded.
+ *
+ * The host is read from `X-Forwarded-Host` before `Host`, because behind a
+ * gateway the latter is the upstream's address. Trusting it is safe here: a
+ * forged value can only choose which page of this same site renders for the
+ * root path, which the requester could have asked for by its own path.
+ */
+/** One label of a compiled pattern. */
+declare type Label = { literal: string } | { param: string }
+export type DomainRoutesOption = Record<string, string | { to: string, elsewhere?: string }>;

package/dist/serve.d.ts

@@ -1,5 +1,8 @@
 import { serve as bunServe } from 'bun';
+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';
 export type { MiddlewareContext, MiddlewareDefinition, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
 /**
  * Extract real top-level `<script server>` elements without matching tag-like
@@ -358,6 +361,7 @@ export declare interface ServeOptions {
   | null
   | undefined
   | Promise<Response | Record<string, unknown> | null | undefined>
+  domains?: DomainRoutesOption
   onResponse?: (req: Request, response: Response) =>
   | Response
   | null
@@ -388,3 +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, resolveDomainElsewhere, resolveDomainRoute } from './domain-routes';

package/dist/serve.js

@@ -8723,6 +8723,107 @@ 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/domain-routes.ts
+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, 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 "/"`);
+      continue;
+    }
+    const labels = [];
+    const params = new Set;
+    let valid = true;
+    for (const part of parts) {
+      const param = PARAM.exec(part);
+      if (param) {
+        labels.push({ param: param[1] });
+        params.add(param[1]);
+      } else if (LABEL.test(part)) {
+        labels.push({ literal: part });
+      } else {
+        valid = false;
+      }
+    }
+    const missing = [...to.matchAll(/\{(\w+)\}/g)].map((match) => match[1]).filter((name) => !params.has(name));
+    if (!valid || missing.length) {
+      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, ...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);
+}
+function requestHost(req) {
+  const forwarded = req.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
+  const host = forwarded || req.headers.get("host") || new URL(req.url).host;
+  return host.replace(/:\d+$/, "").replace(/\.$/, "").toLowerCase();
+}
+function matchDomain(host, route) {
+  const parts = host.split(".");
+  if (parts.length !== route.labels.length)
+    return null;
+  const params = {};
+  for (let i = 0;i < parts.length; i++) {
+    const label = route.labels[i];
+    const part = parts[i];
+    if ("literal" in label) {
+      if (label.literal !== part)
+        return null;
+    } else {
+      if (!LABEL.test(part))
+        return null;
+      params[label.param] = part;
+    }
+  }
+  return params;
+}
+function resolveDomainRoute(host, pathname, routes) {
+  if (!routes.length)
+    return null;
+  if (pathname !== "/" && pathname !== "" && pathname !== "/index")
+    return null;
+  for (const route of routes) {
+    const params = matchDomain(host, route);
+    if (!params)
+      continue;
+    return route.to.replace(/\{(\w+)\}/g, (_, name) => encodeURIComponent(params[name] ?? ""));
+  }
+  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}${route.elsewhere ? ` (other pages: ${route.elsewhere})` : ""}`).join(", ");
+}
 // src/page-middleware.ts
 var DEFAULT_PRIORITY = 10;
 function middlewarePriority(middleware) {
@@ -9301,6 +9402,9 @@ async function serve(options) {
   const fallbackComponentsDir = options.fallbackComponentsDir ?? stxConfig.fallbackComponentsDir;
   const partialsDir = options.partialsDir ?? stxConfig.partialsDir ?? defaultStxConfig.partialsDir;
   const publicDir = options.publicDir ?? stxConfig.publicDir ?? "public";
+  const domainRoutes = compileDomainRoutes(options.domains ?? stxConfig.server?.domains, (message) => console.warn(message));
+  if (domainRoutes.length)
+    console.log(`[stx] domain routes: ${describeDomainRoutes(domainRoutes)}`);
   let markPlaceholdersReady = () => {};
   const placeholdersReady = new Promise((resolve13) => {
     markPlaceholdersReady = resolve13;
@@ -10490,6 +10594,20 @@ ${block}`;
           if (warmup)
             await warmup;
           return compressResponse(req, await (async () => {
+            if (domainRoutes.length) {
+              const original = new URL(req.url);
+              const routed = resolveDomainRoute(requestHost(req), original.pathname, domainRoutes);
+              if (routed) {
+                original.pathname = routed;
+                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);
             let path = url.pathname;
             const proxyRules = stxConfig.server?.proxy;
@@ -11378,20 +11496,26 @@ export {
   responseTakesCsrfCookie,
   resolveServeOpenUrl,
   resolveImageWarmupBindBudget,
+  resolveDomainRoute,
+  resolveDomainElsewhere,
+  requestHost,
   render404Page,
   publicFileExists,
   projectUsesImageBuiltins,
   pageRootOf,
   pageExcluder,
   orderDynamicRouteFiles,
+  matchDomain,
   isStaticAssetPath,
   isRenderableCacheCandidate,
   isRenderFailure,
   isProductionServe,
   fillRouteParams,
   extractServerScriptsFromTemplate,
+  describeDomainRoutes,
   csrfTokenToMint,
   csrfCookieHeader,
+  compileDomainRoutes,
   bundleBrowserAsset,
   buildDynamicRouteRegexes,
   boundedCache,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.409",
+  "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.409",
-    "stx-router": "0.2.409"
+    "@stacksjs/stx": "0.2.411",
+    "stx-router": "0.2.411"
   }
 }