vinext 0.0.51 → 0.0.53

package/dist/entries/pages-server-entry.js

@@ -18,6 +18,8 @@ const _routeTriePath = resolveEntryPath("../routing/route-trie.js", import.meta.
 const _pagesI18nPath = resolveEntryPath("../server/pages-i18n.js", import.meta.url);
 const _pagesPageResponsePath = resolveEntryPath("../server/pages-page-response.js", import.meta.url);
 const _pagesPageDataPath = resolveEntryPath("../server/pages-page-data.js", import.meta.url);
+const _pagesDataRoutePath = resolveEntryPath("../server/pages-data-route.js", import.meta.url);
+const _pagesDefault404Path = resolveEntryPath("../server/pages-default-404.js", import.meta.url);
 const _pagesNodeCompatPath = resolveEntryPath("../server/pages-node-compat.js", import.meta.url);
 const _pagesApiRoutePath = resolveEntryPath("../server/pages-api-route.js", import.meta.url);
 const _isrCachePath = resolveEntryPath("../server/isr-cache.js", import.meta.url);
@@ -45,9 +47,12 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 	const apiRouteEntries = apiRoutes.map((r, i) => `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: api_${i} }`);
 	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
 	const docFilePath = findFileWithExts(pagesDir, "_document", fileMatcher);
+	const errorFilePath = findFileWithExts(pagesDir, "_error", fileMatcher);
 	const appAssetPathJson = appFilePath !== null ? JSON.stringify(normalizePathSeparators(appFilePath)) : "null";
 	const appImportCode = appFilePath !== null ? `import { default as AppComponent } from ${JSON.stringify(normalizePathSeparators(appFilePath))};` : `const AppComponent = null;`;
 	const docImportCode = docFilePath !== null ? `import { default as DocumentComponent } from ${JSON.stringify(normalizePathSeparators(docFilePath))};` : `const DocumentComponent = null;`;
+	const errorAssetPathJson = errorFilePath !== null ? JSON.stringify(normalizePathSeparators(errorFilePath)) : "null";
+	const errorImportCode = errorFilePath !== null ? `import * as ErrorPageModule from ${JSON.stringify(normalizePathSeparators(errorFilePath))};` : `const ErrorPageModule = null;`;
 	const i18nConfigJson = nextConfig?.i18n ? JSON.stringify({
 		locales: nextConfig.i18n.locales,
 		defaultLocale: nextConfig.i18n.defaultLocale,
@@ -91,18 +96,45 @@ if (typeof _instrumentation.onRequestError === "function") {
 }` : "";
 	const middlewareImportCode = middlewarePath ? `import * as middlewareModule from ${JSON.stringify(normalizePathSeparators(middlewarePath))};` : "";
 	const middlewareExportCode = middlewarePath ? `
-export async function runMiddleware(request, ctx) {
-  return __runGeneratedMiddleware({
+export async function runMiddleware(request, ctx, options) {
+  // Auto-detect /_next/data/<buildId>/<page>.json requests so user-written
+  // worker entries don't need to know about the data endpoint protocol.
+  // Mismatched buildId → JSON 404 short-circuit. Matched → middleware sees
+  // the normalized page path via the request URL, and the worker sees the
+  // normalized URL via result.rewriteUrl (if middleware didn't already
+  // rewrite to something else).
+  const __dataNorm = __normalizePagesDataRequest(request);
+  if (__dataNorm.notFoundResponse) {
+    return { continue: false, response: __dataNorm.notFoundResponse };
+  }
+  const __result = await __runGeneratedMiddleware({
     basePath: vinextConfig.basePath,
     ctx,
     i18nConfig,
+    isDataRequest: options?.isDataRequest === true || __dataNorm.isDataReq,
     isProxy: ${JSON.stringify(isProxyFile(middlewarePath))},
     module: middlewareModule,
-    request,
+    request: __dataNorm.request,
+    trailingSlash: vinextConfig.trailingSlash,
   });
+  if (__dataNorm.isDataReq && __result.continue && !__result.rewriteUrl && !__result.redirectUrl) {
+    return { ...__result, rewriteUrl: __dataNorm.normalizedPathname + __dataNorm.search };
+  }
+  return __result;
 }
 ` : `
-export async function runMiddleware() { return { continue: true }; }
+export async function runMiddleware(request) {
+  // Even without user middleware, the data-endpoint URL must be normalized so
+  // the worker pipeline sees the page path. Mismatched buildId → JSON 404.
+  const __dataNorm = __normalizePagesDataRequest(request);
+  if (__dataNorm.notFoundResponse) {
+    return { continue: false, response: __dataNorm.notFoundResponse };
+  }
+  if (__dataNorm.isDataReq) {
+    return { continue: true, rewriteUrl: __dataNorm.normalizedPathname + __dataNorm.search };
+  }
+  return { continue: true };
+}
 `;
 	return `
 import ${JSON.stringify(_serverGlobalsPath)};
@@ -139,6 +171,8 @@ import {
 } from ${JSON.stringify(_isrCachePath)};
 import { getScriptNonceFromHeaderSources as __getScriptNonceFromHeaderSources } from ${JSON.stringify(_cspPath)};
 import { resolvePagesPageData as __resolvePagesPageData } from ${JSON.stringify(_pagesPageDataPath)};
+import { buildNextDataJsonResponse as __buildNextDataJsonResponse, buildNextDataNotFoundResponse as __buildNextDataNotFoundResponse, isNextDataPathname as __isNextDataPathname, parseNextDataPathname as __parseNextDataPathname } from ${JSON.stringify(_pagesDataRoutePath)};
+import { buildDefaultPagesNotFoundResponse as __buildDefaultPagesNotFoundResponse } from ${JSON.stringify(_pagesDefault404Path)};
 import { renderPagesPageResponse as __renderPagesPageResponse } from ${JSON.stringify(_pagesPageResponsePath)};
 ${instrumentationImportCode}
 ${middlewareImportCode}
@@ -148,8 +182,11 @@ ${instrumentationInitCode}
 // i18n config (embedded at build time)
 const i18nConfig = ${i18nConfigJson};
 
-// Build ID (embedded at build time)
-const buildId = ${buildIdJson};
+// Build ID (embedded at build time). Exported so the production server can
+// match _next/data requests against the embedded buildId without needing
+// to load next.config.js at runtime.
+export const buildId = ${buildIdJson};
+const __hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
 
 // Full resolved config for production server (embedded at build time)
 export const vinextConfig = ${vinextConfigJson};
@@ -172,6 +209,40 @@ function isrCacheKey(router, pathname) {
   return __sharedIsrCacheKey(router, pathname, buildId || undefined);
 }
 
+/**
+ * Detect and normalize /_next/data/<buildId>/<page>.json requests in one
+ * place so user-written worker entries don't need to know about the data
+ * endpoint protocol. Returns the normalized request (with the page path as
+ * its URL), an isDataReq flag, and notFoundResponse when the buildId in
+ * the URL does not match this server's buildId — callers should return that
+ * response immediately so a stale client falls back to a hard navigation.
+ */
+function __normalizePagesDataRequest(request) {
+  const reqUrl = new URL(request.url);
+  if (!__isNextDataPathname(reqUrl.pathname)) {
+    return { isDataReq: false, request, normalizedPathname: null, search: "", notFoundResponse: null };
+  }
+  const dataMatch = buildId ? __parseNextDataPathname(reqUrl.pathname, buildId) : null;
+  if (!dataMatch) {
+    return {
+      isDataReq: false,
+      request,
+      normalizedPathname: null,
+      search: "",
+      notFoundResponse: __buildNextDataNotFoundResponse(),
+    };
+  }
+  const normalizedUrl = new URL(reqUrl);
+  normalizedUrl.pathname = dataMatch.pagePathname;
+  return {
+    isDataReq: true,
+    request: new Request(normalizedUrl, request),
+    normalizedPathname: dataMatch.pagePathname,
+    search: reqUrl.search,
+    notFoundResponse: null,
+  };
+}
+
 async function renderToStringAsync(element) {
   const stream = await renderToReadableStream(element);
   await stream.allReady;
@@ -198,11 +269,22 @@ ${apiImports.join("\n")}
 
 ${appImportCode}
 ${docImportCode}
+${errorImportCode}
 
 export const pageRoutes = [
 ${pageRouteEntries.join(",\n")}
 ];
 const _pageRouteTrie = _buildRouteTrie(pageRoutes);
+const _errorPageRoute = ErrorPageModule
+  ? {
+      pattern: "/_error",
+      patternParts: ["_error"],
+      isDynamic: false,
+      params: [],
+      module: ErrorPageModule,
+      filePath: ${errorAssetPathJson},
+    }
+  : null;
 
 const apiRoutes = [
 ${apiRouteEntries.join(",\n")}
@@ -234,7 +316,14 @@ export function matchPageRoute(url, request) {
 }
 
 function parseQuery(url) {
-  const qs = url.split("?")[1];
+  // Per RFC 3986 only the first "?" separates path from query, so additional
+  // "?" chars belong to the query string (e.g. /linker?href=/about?hello=world
+  // has query "href=/about?hello=world"). split("?")[1] would drop everything
+  // after the second "?" and strip embedded query strings from values.
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) return {};
+  const hashIndex = url.indexOf("#", queryIndex + 1);
+  const qs = hashIndex === -1 ? url.slice(queryIndex + 1) : url.slice(queryIndex + 1, hashIndex);
   if (!qs) return {};
   const p = new URLSearchParams(qs);
   const q = {};
@@ -262,11 +351,29 @@ function patternToNextFormat(pattern) {
     .replace(/:([^\\/]+?)(?=\\/|$)/g, "[$1]");
 }
 
-function collectAssetTags(manifest, moduleIds, scriptNonce) {
+function resolveSsrManifest(manifest) {
   // Fall back to embedded manifest (set by vinext:cloudflare-build for Workers)
-  const m = (manifest && Object.keys(manifest).length > 0)
+  return (manifest && Object.keys(manifest).length > 0)
     ? manifest
     : (typeof globalThis !== "undefined" && globalThis.__VINEXT_SSR_MANIFEST__) || null;
+}
+
+function getManifestFilesForModule(manifest, moduleId) {
+  if (!manifest || !moduleId) return null;
+
+  var files = manifest[moduleId];
+  if (files) return files;
+
+  for (var key in manifest) {
+    if (moduleId.endsWith("/" + key) || moduleId === key) {
+      return manifest[key];
+    }
+  }
+  return null;
+}
+
+function collectAssetTags(manifest, moduleIds, scriptNonce) {
+  const m = resolveSsrManifest(manifest);
   const tags = [];
   const seen = new Set();
   const nonceAttr = __createNonceAttribute(scriptNonce);
@@ -299,18 +406,7 @@ function collectAssetTags(manifest, moduleIds, scriptNonce) {
       // Collect assets for the requested page modules
       for (var mi = 0; mi < moduleIds.length; mi++) {
         var id = moduleIds[mi];
-        var files = m[id];
-        if (!files) {
-          // Absolute path didn't match — try matching by suffix.
-          // Manifest keys are relative (e.g. "pages/about.tsx") while
-          // moduleIds may be absolute (e.g. "/home/.../pages/about.tsx").
-          for (var mk in m) {
-            if (id.endsWith("/" + mk) || id === mk) {
-              files = m[mk];
-              break;
-            }
-          }
-        }
+        var files = getManifestFilesForModule(m, id);
         if (files) {
           for (var fi = 0; fi < files.length; fi++) allFiles.push(files[fi]);
         }
@@ -371,12 +467,43 @@ function collectAssetTags(manifest, moduleIds, scriptNonce) {
   return tags.join("\\n  ");
 }
 
-export async function renderPage(request, url, manifest, ctx, middlewareHeaders) {
-  if (ctx) return _runWithExecutionContext(ctx, () => _renderPage(request, url, manifest, middlewareHeaders));
-  return _renderPage(request, url, manifest, middlewareHeaders);
+function resolveClientModuleUrl(manifest, moduleId) {
+  const files = getManifestFilesForModule(resolveSsrManifest(manifest), moduleId);
+  if (!files) return undefined;
+  for (var i = 0; i < files.length; i++) {
+    var file = files[i];
+    if (!file || !file.endsWith(".js")) continue;
+    if (file.charAt(0) !== "/") file = "/" + file;
+    return file;
+  }
+  return undefined;
 }
 
-async function _renderPage(request, url, manifest, middlewareHeaders) {
+export async function renderPage(request, url, manifest, ctx, middlewareHeaders, options) {
+  if (ctx) return _runWithExecutionContext(ctx, () => _renderPage(request, url, manifest, middlewareHeaders, options));
+  return _renderPage(request, url, manifest, middlewareHeaders, options);
+}
+
+async function _renderPage(request, url, manifest, middlewareHeaders, options) {
+  let isDataReq = !!(options && options.isDataReq);
+  // Auto-detect /_next/data/... requests by inspecting the incoming request
+  // URL. The worker pipeline does not need to know about the data endpoint
+  // protocol — when it forwards an unrewritten data URL as the url arg, we
+  // normalize it to the page path here.
+  if (!isDataReq) {
+    const __dataNorm = __normalizePagesDataRequest(request);
+    if (__dataNorm.notFoundResponse) return __dataNorm.notFoundResponse;
+    if (__dataNorm.isDataReq) {
+      isDataReq = true;
+      if (url && url.startsWith("/_next/data/")) {
+        const __qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+        url = __dataNorm.normalizedPathname + __qs;
+      }
+    }
+  }
+  const statusCode = options && typeof options.statusCode === "number" ? options.statusCode : undefined;
+  const asPath = options && typeof options.asPath === "string" ? options.asPath : undefined;
+  const renderErrorPageOnMiss = !(options && options.renderErrorPageOnMiss === false);
   const localeInfo = i18nConfig
     ? resolvePagesI18nRequest(
         url,
@@ -398,10 +525,29 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
     return new Response(null, { status: 307, headers: { Location: localeInfo.redirectUrl } });
   }
 
-  const match = matchRoute(routeUrl, pageRoutes);
+  let match = matchRoute(routeUrl, pageRoutes);
+  let renderStatusCodeOverride = statusCode;
+  let renderAsPath = asPath;
   if (!match) {
-    return new Response("<!DOCTYPE html><html><body><h1>404 - Page not found</h1></body></html>",
-      { status: 404, headers: { "Content-Type": "text/html" } });
+    if (isDataReq) {
+      return __buildNextDataNotFoundResponse();
+    }
+    if (!renderErrorPageOnMiss) {
+      return __buildDefaultPagesNotFoundResponse();
+    }
+    const notFoundMatch = matchRoute("/404", pageRoutes);
+    // matchRoute may match a catch-all (e.g. [...slug]); only use the explicit pages/404 route.
+    if (notFoundMatch && notFoundMatch.route.pattern === "/404") {
+      match = notFoundMatch;
+      renderStatusCodeOverride = 404;
+      renderAsPath = routeUrl;
+    } else if (_errorPageRoute) {
+      match = { route: _errorPageRoute, params: {} };
+      renderStatusCodeOverride = 404;
+      renderAsPath = routeUrl;
+    } else {
+      return __buildDefaultPagesNotFoundResponse();
+    }
   }
 
   const { route, params } = match;
@@ -412,12 +558,13 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
     ensureFetchPatch();
     try {
       const routePattern = patternToNextFormat(route.pattern);
+      const renderStatusCode = renderStatusCodeOverride ?? (routePattern === "/404" ? 404 : undefined);
       const query = mergeRouteParamsIntoQuery(parseQuery(routeUrl), params);
       if (typeof setSSRContext === "function") {
         setSSRContext({
           pathname: routePattern,
           query,
-          asPath: routeUrl,
+          asPath: renderAsPath || routeUrl,
           locale: locale,
           locales: i18nConfig ? i18nConfig.locales : undefined,
           defaultLocale: currentDefaultLocale,
@@ -440,6 +587,8 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
       if (!PageComponent) {
         return new Response("Page has no default export", { status: 500 });
       }
+      const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath);
+      const appModuleUrl = resolveClientModuleUrl(manifest, _appAssetPath);
       const scriptNonce = __getScriptNonceFromHeaderSources(request.headers, middlewareHeaders);
       // Build font Link header early so it's available for ISR cached responses too.
       // Font preloads are module-level state populated at import time and persist across requests.
@@ -454,12 +603,13 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
         }
       } catch (e) { /* font preloads not available */ }
       const pageDataResult = await __resolvePagesPageData({
+        isDataReq,
         applyRequestContexts() {
           if (typeof setSSRContext === "function") {
             setSSRContext({
               pathname: routePattern,
               query,
-              asPath: routeUrl,
+              asPath: renderAsPath || routeUrl,
               locale: locale,
               locales: i18nConfig ? i18nConfig.locales : undefined,
               defaultLocale: currentDefaultLocale,
@@ -497,6 +647,13 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
         isrGet,
         isrSet,
         expireSeconds: vinextConfig.expireTime,
+        // The vinext build phase boots the prod server with VINEXT_PRERENDER=1
+        // and fetches every statically-generated page through it. That hit is
+        // the "build" prerender for revalidateReason; runtime hits are not.
+        // Mirrors Next.js's \`renderOpts.isBuildTimePrerendering\`. See
+        // \`.nextjs-ref/packages/next/src/server/render.tsx\` and
+        // \`packages/vinext/src/build/prerender.ts\`.
+        isBuildTimePrerendering: typeof process !== "undefined" && process.env && process.env.VINEXT_PRERENDER === "1",
         pageModule,
         params,
         query,
@@ -518,14 +675,79 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
         safeJsonStringify,
         sanitizeDestination: sanitizeDestinationLocal,
         scriptNonce,
+        statusCode: renderStatusCode,
         triggerBackgroundRegeneration,
+        vinext: {
+          pageModuleUrl,
+          appModuleUrl,
+          hasMiddleware: __hasMiddleware,
+        },
       });
       if (pageDataResult.kind === "response") {
         return pageDataResult.response;
       }
       let pageProps = pageDataResult.pageProps;
+      if (routePattern === "/_error" && typeof renderStatusCode === "number") {
+        pageProps = { ...pageProps, statusCode: renderStatusCode };
+      }
       var gsspRes = pageDataResult.gsspRes;
       let isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
+      const isFallbackRender = pageDataResult.isFallback === true;
+
+      // Republish the SSR context with isFallback flipped on so the page's
+      // \`useRouter().isFallback\` returns true during render, matching Next.js's
+      // \`render.tsx\` fallback shell. Without this, the page would still see
+      // \`isFallback: false\` and run the non-fallback branch.
+      if (isFallbackRender && typeof setSSRContext === "function") {
+        setSSRContext({
+          pathname: routePattern,
+          query,
+          asPath: renderAsPath || routeUrl,
+          locale: locale,
+          locales: i18nConfig ? i18nConfig.locales : undefined,
+          defaultLocale: currentDefaultLocale,
+          domainLocales: domainLocales,
+          isFallback: true,
+        });
+      }
+
+      // ── _next/data JSON envelope short-circuit ───────────────────────
+      // For client-side navigations Next.js fetches /_next/data/<buildId>/<page>.json
+      // and expects { pageProps } as JSON instead of the full HTML page. Skip
+      // rendering the React tree and emit the JSON envelope directly via the
+      // typed helper so the envelope shape stays in one place. Headers and
+      // cookies set on the gsspRes by getServerSideProps are forwarded so
+      // middleware/auth flows work the same as the HTML page.
+      if (isDataReq) {
+        const init = { headers: {} };
+        if (gsspRes && typeof gsspRes.getHeaders === "function") {
+          const gsspHeaders = gsspRes.getHeaders();
+          for (const k of Object.keys(gsspHeaders)) {
+            const v = gsspHeaders[k];
+            if (v === undefined || v === null) continue;
+            init.headers[k] = Array.isArray(v) ? v.join(", ") : String(v);
+          }
+        }
+        if (gsspRes) {
+          // Default Cache-Control for gSSP-driven _next/data responses,
+          // matching Next.js's pages-handler.ts (revalidate: 0 →
+          // getCacheControlHeader). Skip when gSSP already set one via
+          // res.setHeader (case-insensitive). Mirrors the HTML branch in
+          // pages-page-response.ts and the dev-server branch. Fixes #1461.
+          var hasUserCacheControl = false;
+          for (const headerKey of Object.keys(init.headers)) {
+            if (headerKey.toLowerCase() === "cache-control") {
+              hasUserCacheControl = true;
+              break;
+            }
+          }
+          if (!hasUserCacheControl) {
+            init.headers["Cache-Control"] =
+              "private, no-cache, no-store, max-age=0, must-revalidate";
+          }
+        }
+        return __buildNextDataJsonResponse(pageProps, safeJsonStringify, init);
+      }
 
       // Include both the matched page module and the global _app module
       // (if present). _app is wrapped around every page in Pages Router,
@@ -587,6 +809,7 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
           defaultLocale: currentDefaultLocale,
           domainLocales: domainLocales,
         },
+        isFallback: isFallbackRender,
         pageProps,
         params,
         renderDocumentToString(element) {
@@ -600,6 +823,12 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
         routeUrl,
         safeJsonStringify,
         scriptNonce,
+        statusCode: renderStatusCode,
+        vinext: {
+          pageModuleUrl,
+          appModuleUrl,
+          hasMiddleware: __hasMiddleware,
+        },
       });
     } catch (e) {
       console.error("[vinext] SSR error:", e);
@@ -613,9 +842,10 @@ async function _renderPage(request, url, manifest, middlewareHeaders) {
   });
 }
 
-export async function handleApiRoute(request, url) {
+export async function handleApiRoute(request, url, ctx) {
   const match = matchRoute(url, apiRoutes);
   return __handlePagesApiRoute({
+    ctx,
     match,
     request,
     url,