@reckona/mreact-router 0.0.174 → 0.0.176

package/src/build.ts

@@ -279,6 +279,7 @@ export interface BuiltServerManifest {
   routesDir?: string;
   routeServerActionReferences?: Record<string, BuiltServerActionExpressionReference[]>;
   serverActionManifest?: BuiltServerActionReference[];
+  serverModuleClosureFiles?: Record<string, string[]>;
   serverModuleFiles?: Record<string, string>;
   serverModuleRenderFiles?: Record<string, string>;
   serverModuleRequestFiles?: Record<string, string>;
@@ -625,6 +626,10 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
       ...(navigationRuntimeScript === undefined ? [] : [navigationRuntimeScript]),
     ]),
   ).sort();
+  const serverModuleClosureFiles = buildServerModuleClosureManifest(
+    serverModules,
+    sourceAnalysis,
+  );
   const prerenderedRoutes =
     shouldTrackBuildPhases === false
       ? await prerenderStaticRoutes({
@@ -708,6 +713,9 @@ export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult
     ...(serverActionManifest.allowedActions.length === 0
       ? {}
       : { serverActionManifest: serverActionManifest.allowedActions }),
+    ...(Object.keys(serverModuleClosureFiles).length === 0
+      ? {}
+      : { serverModuleClosureFiles }),
     ...(Object.keys(serverModuleArtifacts.files).length === 0
       ? {}
       : { serverModuleFiles: serverModuleArtifacts.files }),
@@ -988,6 +996,141 @@ function buildSourceAnalysisForFile(
   return sourceAnalysis.byFile.get(relative(projectRoot, file).split(sep).join("/"));
 }
 
+function buildServerModuleClosureManifest(
+  serverModules: Record<string, BuiltServerModuleArtifact>,
+  sourceAnalysis: BuildSourceAnalysisScope,
+): Record<string, string[]> {
+  const sourceFiles = new Set(sourceAnalysis.byFile.keys());
+  const closureFiles: Record<string, string[]> = {};
+
+  for (const file of Object.keys(serverModules).sort()) {
+    const closure: string[] = [];
+    collectManifestServerModuleClosureFiles(file, sourceAnalysis, sourceFiles, new Set(), closure);
+
+    if (closure.length > 0) {
+      closureFiles[file] = closure;
+    }
+  }
+
+  return closureFiles;
+}
+
+function collectManifestServerModuleClosureFiles(
+  file: string,
+  sourceAnalysis: BuildSourceAnalysisScope,
+  sourceFiles: ReadonlySet<string>,
+  seen: Set<string>,
+  closure: string[],
+): void {
+  if (seen.has(file)) {
+    return;
+  }
+  seen.add(file);
+  closure.push(file);
+
+  const source = sourceAnalysis.byFile.get(file)?.source;
+  if (source === undefined) {
+    return;
+  }
+
+  for (const specifier of localManifestServerModuleSpecifiers(source)) {
+    const resolved = resolveManifestLocalServerSourceImport(file, specifier, sourceFiles);
+    if (resolved !== undefined) {
+      collectManifestServerModuleClosureFiles(
+        resolved,
+        sourceAnalysis,
+        sourceFiles,
+        seen,
+        closure,
+      );
+    }
+  }
+}
+
+const localManifestServerModuleImportPattern =
+  /\b(?:import|export)\s+(?:type\s+)?(?:[^"']*?\s+from\s*)?["'](?<source>\.{1,2}\/[^"']+)["']/g;
+
+function localManifestServerModuleSpecifiers(code: string): string[] {
+  const specifiers = new Set<string>();
+  localManifestServerModuleImportPattern.lastIndex = 0;
+
+  for (const match of code.matchAll(localManifestServerModuleImportPattern)) {
+    const source = match.groups?.source;
+
+    if (source !== undefined) {
+      specifiers.add(source);
+    }
+  }
+
+  return Array.from(specifiers);
+}
+
+function resolveManifestLocalServerSourceImport(
+  fromFile: string,
+  specifier: string,
+  sourceFiles: ReadonlySet<string>,
+): string | undefined {
+  const base = resolveManifestRelativePath(manifestDirname(fromFile), specifier);
+
+  for (const candidate of manifestLocalServerSourceImportCandidates(base)) {
+    if (sourceFiles.has(candidate)) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+function manifestLocalServerSourceImportCandidates(base: string): string[] {
+  const candidates = [base];
+
+  if (base.endsWith(".js")) {
+    const withoutJs = base.slice(0, -".js".length);
+    candidates.push(`${withoutJs}.ts`, `${withoutJs}.tsx`, `${withoutJs}.mreact.tsx`);
+  } else if (base.endsWith(".jsx")) {
+    const withoutJsx = base.slice(0, -".jsx".length);
+    candidates.push(`${withoutJsx}.tsx`, `${withoutJsx}.mreact.tsx`);
+  } else if (base.endsWith(".mreact")) {
+    candidates.push(`${base}.tsx`);
+  } else {
+    candidates.push(
+      `${base}.ts`,
+      `${base}.tsx`,
+      `${base}.mreact.tsx`,
+      `${base}/index.ts`,
+      `${base}/index.tsx`,
+      `${base}/index.mreact.tsx`,
+    );
+  }
+
+  return candidates;
+}
+
+function manifestDirname(file: string): string {
+  const index = file.lastIndexOf("/");
+
+  return index === -1 ? "" : file.slice(0, index);
+}
+
+function resolveManifestRelativePath(fromDir: string, specifier: string): string {
+  const segments = fromDir === "" ? [] : fromDir.split("/");
+
+  for (const segment of specifier.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+
+    segments.push(segment);
+  }
+
+  return segments.join("/");
+}
+
 function canUseBuildServerActionPlaceholders(
   references: readonly BuiltServerActionExpressionReference[],
 ): boolean {

package/src/built-assets.ts

@@ -0,0 +1,164 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join, normalize, sep } from "node:path";
+import type { ClientRouteManifestEntry } from "./client-route-inference.js";
+import { clientManifestAssetPaths } from "./client-manifest-assets.js";
+import { bytesResponse, rawNodeRequestUrl } from "./http.js";
+
+const builtPublicAssetCache = new Map<
+  string,
+  {
+    bytes: Uint8Array;
+    headers: HeadersInit;
+  }
+>();
+
+export async function readBuiltClientAsset(
+  outDir: string,
+  pathname: string,
+  allowedPaths: ReadonlySet<string>,
+): Promise<Response> {
+  const clientPrefix = "/_mreact/client/";
+  const normalized = safeBuiltClientAssetPath(pathname.slice(clientPrefix.length));
+
+  if (normalized === undefined || !allowedPaths.has(normalized)) {
+    return new Response("Not Found", { status: 404 });
+  }
+
+  try {
+    const code = await readFile(join(outDir, "client", normalized), "utf8");
+
+    return new Response(code, {
+      headers: clientAssetHeaders(normalized),
+    });
+  } catch {
+    return new Response("Not Found", { status: 404 });
+  }
+}
+
+export function builtClientAssetPathname(request: Request, url: URL): string | undefined {
+  const rawUrl = rawNodeRequestUrl(request);
+  const rawPathname = rawUrl?.split(/[?#]/, 1)[0];
+  const pathname = rawPathname === undefined || rawPathname === "" ? url.pathname : rawPathname;
+  const normalizedPathname = pathname.startsWith("/") ? pathname : `/${pathname}`;
+
+  return normalizedPathname.startsWith("/_mreact/client/") ? normalizedPathname : undefined;
+}
+
+function safeBuiltClientAssetPath(relativePath: string): string | undefined {
+  let decoded: string;
+
+  try {
+    decoded = decodeURIComponent(relativePath);
+  } catch {
+    return undefined;
+  }
+
+  if (decoded.includes("\\") || decoded.includes("\0")) {
+    return undefined;
+  }
+
+  if (decoded.split("/").some((segment) => segment === "..")) {
+    return undefined;
+  }
+
+  const normalized = normalize(decoded);
+
+  if (isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${sep}`)) {
+    return undefined;
+  }
+
+  return normalized;
+}
+
+export function builtClientAssetPaths(manifest: {
+  assets?: readonly string[] | undefined;
+  routes: readonly ClientRouteManifestEntry[];
+}): ReadonlySet<string> {
+  return clientManifestAssetPaths(manifest);
+}
+
+export async function readBuiltPublicAsset(
+  outDir: string,
+  pathname: string,
+): Promise<Response | undefined> {
+  const relativePath = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+
+  if (relativePath === "") {
+    return undefined;
+  }
+
+  const normalized = normalize(relativePath);
+
+  if (isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+    return undefined;
+  }
+
+  try {
+    const cacheKey = `${outDir}\0${normalized}`;
+    const cached = builtPublicAssetCache.get(cacheKey);
+
+    if (cached !== undefined) {
+      return bytesResponse(cached.bytes, {
+        headers: cached.headers,
+      });
+    }
+
+    const bytes = await readFile(join(outDir, "client", "public", normalized));
+    const headers = publicAssetHeaders(normalized);
+
+    builtPublicAssetCache.set(cacheKey, {
+      bytes,
+      headers,
+    });
+
+    return bytesResponse(bytes, { headers });
+  } catch {
+    return undefined;
+  }
+}
+
+export function clearBuiltPublicAssetCacheForTest(): void {
+  builtPublicAssetCache.clear();
+}
+
+export function getBuiltPublicAssetCacheSizeForTest(): number {
+  return builtPublicAssetCache.size;
+}
+
+function clientAssetHeaders(pathname: string): HeadersInit {
+  if (pathname === "manifest.json") {
+    return {
+      "cache-control": "no-cache",
+      "content-type": "application/json; charset=utf-8",
+    };
+  }
+
+  return {
+    "cache-control": "public, max-age=31536000, immutable",
+    "content-type": pathname.endsWith(".css")
+      ? "text/css; charset=utf-8"
+      : "text/javascript; charset=utf-8",
+  };
+}
+
+function publicAssetHeaders(pathname: string): HeadersInit {
+  return {
+    "cache-control": "public, max-age=3600",
+    "content-type": publicAssetContentType(pathname),
+  };
+}
+
+function publicAssetContentType(pathname: string): string {
+  if (pathname.endsWith(".css")) return "text/css; charset=utf-8";
+  if (pathname.endsWith(".html")) return "text/html; charset=utf-8";
+  if (pathname.endsWith(".js")) return "text/javascript; charset=utf-8";
+  if (pathname.endsWith(".json")) return "application/json; charset=utf-8";
+  if (pathname.endsWith(".svg")) return "image/svg+xml";
+  if (pathname.endsWith(".png")) return "image/png";
+  if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) return "image/jpeg";
+  if (pathname.endsWith(".webp")) return "image/webp";
+  if (pathname.endsWith(".ico")) return "image/x-icon";
+  if (pathname.endsWith(".txt")) return "text/plain; charset=utf-8";
+
+  return "application/octet-stream";
+}

package/src/built-runtime.ts

@@ -0,0 +1,312 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, normalize } from "node:path";
+import type {
+  BuiltPrerenderedRoute,
+  BuiltServerManifest,
+  BuiltServerModuleArtifact,
+} from "./build.js";
+import { builtClientAssetPaths } from "./built-assets.js";
+import type { BuiltServerModuleArtifactRuntime } from "./built-server-module-artifacts.js";
+import type { ClientRouteManifestEntry } from "./client-route-inference.js";
+import type { AppRouterImportPolicy } from "./import-policy.js";
+import { createRouteMatcher, type AppRoute, type RouteMatcher } from "./routes.js";
+
+export interface BuiltRuntime extends BuiltServerModuleArtifactRuntime {
+  allowedSourceDirs: readonly string[];
+  assetBaseUrl?: string | undefined;
+  clientAssetPaths: ReadonlySet<string>;
+  clientScripts: ReadonlyMap<string, string>;
+  clientStylesByFile: ReadonlyMap<string, readonly string[]>;
+  clientStyles: ReadonlyMap<string, readonly string[]>;
+  generatedImportPolicy?: AppRouterImportPolicy | undefined;
+  hasMiddleware: boolean;
+  navigationScripts: ReadonlyMap<string, string>;
+  projectRoot: string;
+  publicAssetBaseUrl?: string | undefined;
+  prerenderableRoutes: ReadonlySet<string>;
+  prerenderLocks: Map<string, Promise<Response>>;
+  prerenderedRoutes: Map<string, BuiltPrerenderedRoute>;
+  routeMatcher: RouteMatcher;
+  routes: readonly AppRoute[];
+  serverActionReferencesByFile: ReadonlyMap<
+    string,
+    readonly {
+      end: number;
+      expression: string;
+      expressionEnd: number;
+      expressionStart: number;
+      moduleId: string;
+      exportName: string;
+      inferred: boolean;
+      sourceHash: string;
+      start: number;
+    }[]
+  >;
+  serverActionManifest?: readonly { moduleId: string; exportName: string; inferred?: boolean }[] | undefined;
+  serverModuleCacheVersion: string;
+}
+
+export async function materializeBuiltRuntime(options: {
+  clientManifestText: string;
+  clientManifestPath: string;
+  importPolicyPath: string;
+  importPolicyText: string | undefined;
+  onMaterialize?: (() => void) | undefined;
+  outDir: string;
+  runtimeDir: string;
+  serverManifestText: string;
+  serverManifestPath: string;
+}): Promise<BuiltRuntime> {
+  options.onMaterialize?.();
+  const serverManifest = parseBuiltJsonArtifact<BuiltServerManifest>(
+    options.serverManifestText,
+    options.serverManifestPath,
+    "built app server manifest",
+  );
+  const clientManifest = parseBuiltJsonArtifact<{
+    assets?: readonly string[];
+    routes: ClientRouteManifestEntry[];
+    styles?: Array<{ css?: readonly string[]; file: string }>;
+  }>(options.clientManifestText, options.clientManifestPath, "built app client manifest");
+  const appDir = await materializeBuiltServerApp(options.runtimeDir, serverManifest);
+  const projectRoot = appDir;
+  const routesDir = join(projectRoot, serverManifest.routesDir ?? "");
+  const routes = serverManifest.routes.map((route) => ({
+    ...route,
+    file: join(projectRoot, route.file),
+  }));
+  const prerenderedRoutes = new Map(Object.entries(serverManifest.prerenderedRoutes ?? {}));
+  const prerenderableRoutes = new Set(prerenderedRoutes.keys());
+  const prerenderLocks = new Map<string, Promise<Response>>();
+  const serverModules = new Map<string, BuiltServerModuleArtifact>(
+    Object.entries(serverManifest.serverModules ?? {}).map(([file, artifact]) => [
+      join(appDir, file),
+      artifact,
+    ]),
+  );
+  const serverModuleClosureFiles = new Map<string, readonly string[]>(
+    Object.entries(serverManifest.serverModuleClosureFiles ?? {}).map(([file, closure]) => [
+      join(appDir, safeManifestFilePath(file)),
+      closure.map((closureFile) => join(appDir, safeManifestFilePath(closureFile))),
+    ]),
+  );
+  const serverModuleFiles = new Map(
+    Object.entries(serverManifest.serverModuleFiles ?? {}).map(([file, artifactFile]) => [
+      join(appDir, file),
+      join(options.outDir, "server", safeManifestFilePath(artifactFile)),
+    ]),
+  );
+  const serverModuleRequestFiles = new Map(
+    Object.entries(serverManifest.serverModuleRequestFiles ?? {}).map(([file, artifactFile]) => [
+      join(appDir, file),
+      join(options.outDir, "server", safeManifestFilePath(artifactFile)),
+    ]),
+  );
+  const serverModuleRenderFiles = new Map(
+    Object.entries(serverManifest.serverModuleRenderFiles ?? {}).map(([file, artifactFile]) => [
+      join(appDir, file),
+      join(options.outDir, "server", safeManifestFilePath(artifactFile)),
+    ]),
+  );
+  const serverSourceFiles = new Map(
+    Object.entries(serverManifest.files).map(([file, source]) => [join(appDir, file), source]),
+  );
+  const serverActionReferencesByFile = new Map(
+    Object.entries(serverManifest.routeServerActionReferences ?? {}).map(([file, references]) => [
+      join(appDir, file),
+      references,
+    ]),
+  );
+  const routeMatcher = createRouteMatcher(routes, serverManifest.routeMatcher);
+  const clientScripts = new Map(
+    clientManifest.routes.flatMap((route) =>
+      route.client && route.script !== undefined ? [[route.path, route.script]] : [],
+    ),
+  );
+  const clientStyles = new Map(
+    clientManifest.routes.flatMap((route) =>
+      route.css !== undefined && route.css.length > 0 ? [[route.path, route.css]] : [],
+    ),
+  );
+  const clientStylesByFile = new Map(
+    (clientManifest.styles ?? []).flatMap((style) =>
+      style.css !== undefined && style.css.length > 0
+        ? [[join(routesDir, style.file), style.css] as const]
+        : [],
+    ),
+  );
+  const navigationScripts = new Map(
+    clientManifest.routes.flatMap((route) =>
+      route.navigation === true && route.navigationScript !== undefined
+        ? [[route.path, route.navigationScript]]
+        : [],
+    ),
+  );
+  const hasMiddleware =
+    serverSourceFiles.has(join(routesDir, "middleware.ts")) ||
+    serverSourceFiles.has(join(routesDir, "middleware.mreact.ts"));
+  const serverModuleCacheVersion = createHash("sha256")
+    .update(options.serverManifestText)
+    .update("\0")
+    .update(options.clientManifestText)
+    .digest("hex")
+    .slice(0, 16);
+
+  const allowedSourceDirs = (serverManifest.allowedSourceDirs ?? [""]).map((directory) =>
+    join(projectRoot, directory),
+  );
+  const generatedImportPolicy = builtGeneratedImportPolicy(
+    options.importPolicyText,
+    options.importPolicyPath,
+  );
+
+  return {
+    appDir: routesDir,
+    allowedSourceDirs,
+    ...(serverManifest.assetBaseUrl === undefined
+      ? {}
+      : { assetBaseUrl: serverManifest.assetBaseUrl }),
+    clientAssetPaths: builtClientAssetPaths(clientManifest),
+    clientScripts,
+    clientStylesByFile,
+    clientStyles,
+    ...(generatedImportPolicy === undefined ? {} : { generatedImportPolicy }),
+    hasMiddleware,
+    navigationScripts,
+    projectRoot,
+    ...(serverManifest.publicAssetBaseUrl === undefined
+      ? {}
+      : { publicAssetBaseUrl: serverManifest.publicAssetBaseUrl }),
+    prerenderableRoutes,
+    prerenderLocks,
+    prerenderedRoutes,
+    routeMatcher,
+    routes,
+    serverActionReferencesByFile,
+    ...(serverManifest.serverActionManifest === undefined
+      ? {}
+      : { serverActionManifest: serverManifest.serverActionManifest }),
+    serverModuleArtifactLoads: new Map(),
+    serverModuleClosureFiles,
+    serverModuleFiles,
+    serverModuleRenderFiles,
+    serverModuleRequestFiles,
+    serverModules,
+    serverModuleCacheVersion,
+    serverSourceFiles,
+  };
+}
+
+export async function readBuiltImportPolicyText(outDir: string): Promise<string | undefined> {
+  const policyPath = join(outDir, "server", "import-policy.json");
+
+  try {
+    return await readFile(policyPath, "utf8");
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return undefined;
+    }
+
+    throw builtArtifactReadError("built app import policy", policyPath, error);
+  }
+}
+
+export function mergeBuiltRuntimeImportPolicy(
+  runtime: BuiltRuntime,
+  importPolicy: AppRouterImportPolicy | undefined,
+): AppRouterImportPolicy | undefined {
+  const generatedImportPolicy = runtime.generatedImportPolicy;
+
+  if (generatedImportPolicy === undefined) {
+    return importPolicy;
+  }
+
+  const allowedPackages = [
+    ...new Set([
+      ...(generatedImportPolicy.allowedPackages ?? []),
+      ...(importPolicy?.allowedPackages ?? []),
+    ]),
+  ];
+
+  return {
+    ...(allowedPackages.length === 0 ? {} : { allowedPackages }),
+    ...(importPolicy?.allowedSourceDirs === undefined
+      ? {}
+      : { allowedSourceDirs: importPolicy.allowedSourceDirs }),
+    ...(importPolicy?.projectRoot === undefined ? {} : { projectRoot: importPolicy.projectRoot }),
+  };
+}
+
+function builtGeneratedImportPolicy(
+  importPolicyText: string | undefined,
+  importPolicyPath: string,
+): AppRouterImportPolicy | undefined {
+  if (importPolicyText === undefined) {
+    return undefined;
+  }
+
+  const artifact = parseBuiltJsonArtifact<{
+    runtimePackages?: unknown;
+  }>(importPolicyText, importPolicyPath, "built app import policy");
+  const runtimePackages = Array.isArray(artifact.runtimePackages)
+    ? artifact.runtimePackages.filter((name): name is string => typeof name === "string")
+    : [];
+
+  return runtimePackages.length === 0 ? undefined : { allowedPackages: runtimePackages };
+}
+
+async function materializeBuiltServerApp(
+  runtimeDir: string,
+  manifest: BuiltServerManifest,
+): Promise<string> {
+  const appDir = join(runtimeDir, "app");
+
+  await rm(appDir, { force: true, recursive: true });
+  await Promise.all(
+    Object.entries(manifest.files).map(async ([file, code]) => {
+      const outputFile = join(appDir, safeManifestFilePath(file));
+
+      await mkdir(dirname(outputFile), { recursive: true });
+      await writeFile(outputFile, code);
+    }),
+  );
+
+  return appDir;
+}
+
+function isMissingFileError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "ENOENT"
+  );
+}
+
+function builtArtifactReadError(label: string, artifactPath: string, error: unknown): Error {
+  const prefix = isMissingFileError(error) ? "Missing" : "Unable to read";
+  const detail = error instanceof Error && error.message !== "" ? `: ${error.message}` : "";
+
+  return new Error(`${prefix} ${label}: ${artifactPath}${detail}`, { cause: error });
+}
+
+function parseBuiltJsonArtifact<T>(text: string, artifactPath: string, label: string): T {
+  try {
+    return JSON.parse(text) as T;
+  } catch (error) {
+    const detail = error instanceof Error && error.message !== "" ? `: ${error.message}` : "";
+
+    throw new Error(`Invalid ${label}: ${artifactPath}${detail}`, { cause: error });
+  }
+}
+
+function safeManifestFilePath(pathname: string): string {
+  const normalized = normalize(pathname);
+
+  if (isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(`Invalid built app manifest file path: ${pathname}`);
+  }
+
+  return normalized;
+}