react-bun-ssr 0.3.2 → 0.4.1

package/framework/runtime/response-context.ts

@@ -0,0 +1,206 @@
+import type { ResponseContext, ResponseCookieOptions, ResponseCookies } from "./types";
+
+type HeaderOperation =
+  | { type: "set"; name: string; value: string }
+  | { type: "append"; name: string; value: string }
+  | { type: "delete"; name: string };
+
+interface ResponseContextState {
+  requestCookies: Map<string, string>;
+  pendingCookies: Map<string, string | undefined>;
+  headerOperations: HeaderOperation[];
+  headerPreview: Headers;
+}
+
+const responseContextState = new WeakMap<ResponseContext, ResponseContextState>();
+
+function toHeaderName(name: string): string {
+  return String(name).trim();
+}
+
+function toCookieDate(value: Date | string): string {
+  if (value instanceof Date) {
+    return value.toUTCString();
+  }
+
+  const parsed = new Date(value);
+  if (!Number.isNaN(parsed.valueOf())) {
+    return parsed.toUTCString();
+  }
+
+  return value;
+}
+
+function normalizeSameSite(value: ResponseCookieOptions["sameSite"]): "Strict" | "Lax" | "None" | null {
+  if (!value) {
+    return null;
+  }
+
+  const lowered = value.toLowerCase();
+  if (lowered === "strict") {
+    return "Strict";
+  }
+  if (lowered === "lax") {
+    return "Lax";
+  }
+  if (lowered === "none") {
+    return "None";
+  }
+
+  return null;
+}
+
+function serializeCookie(name: string, value: string, options: ResponseCookieOptions = {}): string {
+  const parts = [`${name}=${encodeURIComponent(value)}`];
+
+  if (options.path) {
+    parts.push(`Path=${options.path}`);
+  }
+  if (options.domain) {
+    parts.push(`Domain=${options.domain}`);
+  }
+  if (typeof options.maxAge === "number" && Number.isFinite(options.maxAge)) {
+    parts.push(`Max-Age=${Math.trunc(options.maxAge)}`);
+  }
+  if (options.expires) {
+    parts.push(`Expires=${toCookieDate(options.expires)}`);
+  }
+  if (options.httpOnly) {
+    parts.push("HttpOnly");
+  }
+  if (options.secure) {
+    parts.push("Secure");
+  }
+  const sameSite = normalizeSameSite(options.sameSite);
+  if (sameSite) {
+    parts.push(`SameSite=${sameSite}`);
+  }
+
+  return parts.join("; ");
+}
+
+function serializeDeleteCookie(
+  name: string,
+  options: Omit<ResponseCookieOptions, "expires" | "maxAge"> = {},
+): string {
+  return serializeCookie(name, "", {
+    ...options,
+    maxAge: 0,
+    expires: new Date(0),
+  });
+}
+
+function createMutableHeaders(state: ResponseContextState): ResponseContext["headers"] {
+  return {
+    set(name, value) {
+      const normalizedName = toHeaderName(name);
+      state.headerOperations.push({
+        type: "set",
+        name: normalizedName,
+        value: String(value),
+      });
+      state.headerPreview.set(normalizedName, String(value));
+    },
+    append(name, value) {
+      const normalizedName = toHeaderName(name);
+      state.headerOperations.push({
+        type: "append",
+        name: normalizedName,
+        value: String(value),
+      });
+      state.headerPreview.append(normalizedName, String(value));
+    },
+    delete(name) {
+      const normalizedName = toHeaderName(name);
+      state.headerOperations.push({
+        type: "delete",
+        name: normalizedName,
+      });
+      state.headerPreview.delete(normalizedName);
+    },
+    get(name) {
+      return state.headerPreview.get(toHeaderName(name));
+    },
+    has(name) {
+      return state.headerPreview.has(toHeaderName(name));
+    },
+  };
+}
+
+class MutableResponseCookies implements ResponseCookies {
+  constructor(private readonly state: ResponseContextState) {}
+
+  get(name: string): string | undefined {
+    if (this.state.pendingCookies.has(name)) {
+      return this.state.pendingCookies.get(name);
+    }
+
+    return this.state.requestCookies.get(name);
+  }
+
+  set(name: string, value: string, options: ResponseCookieOptions = {}): void {
+    const serialized = serializeCookie(name, value, options);
+    this.state.pendingCookies.set(name, value);
+    this.state.headerOperations.push({
+      type: "append",
+      name: "set-cookie",
+      value: serialized,
+    });
+    this.state.headerPreview.append("set-cookie", serialized);
+  }
+
+  delete(name: string, options: Omit<ResponseCookieOptions, "expires" | "maxAge"> = {}): void {
+    const serialized = serializeDeleteCookie(name, options);
+    this.state.pendingCookies.set(name, undefined);
+    this.state.headerOperations.push({
+      type: "append",
+      name: "set-cookie",
+      value: serialized,
+    });
+    this.state.headerPreview.append("set-cookie", serialized);
+  }
+}
+
+export function createResponseContext(requestCookies: Map<string, string>): ResponseContext {
+  const state: ResponseContextState = {
+    requestCookies,
+    pendingCookies: new Map(),
+    headerOperations: [],
+    headerPreview: new Headers(),
+  };
+
+  const context: ResponseContext = {
+    headers: createMutableHeaders(state),
+    cookies: new MutableResponseCookies(state),
+  };
+
+  responseContextState.set(context, state);
+  return context;
+}
+
+export function applyResponseContext(response: Response, context: ResponseContext): Response {
+  const state = responseContextState.get(context);
+  if (!state || state.headerOperations.length === 0) {
+    return response;
+  }
+
+  const headers = new Headers(response.headers);
+  for (const operation of state.headerOperations) {
+    if (operation.type === "set") {
+      headers.set(operation.name, operation.value);
+      continue;
+    }
+    if (operation.type === "append") {
+      headers.append(operation.name, operation.value);
+      continue;
+    }
+
+    headers.delete(operation.name);
+  }
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}

package/framework/runtime/route-api.ts

@@ -1,23 +1,56 @@
-export type {
-  Action,
-  ActionContext,
-  ActionResult,
-  DeferredLoaderResult,
-  DeferredToken,
-  Loader,
-  LoaderContext,
-  LoaderResult,
-  Middleware,
-  Params,
-  RedirectResult,
-  RequestContext,
-  RouteCatchContext,
-  RouteErrorContext,
-  RouteErrorResponse,
+import type { AppRouteLocals as RootAppRouteLocals } from "react-bun-ssr";
+import type {
+  Action as RuntimeAction,
+  ActionContext as RuntimeActionContext,
+  ActionResult as RuntimeActionResult,
+  DeferredLoaderResult as RuntimeDeferredLoaderResult,
+  DeferredToken as RuntimeDeferredToken,
+  Loader as RuntimeLoader,
+  LoaderContext as RuntimeLoaderContext,
+  LoaderResult as RuntimeLoaderResult,
+  Middleware as RuntimeMiddleware,
+  Params as RuntimeParams,
+  RedirectResult as RuntimeRedirectResult,
+  RequestContext as RuntimeRequestContext,
+  ResponseContext as RuntimeResponseContext,
+  ResponseCookies as RuntimeResponseCookies,
+  ResponseCookieOptions as RuntimeResponseCookieOptions,
+  RouteCatchContext as RuntimeRouteCatchContext,
+  RouteErrorContext as RuntimeRouteErrorContext,
+  RouteErrorResponse as RuntimeRouteErrorResponse,
 } from "./types";
 
-export { defer, json, redirect } from "./helpers";
+export interface AppRouteLocals extends RootAppRouteLocals, Record<string, unknown> {}
+
+export type Action = RuntimeAction<AppRouteLocals>;
+export type ActionContext = RuntimeActionContext<AppRouteLocals>;
+export type ActionResult = RuntimeActionResult;
+export type DeferredLoaderResult = RuntimeDeferredLoaderResult;
+export type DeferredToken = RuntimeDeferredToken;
+export type Loader = RuntimeLoader<AppRouteLocals>;
+export type LoaderContext = RuntimeLoaderContext<AppRouteLocals>;
+export type LoaderResult = RuntimeLoaderResult;
+export type Middleware = RuntimeMiddleware<AppRouteLocals>;
+export type Params = RuntimeParams;
+export type RedirectResult = RuntimeRedirectResult;
+export type RequestContext = RuntimeRequestContext<AppRouteLocals>;
+export type ResponseContext = RuntimeResponseContext;
+export type ResponseCookies = RuntimeResponseCookies;
+export type ResponseCookieOptions = RuntimeResponseCookieOptions;
+export type RouteCatchContext = RuntimeRouteCatchContext;
+export type RouteErrorContext = RuntimeRouteErrorContext;
+export type RouteErrorResponse = RuntimeRouteErrorResponse;
+
+export { assertSameOriginAction, defer, json, redirect, sanitizeRedirectTarget } from "./helpers";
 export { isRouteErrorResponse, notFound, routeError } from "./route-errors";
 export { Link, type LinkProps } from "./link";
 export { useRouter, type Router, type RouterNavigateInfo, type RouterNavigateListener, type RouterNavigateOptions } from "./router";
-export { Outlet, useLoaderData, useParams, useRequestUrl, useRouteError } from "./tree";
+export {
+  Outlet,
+  createRouteAction,
+  useLoaderData,
+  useParams,
+  useRequestUrl,
+  useRouteAction,
+  useRouteError,
+} from "./tree";

package/framework/runtime/route-scanner.ts

@@ -21,6 +21,7 @@ const LAYOUT_FILE_RE = /\.(tsx|jsx|ts|js)$/;
 const API_FILE_RE = /\.(ts|js|tsx|jsx)$/;
 const MD_FILE_RE = /\.md$/;
 const MDX_FILE_RE = /\.mdx$/;
+const SERVER_SUFFIX_RE = /\.server$/;
 
 async function walkFiles(rootDir: string): Promise<string[]> {
   if (!(await existsPath(rootDir))) {
@@ -104,6 +105,23 @@ function getAncestorDirs(relativeDir: string): string[] {
   return result;
 }
 
+function stripServerSuffix(value: string): string {
+  return value.replace(SERVER_SUFFIX_RE, "");
+}
+
+function hasServerSuffix(value: string): boolean {
+  return SERVER_SUFFIX_RE.test(value);
+}
+
+function removeServerSuffixFromRelativePath(relativeFilePath: string): string {
+  const extension = path.extname(relativeFilePath);
+  if (!extension) {
+    return relativeFilePath;
+  }
+  const withoutExt = relativeFilePath.slice(0, -extension.length);
+  return `${stripServerSuffix(withoutExt)}${extension}`;
+}
+
 export async function scanRoutes(
   routesDir: string,
   options: {
@@ -113,16 +131,21 @@ export async function scanRoutes(
   const allFiles = (await walkFiles(routesDir)).sort((a, b) => a.localeCompare(b));
 
   const layoutByDir = new Map<string, string>();
+  const layoutServerByDir = new Map<string, string>();
   const middlewareByDir = new Map<string, string>();
+  const pageCompanionByKey = new Map<string, string>();
 
   const pageRouteTasks: Array<Promise<PageRouteDefinition>> = [];
-  const apiRoutes: ApiRouteDefinition[] = [];
+  const pageRouteKeys = new Set<string>();
+  const apiRouteByKey = new Map<string, ApiRouteDefinition>();
 
   for (const absoluteFilePath of allFiles) {
     const relativeFilePath = normalizeSlashes(path.relative(routesDir, absoluteFilePath));
     const relativeDir = normalizeSlashes(path.dirname(relativeFilePath) === "." ? "" : path.dirname(relativeFilePath));
     const fileName = path.basename(relativeFilePath);
     const fileBaseName = trimFileExtension(fileName);
+    const logicalBaseName = stripServerSuffix(fileBaseName);
+    const isServerVariant = hasServerSuffix(fileBaseName);
 
     if (MDX_FILE_RE.test(fileName)) {
       throw new Error(
@@ -130,13 +153,56 @@ export async function scanRoutes(
       );
     }
 
-    if (fileBaseName === "_layout" && LAYOUT_FILE_RE.test(fileName)) {
-      layoutByDir.set(relativeDir, absoluteFilePath);
+    if (logicalBaseName === "_layout" && LAYOUT_FILE_RE.test(fileName)) {
+      if (isServerVariant) {
+        if (layoutServerByDir.has(relativeDir)) {
+          throw new Error(
+            `Duplicate layout companion route files in "${relativeDir || "/"}": ` +
+              `"${layoutServerByDir.get(relativeDir)!}" and "${absoluteFilePath}".`,
+          );
+        }
+        layoutServerByDir.set(relativeDir, absoluteFilePath);
+      } else {
+        layoutByDir.set(relativeDir, absoluteFilePath);
+      }
       continue;
     }
 
-    if (fileBaseName === "_middleware" && API_FILE_RE.test(fileName)) {
+    if (logicalBaseName === "_middleware" && API_FILE_RE.test(fileName)) {
+      const existing = middlewareByDir.get(relativeDir);
+      if (existing && existing !== absoluteFilePath) {
+        throw new Error(
+          `Middleware file collision in "${relativeDir || "/"}": ` +
+            `"${existing}" and "${absoluteFilePath}" both resolve to "_middleware".`,
+        );
+      }
       middlewareByDir.set(relativeDir, absoluteFilePath);
+      continue;
+    }
+
+    if (
+      isServerVariant
+      && !relativeFilePath.startsWith("api/")
+      && PAGE_FILE_RE.test(fileName)
+      && !logicalBaseName.startsWith("_")
+    ) {
+      const canonicalRelativeFilePath = removeServerSuffixFromRelativePath(relativeFilePath);
+      const routeKey = trimFileExtension(canonicalRelativeFilePath);
+      const existing = pageCompanionByKey.get(routeKey);
+      if (existing && existing !== absoluteFilePath) {
+        throw new Error(
+          `Duplicate route companion files for "${routeKey}": "${existing}" and "${absoluteFilePath}".`,
+        );
+      }
+      pageCompanionByKey.set(routeKey, absoluteFilePath);
+    }
+  }
+
+  for (const [relativeDir, layoutServerFilePath] of layoutServerByDir.entries()) {
+    if (!layoutByDir.has(relativeDir)) {
+      throw new Error(
+        `Found layout companion "${layoutServerFilePath}" without base layout file "${relativeDir ? `${relativeDir}/` : ""}_layout.tsx".`,
+      );
     }
   }
 
@@ -145,10 +211,12 @@ export async function scanRoutes(
     const relativeDir = normalizeSlashes(path.dirname(relativeFilePath) === "." ? "" : path.dirname(relativeFilePath));
     const fileName = path.basename(relativeFilePath);
     const fileBaseName = trimFileExtension(fileName);
+    const logicalBaseName = stripServerSuffix(fileBaseName);
+    const isServerVariant = hasServerSuffix(fileBaseName);
 
     if (
-      (fileBaseName === "_layout" && LAYOUT_FILE_RE.test(fileName))
-      || (fileBaseName === "_middleware" && API_FILE_RE.test(fileName))
+      (logicalBaseName === "_layout" && LAYOUT_FILE_RE.test(fileName))
+      || (logicalBaseName === "_middleware" && API_FILE_RE.test(fileName))
     ) {
       continue;
     }
@@ -156,18 +224,31 @@ export async function scanRoutes(
     const isApiRoute = relativeFilePath.startsWith("api/");
 
     if (isApiRoute) {
-      if (!API_FILE_RE.test(fileName) || fileBaseName.startsWith("_")) {
+      if (!API_FILE_RE.test(fileName) || logicalBaseName.startsWith("_")) {
         continue;
       }
 
-      const withoutExt = trimFileExtension(relativeFilePath);
+      const canonicalRelativeFilePath = isServerVariant
+        ? removeServerSuffixFromRelativePath(relativeFilePath)
+        : relativeFilePath;
+      const withoutExt = trimFileExtension(canonicalRelativeFilePath);
+      if (apiRouteByKey.has(withoutExt)) {
+        const existing = apiRouteByKey.get(withoutExt)!;
+        throw new Error(
+          `API route collision for "${withoutExt}": "${existing.filePath}" and "${absoluteFilePath}". ` +
+            "Use only one of the plain route file or .server route file.",
+        );
+      }
       const shape = toUrlShape(withoutExt);
-      const ancestors = getAncestorDirs(relativeDir);
+      const canonicalRelativeDir = normalizeSlashes(
+        path.dirname(canonicalRelativeFilePath) === "." ? "" : path.dirname(canonicalRelativeFilePath),
+      );
+      const ancestors = getAncestorDirs(canonicalRelativeDir);
       const middlewareFiles = ancestors
         .map(dir => middlewareByDir.get(dir))
         .filter((value): value is string => Boolean(value));
 
-      apiRoutes.push({
+      apiRouteByKey.set(withoutExt, {
         type: "api",
         id: toRouteId(withoutExt),
         filePath: absoluteFilePath,
@@ -175,12 +256,12 @@ export async function scanRoutes(
         segments: shape.segments,
         score: getRouteScore(shape.segments),
         middlewareFiles,
-        directory: relativeDir,
+        directory: canonicalRelativeDir,
       });
       continue;
     }
 
-    if (!PAGE_FILE_RE.test(fileName) || fileBaseName.startsWith("_")) {
+    if (!PAGE_FILE_RE.test(fileName) || logicalBaseName.startsWith("_") || isServerVariant) {
       continue;
     }
 
@@ -203,11 +284,13 @@ export async function scanRoutes(
       .map(dir => middlewareByDir.get(dir))
       .filter((value): value is string => Boolean(value));
 
+    pageRouteKeys.add(withoutExt);
     pageRouteTasks.push(routeFilePath.then((resolvedRouteFilePath) => {
       return {
         type: "page",
         id: toRouteId(withoutExt),
         filePath: resolvedRouteFilePath,
+        serverFilePath: pageCompanionByKey.get(withoutExt),
         routePath: shape.routePath,
         segments: shape.segments,
         score: getRouteScore(shape.segments),
@@ -218,7 +301,16 @@ export async function scanRoutes(
     }));
   }
 
+  for (const [routeKey, companionPath] of pageCompanionByKey.entries()) {
+    if (!pageRouteKeys.has(routeKey)) {
+      throw new Error(
+        `Found route companion "${companionPath}" without base route module "${routeKey}.tsx".`,
+      );
+    }
+  }
+
   const pageRoutes = await Promise.all(pageRouteTasks);
+  const apiRoutes = [...apiRouteByKey.values()];
 
   return {
     pages: sortRoutesBySpecificity(pageRoutes),