@stacksjs/server 0.70.87 → 0.70.90

package/dist/maintenance.js

@@ -0,0 +1,365 @@
+import { log } from "@stacksjs/logging";
+import * as p from "@stacksjs/path";
+const DEFAULT_MAINTENANCE_PAYLOAD = {
+  mode: "maintenance",
+  status: 503,
+  message: "We are currently performing maintenance. Please check back soon."
+}, DEFAULT_COMING_SOON_PAYLOAD = {
+  mode: "coming-soon",
+  status: 200,
+  message: "Stacks is setting up camp. Check back soon for the public launch.",
+  redirect: "/coming-soon"
+};
+function defaultsForMode(mode) {
+  return mode === "coming-soon" ? DEFAULT_COMING_SOON_PAYLOAD : DEFAULT_MAINTENANCE_PAYLOAD;
+}
+export function maintenanceFilePath() {
+  return p.storagePath("framework/down");
+}
+export function comingSoonFilePath() {
+  return p.storagePath("framework/coming-soon");
+}
+export function siteModeFilePath(mode) {
+  return mode === "coming-soon" ? comingSoonFilePath() : maintenanceFilePath();
+}
+export async function isDownForMaintenance() {
+  try {
+    return await Bun.file(maintenanceFilePath()).exists();
+  } catch {
+    return !1;
+  }
+}
+export async function isComingSoon() {
+  try {
+    return await Bun.file(comingSoonFilePath()).exists();
+  } catch {
+    return !1;
+  }
+}
+export async function maintenancePayload() {
+  return siteModePayload("maintenance");
+}
+export async function comingSoonPayload() {
+  return siteModePayload("coming-soon");
+}
+export async function siteModePayload(mode) {
+  try {
+    const file = Bun.file(siteModeFilePath(mode));
+    if (!await file.exists())
+      return null;
+    const content = await file.text();
+    return {
+      ...defaultsForMode(mode),
+      ...JSON.parse(content),
+      mode
+    };
+  } catch {
+    return null;
+  }
+}
+export async function activeSiteModePayload() {
+  return await maintenancePayload() ?? await comingSoonPayload() ?? envSiteModePayload();
+}
+function envSiteModePayload() {
+  if (isTruthy(process.env.APP_MAINTENANCE))
+    return {
+      ...DEFAULT_MAINTENANCE_PAYLOAD,
+      mode: "maintenance",
+      time: Date.now(),
+      secret: process.env.APP_MAINTENANCE_SECRET || void 0
+    };
+  if (isTruthy(process.env.APP_COMING_SOON))
+    return {
+      ...DEFAULT_COMING_SOON_PAYLOAD,
+      mode: "coming-soon",
+      time: Date.now(),
+      secret: process.env.APP_COMING_SOON_SECRET || void 0
+    };
+  return null;
+}
+function isTruthy(value) {
+  return ["1", "true", "yes", "on"].includes(String(value || "").toLowerCase());
+}
+export async function down(options = {}) {
+  const payload = {
+    ...DEFAULT_MAINTENANCE_PAYLOAD,
+    ...options,
+    mode: "maintenance",
+    time: Date.now()
+  }, frameworkDir = p.storagePath("framework"), { mkdirSync, existsSync } = await import("@stacksjs/storage");
+  if (!existsSync(frameworkDir))
+    mkdirSync(frameworkDir, { recursive: !0 });
+  await Bun.write(maintenanceFilePath(), JSON.stringify(payload, null, 2));
+  log.info("Application is now in maintenance mode.");
+  if (payload.secret)
+    log.info("Maintenance bypass secret has been configured");
+}
+export async function comingSoon(options = {}) {
+  const payload = {
+    ...DEFAULT_COMING_SOON_PAYLOAD,
+    ...options,
+    mode: "coming-soon",
+    time: Date.now()
+  }, frameworkDir = p.storagePath("framework"), { mkdirSync, existsSync } = await import("@stacksjs/storage");
+  if (!existsSync(frameworkDir))
+    mkdirSync(frameworkDir, { recursive: !0 });
+  await Bun.write(comingSoonFilePath(), JSON.stringify(payload, null, 2));
+  log.info("Application is now in coming soon mode.");
+  if (payload.secret)
+    log.info("Coming soon bypass secret has been configured");
+}
+export async function up() {
+  const { unlinkSync, existsSync } = await import("node:fs"), filePath = maintenanceFilePath();
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+    log.info("Application is now live.");
+  } else
+    log.info("Application is already live.");
+}
+export async function launch() {
+  const { unlinkSync, existsSync } = await import("node:fs"), filePath = comingSoonFilePath();
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+    log.info("Application is out of coming soon mode.");
+  } else
+    log.info("Application is not in coming soon mode.");
+}
+export function isAllowedIp(ip, allowed = []) {
+  if (allowed.length === 0)
+    return !1;
+  if (["127.0.0.1", "::1", "localhost"].includes(ip))
+    return !0;
+  return allowed.includes(ip);
+}
+export function bypassCookieName(mode = "maintenance") {
+  return mode === "coming-soon" ? "stacks_coming_soon_bypass" : "stacks_maintenance_bypass";
+}
+export function hasValidBypassCookie(cookies, secret, mode = "maintenance") {
+  return cookies[bypassCookieName(mode)] === secret;
+}
+export function isSecretPath(path, secret) {
+  return path === `/${secret}` || path.startsWith(`/${secret}/`);
+}
+export function maintenanceHtml(payload) {
+  const mode = payload.mode ?? "maintenance", defaults = defaultsForMode(mode), message = escapeHtml(payload.message || defaults.message || ""), title = escapeHtml(payload.title || (mode === "coming-soon" ? "Opening Soon" : "Trail Maintenance"));
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>
+    @font-face {
+      font-display: swap;
+      font-family: "Campmate Script";
+      src: url("/assets/fonts/nps/CampmateScript-Regular.woff2") format("woff2");
+    }
+    @font-face {
+      font-display: swap;
+      font-family: "Switchback";
+      src: url("/assets/fonts/nps/Switchback-Regular.woff2") format("woff2");
+    }
+    @font-face {
+      font-display: swap;
+      font-family: "NPS 2026";
+      font-weight: 100 900;
+      src: url("/assets/fonts/nps/NPS_2026-variable.woff2") format("woff2");
+    }
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      font-family: "Switchback", ui-sans-serif, system-ui, sans-serif;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background:
+        linear-gradient(180deg, rgba(10, 28, 18, 0.78), rgba(10, 28, 18, 0.94)),
+        url("/assets/images/topography.svg") center / 760px auto,
+        #0d1e16;
+      color: #fff7e1;
+      padding: 20px;
+    }
+    .container {
+      position: relative;
+      width: min(760px, 100%);
+      overflow: hidden;
+      border: 1px solid rgba(255, 240, 200, 0.28);
+      border-top: 6px solid #df9a2f;
+      border-radius: 8px;
+      padding: clamp(2rem, 7vw, 4.5rem);
+      background:
+        linear-gradient(180deg, rgba(27, 65, 40, 0.86), rgba(12, 31, 21, 0.96)),
+        #163824;
+      box-shadow: 0 30px 80px rgba(0, 0, 0, 0.38);
+    }
+    .container::after {
+      position: absolute;
+      inset: auto 0 0;
+      height: 44%;
+      content: "";
+      background: url("/assets/images/park-ridge.svg") center bottom / cover no-repeat;
+      opacity: 0.34;
+      pointer-events: none;
+    }
+    .eyebrow {
+      position: relative;
+      z-index: 1;
+      display: flex;
+      gap: .75rem;
+      align-items: center;
+      color: #aac47d;
+      font-family: "Switchback", ui-sans-serif, system-ui, sans-serif;
+      font-size: .9rem;
+      font-weight: 800;
+      text-transform: uppercase;
+    }
+    .eyebrow::before {
+      width: 44px;
+      height: 2px;
+      content: "";
+      background: #df9a2f;
+    }
+    h1 {
+      position: relative;
+      z-index: 1;
+      margin-top: 1rem;
+      font-family: "Campmate Script", ui-serif, Georgia, serif;
+      font-size: clamp(4.5rem, 16vw, 8rem);
+      font-weight: 400;
+      line-height: .82;
+    }
+    .lead,
+    .message,
+    .retry {
+      position: relative;
+      z-index: 1;
+      max-width: 560px;
+      color: rgba(255, 247, 225, .84);
+      font-size: 1.08rem;
+      line-height: 1.65;
+    }
+    .lead {
+      margin-top: 1.25rem;
+      color: #b8d9cf;
+      font-family: "NPS 2026", "Switchback", ui-sans-serif, system-ui, sans-serif;
+      font-size: 1.22rem;
+      font-weight: 850;
+      line-height: 1.3;
+      text-transform: uppercase;
+    }
+    .message {
+      margin-top: .75rem;
+    }
+    .retry {
+      margin-top: 1.4rem;
+      color: #aac47d;
+      font-family: "Switchback", ui-sans-serif, system-ui, sans-serif;
+      font-size: .95rem;
+      font-weight: 800;
+      text-transform: uppercase;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="eyebrow">${mode === "coming-soon" ? "Stacks basecamp" : "Service notice"}</div>
+    <h1>${title}</h1>
+    <p class="lead">${mode === "coming-soon" ? "The public trailhead is almost ready." : "The route is temporarily closed while the crew improves the path."}</p>
+    <p class="message">${message}</p>
+    ${payload.retry ? `<p class="retry">Estimated reopening: ${Math.ceil(payload.retry / 60)} minutes.</p>` : ""}
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
+}
+export function maintenanceResponse(payload) {
+  return siteModeResponse(payload);
+}
+export function siteModeResponse(payload) {
+  const headers = {
+    "Content-Type": "text/html; charset=utf-8"
+  };
+  if (payload.retry)
+    headers["Retry-After"] = String(payload.retry);
+  if (payload.redirect)
+    return new Response(null, {
+      status: 302,
+      headers: { Location: payload.redirect }
+    });
+  return new Response(maintenanceHtml(payload), {
+    status: payload.status || (payload.mode === "coming-soon" ? 200 : 503),
+    headers
+  });
+}
+export function bypassCookieValue(secret, mode = "maintenance") {
+  return `${bypassCookieName(mode)}=${secret}; Path=/; HttpOnly; SameSite=Lax`;
+}
+const ALWAYS_ALLOWED_PATHS = new Set([
+  "/coming-soon",
+  "/api/email/subscribe",
+  "/favicon.ico"
+]), ALWAYS_ALLOWED_PREFIXES = [
+  "/css/",
+  "/js/",
+  "/images/",
+  "/fonts/",
+  "/assets/",
+  "/_modules/",
+  "/@vite/",
+  "/@fs/",
+  "/__deps/"
+];
+function isAlwaysAllowed(path) {
+  if (ALWAYS_ALLOWED_PATHS.has(path))
+    return !0;
+  return ALWAYS_ALLOWED_PREFIXES.some((p) => path.startsWith(p));
+}
+function parseCookieHeader(header) {
+  const out = {};
+  if (!header)
+    return out;
+  for (const part of header.split(";")) {
+    const trimmed = part.trim(), eq = trimmed.indexOf("=");
+    if (eq === -1)
+      continue;
+    const k = trimmed.slice(0, eq).trim(), v = trimmed.slice(eq + 1).trim();
+    if (k)
+      out[k] = v;
+  }
+  return out;
+}
+function clientIp(req) {
+  const fwd = req.headers.get("x-forwarded-for");
+  if (fwd)
+    return fwd.split(",")[0]?.trim() ?? "127.0.0.1";
+  const real = req.headers.get("x-real-ip");
+  if (real)
+    return real;
+  return "127.0.0.1";
+}
+export async function maintenanceGate(req) {
+  const payload = await activeSiteModePayload();
+  if (!payload)
+    return null;
+  const mode = payload.mode ?? "maintenance", path = new URL(req.url).pathname;
+  if (isAlwaysAllowed(path))
+    return null;
+  if (payload.secret && isSecretPath(path, payload.secret))
+    return new Response(null, {
+      status: 302,
+      headers: {
+        Location: "/",
+        "Set-Cookie": bypassCookieValue(payload.secret, mode)
+      }
+    });
+  const cookies = parseCookieHeader(req.headers.get("cookie")), hasCookie = !!payload.secret && hasValidBypassCookie(cookies, payload.secret, mode), ipAllowed = isAllowedIp(clientIp(req), payload.allowed);
+  if (hasCookie || ipAllowed)
+    return null;
+  return siteModeResponse(payload);
+}

package/dist/proxy.js

@@ -0,0 +1,28 @@
+const API_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+export function isApiBoundRequest(req, pathname) {
+  return pathname.startsWith("/api/") || API_METHODS.has(req.method);
+}
+export async function proxyToBackend(req, backendBase, stripPrefix) {
+  const incoming = new URL(req.url);
+  let pathname = incoming.pathname;
+  if (stripPrefix && (pathname === stripPrefix || pathname.startsWith(`${stripPrefix}/`)))
+    pathname = pathname.slice(stripPrefix.length) || "/";
+  const target = `${backendBase}${pathname}${incoming.search}`, fwd = new Headers(req.headers);
+  fwd.delete("host");
+  fwd.delete("content-length");
+  fwd.set("x-forwarded-host", incoming.host);
+  fwd.set("x-forwarded-proto", incoming.protocol.replace(":", ""));
+  const body = req.method === "GET" || req.method === "HEAD" ? void 0 : await req.arrayBuffer(), upstream = await fetch(target, {
+    method: req.method,
+    headers: fwd,
+    body,
+    redirect: "manual"
+  }), out = new Headers(upstream.headers);
+  out.delete("content-length");
+  out.delete("content-encoding");
+  return new Response(upstream.body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: out
+  });
+}

package/dist/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/start.js

@@ -0,0 +1,54 @@
+globalThis.__STACKS_BINARY_MODE__ = !0;
+import { assertRouteMiddlewareResolvable, loadRoutes, serve } from "@stacksjs/router";
+import { log, report } from "@stacksjs/logging";
+import config from "./config-production";
+import routeRegistry from "../../../../../app/Routes";
+process.on("unhandledRejection", (reason) => {
+  report(reason, { label: "[server] unhandledRejection" });
+});
+process.on("uncaughtException", (error) => {
+  report(error, { label: "[server] uncaughtException" });
+  log.flush().finally(() => process.exit(1));
+});
+console.log("[START] Application starting...");
+console.log("[START] Node version:", process.version);
+console.log("[START] Working directory:", process.cwd());
+console.log("[START] Environment:", process.env.APP_ENV || "not set");
+process.env.SKIP_CONFIG_LOADING = "true";
+console.log("[START] Config loaded:", {
+  port: config.server.port,
+  host: config.server.host,
+  appName: config.app.name,
+  appUrl: config.app.url
+});
+console.log("[START] Loading routes from registry...");
+loadRoutes(routeRegistry).then(async () => {
+  console.log("[START] Routes loaded successfully");
+  try {
+    await import("../../orm/routes");
+    console.log("[START] ORM routes loaded successfully");
+  } catch (ormError) {
+    console.warn("[START] ORM routes skipped:", ormError instanceof Error ? ormError.message : String(ormError));
+  }
+  try {
+    await assertRouteMiddlewareResolvable();
+    console.log("[START] Route middleware validated");
+  } catch (middlewareError) {
+    console.error("[START] FATAL: unresolvable route middleware \u2014 refusing to serve unprotected routes:", middlewareError instanceof Error ? middlewareError.message : String(middlewareError));
+    process.exit(1);
+  }
+  console.log("[START] Calling serve()...");
+  try {
+    serve({
+      port: config.server.port,
+      host: config.server.host
+    });
+    console.log("[START] serve() called successfully");
+  } catch (error) {
+    console.error("[START] ERROR calling serve():", error);
+    process.exit(1);
+  }
+}).catch((error) => {
+  console.error("[START] ERROR loading routes:", error);
+  process.exit(1);
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/server",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.87",
+  "version": "0.70.90",
   "description": "Local development and production-ready.",
   "author": "Chris Breuer",
   "contributors": [
@@ -53,11 +53,11 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/config": "0.70.87",
+    "@stacksjs/config": "0.70.90",
     "better-dx": "^0.2.16",
-    "@stacksjs/path": "0.70.87",
-    "@stacksjs/router": "0.70.87",
-    "@stacksjs/validation": "0.70.87",
+    "@stacksjs/path": "0.70.90",
+    "@stacksjs/router": "0.70.90",
+    "@stacksjs/validation": "0.70.90",
     "bun-plugin-auto-imports": "^0.4.0"
   }
 }