}> =
+ pathsResult?.paths ?? [];
+ for (const { params } of paths) {
+ urls.push(buildUrlFromParams(route.pattern, params));
+ }
+ } else {
+ urls.push(route.pattern);
+ }
+ } catch {
+ // Skip routes that fail to load
+ }
+ }
+ }
+
+ return urls;
+ } finally {
+ await server.close();
+ }
+}
+
diff --git a/tests/build-prerender.test.ts b/tests/build-prerender.test.ts
new file mode 100644
index 00000000..c60feb32
--- /dev/null
+++ b/tests/build-prerender.test.ts
@@ -0,0 +1,162 @@
+/**
+ * Tests for Phase 2 of static pre-rendering.
+ *
+ * Tests:
+ * 1. Production server serving pre-rendered HTML from dist/server/pages/
+ * 2. prerenderStaticPages() function existence and return type
+ */
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import type { Server } from "node:http";
+
+const PAGES_FIXTURE = path.resolve(import.meta.dirname, "./fixtures/pages-basic");
+
+// ─── Production server — serves pre-rendered HTML ─────────────────────────────
+
+describe("Production server — serves pre-rendered HTML", () => {
+ const outDir = path.resolve(PAGES_FIXTURE, "dist");
+ const serverEntryPath = path.join(outDir, "server", "entry.js");
+ const pagesDir = path.join(outDir, "server", "pages");
+ const prerenderedFile = path.join(pagesDir, "prerendered-test.html");
+ const hasServerEntry = fs.existsSync(serverEntryPath);
+
+ let server: Server;
+ let baseUrl: string;
+
+ beforeAll(async () => {
+ if (!hasServerEntry) return;
+
+ // Create a fake pre-rendered HTML file at dist/server/pages/prerendered-test.html
+ fs.mkdirSync(pagesDir, { recursive: true });
+ fs.writeFileSync(
+ prerenderedFile,
+ `Pre-renderedPre-rendered test content
`,
+ "utf-8",
+ );
+
+ const { startProdServer } = await import(
+ "../packages/vinext/src/server/prod-server.js"
+ );
+ server = await startProdServer({
+ port: 0,
+ host: "127.0.0.1",
+ outDir,
+ });
+ const addr = server.address() as { port: number };
+ baseUrl = `http://127.0.0.1:${addr.port}`;
+ });
+
+ afterAll(async () => {
+ if (server) {
+ await new Promise((resolve) => server.close(() => resolve()));
+ }
+ // Clean up the fake pre-rendered file and pages directory
+ if (fs.existsSync(prerenderedFile)) {
+ fs.rmSync(prerenderedFile);
+ }
+ if (fs.existsSync(pagesDir) && fs.readdirSync(pagesDir).length === 0) {
+ fs.rmdirSync(pagesDir);
+ }
+ });
+
+ it.skipIf(!hasServerEntry)(
+ "serves pre-rendered HTML for /prerendered-test",
+ async () => {
+ const res = await fetch(`${baseUrl}/prerendered-test`);
+ expect(res.status).toBe(200);
+ const html = await res.text();
+ expect(html).toContain("Pre-rendered test content");
+ },
+ );
+
+ it.skipIf(!hasServerEntry)(
+ "serves pre-rendered HTML with text/html content type",
+ async () => {
+ const res = await fetch(`${baseUrl}/prerendered-test`);
+ expect(res.status).toBe(200);
+ expect(res.headers.get("content-type")).toContain("text/html");
+ },
+ );
+
+ it.skipIf(!hasServerEntry)(
+ "falls back to SSR when no pre-rendered file exists",
+ async () => {
+ // /about is a real page in pages-basic but has no pre-rendered file
+ const res = await fetch(`${baseUrl}/about`);
+ expect(res.status).toBe(200);
+ const html = await res.text();
+ expect(html).toContain("About");
+ },
+ );
+
+ it.skipIf(!hasServerEntry)(
+ "serves nested pre-rendered HTML (e.g. /blog/hello-world)",
+ async () => {
+ // Create a nested pre-rendered file simulating a dynamic route
+ const nestedDir = path.join(pagesDir, "blog");
+ const nestedFile = path.join(nestedDir, "hello-world.html");
+ fs.mkdirSync(nestedDir, { recursive: true });
+ fs.writeFileSync(
+ nestedFile,
+ `Blog post content`,
+ "utf-8",
+ );
+
+ try {
+ const res = await fetch(`${baseUrl}/blog/hello-world`);
+ expect(res.status).toBe(200);
+ const html = await res.text();
+ expect(html).toContain("Blog post content");
+ } finally {
+ fs.rmSync(nestedFile);
+ if (fs.existsSync(nestedDir) && fs.readdirSync(nestedDir).length === 0) {
+ fs.rmdirSync(nestedDir);
+ }
+ }
+ },
+ );
+
+ it.skipIf(!hasServerEntry)(
+ "serves pre-rendered index.html for /",
+ async () => {
+ const indexFile = path.join(pagesDir, "index.html");
+ fs.writeFileSync(
+ indexFile,
+ `Pre-rendered home`,
+ "utf-8",
+ );
+
+ try {
+ const res = await fetch(`${baseUrl}/`);
+ expect(res.status).toBe(200);
+ const html = await res.text();
+ expect(html).toContain("Pre-rendered home");
+ } finally {
+ fs.rmSync(indexFile);
+ }
+ },
+ );
+});
+
+// ─── prerenderStaticPages — function exists ───────────────────────────────────
+
+describe("prerenderStaticPages — function exists", () => {
+ it("prerenderStaticPages is exported as a function", async () => {
+ const mod = await import("../packages/vinext/src/build/static-export.js");
+ expect(typeof mod.prerenderStaticPages).toBe("function");
+ });
+
+ it("PrerenderResult type is returned", async () => {
+ // This will fail because prerenderStaticPages doesn't exist yet
+ const { prerenderStaticPages } = await import(
+ "../packages/vinext/src/build/static-export.js"
+ );
+ // Call with the pages-basic fixture which has a built dist/
+ const result = await prerenderStaticPages({ root: PAGES_FIXTURE });
+ expect(result).toHaveProperty("pageCount");
+ expect(result).toHaveProperty("files");
+ expect(result).toHaveProperty("warnings");
+ expect(result).toHaveProperty("skipped");
+ });
+});
From bbcf6e4910080265dbf0486482d1d0ac872cbdc1 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <146415969+NathanDrake2406@users.noreply.github.com>
Date: Fri, 6 Mar 2026 05:20:17 +1100
Subject: [PATCH 03/12] feat: serve pre-rendered HTML from prod server
Add resolvePrerenderedHtml() helper and pre-render check to both
App Router and Pages Router production servers. Pre-rendered files
in dist/server/pages/ are served directly with text/html before
falling back to SSR.
Includes path traversal protection and supports both /page.html
and /page/index.html patterns for trailingSlash compatibility.
Phase 2 of #9
---
packages/vinext/src/server/prod-server.ts | 50 +++++++++++++++++++++++
1 file changed, 50 insertions(+)
diff --git a/packages/vinext/src/server/prod-server.ts b/packages/vinext/src/server/prod-server.ts
index d4051468..27ed4419 100644
--- a/packages/vinext/src/server/prod-server.ts
+++ b/packages/vinext/src/server/prod-server.ts
@@ -240,6 +240,36 @@ function tryServeStatic(
return true;
}
+/**
+ * Check if a pre-rendered HTML file exists for a given pathname.
+ * Returns the absolute file path if found, null otherwise.
+ *
+ * Checks both `/pathname.html` and `/pathname/index.html` to support
+ * both trailingSlash modes. Pre-rendered files are written during
+ * `vinext build` to dist/server/pages/.
+ */
+function resolvePrerenderedHtml(dir: string, pathname: string): string | null {
+ if (!fs.existsSync(dir)) return null;
+
+ // Normalize: "/" → "index", "/about" → "about", "/blog/post" → "blog/post"
+ const normalized = pathname === "/" ? "index" : pathname.replace(/^\//, "").replace(/\/$/, "");
+
+ // Guard against directory traversal
+ const resolvedDir = path.resolve(dir);
+
+ const directPath = path.join(dir, `${normalized}.html`);
+ if (path.resolve(directPath).startsWith(resolvedDir) && fs.existsSync(directPath) && fs.statSync(directPath).isFile()) {
+ return directPath;
+ }
+
+ const indexPath = path.join(dir, normalized, "index.html");
+ if (path.resolve(indexPath).startsWith(resolvedDir) && fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
+ return indexPath;
+ }
+
+ return null;
+}
+
/**
* Resolve the host for a request, ignoring X-Forwarded-Host to prevent
* host header poisoning attacks (open redirects, cache poisoning).
@@ -546,6 +576,15 @@ async function startAppRouterServer(options: AppRouterServerOptions) {
return;
}
+ // Pre-rendered HTML — serve build-time rendered pages before hitting RSC/SSR
+ const appPrerenderedDir = path.join(path.dirname(rscEntryPath), "pages");
+ const appPrerenderedFile = resolvePrerenderedHtml(appPrerenderedDir, pathname);
+ if (appPrerenderedFile) {
+ const html = fs.readFileSync(appPrerenderedFile, "utf-8");
+ sendCompressed(req, res, html, "text/html; charset=utf-8", 200, {}, compress);
+ return;
+ }
+
try {
// Convert Node.js request to Web Request and call the RSC handler
const request = nodeToWebRequest(req);
@@ -712,6 +751,17 @@ async function startPagesRouterServer(options: PagesRouterServerOptions) {
return;
}
+ // ── 1b. Pre-rendered HTML ──────────────────────────────────
+ // Check if a pre-rendered HTML file exists for this pathname.
+ // These are generated during `vinext build` for static pages.
+ const pagesPrerenderedDir = path.join(path.dirname(serverEntryPath), "pages");
+ const pagesPrerenderedFile = resolvePrerenderedHtml(pagesPrerenderedDir, pathname);
+ if (pagesPrerenderedFile) {
+ const html = fs.readFileSync(pagesPrerenderedFile, "utf-8");
+ sendCompressed(req, res, html, "text/html; charset=utf-8", 200, {}, compress);
+ return;
+ }
+
try {
// ── 2. Strip basePath ─────────────────────────────────────────
if (basePath && pathname.startsWith(basePath)) {
From f44f44692ac72c6aa42e0aae9bb94101920f626a Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <146415969+NathanDrake2406@users.noreply.github.com>
Date: Fri, 6 Mar 2026 05:20:22 +1100
Subject: [PATCH 04/12] feat: wire prerenderStaticPages() into vinext build
After a non-export build completes, automatically pre-render static
pages to dist/server/pages/. The prod server serves these directly
without SSR on first request.
Phase 2 of #9
---
packages/vinext/src/cli.ts | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/packages/vinext/src/cli.ts b/packages/vinext/src/cli.ts
index fc033125..b7d3b19b 100644
--- a/packages/vinext/src/cli.ts
+++ b/packages/vinext/src/cli.ts
@@ -304,6 +304,26 @@ async function buildApp() {
return;
}
+ // ── Pre-render static pages (non-export builds) ────────────────
+ console.log(" Pre-rendering static pages...\n");
+
+ const { prerenderStaticPages } = await import(
+ /* @vite-ignore */ "./build/static-export.js"
+ );
+
+ const prerenderResult = await prerenderStaticPages({ root: process.cwd() });
+
+ if (prerenderResult.warnings.length > 0) {
+ for (const w of prerenderResult.warnings) console.log(` Warning: ${w}`);
+ }
+ if (prerenderResult.skipped.length > 0) {
+ console.log(` Skipped ${prerenderResult.skipped.length} route(s) (dynamic or errored)`);
+ }
+
+ if (prerenderResult.pageCount > 0) {
+ console.log(`\n Pre-rendered ${prerenderResult.pageCount} static page(s)\n`);
+ }
+
console.log("\n Build complete. Run `vinext start` to start the production server.\n");
}
From 1b8a0f9769f0b6bb886c8b8f6c274f766122909f Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <146415969+NathanDrake2406@users.noreply.github.com>
Date: Fri, 6 Mar 2026 06:21:51 +1100
Subject: [PATCH 05/12] fix: address 6 bugs found in code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
1. Remove App Router pre-rendered HTML shortcut — was bypassing RSC
streaming and middleware/auth pipeline
2. Move Pages Router pre-rendered check after middleware/basePath/
redirects/rewrites pipeline (step 7b instead of 1b)
3. Skip ISR pages (revalidate != false) in collectStaticRoutes()
to prevent freezing dynamic content as static HTML
4. basePath handling covered by fix #2 (uses resolvedPathname)
5. Temp Vite servers now check for project vite.config and use it
when present, so user plugins/aliases are available
6. vinext start guard now checks config.output directly instead of
relying on out/ directory existence heuristic
---
packages/vinext/src/build/static-export.ts | 78 ++++++++++++++++------
packages/vinext/src/cli.ts | 12 ++--
packages/vinext/src/server/prod-server.ts | 32 ++++-----
3 files changed, 77 insertions(+), 45 deletions(-)
diff --git a/packages/vinext/src/build/static-export.ts b/packages/vinext/src/build/static-export.ts
index 2390bf87..40005fd2 100644
--- a/packages/vinext/src/build/static-export.ts
+++ b/packages/vinext/src/build/static-export.ts
@@ -815,16 +815,31 @@ export async function runStaticExport(
}
// 3. Start a temporary Vite dev server
- const { default: vinextPlugin } = await import("../index.js");
const vite = await import("vite");
- const server = await vite.createServer({
- root,
- configFile: false,
- plugins: [vinextPlugin({ appDir: root })],
- optimizeDeps: { holdUntilCrawlEnd: true },
- server: { port: 0, cors: false },
- logLevel: "silent",
- });
+ const hasViteConfig = ["vite.config.ts", "vite.config.js", "vite.config.mjs"]
+ .some((f) => fs.existsSync(path.join(root, f)));
+
+ let serverConfig: Record;
+ if (hasViteConfig) {
+ // Use the project's vite config so user plugins/aliases/transforms are available
+ serverConfig = {
+ root,
+ optimizeDeps: { holdUntilCrawlEnd: true },
+ server: { port: 0, cors: false },
+ logLevel: "silent",
+ };
+ } else {
+ const { default: vinextPlugin } = await import("../index.js");
+ serverConfig = {
+ root,
+ configFile: false,
+ plugins: [vinextPlugin({ appDir: root })],
+ optimizeDeps: { holdUntilCrawlEnd: true },
+ server: { port: 0, cors: false },
+ logLevel: "silent",
+ };
+ }
+ const server = await vite.createServer(serverConfig);
await server.listen();
try {
@@ -1000,16 +1015,30 @@ async function collectStaticRoutes(root: string, isAppRouter: boolean): Promise<
if (!isAppRouter && !pagesDir) return [];
// Start a temporary Vite dev server for module inspection
- const { default: vinextPlugin } = await import("../index.js");
const vite = await import("vite");
- const server = await vite.createServer({
- root,
- configFile: false,
- plugins: [vinextPlugin({ appDir: root })],
- optimizeDeps: { holdUntilCrawlEnd: true },
- server: { port: 0, cors: false },
- logLevel: "silent",
- });
+ const hasViteConfig = ["vite.config.ts", "vite.config.js", "vite.config.mjs"]
+ .some((f) => fs.existsSync(path.join(root, f)));
+
+ let serverConfig: Record;
+ if (hasViteConfig) {
+ serverConfig = {
+ root,
+ optimizeDeps: { holdUntilCrawlEnd: true },
+ server: { port: 0, cors: false },
+ logLevel: "silent",
+ };
+ } else {
+ const { default: vinextPlugin } = await import("../index.js");
+ serverConfig = {
+ root,
+ configFile: false,
+ plugins: [vinextPlugin({ appDir: root })],
+ optimizeDeps: { holdUntilCrawlEnd: true },
+ server: { port: 0, cors: false },
+ logLevel: "silent",
+ };
+ }
+ const server = await vite.createServer(serverConfig);
await server.listen();
try {
@@ -1025,8 +1054,9 @@ async function collectStaticRoutes(root: string, isAppRouter: boolean): Promise<
try {
const pageModule = await server.ssrLoadModule(route.pagePath);
- // Skip force-dynamic pages
+ // Skip dynamic/request-dependent pages
if (pageModule.dynamic === "force-dynamic") continue;
+ if (pageModule.revalidate !== undefined && pageModule.revalidate !== false) continue;
if (route.isDynamic) {
// Need generateStaticParams to expand
@@ -1074,6 +1104,16 @@ async function collectStaticRoutes(root: string, isAppRouter: boolean): Promise<
// Skip pages with getServerSideProps
if (typeof pageModule.getServerSideProps === "function") continue;
+ // Skip ISR pages (getStaticProps with revalidate)
+ if (typeof pageModule.getStaticProps === "function") {
+ try {
+ const propsResult = await pageModule.getStaticProps({});
+ if (propsResult?.revalidate) continue;
+ } catch {
+ continue; // Skip if getStaticProps fails
+ }
+ }
+
if (route.isDynamic) {
// Need getStaticPaths with fallback: false
if (typeof pageModule.getStaticPaths !== "function") continue;
diff --git a/packages/vinext/src/cli.ts b/packages/vinext/src/cli.ts
index b7d3b19b..4fee3cc2 100644
--- a/packages/vinext/src/cli.ts
+++ b/packages/vinext/src/cli.ts
@@ -337,12 +337,12 @@ async function start() {
});
// Reject static export builds — they don't need a production server
- const outExportDir = path.resolve(process.cwd(), "out");
- const distServerDir = path.resolve(process.cwd(), "dist", "server");
- if (
- fs.existsSync(path.join(outExportDir, "index.html")) &&
- !fs.existsSync(distServerDir)
- ) {
+ const { loadNextConfig, resolveNextConfig } = await import(
+ /* @vite-ignore */ "./config/next-config.js"
+ );
+ const startRawConfig = await loadNextConfig(process.cwd());
+ const startResolvedConfig = await resolveNextConfig(startRawConfig);
+ if (startResolvedConfig.output === "export") {
console.error(
'\n "vinext start" does not work with "output: export" configuration.',
);
diff --git a/packages/vinext/src/server/prod-server.ts b/packages/vinext/src/server/prod-server.ts
index 27ed4419..612896b9 100644
--- a/packages/vinext/src/server/prod-server.ts
+++ b/packages/vinext/src/server/prod-server.ts
@@ -576,15 +576,6 @@ async function startAppRouterServer(options: AppRouterServerOptions) {
return;
}
- // Pre-rendered HTML — serve build-time rendered pages before hitting RSC/SSR
- const appPrerenderedDir = path.join(path.dirname(rscEntryPath), "pages");
- const appPrerenderedFile = resolvePrerenderedHtml(appPrerenderedDir, pathname);
- if (appPrerenderedFile) {
- const html = fs.readFileSync(appPrerenderedFile, "utf-8");
- sendCompressed(req, res, html, "text/html; charset=utf-8", 200, {}, compress);
- return;
- }
-
try {
// Convert Node.js request to Web Request and call the RSC handler
const request = nodeToWebRequest(req);
@@ -751,17 +742,6 @@ async function startPagesRouterServer(options: PagesRouterServerOptions) {
return;
}
- // ── 1b. Pre-rendered HTML ──────────────────────────────────
- // Check if a pre-rendered HTML file exists for this pathname.
- // These are generated during `vinext build` for static pages.
- const pagesPrerenderedDir = path.join(path.dirname(serverEntryPath), "pages");
- const pagesPrerenderedFile = resolvePrerenderedHtml(pagesPrerenderedDir, pathname);
- if (pagesPrerenderedFile) {
- const html = fs.readFileSync(pagesPrerenderedFile, "utf-8");
- sendCompressed(req, res, html, "text/html; charset=utf-8", 200, {}, compress);
- return;
- }
-
try {
// ── 2. Strip basePath ─────────────────────────────────────────
if (basePath && pathname.startsWith(basePath)) {
@@ -930,6 +910,18 @@ async function startPagesRouterServer(options: PagesRouterServerOptions) {
}
}
+ // ── 7b. Pre-rendered HTML ─────────────────────────────────────
+ // Serve build-time rendered static pages. Placed after middleware,
+ // basePath stripping, redirects, and rewrites so those all run first.
+ const pagesPrerenderedDir = path.join(path.dirname(serverEntryPath), "pages");
+ const pagesPrerenderedFile = resolvePrerenderedHtml(pagesPrerenderedDir, resolvedPathname);
+ if (pagesPrerenderedFile) {
+ const html = fs.readFileSync(pagesPrerenderedFile, "utf-8");
+ const prerenderedHeaders: Record = { ...middlewareHeaders };
+ sendCompressed(req, res, html, "text/html; charset=utf-8", 200, prerenderedHeaders, compress);
+ return;
+ }
+
// ── 8. API routes ─────────────────────────────────────────────
if (resolvedPathname.startsWith("/api/") || resolvedPathname === "/api") {
let response: Response;
From df3830f05d0a56d43e0b3d0b8d81cfc16297a6fd Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <146415969+NathanDrake2406@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:00:24 +1100
Subject: [PATCH 06/12] fix: downgrade missing
generateStaticParams/getStaticPaths from error to warning
Dynamic routes without generateStaticParams (App Router) or
getStaticPaths (Pages Router) in output: 'export' mode now produce
a warning and skip the route instead of failing the build.
This enables legitimate use cases like CMS apps with no published
content and SPA-style client-rendered dynamic routes.
Addresses vercel/next.js#61213 and vercel/next.js#55393.
---
packages/vinext/src/build/static-export.ts | 16 +++++++---------
tests/app-router.test.ts | 7 ++++---
2 files changed, 11 insertions(+), 12 deletions(-)
diff --git a/packages/vinext/src/build/static-export.ts b/packages/vinext/src/build/static-export.ts
index 40005fd2..5ff54a64 100644
--- a/packages/vinext/src/build/static-export.ts
+++ b/packages/vinext/src/build/static-export.ts
@@ -122,12 +122,11 @@ export async function staticExportPages(
}
if (route.isDynamic) {
- // Dynamic route — must have getStaticPaths
+ // Dynamic route — needs getStaticPaths to enumerate params
if (typeof pageModule.getStaticPaths !== "function") {
- result.errors.push({
- route: route.pattern,
- error: `Dynamic route requires getStaticPaths with output: 'export'`,
- });
+ result.warnings.push(
+ `Dynamic route ${route.pattern} has no getStaticPaths() — skipping (no pages generated)`,
+ );
continue;
}
@@ -665,10 +664,9 @@ export async function staticExportApp(
const pageModule = await server.ssrLoadModule(route.pagePath);
if (typeof pageModule.generateStaticParams !== "function") {
- result.errors.push({
- route: route.pattern,
- error: `Dynamic route requires generateStaticParams() with output: 'export'`,
- });
+ result.warnings.push(
+ `Dynamic route ${route.pattern} has no generateStaticParams() — skipping (no pages generated)`,
+ );
continue;
}
diff --git a/tests/app-router.test.ts b/tests/app-router.test.ts
index 89ac8c36..5e828184 100644
--- a/tests/app-router.test.ts
+++ b/tests/app-router.test.ts
@@ -1590,7 +1590,7 @@ describe("App Router Static export", () => {
expect(html404).toContain("Page Not Found");
});
- it("reports errors for dynamic routes without generateStaticParams", async () => {
+ it("warns and skips dynamic routes without generateStaticParams", async () => {
const { staticExportApp } = await import(
"../packages/vinext/src/build/static-export.js"
);
@@ -1632,9 +1632,10 @@ describe("App Router Static export", () => {
config,
});
- // Should have an error about missing generateStaticParams
+ // Should warn (not error) about missing generateStaticParams
+ expect(result.errors).toHaveLength(0);
expect(
- result.errors.some((e) => e.error.includes("generateStaticParams")),
+ result.warnings.some((w) => w.includes("generateStaticParams")),
).toBe(true);
} finally {
fs.rmSync(tempDir, { recursive: true, force: true });
From ce830ad415eebc8ad0ed53ba26566a45288bf1ce Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <146415969+NathanDrake2406@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:13:03 +1100
Subject: [PATCH 07/12] fix: address code review findings in static export
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Must-fixes:
- Update stale file header comments (warning, not error)
- Sanitize getOutputPath() against path traversal from user params
- Fix revalidate filtering: only skip revalidate=0 (force-dynamic),
not all ISR pages — they should be pre-rendered
- Fix clearTimeout leak on fetch failure in prerenderStaticPages
- Consume response body on non-ok fetch in staticExportApp
- Fix revalidate:0 handling in Pages Router collectStaticRoutes
(0 is falsy, so the old check didn't catch it)
Should-fixes:
- Wrap renderStaticPage in try/finally to clear SSR context on error
- Extract createTempViteServer() helper (was duplicated 2x)
- Extract expandDynamicAppRoute() helper (was duplicated with
diverging behavior between staticExportApp and collectStaticRoutes)
- Remove unnecessary server.listen() in collectStaticRoutes —
only ssrLoadModule is needed, not an HTTP listener
- Add Pages Router test for warning on missing getStaticPaths
---
packages/vinext/src/build/static-export.ts | 371 ++++++++++-----------
tests/pages-router.test.ts | 40 +++
2 files changed, 224 insertions(+), 187 deletions(-)
diff --git a/packages/vinext/src/build/static-export.ts b/packages/vinext/src/build/static-export.ts
index 5ff54a64..9981be58 100644
--- a/packages/vinext/src/build/static-export.ts
+++ b/packages/vinext/src/build/static-export.ts
@@ -8,14 +8,15 @@
* Pages Router:
* - Static pages → render to HTML
* - getStaticProps pages → call at build time, render with props
- * - Dynamic routes → call getStaticPaths (must be fallback: false), render each
+ * - Dynamic routes → call getStaticPaths, render each (fallback: false required)
+ * - Dynamic routes without getStaticPaths → warning, skipped
* - getServerSideProps → build error
* - API routes → skipped with warning
*
* App Router:
* - Static pages → run Server Components at build time, render to HTML
* - Dynamic routes → call generateStaticParams(), render each
- * - Dynamic routes without generateStaticParams → build error
+ * - Dynamic routes without generateStaticParams → warning, skipped
*/
import type { ViteDevServer } from "vite";
import type { Route } from "../routing/pages-router.js";
@@ -31,6 +32,44 @@ import React from "react";
import { renderToReadableStream } from "react-dom/server.edge";
const PAGE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+const VITE_CONFIG_FILES = ["vite.config.ts", "vite.config.js", "vite.config.mjs"];
+
+/**
+ * Create a temporary Vite dev server for a project root.
+ * Uses the project's vite config if present, otherwise auto-configures with vinext.
+ * Pass `listen: true` to bind an HTTP port (needed for fetching pages).
+ */
+async function createTempViteServer(
+ root: string,
+ opts: { listen?: boolean } = {},
+): Promise {
+ const vite = await import("vite");
+ const hasViteConfig = VITE_CONFIG_FILES.some((f) => fs.existsSync(path.join(root, f)));
+
+ let serverConfig: Record;
+ if (hasViteConfig) {
+ serverConfig = {
+ root,
+ optimizeDeps: { holdUntilCrawlEnd: true },
+ server: { port: 0, cors: false },
+ logLevel: "silent",
+ };
+ } else {
+ const { default: vinextPlugin } = await import("../index.js");
+ serverConfig = {
+ root,
+ configFile: false,
+ plugins: [vinextPlugin({ appDir: root })],
+ optimizeDeps: { holdUntilCrawlEnd: true },
+ server: { port: 0, cors: false },
+ logLevel: "silent",
+ };
+ }
+
+ const server = await vite.createServer(serverConfig);
+ if (opts.listen) await server.listen();
+ return server;
+}
function findFileWithExtensions(basePath: string): boolean {
return PAGE_EXTENSIONS.some((ext) => fs.existsSync(basePath + ext));
@@ -286,85 +325,86 @@ async function renderStaticPage(options: RenderStaticPageOptions): Promise = {};
+
+ if (typeof pageModule.getStaticProps === "function") {
+ const result = await pageModule.getStaticProps({ params });
+ if (result && "props" in result) {
+ pageProps = result.props as Record;
+ }
+ if (result && "redirect" in result) {
+ // Static export can't handle redirects — write a meta redirect
+ const redirect = result.redirect as { destination: string };
+ return ``;
+ }
+ if (result && "notFound" in result && result.notFound) {
+ throw new Error(`Page ${urlPath} returned notFound: true`);
+ }
+ }
- // Collect page props
- let pageProps: Record = {};
+ // Build element
+ const createElement = React.createElement;
+ let element: React.ReactElement;
- if (typeof pageModule.getStaticProps === "function") {
- const result = await pageModule.getStaticProps({ params });
- if (result && "props" in result) {
- pageProps = result.props as Record;
+ if (AppComponent) {
+ element = createElement(AppComponent, {
+ Component: PageComponent,
+ pageProps,
+ });
+ } else {
+ element = createElement(PageComponent, pageProps);
}
- if (result && "redirect" in result) {
- // Static export can't handle redirects — write a meta redirect
- const redirect = result.redirect as { destination: string };
- return ``;
+
+ // Reset head collector and flush dynamic preloads
+ if (typeof headShim.resetSSRHead === "function") {
+ headShim.resetSSRHead();
}
- if (result && "notFound" in result && result.notFound) {
- throw new Error(`Page ${urlPath} returned notFound: true`);
+ if (typeof dynamicShim.flushPreloads === "function") {
+ await dynamicShim.flushPreloads();
}
- }
- // Build element
- const createElement = React.createElement;
- let element: React.ReactElement;
+ // Render page body
+ const bodyHtml = await renderToStringAsync(element);
- if (AppComponent) {
- element = createElement(AppComponent, {
- Component: PageComponent,
- pageProps,
- });
- } else {
- element = createElement(PageComponent, pageProps);
- }
+ // Collect head tags
+ const ssrHeadHTML =
+ typeof headShim.getSSRHeadHTML === "function"
+ ? headShim.getSSRHeadHTML()
+ : "";
- // Reset head collector and flush dynamic preloads
- if (typeof headShim.resetSSRHead === "function") {
- headShim.resetSSRHead();
- }
- if (typeof dynamicShim.flushPreloads === "function") {
- await dynamicShim.flushPreloads();
- }
+ // __NEXT_DATA__ for client hydration
+ const nextDataScript = ``;
- // Render page body
- const bodyHtml = await renderToStringAsync(element);
-
- // Collect head tags
- const ssrHeadHTML =
- typeof headShim.getSSRHeadHTML === "function"
- ? headShim.getSSRHeadHTML()
- : "";
-
- // __NEXT_DATA__ for client hydration
- const nextDataScript = ``;
-
- // Build HTML shell
- let html: string;
-
- if (DocumentComponent) {
- const docElement = createElement(DocumentComponent);
- // renderToReadableStream auto-prepends when root is
- let docHtml = await renderToStringAsync(docElement);
- docHtml = docHtml.replace("__NEXT_MAIN__", bodyHtml);
- if (ssrHeadHTML) {
- docHtml = docHtml.replace("", ` ${ssrHeadHTML}\n`);
- }
- docHtml = docHtml.replace("", nextDataScript);
- if (!docHtml.includes("__NEXT_DATA__")) {
- docHtml = docHtml.replace("