nitro 3.0.1-alpha.0 → 3.0.1-alpha.2

package/dist/presets/node/runtime/node-server.mjs

@@ -1,44 +1,46 @@
-import "#nitro-internal-pollyfills";
-import { Server as HttpServer } from "node:http";
-import { Server as HttpsServer } from "node:https";
+import "#nitro/virtual/polyfills";
+import { NodeRequest, serve } from "srvx/node";
 import wsAdapter from "crossws/adapters/node";
-import destr from "destr";
-import { toNodeHandler } from "srvx/node";
-import { useNitroApp, useRuntimeConfig } from "nitro/runtime";
-import {
-  setupGracefulShutdown,
-  startScheduleRunner,
-  trapUnhandledNodeErrors
-} from "nitro/runtime/internal";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { trapUnhandledErrors } from "#nitro/runtime/error/hooks";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const port = Number.parseInt(process.env.NITRO_PORT || process.env.PORT || "") || 3e3;
+const host = process.env.NITRO_HOST || process.env.HOST;
 const cert = process.env.NITRO_SSL_CERT;
 const key = process.env.NITRO_SSL_KEY;
+// const socketPath = process.env.NITRO_UNIX_SOCKET; // TODO
 const nitroApp = useNitroApp();
-const server = cert && key ? new HttpsServer({ key, cert }, toNodeHandler(nitroApp.fetch)) : new HttpServer(toNodeHandler(nitroApp.fetch));
-const port = destr(process.env.NITRO_PORT || process.env.PORT) || 3e3;
-const host = process.env.NITRO_HOST || process.env.HOST;
-const path = process.env.NITRO_UNIX_SOCKET;
-const listener = server.listen(path ? { path } : { port, host }, (err) => {
-  if (err) {
-    console.error(err);
-    process.exit(1);
-  }
-  const protocol = cert && key ? "https" : "http";
-  const addressInfo = listener.address();
-  if (typeof addressInfo === "string") {
-    console.log(`Listening on unix socket ${addressInfo}`);
-    return;
-  }
-  const baseURL = (useRuntimeConfig().app.baseURL || "").replace(/\/$/, "");
-  const url = `${protocol}://${addressInfo.family === "IPv6" ? `[${addressInfo.address}]` : addressInfo.address}:${addressInfo.port}${baseURL}`;
-  console.log(`Listening on ${url}`);
+const server = serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	fetch: nitroApp.fetch
 });
-trapUnhandledNodeErrors();
-setupGracefulShutdown(listener, nitroApp);
 if (import.meta._websocket) {
-  const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
-  server.on("upgrade", handleUpgrade);
+	const { handleUpgrade } = wsAdapter({ resolve: resolveWebsocketHooks });
+	server.node.server.on("upgrade", (req, socket, head) => {
+		handleUpgrade(
+			req,
+			socket,
+			head,
+			// @ts-expect-error (upgrade is not typed)
+			new NodeRequest({
+				req,
+				upgrade: {
+					socket,
+					head
+				}
+			})
+		);
+	});
 }
+trapUnhandledErrors();
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }
 export default {};

package/dist/presets/standard/runtime/server.d.mts

@@ -1,5 +1,3 @@
-import "#nitro-internal-pollyfills";
-declare const _default: {
-    fetch: any;
-};
+import "#nitro/virtual/polyfills";
+declare const _default: {};
 export default _default;

package/dist/presets/standard/runtime/server.mjs

@@ -1,6 +1,4 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
 const nitroApp = useNitroApp();
-export default {
-  fetch: nitroApp.fetch
-};
+export default { fetch: nitroApp.fetch };

package/dist/presets/stormkit/runtime/stormkit.d.mts

@@ -1,21 +1,21 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import type { Handler } from "aws-lambda";
 type StormkitEvent = {
-    url: string;
-    path: string;
-    method: string;
-    body?: string;
-    query?: Record<string, Array<string>>;
-    headers?: Record<string, string>;
-    rawHeaders?: Array<string>;
+	url: string;
+	path: string;
+	method: string;
+	body?: string;
+	query?: Record<string, Array<string>>;
+	headers?: Record<string, string>;
+	rawHeaders?: Array<string>;
 };
 type StormkitResponse = {
-    headers?: Record<string, string>;
-    body?: string;
-    buffer?: string;
-    statusCode: number;
-    errorMessage?: string;
-    errorStack?: string;
+	headers?: Record<string, string>;
+	body?: string;
+	buffer?: string;
+	statusCode: number;
+	errorMessage?: string;
+	errorStack?: string;
 };
 export declare const handler: Handler<StormkitEvent, StormkitResponse>;
 export {};

package/dist/presets/stormkit/runtime/stormkit.mjs

@@ -1,28 +1,28 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
 import { awsResponseBody } from "../../aws-lambda/runtime/_utils.mjs";
 const nitroApp = useNitroApp();
 export const handler = async function(event, context) {
-  const req = new Request(event.url, {
-    method: event.method || "GET",
-    headers: event.headers,
-    body: event.body
-  });
-  req.runtime ??= { name: "stormkit" };
-  req.runtime.stormkit ??= { event, context };
-  const response = await nitroApp.fetch(req);
-  const { body, isBase64Encoded } = await awsResponseBody(response);
-  return {
-    statusCode: response.status,
-    headers: normalizeOutgoingHeaders(response.headers),
-    [isBase64Encoded ? "buffer" : "body"]: body
-  };
+	const req = new Request(event.url, {
+		method: event.method || "GET",
+		headers: event.headers,
+		body: event.body
+	});
+	// srvx compatibility
+	req.runtime ??= { name: "stormkit" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.stormkit ??= {
+		event,
+		context
+	};
+	const response = await nitroApp.fetch(req);
+	const { body, isBase64Encoded } = await awsResponseBody(response);
+	return {
+		statusCode: response.status,
+		headers: normalizeOutgoingHeaders(response.headers),
+		[isBase64Encoded ? "buffer" : "body"]: body
+	};
 };
 function normalizeOutgoingHeaders(headers) {
-  return Object.fromEntries(
-    Object.entries(headers).map(([k, v]) => [
-      k,
-      Array.isArray(v) ? v.join(",") : String(v)
-    ])
-  );
+	return Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : String(v)]));
 }

package/dist/presets/vercel/runtime/isr.d.mts

@@ -0,0 +1,2 @@
+export declare const ISR_URL_PARAM = "__isr_route";
+export declare function isrRouteRewrite(reqUrl: string, xNowRouteMatches: string | null): [pathname: string, search: string] | undefined;

package/dist/presets/vercel/runtime/isr.mjs

@@ -0,0 +1,19 @@
+export const ISR_URL_PARAM = "__isr_route";
+export function isrRouteRewrite(reqUrl, xNowRouteMatches) {
+	if (xNowRouteMatches) {
+		const isrURL = new URLSearchParams(xNowRouteMatches).get(ISR_URL_PARAM);
+		if (isrURL) {
+			return [decodeURIComponent(isrURL), ""];
+		}
+	} else {
+		const queryIndex = reqUrl.indexOf("?");
+		if (queryIndex !== -1) {
+			const params = new URLSearchParams(reqUrl.slice(queryIndex + 1));
+			const isrURL = params.get(ISR_URL_PARAM);
+			if (isrURL) {
+				params.delete(ISR_URL_PARAM);
+				return [decodeURIComponent(isrURL), params.toString()];
+			}
+		}
+	}
+}

package/dist/presets/vercel/runtime/vercel.node.d.mts

@@ -0,0 +1,3 @@
+import "#nitro/virtual/polyfills";
+import type { NodeServerRequest, NodeServerResponse } from "srvx";
+export default function nodeHandler(req: NodeServerRequest, res: NodeServerResponse);

package/dist/presets/vercel/runtime/vercel.node.mjs

@@ -0,0 +1,24 @@
+import "#nitro/virtual/polyfills";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp, getRouteRules } from "nitro/app";
+import { isrRouteRewrite } from "./isr.mjs";
+const nitroApp = useNitroApp();
+const handler = toNodeHandler(nitroApp.fetch);
+export default function nodeHandler(req, res) {
+	// https://vercel.com/docs/headers/request-headers#x-forwarded-for
+	// srvx node adapter uses req.socket.remoteAddress for req.ip
+	let ip;
+	Object.defineProperty(req.socket, "remoteAddress", { get() {
+		const h = req.headers["x-forwarded-for"];
+		return ip ??= h?.split?.(",").shift()?.trim();
+	} });
+	// ISR route rewrite
+	const isrURL = isrRouteRewrite(req.url, req.headers["x-now-route-matches"]);
+	if (isrURL) {
+		const { routeRules } = getRouteRules("", isrURL[0]);
+		if (routeRules?.isr) {
+			req.url = isrURL[0] + (isrURL[1] ? `?${isrURL[1]}` : "");
+		}
+	}
+	return handler(req, res);
+}

package/dist/presets/vercel/runtime/vercel.web.d.mts

@@ -0,0 +1,8 @@
+import "#nitro/virtual/polyfills";
+import type { ServerRequest } from "srvx";
+declare const _default: {
+	fetch(req: ServerRequest, context: {
+		waitUntil: (promise: Promise<any>) => void;
+	});
+};
+export default _default;

package/dist/presets/vercel/runtime/vercel.web.mjs

@@ -0,0 +1,25 @@
+import "#nitro/virtual/polyfills";
+import { useNitroApp, getRouteRules } from "nitro/app";
+import { isrRouteRewrite } from "./isr.mjs";
+const nitroApp = useNitroApp();
+export default { fetch(req, context) {
+	// ISR route rewrite
+	const isrURL = isrRouteRewrite(req.url, req.headers.get("x-now-route-matches"));
+	if (isrURL) {
+		const { routeRules } = getRouteRules("", isrURL[0]);
+		if (routeRules?.isr) {
+			req = new Request(new URL(isrURL[0] + (isrURL[1] ? `?${isrURL[1]}` : ""), req.url).href, req);
+		}
+	}
+	req.runtime = {
+		name: "vercel",
+		vercel: { context }
+	};
+	let ip;
+	Object.defineProperty(req, "ip", { get() {
+		const h = req.headers.get("x-forwarded-for");
+		return ip ??= h?.split(",").shift()?.trim();
+	} });
+	req.waitUntil = context?.waitUntil;
+	return nitroApp.fetch(req);
+} };

package/dist/presets/winterjs/runtime/winterjs.d.mts

@@ -1 +1,2 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
+export {};

package/dist/presets/winterjs/runtime/winterjs.mjs

@@ -1,87 +1,91 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+// @ts-nocheck TODO: Remove after removing polyfills
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
 import { hasProtocol, joinURL } from "ufo";
 const nitroApp = useNitroApp();
+// Use plain handler as winterjs Web API is incomplete
+// TODO: Migrate to toWebHandler
 const _handler = toPlainHandler(nitroApp.h3App);
 async function _handleEvent(event) {
-  try {
-    const res = await _handler({
-      path: event.request.url.pathname + (event.request.url.search ? `?${event.request.url.search}` : ""),
-      method: event.request.getMethod() || "GET",
-      body: event.request.body,
-      headers: event.request.headers,
-      context: {
-        waitUntil: (promise) => event.waitUntil(promise),
-        _platform: {
-          winterjs: {
-            event
-          }
-        }
-      }
-    });
-    const body = typeof res.body === "string" ? res.body : await toBuffer(res.body);
-    return new Response(body, {
-      status: res.status,
-      statusText: res.statusText,
-      headers: res.headers
-    });
-  } catch (error) {
-    const errString = error?.message + "\n" + error?.stack;
-    console.error(errString);
-    return new Response(errString, { status: 500 });
-  }
+	try {
+		const res = await _handler({
+			path: event.request.url.pathname + (event.request.url.search ? `?${event.request.url.search}` : ""),
+			method: event.request.getMethod() || "GET",
+			body: event.request.body,
+			headers: event.request.headers,
+			context: {
+				waitUntil: (promise) => event.waitUntil(promise),
+				_platform: { winterjs: { event } }
+			}
+		});
+		const body = typeof res.body === "string" ? res.body : await toBuffer(res.body);
+		return new Response(body, {
+			status: res.status,
+			statusText: res.statusText,
+			headers: res.headers
+		});
+	} catch (error) {
+		const errString = error?.message + "\n" + error?.stack;
+		console.error(errString);
+		return new Response(errString, { status: 500 });
+	}
 }
 addEventListener("fetch", async (event) => {
-  event.respondWith(await _handleEvent(event));
+	event.respondWith(await _handleEvent(event));
 });
+// ------------------------------
+// Polyfills for missing APIs
+// ------------------------------
 function toBuffer(data) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    data.pipeTo(
-      new WritableStream({
-        write(chunk) {
-          chunks.push(chunk);
-        },
-        close() {
-          resolve(Buffer.concat(chunks));
-        },
-        abort(reason) {
-          reject(reason);
-        }
-      })
-    ).catch(reject);
-  });
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		data.pipeTo(new WritableStream({
+			write(chunk) {
+				chunks.push(chunk);
+			},
+			close() {
+				resolve(Buffer.concat(chunks));
+			},
+			abort(reason) {
+				reject(reason);
+			}
+		})).catch(reject);
+	});
 }
+// Headers.entries
 if (!Headers.prototype.entries) {
-  Headers.prototype.entries = function() {
-    return [...this];
-  };
+	// @ts-ignore
+	Headers.prototype.entries = function() {
+		return [...this];
+	};
 }
+// URL.pathname
 if (!URL.prototype.pathname) {
-  Object.defineProperty(URL.prototype, "pathname", {
-    get() {
-      return this.path || "/";
-    }
-  });
+	Object.defineProperty(URL.prototype, "pathname", { get() {
+		return this.path || "/";
+	} });
 }
+// URL constructor (relative support)
 const _URL = globalThis.URL;
-globalThis.URL = class URL2 extends _URL {
-  constructor(url, base) {
-    if (!base || hasProtocol(url)) {
-      super(url);
-      return;
-    }
-    super(joinURL(base, url));
-  }
+globalThis.URL = class URL extends _URL {
+	constructor(url, base) {
+		if (!base || hasProtocol(url)) {
+			super(url);
+			return;
+		}
+		super(joinURL(base, url));
+	}
 };
+// Response (avoid Promise body)
 const _Response = globalThis.Response;
-globalThis.Response = class Response2 extends _Response {
-  _body;
-  constructor(body, init) {
-    super(body, init);
-    this._body = body;
-  }
-  get body() {
-    return this._body;
-  }
+globalThis.Response = class Response extends _Response {
+	_body;
+	constructor(body, init) {
+		super(body, init);
+		this._body = body;
+	}
+	get body() {
+		// TODO: Return ReadableStream (should be iterable)
+		return this._body;
+	}
 };

package/dist/presets/zeabur/runtime/zeabur.d.mts

@@ -1,3 +1,3 @@
-import "#nitro-internal-pollyfills";
-declare const _default: any;
+import "#nitro/virtual/polyfills";
+declare const _default;
 export default _default;

package/dist/presets/zeabur/runtime/zeabur.mjs

@@ -1,4 +1,4 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import { toNodeHandler } from "srvx/node";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp } from "nitro/app";
 export default toNodeHandler(useNitroApp().fetch);

package/dist/runtime/app.d.mts

@@ -0,0 +1 @@
+export { useNitroApp, useNitroHooks, serverFetch, getRouteRules, fetch } from "./internal/app.mjs";

package/dist/runtime/app.mjs

@@ -0,0 +1 @@
+export { useNitroApp, useNitroHooks, serverFetch, getRouteRules, fetch } from "./internal/app.mjs";

package/dist/runtime/cache.d.mts

@@ -0,0 +1 @@
+export { defineCachedFunction, defineCachedHandler } from "./internal/cache.mjs";

package/dist/runtime/cache.mjs

@@ -0,0 +1 @@
+export { defineCachedFunction, defineCachedHandler } from "./internal/cache.mjs";

package/dist/runtime/config.d.mts

@@ -0,0 +1,3 @@
+import type { NitroConfig } from "nitro/types";
+export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit<NitroConfig, "rootDir">;
+export { defineConfig as defineNitroConfig };

package/dist/runtime/config.mjs

@@ -0,0 +1,4 @@
+export function defineConfig(config) {
+	return config;
+}
+export { defineConfig as defineNitroConfig };

package/dist/runtime/context.d.mts

@@ -0,0 +1 @@
+export { useRequest } from "./internal/context.mjs";

package/dist/runtime/context.mjs

@@ -0,0 +1 @@
+export { useRequest } from "./internal/context.mjs";

package/dist/runtime/database.d.mts

@@ -0,0 +1 @@
+export { useDatabase } from "./internal/database.mjs";

package/dist/runtime/database.mjs

@@ -0,0 +1 @@
+export { useDatabase } from "./internal/database.mjs";

package/dist/runtime/internal/app.d.mts

@@ -1,2 +1,16 @@
-import type { NitroApp } from "nitro/types";
+import type { MatchedRouteRules, NitroApp, NitroRuntimeHooks } from "nitro/types";
+import type { ServerRequest, ServerRequestContext } from "srvx";
+import type { H3EventContext, Middleware, WebSocketHooks } from "h3";
+import { HookableCore } from "hookable";
+declare global {
+	var __nitro__: Partial<Record<"default" | "prerender" | (string & {}), NitroApp | undefined>> | undefined;
+}
 export declare function useNitroApp(): NitroApp;
+export declare function useNitroHooks(): HookableCore<NitroRuntimeHooks>;
+export declare function serverFetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
+export declare function resolveWebsocketHooks(req: ServerRequest): Promise<Partial<WebSocketHooks>>;
+export declare function fetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
+export declare function getRouteRules(method: string, pathname: string): {
+	routeRules?: MatchedRouteRules;
+	routeRuleMiddleware: Middleware[];
+};