vinext 0.0.50 → 0.0.52

package/dist/server/prod-server.js

@@ -1,20 +1,24 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
-import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { applyConfigHeadersToHeaderRecord, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { applyConfigHeadersToHeaderRecord, filterInternalHeaders, isOpenRedirectShaped, normalizeTrailingSlash } from "./request-pipeline.js";
+import { mergeRewriteQuery } from "../utils/query.js";
+import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
 import { installSocketErrorBackstop } from "./socket-error-backstop.js";
-import { manifestFileWithBase } from "../utils/manifest-paths.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
 import { CONTENT_TYPES, StaticFileCache, etagFromFilenameHash } from "./static-file-cache.js";
+import { buildNextDataNotFoundResponse, isNextDataPathname, parseNextDataPathname } from "./pages-data-route.js";
+import { manifestFileWithBase } from "../utils/manifest-paths.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
 import { computeLazyChunks } from "../utils/lazy-chunks.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
 import fs from "node:fs";
 import path from "node:path";
-import fsp from "node:fs/promises";
+import fs$1 from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import zlib from "node:zlib";
 import { createServer } from "node:http";
@@ -324,7 +328,7 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	if (!resolved) return false;
 	const ext = path.extname(resolved.path);
 	const ct = CONTENT_TYPES[ext] ?? "application/octet-stream";
-	const isHashed = pathname.startsWith("/assets/");
+	const isHashed = pathname.includes(`/${ASSET_PREFIX_URL_DIR}/`);
 	const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
 	const etag = isHashed && etagFromFilenameHash(resolved.path, ext) || `W/"${resolved.size}-${Math.floor(resolved.mtimeMs / 1e3)}"`;
 	const baseType = ct.split(";")[0].trim();
@@ -414,7 +418,7 @@ async function resolveStaticFile(staticFile) {
 }
 async function statIfFile(filePath) {
 	try {
-		const stat = await fsp.stat(filePath);
+		const stat = await fs$1.stat(filePath);
 		return stat.isFile() ? {
 			size: stat.size,
 			mtimeMs: stat.mtimeMs
@@ -583,6 +587,59 @@ function resolveAppRouterHandler(entry) {
 	console.error("[vinext] App Router entry must export either a default handler function or a Worker-style default export with fetch()");
 	process.exit(1);
 }
+function isAppRouterPrerenderSeederExport(value) {
+	return typeof value === "function";
+}
+function resolveAppRouterPrerenderSeeder(entryModule) {
+	if (typeof entryModule !== "object" || entryModule === null) return seedMemoryCacheFromPrerender;
+	const seedExport = Object.getOwnPropertyDescriptor(entryModule, "seedMemoryCacheFromPrerender")?.value;
+	if (!isAppRouterPrerenderSeederExport(seedExport)) {
+		if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using fallback prerender cache seeder");
+		return seedMemoryCacheFromPrerender;
+	}
+	if (process.env.NEXT_PRIVATE_DEBUG_CACHE) console.debug("[vinext] ISR: using App Router entry prerender cache seeder");
+	return async (serverDir) => {
+		const result = await Promise.resolve(seedExport(serverDir));
+		return typeof result === "number" ? result : 0;
+	};
+}
+/**
+* Resolve a request pathname to a static-asset lookup path inside `clientDir`.
+*
+* Returns `null` when the request is not for a built asset, in which case
+* the caller should let the request fall through to the RSC handler.
+*
+* Three URL shapes are recognised:
+*
+*  - `/_next/static/...` — the default layout. Files land on disk at
+*    `dist/client/_next/static/...`, so the pathname maps 1:1. Also covers
+*    absolute-URL `assetPrefix` with no path component (same on-disk and
+*    URL shape).
+*  - `<assetPathPrefix>/_next/static/...` — when `assetPrefix` is a path
+*    prefix (e.g. `/custom-asset-prefix`). The on-disk layout is
+*    `dist/client/<prefix>/_next/static/...`, so the pathname maps 1:1.
+*  - `<absoluteURLPathname>/_next/static/...` — when `assetPrefix` is an
+*    absolute URL with a non-empty pathname (e.g. `https://cdn/sub`).
+*    Files are written to `dist/client/_next/static/...` but emitted URLs
+*    prepend the full URL. Requests do not normally arrive here — they go
+*    to the CDN — but we accept them so a same-origin reverse proxy can
+*    route through; the on-disk path is just `_next/static/...`.
+*/
+function resolveAppRouterAssetPath(pathname, assetPathPrefix, assetPrefix) {
+	const nextStaticDir = `/${ASSET_PREFIX_URL_DIR}/`;
+	if (assetPathPrefix) {
+		if (pathname === assetPathPrefix || pathname.startsWith(assetPathPrefix + "/")) {
+			const rest = pathname.slice(assetPathPrefix.length) || "/";
+			if (rest.startsWith(nextStaticDir)) {
+				if (!isAbsoluteAssetPrefix(assetPrefix)) return pathname;
+				return rest;
+			}
+		}
+		return null;
+	}
+	if (pathname.startsWith(nextStaticDir)) return pathname;
+	return null;
+}
 /**
 * Start the App Router production server.
 *
@@ -609,8 +666,11 @@ async function startAppRouterServer(options) {
 	} catch {}
 	const prerenderSecret = readPrerenderSecret(path.dirname(rscEntryPath));
 	const rscMtime = fs.statSync(rscEntryPath).mtimeMs;
-	const rscHandler = resolveAppRouterHandler((await import(`${pathToFileURL(rscEntryPath).href}?t=${rscMtime}`)).default);
-	const seededRoutes = await seedMemoryCacheFromPrerender(path.dirname(rscEntryPath));
+	const rscModule = await import(`${pathToFileURL(rscEntryPath).href}?t=${rscMtime}`);
+	const rscHandler = resolveAppRouterHandler(rscModule.default);
+	const appRouterAssetPrefix = typeof rscModule.__assetPrefix === "string" ? rscModule.__assetPrefix : "";
+	const appAssetPathPrefix = assetPrefixPathname(appRouterAssetPrefix);
+	const seededRoutes = await resolveAppRouterPrerenderSeeder(rscModule)(path.dirname(rscEntryPath));
 	if (seededRoutes > 0) console.log(`[vinext] Seeded ${seededRoutes} pre-rendered route${seededRoutes !== 1 ? "s" : ""} into memory cache`);
 	const staticCache = await StaticFileCache.create(clientDir);
 	const handleRequest = async (req, res) => {
@@ -618,7 +678,7 @@ async function startAppRouterServer(options) {
 		const rawPathname = rawUrl.split("?")[0];
 		if (isOpenRedirectShaped(rawPathname)) {
 			res.writeHead(404);
-			res.end("404 Not Found");
+			res.end("This page could not be found");
 			return;
 		}
 		const normalizedRawPathname = rawPathname.replaceAll("\\", "/");
@@ -638,7 +698,15 @@ async function startAppRouterServer(options) {
 				return;
 			}
 		}
-		if (pathname.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, pathname, compress, staticCache)) return;
+		{
+			const assetLookupPath = resolveAppRouterAssetPath(pathname, appAssetPathPrefix, appRouterAssetPrefix);
+			if (assetLookupPath) {
+				if (await tryServeStatic(req, res, clientDir, assetLookupPath, compress, staticCache)) return;
+				res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+				res.end("Not Found");
+				return;
+			}
+		}
 		if (pathname === "/_vinext/image") {
 			const params = parseImageParams(new URL(rawUrl, "http://localhost"), [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES]);
 			if (!params) {
@@ -725,7 +793,7 @@ function readPagesServerEntryPageRoutes(value) {
 *
 * Uses the server entry (dist/server/entry.js) which exports:
 * - renderPage(request, url, manifest, ctx?, middlewareHeaders?) — SSR rendering (Web Request → Response)
-* - handleApiRoute(request, url) — API route handling (Web Request → Response)
+* - handleApiRoute(request, url, ctx?) — API route handling (ctx optional; pass for ctx.waitUntil() on Workers)
 * - runMiddleware(request, ctx?) — middleware execution (ctx optional; pass for ctx.waitUntil() on Workers)
 * - vinextConfig — embedded next.config.js settings
 */
@@ -733,13 +801,16 @@ async function startPagesRouterServer(options) {
 	const { port, host, clientDir, serverEntryPath, compress, purpose } = options;
 	const serverMtime = fs.statSync(serverEntryPath).mtimeMs;
 	const serverEntry = await import(`${pathToFileURL(serverEntryPath).href}?t=${serverMtime}`);
-	const { renderPage, handleApiRoute: handleApi, runMiddleware, vinextConfig } = serverEntry;
+	const { renderPage, handleApiRoute: handleApi, runMiddleware, vinextConfig, buildId: pagesBuildId } = serverEntry;
 	const matchPageRoute = typeof serverEntry.matchPageRoute === "function" ? serverEntry.matchPageRoute : void 0;
 	const pageRoutes = readPagesServerEntryPageRoutes(serverEntry.pageRoutes);
 	const prerenderSecret = readPrerenderSecret(path.dirname(serverEntryPath));
 	const basePath = vinextConfig?.basePath ?? "";
+	const assetPrefix = vinextConfig?.assetPrefix ?? "";
+	const pagesAssetPathPrefix = assetPrefixPathname(assetPrefix);
 	const assetBase = basePath ? `${basePath}/` : "/";
 	const trailingSlash = vinextConfig?.trailingSlash ?? false;
+	const i18nConfig = vinextConfig?.i18n ?? null;
 	const configRedirects = vinextConfig?.redirects ?? [];
 	const configRewrites = vinextConfig?.rewrites ?? {
 		beforeFiles: [],
@@ -768,7 +839,7 @@ async function startPagesRouterServer(options) {
 		const rawPagesPathnameBeforeNormalize = rawUrl.split("?")[0];
 		if (isOpenRedirectShaped(rawPagesPathnameBeforeNormalize)) {
 			res.writeHead(404);
-			res.end("404 Not Found");
+			res.end("This page could not be found");
 			return;
 		}
 		const rawPagesPathname = rawPagesPathnameBeforeNormalize.replaceAll("\\", "/");
@@ -814,7 +885,13 @@ async function startPagesRouterServer(options) {
 			return;
 		}
 		const staticLookupPath = stripBasePath(pathname, basePath);
-		if (staticLookupPath.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache)) return;
+		const pagesAssetLookup = resolveAppRouterAssetPath(pathname, pagesAssetPathPrefix, assetPrefix);
+		if (pagesAssetLookup) {
+			if (await tryServeStatic(req, res, clientDir, pagesAssetLookup, compress, staticCache)) return;
+			res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+			res.end("Not Found");
+			return;
+		}
 		if (pathname === "/_vinext/image" || staticLookupPath === "/_vinext/image") {
 			const params = parseImageParams(new URL(rawUrl, "http://localhost"), allowedImageWidths);
 			if (!params) {
@@ -838,6 +915,7 @@ async function startPagesRouterServer(options) {
 			return;
 		}
 		try {
+			const hadBasePath = !basePath || hasBasePath(pathname, basePath);
 			{
 				const stripped = stripBasePath(pathname, basePath);
 				if (stripped !== pathname) {
@@ -845,27 +923,41 @@ async function startPagesRouterServer(options) {
 					pathname = stripped;
 				}
 			}
-			if (pathname !== "/" && pathname !== "/api" && !pathname.startsWith("/api/")) {
-				const hasTrailing = pathname.endsWith("/");
-				if (trailingSlash && !hasTrailing) {
-					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
-					res.writeHead(308, { Location: basePath + pathname + "/" + qs });
+			const basePathState = {
+				basePath,
+				hadBasePath
+			};
+			{
+				const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+				const trailingSlashRedirect = normalizeTrailingSlash(pathname, basePath, trailingSlash, qs);
+				if (trailingSlashRedirect) {
+					const location = trailingSlashRedirect.headers.get("Location");
+					res.writeHead(trailingSlashRedirect.status, location ? { Location: location } : void 0);
 					res.end();
 					return;
-				} else if (!trailingSlash && hasTrailing) {
-					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
-					res.writeHead(308, { Location: basePath + removeTrailingSlash(pathname) + qs });
-					res.end();
+				}
+			}
+			let isDataReq = false;
+			if (isNextDataPathname(pathname)) {
+				const dataMatch = pagesBuildId ? parseNextDataPathname(pathname, pagesBuildId) : null;
+				if (!dataMatch) {
+					await sendWebResponse(buildNextDataNotFoundResponse(), req, res, compress);
 					return;
 				}
+				isDataReq = true;
+				const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+				url = dataMatch.pagePathname + qs;
+				pathname = dataMatch.pagePathname;
 			}
 			const rawProtocol = trustProxy ? req.headers["x-forwarded-proto"]?.split(",")[0]?.trim() : void 0;
 			const protocol = rawProtocol === "https" || rawProtocol === "http" ? rawProtocol : "http";
 			const hostHeader = resolveHost(req, `${host}:${port}`);
-			const reqHeaders = filterInternalHeaders(Object.entries(req.headers).reduce((h, [k, v]) => {
+			const rawReqHeaders = Object.entries(req.headers).reduce((h, [k, v]) => {
 				if (v) h.set(k, Array.isArray(v) ? v.join(", ") : v);
 				return h;
-			}, new Headers()));
+			}, new Headers());
+			const isDataRequest = rawReqHeaders.get("x-nextjs-data") === "1";
+			const reqHeaders = filterInternalHeaders(rawReqHeaders);
 			const method = req.method ?? "GET";
 			const hasBody = method !== "GET" && method !== "HEAD";
 			let webRequest = new Request(`${protocol}://${hostHeader}${url}`, {
@@ -875,10 +967,12 @@ async function startPagesRouterServer(options) {
 				duplex: hasBody ? "half" : void 0
 			});
 			const reqCtx = requestContextFromRequest(webRequest);
+			const requestHostname = i18nConfig ? new URL(webRequest.url).hostname : "";
+			const matchPathname = i18nConfig ? normalizeDefaultLocalePathname(pathname, i18nConfig, { hostname: requestHostname }) : pathname;
 			if (configRedirects.length) {
-				const redirect = matchRedirect(pathname, configRedirects, reqCtx);
+				const redirect = matchRedirect(matchPathname, configRedirects, reqCtx, basePathState);
 				if (redirect) {
-					const dest = sanitizeDestination(basePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
+					const dest = sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
 					res.writeHead(redirect.permanent ? 308 : 307, { Location: dest });
 					res.end();
 					return;
@@ -888,7 +982,7 @@ async function startPagesRouterServer(options) {
 			const middlewareHeaders = {};
 			let middlewareStatus;
 			if (typeof runMiddleware === "function") {
-				const result = await runMiddleware(webRequest, void 0);
+				const result = await runMiddleware(webRequest, void 0, { isDataRequest });
 				if (result.waitUntilPromises && result.waitUntilPromises.length > 0) Promise.allSettled(result.waitUntilPromises);
 				if (!result.continue) {
 					if (result.redirectUrl) {
@@ -930,30 +1024,41 @@ async function startPagesRouterServer(options) {
 			const { postMwReqCtx, request: postMwReq } = applyMiddlewareRequestHeaders(middlewareHeaders, webRequest, { preserveCredentialHeaders: isExternalUrl(resolvedUrl) });
 			webRequest = postMwReq;
 			let resolvedPathname = resolvedUrl.split("?")[0];
+			const matchResolvedPathname = (p) => i18nConfig ? normalizeDefaultLocalePathname(p, i18nConfig, { hostname: requestHostname }) : p;
 			if (configHeaders.length) applyConfigHeadersToHeaderRecord(middlewareHeaders, {
 				configHeaders,
-				pathname,
-				requestContext: reqCtx
+				pathname: matchPathname,
+				requestContext: reqCtx,
+				basePathState
 			});
 			if (isExternalUrl(resolvedUrl)) {
 				await sendWebResponse(mergeWebResponse(middlewareHeaders, await proxyExternalRequest(webRequest, resolvedUrl), void 0), req, res, compress);
 				return;
 			}
-			if (staticLookupPath !== "/" && !staticLookupPath.startsWith("/api/") && !staticLookupPath.startsWith("/assets/") && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache, middlewareHeaders)) return;
+			if (staticLookupPath !== "/" && !staticLookupPath.startsWith("/api/") && !staticLookupPath.startsWith(`/_next/static/`) && await tryServeStatic(req, res, clientDir, staticLookupPath, compress, staticCache, middlewareHeaders)) return;
+			let configRewriteFired = false;
 			if (configRewrites.beforeFiles?.length) {
-				const rewritten = matchRewrite(resolvedPathname, configRewrites.beforeFiles, postMwReqCtx);
+				const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.beforeFiles, postMwReqCtx, basePathState);
 				if (rewritten) {
 					if (isExternalUrl(rewritten)) {
 						await sendWebResponse(await proxyExternalRequest(webRequest, rewritten), req, res, compress);
 						return;
 					}
-					resolvedUrl = rewritten;
-					resolvedPathname = rewritten.split("?")[0];
+					resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+					resolvedPathname = resolvedUrl.split("?")[0];
+					configRewriteFired = true;
 				}
 			}
-			if (resolvedPathname.startsWith("/api/") || resolvedPathname === "/api") {
+			if (basePath && !hadBasePath && !configRewriteFired) {
+				res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+				res.end("This page could not be found");
+				return;
+			}
+			const apiLookupUrl = stripI18nLocaleForApiRoute(resolvedUrl, vinextConfig?.i18n ?? null);
+			const apiLookupPathname = apiLookupUrl.split("?")[0];
+			if (apiLookupPathname.startsWith("/api/") || apiLookupPathname === "/api") {
 				let response;
-				if (typeof handleApi === "function") response = await handleApi(webRequest, resolvedUrl);
+				if (typeof handleApi === "function") response = await handleApi(webRequest, apiLookupUrl, createNodeExecutionContext());
 				else response = new Response("404 - API route not found", { status: 404 });
 				const mergedResponse = mergeWebResponse(middlewareHeaders, response, middlewareStatus);
 				if (!mergedResponse.body) {
@@ -969,34 +1074,35 @@ async function startPagesRouterServer(options) {
 			}
 			const pageMatch = matchPageRoute ? matchPageRoute(resolvedPathname, webRequest) : null;
 			if ((!pageMatch || pageMatch.route.isDynamic) && configRewrites.afterFiles?.length) {
-				const rewritten = matchRewrite(resolvedPathname, configRewrites.afterFiles, postMwReqCtx);
+				const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.afterFiles, postMwReqCtx, basePathState);
 				if (rewritten) {
 					if (isExternalUrl(rewritten)) {
 						await sendWebResponse(await proxyExternalRequest(webRequest, rewritten), req, res, compress);
 						return;
 					}
-					resolvedUrl = rewritten;
-					resolvedPathname = rewritten.split("?")[0];
+					resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+					resolvedPathname = resolvedUrl.split("?")[0];
 				}
 			}
 			let response;
 			if (typeof renderPage === "function") {
 				const middlewareResponseHeaders = toWebHeaders(middlewareHeaders);
-				response = await renderPage(webRequest, resolvedUrl, ssrManifest, void 0, middlewareResponseHeaders);
+				const renderOptions = isDataReq ? { isDataReq: true } : void 0;
+				response = await renderPage(webRequest, resolvedUrl, ssrManifest, void 0, middlewareResponseHeaders, renderOptions);
 				if (response && response.status === 404 && configRewrites.fallback?.length) {
-					const fallbackRewrite = matchRewrite(resolvedPathname, configRewrites.fallback, postMwReqCtx);
+					const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.fallback, postMwReqCtx, basePathState);
 					if (fallbackRewrite) {
 						if (isExternalUrl(fallbackRewrite)) {
 							await sendWebResponse(await proxyExternalRequest(webRequest, fallbackRewrite), req, res, compress);
 							return;
 						}
-						response = await renderPage(webRequest, fallbackRewrite, ssrManifest, void 0, middlewareResponseHeaders);
+						response = await renderPage(webRequest, mergeRewriteQuery(resolvedUrl, fallbackRewrite), ssrManifest, void 0, middlewareResponseHeaders, renderOptions);
 					}
 				}
 			}
 			if (!response) {
 				res.writeHead(404);
-				res.end("404 - Not found");
+				res.end("This page could not be found");
 				return;
 			}
 			const shouldStreamPagesResponse = isVinextStreamedHtmlResponse(response);
@@ -1035,6 +1141,6 @@ async function startPagesRouterServer(options) {
 	};
 }
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveHost, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
 
 //# sourceMappingURL=prod-server.js.map