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

package/dist/presets/aws-lambda/runtime/_utils.mjs

@@ -1,102 +1,116 @@
 import { stringifyQuery } from "ufo";
+// Incoming (AWS => Web)
 export function awsRequest(event, context) {
-  const method = awsEventMethod(event);
-  const url = awsEventURL(event);
-  const headers = awsEventHeaders(event);
-  const body = awsEventBody(event);
-  const req = new Request(url, { method, headers, body });
-  req.runtime ??= { name: "aws-lambda" };
-  req.runtime.aws ??= { event, context };
-  return new Request(url, { method, headers, body });
+	const method = awsEventMethod(event);
+	const url = awsEventURL(event);
+	const headers = awsEventHeaders(event);
+	const body = awsEventBody(event);
+	const req = new Request(url, {
+		method,
+		headers,
+		body
+	});
+	// srvx compatibility
+	req.runtime ??= { name: "aws-lambda" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.aws ??= {
+		event,
+		context
+	};
+	return new Request(url, {
+		method,
+		headers,
+		body
+	});
 }
 function awsEventMethod(event) {
-  return event.httpMethod || event.requestContext?.http?.method || "GET";
+	return event.httpMethod || event.requestContext?.http?.method || "GET";
 }
 function awsEventURL(event) {
-  const hostname = event.headers.host || event.headers.Host || event.requestContext?.domainName || ".";
-  const path = event.path || event.rawPath;
-  const query = awsEventQuery(event);
-  const protocol = (event.headers["X-Forwarded-Proto"] || event.headers["x-forwarded-proto"]) === "http" ? "http" : "https";
-  return new URL(
-    `${path}${query ? `?${query}` : ""}`,
-    `${protocol}://${hostname}`
-  );
+	const hostname = event.headers.host || event.headers.Host || event.requestContext?.domainName || ".";
+	const path = event.path || event.rawPath;
+	const query = awsEventQuery(event);
+	const protocol = (event.headers["X-Forwarded-Proto"] || event.headers["x-forwarded-proto"]) === "http" ? "http" : "https";
+	return new URL(`${path}${query ? `?${query}` : ""}`, `${protocol}://${hostname}`);
 }
 function awsEventQuery(event) {
-  if (typeof event.rawQueryString === "string") {
-    return event.rawQueryString;
-  }
-  const queryObj = {
-    ...event.queryStringParameters,
-    ...event.multiValueQueryStringParameters
-  };
-  return stringifyQuery(queryObj);
+	if (typeof event.rawQueryString === "string") {
+		return event.rawQueryString;
+	}
+	const queryObj = {
+		...event.queryStringParameters,
+		...event.multiValueQueryStringParameters
+	};
+	return stringifyQuery(queryObj);
 }
 function awsEventHeaders(event) {
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(event.headers)) {
-    if (value) {
-      headers.set(key, value);
-    }
-  }
-  if ("cookies" in event && event.cookies) {
-    for (const cookie of event.cookies) {
-      headers.append("cookie", cookie);
-    }
-  }
-  return headers;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(event.headers)) {
+		if (value) {
+			headers.set(key, value);
+		}
+	}
+	if ("cookies" in event && event.cookies) {
+		for (const cookie of event.cookies) {
+			headers.append("cookie", cookie);
+		}
+	}
+	return headers;
 }
 function awsEventBody(event) {
-  if (!event.body) {
-    return void 0;
-  }
-  if (event.isBase64Encoded) {
-    return Buffer.from(event.body || "", "base64");
-  }
-  return event.body;
+	if (!event.body) {
+		return undefined;
+	}
+	if (event.isBase64Encoded) {
+		return Buffer.from(event.body || "", "base64");
+	}
+	return event.body;
 }
+// Outgoing (Web => AWS)
 export function awsResponseHeaders(response) {
-  const headers = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of response.headers) {
-    if (value) {
-      headers[key] = Array.isArray(value) ? value.join(",") : String(value);
-    }
-  }
-  const cookies = response.headers.getSetCookie();
-  return cookies.length > 0 ? {
-    headers,
-    cookies,
-    // ApiGateway v2
-    multiValueHeaders: { "set-cookie": cookies }
-    // ApiGateway v1
-  } : { headers };
+	const headers = Object.create(null);
+	for (const [key, value] of response.headers) {
+		if (value) {
+			headers[key] = Array.isArray(value) ? value.join(",") : String(value);
+		}
+	}
+	const cookies = response.headers.getSetCookie();
+	return cookies.length > 0 ? {
+		headers,
+		cookies,
+		multiValueHeaders: { "set-cookie": cookies }
+	} : { headers };
 }
+// AWS Lambda proxy integrations requires base64 encoded buffers
+// binaryMediaTypes should be */*
+// see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
 export async function awsResponseBody(response) {
-  if (!response.body) {
-    return { body: "" };
-  }
-  const buffer = await toBuffer(response.body);
-  const contentType = response.headers.get("content-type") || "";
-  return isTextType(contentType) ? { body: buffer.toString("utf8") } : { body: buffer.toString("base64"), isBase64Encoded: true };
+	if (!response.body) {
+		return { body: "" };
+	}
+	const buffer = await toBuffer(response.body);
+	const contentType = response.headers.get("content-type") || "";
+	return isTextType(contentType) ? { body: buffer.toString("utf8") } : {
+		body: buffer.toString("base64"),
+		isBase64Encoded: true
+	};
 }
 function isTextType(contentType = "") {
-  return /^text\/|\/(javascript|json|xml)|utf-?8/i.test(contentType);
+	return /^text\/|\/(javascript|json|xml)|utf-?8/i.test(contentType);
 }
 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);
+	});
 }

package/dist/presets/aws-lambda/runtime/aws-lambda-streaming.d.mts

@@ -1,3 +1,2 @@
-import "#nitro-internal-pollyfills";
-import type { APIGatewayProxyEventV2 } from "aws-lambda";
-export declare const handler: import("aws-lambda").StreamifyHandler<APIGatewayProxyEventV2, void>;
+import "#nitro/virtual/polyfills";
+export declare const handler: unknown;

package/dist/presets/aws-lambda/runtime/aws-lambda-streaming.mjs

@@ -1,33 +1,29 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
 import { awsRequest, awsResponseHeaders } from "./_utils.mjs";
 const nitroApp = useNitroApp();
-export const handler = awslambda.streamifyResponse(
-  async (event, responseStream, context) => {
-    const request = awsRequest(event, context);
-    const response = await nitroApp.fetch(request);
-    response.headers.set("transfer-encoding", "chunked");
-    const httpResponseMetadata = {
-      statusCode: response.status,
-      ...awsResponseHeaders(response)
-    };
-    if (response.body) {
-      const writer = awslambda.HttpResponseStream.from(
-        // @ts-expect-error TODO: IMPORTANT! It should be a Writable according to the aws-lambda types
-        responseStream,
-        httpResponseMetadata
-      );
-      const reader = response.body.getReader();
-      await streamToNodeStream(reader, responseStream);
-      writer.end();
-    }
-  }
-);
+export const handler = awslambda.streamifyResponse(async (event, responseStream, context) => {
+	const request = awsRequest(event, context);
+	const response = await nitroApp.fetch(request);
+	response.headers.set("transfer-encoding", "chunked");
+	const httpResponseMetadata = {
+		statusCode: response.status,
+		...awsResponseHeaders(response)
+	};
+	const body = response.body ?? new ReadableStream({ start(controller) {
+		controller.enqueue("");
+		controller.close();
+	} });
+	const writer = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+	const reader = body.getReader();
+	await streamToNodeStream(reader, responseStream);
+	writer.end();
+});
 async function streamToNodeStream(reader, writer) {
-  let readResult = await reader.read();
-  while (!readResult.done) {
-    writer.write(readResult.value);
-    readResult = await reader.read();
-  }
-  writer.end();
+	let readResult = await reader.read();
+	while (!readResult.done) {
+		writer.write(readResult.value);
+		readResult = await reader.read();
+	}
+	writer.end();
 }

package/dist/presets/aws-lambda/runtime/aws-lambda.d.mts

@@ -1,3 +1,3 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2, Context } from "aws-lambda";
 export declare function handler(event: APIGatewayProxyEvent | APIGatewayProxyEventV2, context: Context): Promise<APIGatewayProxyResult | APIGatewayProxyResultV2>;

package/dist/presets/aws-lambda/runtime/aws-lambda.mjs

@@ -1,13 +1,13 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
 import { awsRequest, awsResponseHeaders, awsResponseBody } from "./_utils.mjs";
 const nitroApp = useNitroApp();
 export async function handler(event, context) {
-  const request = awsRequest(event, context);
-  const response = await nitroApp.fetch(request);
-  return {
-    statusCode: response.status,
-    ...awsResponseHeaders(response),
-    ...await awsResponseBody(response)
-  };
+	const request = awsRequest(event, context);
+	const response = await nitroApp.fetch(request);
+	return {
+		statusCode: response.status,
+		...awsResponseHeaders(response),
+		...await awsResponseBody(response)
+	};
 }

package/dist/presets/azure/runtime/_utils.mjs

@@ -1,50 +1,50 @@
 import { parse } from "cookie-es";
 export function getAzureParsedCookiesFromHeaders(headers) {
-  const setCookieHeader = headers.getSetCookie();
-  if (setCookieHeader.length === 0) {
-    return [];
-  }
-  const azureCookies = [];
-  for (const setCookieStr of setCookieHeader) {
-    const setCookie = Object.entries(parse(setCookieStr));
-    if (setCookie.length === 0) {
-      continue;
-    }
-    const [[key, value], ..._setCookieOptions] = setCookie;
-    const setCookieOptions = Object.fromEntries(
-      _setCookieOptions.map(([k, v]) => [k.toLowerCase(), v])
-    );
-    const cookieObject = {
-      name: key,
-      value,
-      domain: setCookieOptions.domain,
-      path: setCookieOptions.path,
-      expires: parseNumberOrDate(setCookieOptions.expires),
-      sameSite: setCookieOptions.samesite,
-      maxAge: parseNumber(setCookieOptions["max-age"]),
-      secure: setCookieStr.includes("Secure") ? true : void 0,
-      httpOnly: setCookieStr.includes("HttpOnly") ? true : void 0
-    };
-    azureCookies.push(cookieObject);
-  }
-  return azureCookies;
+	const setCookieHeader = headers.getSetCookie();
+	if (setCookieHeader.length === 0) {
+		return [];
+	}
+	const azureCookies = [];
+	for (const setCookieStr of setCookieHeader) {
+		const setCookie = Object.entries(parse(setCookieStr));
+		if (setCookie.length === 0) {
+			continue;
+		}
+		const [[key, value], ..._setCookieOptions] = setCookie;
+		const setCookieOptions = Object.fromEntries(_setCookieOptions.map(([k, v]) => [k.toLowerCase(), v]));
+		const cookieObject = {
+			name: key,
+			value,
+			domain: setCookieOptions.domain,
+			path: setCookieOptions.path,
+			expires: parseNumberOrDate(setCookieOptions.expires),
+			sameSite: setCookieOptions.samesite,
+			maxAge: parseNumber(setCookieOptions["max-age"]),
+			secure: setCookieStr.includes("Secure") ? true : undefined,
+			httpOnly: setCookieStr.includes("HttpOnly") ? true : undefined
+		};
+		azureCookies.push(cookieObject);
+	}
+	return azureCookies;
 }
 function parseNumberOrDate(expires) {
-  const expiresAsNumber = parseNumber(expires);
-  if (expiresAsNumber !== void 0) {
-    return expiresAsNumber;
-  }
-  const expiresAsDate = new Date(expires);
-  if (!Number.isNaN(expiresAsDate.getTime())) {
-    return expiresAsDate;
-  }
+	const expiresAsNumber = parseNumber(expires);
+	if (expiresAsNumber !== undefined) {
+		return expiresAsNumber;
+	}
+	// Convert to Date if possible
+	const expiresAsDate = new Date(expires);
+	if (!Number.isNaN(expiresAsDate.getTime())) {
+		return expiresAsDate;
+	}
 }
 function parseNumber(maxAge) {
-  if (!maxAge) {
-    return void 0;
-  }
-  const maxAgeAsNumber = Number(maxAge);
-  if (!Number.isNaN(maxAgeAsNumber)) {
-    return maxAgeAsNumber;
-  }
+	if (!maxAge) {
+		return undefined;
+	}
+	// Convert to number if possible
+	const maxAgeAsNumber = Number(maxAge);
+	if (!Number.isNaN(maxAgeAsNumber)) {
+		return maxAgeAsNumber;
+	}
 }

package/dist/presets/azure/runtime/azure-swa.d.mts

@@ -1,5 +1,5 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import type { HttpRequest, HttpResponse } from "@azure/functions";
 export declare function handle(context: {
-    res: HttpResponse;
-}, req: HttpRequest): Promise<void>;
+	res: HttpResponse;
+}, req: HttpRequest);

package/dist/presets/azure/runtime/azure-swa.mjs

@@ -1,28 +1,30 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import { parseURL } from "ufo";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp } from "nitro/app";
 import { getAzureParsedCookiesFromHeaders } from "./_utils.mjs";
 const nitroApp = useNitroApp();
 export async function handle(context, req) {
-  let url;
-  if (req.headers["x-ms-original-url"]) {
-    const parsedURL = parseURL(req.headers["x-ms-original-url"]);
-    url = parsedURL.pathname + parsedURL.search;
-  } else {
-    url = "/api/" + (req.params.url || "");
-  }
-  const response = await nitroApp.fetch(url, {
-    method: req.method || void 0,
-    // https://github.com/Azure/azure-functions-nodejs-worker/issues/294
-    // https://github.com/Azure/azure-functions-host/issues/293
-    body: req.bufferBody ?? req.rawBody
-  });
-  context.res = {
-    status: response.status,
-    body: response.body,
-    cookies: getAzureParsedCookiesFromHeaders(response.headers),
-    headers: Object.fromEntries(
-      [...response.headers.entries()].filter(([key]) => key !== "set-cookie")
-    )
-  };
+	let url;
+	if (req.headers["x-ms-original-url"]) {
+		// This URL has been proxied as there was no static file matching it.
+		const parsedURL = parseURL(req.headers["x-ms-original-url"]);
+		url = parsedURL.pathname + parsedURL.search;
+	} else {
+		// Because Azure SWA handles /api/* calls differently they
+		// never hit the proxy and we have to reconstitute the URL.
+		url = "/api/" + (req.params.url || "");
+	}
+	const request = new Request(url, {
+		method: req.method || undefined,
+		body: req.bufferBody ?? req.rawBody
+	});
+	const response = await nitroApp.fetch(request);
+	// (v3 - current) https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=typescript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v3#http-response
+	// (v4) https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=typescript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v4#http-response
+	context.res = {
+		status: response.status,
+		body: response.body,
+		cookies: getAzureParsedCookiesFromHeaders(response.headers),
+		headers: Object.fromEntries([...response.headers.entries()].filter(([key]) => key !== "set-cookie"))
+	};
 }

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

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

package/dist/presets/bun/runtime/bun.mjs

@@ -1,27 +1,39 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { startScheduleRunner } from "nitro/runtime/internal";
+import "#nitro/virtual/polyfills";
+import { serve } from "srvx/bun";
 import wsAdapter from "crossws/adapters/bun";
+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 ws = import.meta._websocket ? (
-  // @ts-expect-error
-  wsAdapter(nitroApp.h3App.websocket)
-) : void 0;
-const server = Bun.serve({
-  port: process.env.NITRO_PORT || process.env.PORT || 3e3,
-  hostname: process.env.NITRO_HOST || process.env.HOST,
-  websocket: import.meta._websocket ? ws.websocket : void 0,
-  async fetch(bunReq, server2) {
-    const req = bunReq;
-    req.runtime ??= { name: "bun" };
-    req.runtime.bun ??= { server: server2 };
-    if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
-      return ws.handleUpgrade(req, server2);
-    }
-    return nitroApp.fetch(req);
-  }
+let _fetch = nitroApp.fetch;
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+if (import.meta._websocket) {
+	_fetch = (req) => {
+		if (req.headers.get("upgrade") === "websocket") {
+			return ws.handleUpgrade(req, req.runtime.bun.server);
+		}
+		return nitroApp.fetch(req);
+	};
+}
+serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	fetch: _fetch,
+	bun: { websocket: import.meta._websocket ? ws?.websocket : undefined }
 });
-console.log(`Listening on ${server.url}...`);
+trapUnhandledErrors();
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }
+export default {};

package/dist/presets/cloudflare/runtime/_module-handler.d.mts

@@ -1,13 +1,16 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import type * as CF from "@cloudflare/workers-types";
-import type { ExportedHandler } from "@cloudflare/workers-types";
+import type { ServerRuntimeContext } from "srvx";
 type MaybePromise<T> = T | Promise<T>;
 export declare function createHandler<Env>(hooks: {
-    fetch: (...params: [
-        ...Parameters<NonNullable<ExportedHandler<Env>["fetch"]>>,
-        url: URL,
-        cfContextExtras: any
-    ]) => MaybePromise<Response | CF.Response | undefined>;
-}): ExportedHandler<Env>;
-export declare function fetchHandler(cfReq: Request | CF.Request, env: unknown, context: CF.ExecutionContext | DurableObjectState, url: URL | undefined, nitroApp: any, ctxExt: any): Promise<Response>;
+	fetch: (...params: [...Parameters<NonNullable<ExportedHandler<Env>["fetch"]>>, url: URL, cfContextExtras: any]) => MaybePromise<Response | CF.Response | undefined>;
+}): {
+	fetch(request, env, context);
+	scheduled(controller, env, context);
+	email(message, env, context);
+	queue(batch, env, context);
+	tail(traces, env, context);
+	trace(traces, env, context);
+};
+export declare function augmentReq(cfReq: Request | CF.Request, ctx: NonNullable<ServerRuntimeContext["cloudflare"]>);
 export {};