/products/unknown.json`
@@ -9870,34 +9901,35 @@ describe("custom App optional pageProps envelope parity", () => {
});
}
- // Next.js renders App with `{ ...props, router }`. Production verifies the
- // ISR MISS -> HIT transition; development reruns GSP for each request.
+ // Next.js renders App with `{ ...props, router }`. A custom App can derive
+ // props from the live request, so production must bypass shared ISR while
+ // both modes preserve the merged props across repeated GSP renders.
// https://github.com/vercel/next.js/blob/canary/packages/next/src/server/render.tsx
// https://github.com/vercel/next.js/blob/canary/test/e2e/prerender.test.ts
for (const mode of ["dev", "prod"] as const) {
it(`merges primitive App props and preserves router across repeated GSP renders in ${mode}`, async () => {
const baseUrl = mode === "dev" ? devUrl : prodUrl;
- const missResponse = await fetch(`${baseUrl}/gsp-string`);
- expect(missResponse.status).toBe(200);
- expect(missResponse.headers.get("x-nextjs-cache")).toBe(mode === "dev" ? "HIT" : "MISS");
+ const firstResponse = await fetch(`${baseUrl}/gsp-string`);
+ expect(firstResponse.status).toBe(200);
+ expect(firstResponse.headers.get("x-nextjs-cache")).toBe(mode === "dev" ? "HIT" : null);
if (mode === "dev") {
- expect(missResponse.headers.get("cache-control")).toBe("no-cache, must-revalidate");
+ expect(firstResponse.headers.get("cache-control")).toBe("no-cache, must-revalidate");
}
- const missHtml = await missResponse.text();
- expect(missHtml).toContain(
+ const firstHtml = await firstResponse.text();
+ expect(firstHtml).toContain(
'{"0":"h","1":"i","fromData":"gsp"}
',
);
- expect(missHtml).toContain('/gsp-string
');
+ expect(firstHtml).toContain('/gsp-string
');
- const hitResponse = await fetch(`${baseUrl}/gsp-string`);
- expect(hitResponse.status).toBe(200);
- expect(hitResponse.headers.get("x-nextjs-cache")).toBe("HIT");
- const hitHtml = await hitResponse.text();
- expect(hitHtml).toContain(
+ const secondResponse = await fetch(`${baseUrl}/gsp-string`);
+ expect(secondResponse.status).toBe(200);
+ expect(secondResponse.headers.get("x-nextjs-cache")).toBe(mode === "dev" ? "HIT" : null);
+ const secondHtml = await secondResponse.text();
+ expect(secondHtml).toContain(
'{"0":"h","1":"i","fromData":"gsp"}
',
);
- expect(hitHtml).toContain('/gsp-string
');
+ expect(secondHtml).toContain('/gsp-string
');
});
}
});
diff --git a/tests/prerender.test.ts b/tests/prerender.test.ts
index 60053a96a..9a55005e2 100644
--- a/tests/prerender.test.ts
+++ b/tests/prerender.test.ts
@@ -21,7 +21,11 @@ import {
type PrerenderRouteResult,
type StaticParamsMap,
} from "../packages/vinext/src/build/prerender.js";
-import { VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../packages/vinext/src/server/headers.js";
+import {
+ VINEXT_PRERENDER_RENDER_ERROR_HEADER,
+ VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER,
+ VINEXT_PRERENDER_SPECULATIVE_HEADER,
+} from "../packages/vinext/src/server/headers.js";
import { safeJsonStringify } from "../packages/vinext/src/server/html.js";
import type { AppRoute } from "../packages/vinext/src/routing/app-router.js";
import {
@@ -776,6 +780,115 @@ describe("prerenderApp — RSC extraction", () => {
// ─── Pages Router ─────────────────────────────────────────────────────────────
+describe("prerenderPages — response cache policy", () => {
+ it.each(["default", "export"] as const)(
+ "handles non-cacheable Pages responses safely in %s mode",
+ async (mode) => {
+ const root = tmpDir("vinext-prerender-pages-no-store-");
+ const pagesDir = path.join(root, "pages");
+ const outDir = path.join(root, "out");
+ fs.mkdirSync(pagesDir, { recursive: true });
+ fs.writeFileSync(
+ path.join(pagesDir, "index.tsx"),
+ `export default function Page() { return null; }
+export function getStaticProps() { return { props: {}, revalidate: 60 }; }
+`,
+ );
+ fs.writeFileSync(
+ path.join(pagesDir, "404.tsx"),
+ `export default function NotFound() { return null; }
+`,
+ );
+ fs.writeFileSync(
+ path.join(pagesDir, "failure.tsx"),
+ `export default function Failure() { return null; }
+`,
+ );
+ fs.writeFileSync(
+ path.join(pagesDir, "fatal.tsx"),
+ `export default function Fatal() { return null; }
+`,
+ );
+ fs.writeFileSync(
+ path.join(pagesDir, "cacheable.tsx"),
+ `export default function Cacheable() { return null; }
+`,
+ );
+
+ const server = createServer((req, res) => {
+ res.setHeader("content-type", "text/html");
+ res.setHeader("cache-control", "private, no-cache, no-store, max-age=0");
+ if (req.url === "/" || req.url === "/404") {
+ res.setHeader(VINEXT_PRERENDER_SHARED_CACHE_BYPASS_HEADER, "1");
+ }
+ if (req.url === "/404") res.statusCode = 404;
+ if (req.url === "/failure") res.statusCode = 500;
+ if (req.url === "/fatal") {
+ res.statusCode = 500;
+ res.setHeader(VINEXT_PRERENDER_RENDER_ERROR_HEADER, "1");
+ }
+ if (req.url === "/cacheable") res.setHeader("cache-control", "no-cache");
+ res.end("request-aware build props");
+ });
+ const port = await listen(server);
+
+ try {
+ const { prerenderPages } = await import("../packages/vinext/src/build/prerender.js");
+ const { pagesRouter, apiRouter } =
+ await import("../packages/vinext/src/routing/pages-router.js");
+ const { resolveNextConfig } = await import("../packages/vinext/src/config/next-config.js");
+ const routes = await pagesRouter(pagesDir);
+ const apiRoutes = await apiRouter(pagesDir);
+ const config = await resolveNextConfig({});
+
+ const result = await prerenderPages({
+ mode,
+ routes,
+ apiRoutes,
+ pagesDir,
+ outDir,
+ config,
+ _prodServer: { server, port },
+ });
+
+ const nonCacheableResults = result.routes.filter(
+ (route) => route.route === "/" || route.route === "/404",
+ );
+ expect(nonCacheableResults.length).toBeGreaterThanOrEqual(2);
+ for (const route of nonCacheableResults) {
+ if (mode === "export") {
+ expect(route).toMatchObject({
+ status: "error",
+ error: expect.stringContaining("not supported with output: 'export'"),
+ });
+ } else {
+ expect(route).toMatchObject({ status: "skipped", reason: "dynamic" });
+ }
+ }
+ expect(findRoute(result.routes, "/failure")).toMatchObject({
+ route: "/failure",
+ status: "error",
+ });
+ expect(findRoute(result.routes, "/fatal")).toMatchObject({
+ route: "/fatal",
+ status: "error",
+ fatal: true,
+ });
+ expect(findRoute(result.routes, "/cacheable")).toMatchObject({
+ route: "/cacheable",
+ status: "rendered",
+ });
+ expect(fs.existsSync(path.join(outDir, "index.html"))).toBe(false);
+ expect(fs.existsSync(path.join(outDir, "404.html"))).toBe(false);
+ expect(fs.existsSync(path.join(outDir, "cacheable.html"))).toBe(true);
+ } finally {
+ await closeServer(server);
+ fs.rmSync(root, { recursive: true, force: true });
+ }
+ },
+ );
+});
+
describe("prerenderPages — basePath export", () => {
it("requests and writes Pages exports under basePath", async () => {
const root = tmpDir("vinext-prerender-pages-basepath-");
diff --git a/tests/prod-server-prerender-endpoints.test.ts b/tests/prod-server-prerender-endpoints.test.ts
new file mode 100644
index 000000000..f93e99075
--- /dev/null
+++ b/tests/prod-server-prerender-endpoints.test.ts
@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vite-plus/test";
+import { VINEXT_PRERENDER_SECRET_HEADER } from "../packages/vinext/src/server/headers.js";
+
+describe("Pages production prerender endpoints", () => {
+ const roots: string[] = [];
+
+ afterEach(() => {
+ for (const root of roots.splice(0)) {
+ fs.rmSync(root, { force: true, recursive: true });
+ }
+ });
+
+ it("rejects incompatible page exports before a missing getStaticPaths returns null", async () => {
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), "vinext-pages-prerender-endpoint-"));
+ roots.push(root);
+ const serverDir = path.join(root, "dist", "server");
+ fs.mkdirSync(path.join(root, "dist", "client"), { recursive: true });
+ fs.mkdirSync(serverDir, { recursive: true });
+ fs.writeFileSync(
+ path.join(serverDir, "entry.js"),
+ [
+ "export const vinextConfig = {};",
+ "export const pageRoutes = [{",
+ " pattern: '/posts/:id',",
+ " module: {",
+ " default: Object.assign(function Page() {}, { getInitialProps: async () => ({}) }),",
+ " getStaticProps: async () => ({ props: {} }),",
+ " },",
+ "}];",
+ "export async function renderPage() { return new Response('ok'); }",
+ "export async function handleApiRoute() { return new Response('api'); }",
+ "export async function runMiddleware() { return null; }",
+ "",
+ ].join("\n"),
+ );
+ fs.writeFileSync(
+ path.join(serverDir, "vinext-server.json"),
+ JSON.stringify({ prerenderSecret: "test-prerender-secret" }),
+ );
+
+ const { startProdServer } = await import("../packages/vinext/src/server/prod-server.js");
+ const { server, port } = await startProdServer({
+ host: "127.0.0.1",
+ noCompression: true,
+ outDir: path.join(root, "dist"),
+ port: 0,
+ silent: true,
+ });
+
+ try {
+ const response = await fetch(
+ `http://127.0.0.1:${port}/__vinext/prerender/pages-static-paths?pattern=/posts/:id`,
+ { headers: { [VINEXT_PRERENDER_SECRET_HEADER]: "test-prerender-secret" } },
+ );
+
+ expect(response.status).toBe(500);
+ await expect(response.text()).resolves.toContain(
+ "You can not use getInitialProps with getStaticProps",
+ );
+ } finally {
+ await new Promise((resolve) => server.close(() => resolve()));
+ }
+ });
+});