vinext 0.1.1 → 0.1.3

package/dist/server/pages-node-compat.js

@@ -1,9 +1,10 @@
-import { parseCookies } from "../config/config-matchers.js";
+import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT } from "./pages-body-parser-config.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { decode } from "node:querystring";
+import { Readable, Writable } from "node:stream";
 //#region src/server/pages-node-compat.ts
 const MAX_PAGES_API_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
 async function readPagesRequestBodyWithLimit(request, maxBytes) {
@@ -41,140 +42,192 @@ async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
 	if (mediaType === "application/x-www-form-urlencoded") return decode(rawBody);
 	return rawBody;
 }
+async function* requestBodyChunks(request) {
+	if (!request.body || request.bodyUsed) return;
+	const reader = request.body.getReader();
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) return;
+			yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+		}
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {}
+		reader.releaseLock();
+	}
+}
+function createRequestReadable(request) {
+	return Readable.from(requestBodyChunks(request), { objectMode: false });
+}
+var PagesResponseStream = class extends Writable {
+	resolveResponse;
+	rejectResponse;
+	requestHeaders;
+	resStatusCode = 200;
+	resHeaders = {};
+	setCookieHeaders = [];
+	resolved = false;
+	controller = null;
+	bufferedChunks = [];
+	streamEnded = false;
+	constructor(resolveResponse, rejectResponse, requestHeaders) {
+		super();
+		this.resolveResponse = resolveResponse;
+		this.rejectResponse = rejectResponse;
+		this.requestHeaders = requestHeaders;
+		this.once("error", (err) => {
+			if (!this.resolved) {
+				this.resolved = true;
+				this.rejectResponse(err);
+			}
+		});
+	}
+	get statusCode() {
+		return this.resStatusCode;
+	}
+	set statusCode(code) {
+		this.resStatusCode = code;
+	}
+	get headersSent() {
+		return this.writableEnded || this.resolved;
+	}
+	writeHead(code, headers) {
+		this.resStatusCode = code;
+		if (headers) for (const [key, value] of Object.entries(headers)) this.setHeaderValue(key, value, { replaceSetCookie: false });
+		return this;
+	}
+	setHeader(name, value) {
+		this.setHeaderValue(name, value, { replaceSetCookie: true });
+		return this;
+	}
+	getHeader(name) {
+		if (name.toLowerCase() === "set-cookie") return this.setCookieHeaders.length > 0 ? this.setCookieHeaders : void 0;
+		return this.resHeaders[name.toLowerCase()];
+	}
+	status(code) {
+		this.resStatusCode = code;
+		return this;
+	}
+	json(data) {
+		this.resHeaders["content-type"] = "application/json";
+		this.end(JSON.stringify(data));
+	}
+	send(data) {
+		if (Buffer.isBuffer(data)) {
+			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
+			this.resHeaders["content-length"] = String(data.length);
+			this.end(data);
+			return;
+		}
+		if (typeof data === "object" && data !== null) {
+			this.resHeaders["content-type"] = "application/json";
+			this.end(JSON.stringify(data));
+			return;
+		}
+		if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "text/plain";
+		this.end(String(data));
+	}
+	redirect(statusOrUrl, url) {
+		if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
+		else this.writeHead(statusOrUrl, { Location: url ?? "" });
+		this.end();
+	}
+	getHeaders() {
+		const headers = { ...this.resHeaders };
+		if (this.setCookieHeaders.length > 0) headers["set-cookie"] = this.setCookieHeaders;
+		return headers;
+	}
+	async revalidate(urlPath, opts) {
+		await performOnDemandRevalidate(this.requestHeaders, urlPath, opts);
+	}
+	_write(chunk, encoding, callback) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+		if (this.controller && !this.streamEnded) try {
+			this.controller.enqueue(buffer);
+		} catch {}
+		else this.bufferedChunks.push(buffer);
+		this.resolveOnce();
+		callback();
+	}
+	_final(callback) {
+		this.streamEnded = true;
+		if (this.controller) try {
+			this.controller.close();
+		} catch {}
+		this.resolveOnce();
+		callback();
+	}
+	_destroy(error, callback) {
+		this.streamEnded = true;
+		if (!this.resolved) if (error) {
+			this.resolved = true;
+			this.rejectResponse(error);
+		} else this.resolveOnce();
+		if (this.controller) try {
+			if (error) this.controller.error(error);
+			else this.controller.close();
+		} catch {}
+		callback(error);
+	}
+	setHeaderValue(name, value, options) {
+		if (name.toLowerCase() === "set-cookie") {
+			if (options.replaceSetCookie) this.setCookieHeaders.length = 0;
+			if (Array.isArray(value)) this.setCookieHeaders.push(...value.map(String));
+			else this.setCookieHeaders.push(String(value));
+			return;
+		}
+		this.resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	resolveOnce() {
+		if (this.resolved) return;
+		this.resolved = true;
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(this.resHeaders)) headers.set(key, String(value));
+		for (const cookie of this.setCookieHeaders) headers.append("set-cookie", cookie);
+		const stream = new ReadableStream({
+			start: (controller) => {
+				this.controller = controller;
+				for (const buffer of this.bufferedChunks) try {
+					controller.enqueue(buffer);
+				} catch {}
+				this.bufferedChunks.length = 0;
+				if (this.streamEnded) try {
+					controller.close();
+				} catch {}
+			},
+			cancel: (reason) => {
+				this.bufferedChunks.length = 0;
+				this.destroy(reason instanceof Error ? reason : /* @__PURE__ */ new Error("Response body cancelled"));
+			}
+		});
+		this.resolveResponse(new Response(stream, {
+			status: this.resStatusCode,
+			headers
+		}));
+	}
+};
 function createPagesReqRes(options) {
 	const headersObj = {};
 	for (const [key, value] of options.request.headers) headersObj[key.toLowerCase()] = value;
-	const requestBody = options.request.body;
-	const reqAsyncIterator = () => {
-		if (!requestBody) return { next() {
-			return Promise.resolve({
-				value: void 0,
-				done: true
-			});
-		} };
-		const reader = requestBody.getReader();
-		return {
-			async next() {
-				const { value, done } = await reader.read();
-				if (done) return {
-					value: void 0,
-					done: true
-				};
-				return {
-					value,
-					done: false
-				};
-			},
-			async return() {
-				try {
-					await reader.cancel();
-				} catch {}
-				return {
-					value: void 0,
-					done: true
-				};
-			}
-		};
-	};
-	const req = {
+	const req = Object.assign(createRequestReadable(options.request), {
 		method: options.request.method,
 		url: options.url,
 		headers: headersObj,
 		query: options.query,
 		body: options.body,
-		cookies: parseCookies(options.request.headers.get("cookie")),
-		[Symbol.asyncIterator]: reqAsyncIterator
-	};
-	let resStatusCode = 200;
-	const resHeaders = {};
-	const setCookieHeaders = [];
-	let resBody = null;
-	let ended = false;
+		cookies: parseCookieHeader(options.request.headers.get("cookie"))
+	});
 	let resolveResponse;
-	const responsePromise = new Promise((resolve) => {
+	let rejectResponse;
+	const responsePromise = new Promise((resolve, reject) => {
 		resolveResponse = resolve;
+		rejectResponse = reject;
 	});
-	const res = {
-		get statusCode() {
-			return resStatusCode;
-		},
-		set statusCode(code) {
-			resStatusCode = code;
-		},
-		get headersSent() {
-			return ended;
-		},
-		writeHead(code, headers) {
-			resStatusCode = code;
-			if (headers) for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === "set-cookie") if (Array.isArray(value)) setCookieHeaders.push(...value.map(String));
-			else setCookieHeaders.push(String(value));
-			else resHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-			return res;
-		},
-		setHeader(name, value) {
-			if (name.toLowerCase() === "set-cookie") {
-				setCookieHeaders.length = 0;
-				if (Array.isArray(value)) setCookieHeaders.push(...value.map(String));
-				else setCookieHeaders.push(String(value));
-			} else resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-			return res;
-		},
-		getHeader(name) {
-			if (name.toLowerCase() === "set-cookie") return setCookieHeaders.length > 0 ? setCookieHeaders : void 0;
-			return resHeaders[name.toLowerCase()];
-		},
-		end(data) {
-			if (ended) return;
-			ended = true;
-			if (data !== void 0 && data !== null) resBody = data;
-			const headers = new Headers();
-			for (const [key, value] of Object.entries(resHeaders)) headers.set(key, String(value));
-			for (const cookie of setCookieHeaders) headers.append("set-cookie", cookie);
-			resolveResponse(new Response(resBody, {
-				status: resStatusCode,
-				headers
-			}));
-		},
-		status(code) {
-			resStatusCode = code;
-			return res;
-		},
-		json(data) {
-			resHeaders["content-type"] = "application/json";
-			res.end(JSON.stringify(data));
-		},
-		send(data) {
-			if (Buffer.isBuffer(data)) {
-				if (!resHeaders["content-type"]) resHeaders["content-type"] = "application/octet-stream";
-				resHeaders["content-length"] = String(data.length);
-				res.end(new Uint8Array(data));
-				return;
-			}
-			if (typeof data === "object" && data !== null) {
-				resHeaders["content-type"] = "application/json";
-				res.end(JSON.stringify(data));
-				return;
-			}
-			if (!resHeaders["content-type"]) resHeaders["content-type"] = "text/plain";
-			res.end(String(data));
-		},
-		redirect(statusOrUrl, url) {
-			if (typeof statusOrUrl === "string") res.writeHead(307, { Location: statusOrUrl });
-			else res.writeHead(statusOrUrl, { Location: url ?? "" });
-			res.end();
-		},
-		getHeaders() {
-			const headers = { ...resHeaders };
-			if (setCookieHeaders.length > 0) headers["set-cookie"] = setCookieHeaders;
-			return headers;
-		},
-		async revalidate(urlPath, opts) {
-			await performOnDemandRevalidate(options.request.headers, urlPath, opts);
-		}
-	};
 	return {
 		req,
-		res,
+		res: new PagesResponseStream(resolveResponse, rejectResponse, options.request.headers),
 		responsePromise
 	};
 }

package/dist/server/pages-page-data.d.ts

@@ -33,6 +33,9 @@ type PagesGsspContextResponse = {
   res: PagesMutableGsspResponse;
   responsePromise: Promise<Response>;
 };
+type PagesRenderProps = Record<string, unknown> & {
+  pageProps: unknown;
+};
 type PagesPageModule = {
   default?: unknown;
   getStaticPaths?: (context: {
@@ -82,9 +85,10 @@ type PagesPageModule = {
 type RenderPagesIsrHtmlOptions = {
   buildId: string | null;
   cachedHtml: string;
-  createPageElement: (pageProps: Record<string, unknown>) => ReactNode;
+  createPageElement: (props: Record<string, unknown>) => ReactNode;
   i18n: PagesI18nRenderContext;
   pageProps: Record<string, unknown>;
+  props?: Record<string, unknown>;
   params: Record<string, unknown>;
   renderIsrPassToStringAsync: (element: ReactNode) => Promise<string>;
   routePattern: string;
@@ -106,7 +110,8 @@ type ResolvePagesPageDataOptions = {
   isDataReq?: boolean;
   err?: unknown;
   createGsspReqRes: () => PagesGsspContextResponse;
-  createPageElement: (pageProps: Record<string, unknown>) => ReactNode;
+  createAppTree?: (props: Record<string, unknown>) => ReactNode;
+  createPageElement: (props: Record<string, unknown>) => ReactNode;
   fontLinkHeader: string;
   i18n: PagesI18nRenderContext;
   isrCacheKey: (router: string, pathname: string) => string;
@@ -138,10 +143,20 @@ type ResolvePagesPageDataOptions = {
    * presence — see the security note in `isr-cache.ts`.
    */
   isOnDemandRevalidate?: boolean;
+  /**
+   * The deployment ID used for deployment-skew protection. When set, it is
+   * included as `x-nextjs-deployment-id` on all `_next/data` responses
+   * (success, redirect, notFound). Mirrors Next.js pages-handler.ts behavior.
+   * Typically sourced from `process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID`.
+   */
+  deploymentId?: string;
+  htmlLimitedBots?: string;
   pageModule: PagesPageModule;
+  AppComponent?: unknown;
   params: Record<string, unknown>;
   query: Record<string, unknown>;
   asPath?: string;
+  resolvedUrl?: string;
   route: Pick<Route, "isDynamic">;
   routePattern: string;
   routeUrl: string;
@@ -158,12 +173,34 @@ type ResolvePagesPageDataOptions = {
   renderIsrPassToStringAsync: (element: ReactNode) => Promise<string>;
   vinext?: VinextNextData["__vinext"];
   nextData?: PagesNextDataExtras;
+  /**
+   * The request's User-Agent string. When this matches a known crawler/bot
+   * pattern, ISR cache-HIT and cache-STALE responses receive an ETag header
+   * for consistency with the fresh-MISS path (which also attaches an ETag for
+   * bot UAs via `renderPagesPageResponse`). See the divergence note in
+   * `pages-page-response.ts` for why UA-gating is used instead of Next.js's
+   * `isDynamic` check.
+   */
+  userAgent?: string;
+  /**
+   * The incoming request's `If-None-Match` header value. When the cached HTML
+   * ETag matches (weak-ETag semantics), the ISR cache-HIT or cache-STALE
+   * response is a `304 Not Modified` with no body.
+   */
+  ifNoneMatch?: string;
+  /**
+   * The incoming request's `Cache-Control` header value. When it contains
+   * `no-cache`, the 304 short-circuit is skipped and a full response is
+   * returned — mirroring the `fresh` package used by Next.js.
+   */
+  requestCacheControl?: string;
 };
 type ResolvePagesPageDataRenderResult = {
   kind: "render";
   gsspRes: PagesGsspResponse | null;
   isrRevalidateSeconds: number | null;
   pageProps: Record<string, unknown>;
+  props: PagesRenderProps;
   /**
    * True when `getStaticPaths` returned `fallback: true` AND the requested path
    * is not in the pre-rendered list. The caller renders a loading shell with