nitro 3.0.0 → 3.0.1-alpha.1

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

@@ -1,28 +1,30 @@
 import "#nitro-internal-pollyfills";
 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";
+declare const _default: {};
+export default _default;

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

@@ -1,27 +1,40 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { startScheduleRunner } from "nitro/runtime/internal";
+import { serve } from "srvx/bun";
 import wsAdapter from "crossws/adapters/bun";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "nitro/~internal/runtime/task";
+import { trapUnhandledErrors } from "nitro/~internal/runtime/error/hooks";
+import { resolveWebsocketHooks } from "nitro/~internal/runtime/app";
+import { hasWebSocket } from "#nitro-internal-virtual/feature-flags";
+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 = hasWebSocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+if (hasWebSocket) {
+	_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: hasWebSocket ? 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

@@ -3,11 +3,14 @@ import type * as CF from "@cloudflare/workers-types";
 import type { ExportedHandler } from "@cloudflare/workers-types";
 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 fetchHandler(cfReq: Request | CF.Request, env: unknown, context: CF.ExecutionContext | DurableObjectState, url: URL, nitroApp, ctxExt: any);
 export {};

package/dist/presets/cloudflare/runtime/_module-handler.mjs

@@ -1,93 +1,85 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { runCronTasks } from "nitro/runtime/internal";
+import { runCronTasks } from "nitro/~internal/runtime/task";
+import { useNitroApp, useNitroHooks } from "nitro/app";
 export function createHandler(hooks) {
-  const nitroApp = useNitroApp();
-  return {
-    async fetch(request, env, context) {
-      const ctxExt = {};
-      const url = new URL(request.url);
-      if (hooks.fetch) {
-        const res = await hooks.fetch(request, env, context, url, ctxExt);
-        if (res) {
-          return res;
-        }
-      }
-      return fetchHandler(request, env, context, url, nitroApp, ctxExt);
-    },
-    scheduled(controller, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:scheduled", {
-          controller,
-          env,
-          context
-        })
-      );
-      if (import.meta._tasks) {
-        context.waitUntil(
-          runCronTasks(controller.cron, {
-            context: {
-              cloudflare: {
-                env,
-                context
-              }
-            },
-            payload: {}
-          })
-        );
-      }
-    },
-    email(message, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:email", {
-          message,
-          event: message,
-          // backward compat
-          env,
-          context
-        })
-      );
-    },
-    queue(batch, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:queue", {
-          batch,
-          event: batch,
-          env,
-          context
-        })
-      );
-    },
-    tail(traces, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:tail", {
-          traces,
-          env,
-          context
-        })
-      );
-    },
-    trace(traces, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:trace", {
-          traces,
-          env,
-          context
-        })
-      );
-    }
-  };
+	const nitroApp = useNitroApp();
+	const nitroHooks = useNitroHooks();
+	return {
+		async fetch(request, env, context) {
+			const ctxExt = {};
+			const url = new URL(request.url);
+			// Preset-specific logic
+			if (hooks.fetch) {
+				const res = await hooks.fetch(request, env, context, url, ctxExt);
+				if (res) {
+					return res;
+				}
+			}
+			return fetchHandler(request, env, context, url, nitroApp, ctxExt);
+		},
+		scheduled(controller, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:scheduled", {
+				controller,
+				env,
+				context
+			}));
+			if (import.meta._tasks) {
+				context.waitUntil(runCronTasks(controller.cron, {
+					context: { cloudflare: {
+						env,
+						context
+					} },
+					payload: {}
+				}));
+			}
+		},
+		email(message, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:email", {
+				message,
+				event: message,
+				env,
+				context
+			}));
+		},
+		queue(batch, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:queue", {
+				batch,
+				event: batch,
+				env,
+				context
+			}));
+		},
+		tail(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:tail", {
+				traces,
+				env,
+				context
+			}));
+		},
+		trace(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:trace", {
+				traces,
+				env,
+				context
+			}));
+		}
+	};
 }
 export async function fetchHandler(cfReq, env, context, url = new URL(cfReq.url), nitroApp = useNitroApp(), ctxExt) {
-  globalThis.__env__ = env;
-  const req = cfReq;
-  req.runtime ??= { name: "cloudflare" };
-  req.runtime.cloudflare ??= { context, env };
-  req.waitUntil = context.waitUntil.bind(context);
-  return nitroApp.fetch(req);
+	// Expose latest env to the global context
+	globalThis.__env__ = env;
+	// srvx compatibility
+	const req = cfReq;
+	req.runtime ??= { name: "cloudflare" };
+	req.runtime.cloudflare ??= {
+		context,
+		env
+	};
+	req.waitUntil = context.waitUntil.bind(context);
+	return nitroApp.fetch(req);
 }

package/dist/presets/cloudflare/runtime/cloudflare-durable.d.mts

@@ -1,19 +1,11 @@
 import "#nitro-internal-pollyfills";
-import type * as CF from "@cloudflare/workers-types";
 import { DurableObject } from "cloudflare:workers";
-declare const DURABLE_BINDING = "$DurableObject";
-interface Env {
-    ASSETS?: {
-        fetch: typeof CF.fetch;
-    };
-    [DURABLE_BINDING]?: CF.DurableObjectNamespace;
-}
-declare const _default: CF.ExportedHandler<Env, unknown, unknown>;
+declare const _default;
 export default _default;
 export declare class $DurableObject extends DurableObject {
-    constructor(state: DurableObjectState, env: Record<string, any>);
-    fetch(request: Request): Promise<Response>;
-    alarm(): void | Promise<void>;
-    webSocketMessage(client: WebSocket, message: ArrayBuffer | string): Promise<void>;
-    webSocketClose(client: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
+	constructor(state: DurableObjectState, env: Record<string, any>);
+	fetch(request: Request);
+	alarm(): void | Promise<void>;
+	webSocketMessage(client: WebSocket, message: ArrayBuffer | string);
+	webSocketClose(client: WebSocket, code: number, reason: string, wasClean: boolean);
 }

package/dist/presets/cloudflare/runtime/cloudflare-durable.mjs

@@ -1,74 +1,71 @@
 import "#nitro-internal-pollyfills";
 import { DurableObject } from "cloudflare:workers";
 import wsAdapter from "crossws/adapters/cloudflare";
-import { useNitroApp } from "nitro/runtime";
-import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 import { createHandler, fetchHandler } from "./_module-handler.mjs";
+import { useNitroApp, useNitroHooks } from "nitro/app";
+import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+import { resolveWebsocketHooks } from "nitro/~internal/runtime/app";
+import { hasWebSocket } from "#nitro-internal-virtual/feature-flags";
 const DURABLE_BINDING = "$DurableObject";
 const DURABLE_INSTANCE = "server";
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 const getDurableStub = (env) => {
-  const binding = env[DURABLE_BINDING];
-  if (!binding) {
-    throw new Error(
-      `Durable Object binding "${DURABLE_BINDING}" not available.`
-    );
-  }
-  const id = binding.idFromName(DURABLE_INSTANCE);
-  return binding.get(id);
+	const binding = env[DURABLE_BINDING];
+	if (!binding) {
+		throw new Error(`Durable Object binding "${DURABLE_BINDING}" not available.`);
+	}
+	const id = binding.idFromName(DURABLE_INSTANCE);
+	return binding.get(id);
 };
-const ws = import.meta._websocket ? wsAdapter({
-  // TODO!
-  // ...nitroApp.h3App.websocket,
-  instanceName: DURABLE_INSTANCE,
-  bindingName: DURABLE_BINDING
-}) : void 0;
-export default createHandler({
-  fetch(request, env, context, url, ctxExt) {
-    if (env.ASSETS && isPublicAssetURL(url.pathname)) {
-      return env.ASSETS.fetch(request);
-    }
-    ctxExt.durableFetch = (req = request) => getDurableStub(env).fetch(req);
-    if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
-      return ws.handleUpgrade(request, env, context);
-    }
-  }
-});
+const ws = hasWebSocket ? wsAdapter({
+	resolve: resolveWebsocketHooks,
+	instanceName: DURABLE_INSTANCE,
+	bindingName: DURABLE_BINDING
+}) : undefined;
+export default createHandler({ fetch(request, env, context, url, ctxExt) {
+	// Static assets fallback (optional binding)
+	if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+		return env.ASSETS.fetch(request);
+	}
+	// Expose stub fetch to the context
+	ctxExt.durableFetch = (req = request) => getDurableStub(env).fetch(req);
+	// Websocket upgrade
+	// https://crossws.unjs.io/adapters/cloudflare#durable-objects
+	if (hasWebSocket && request.headers.get("upgrade") === "websocket") {
+		return ws.handleUpgrade(request, env, context);
+	}
+} });
 export class $DurableObject extends DurableObject {
-  constructor(state, env) {
-    super(state, env);
-    state.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:durable:init", this, {
-        state,
-        env
-      })
-    );
-    if (import.meta._websocket) {
-      ws.handleDurableInit(this, state, env);
-    }
-  }
-  fetch(request) {
-    if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
-      return ws.handleDurableUpgrade(this, request);
-    }
-    const url = new URL(request.url);
-    return fetchHandler(request, this.env, this.ctx, url, nitroApp, {
-      durable: this
-    });
-  }
-  alarm() {
-    this.ctx.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:durable:alarm", this)
-    );
-  }
-  async webSocketMessage(client, message) {
-    if (import.meta._websocket) {
-      return ws.handleDurableMessage(this, client, message);
-    }
-  }
-  async webSocketClose(client, code, reason, wasClean) {
-    if (import.meta._websocket) {
-      return ws.handleDurableClose(this, client, code, reason, wasClean);
-    }
-  }
+	constructor(state, env) {
+		super(state, env);
+		state.waitUntil(nitroHooks.callHook("cloudflare:durable:init", this, {
+			state,
+			env
+		}));
+		if (hasWebSocket) {
+			ws.handleDurableInit(this, state, env);
+		}
+	}
+	fetch(request) {
+		if (hasWebSocket && request.headers.get("upgrade") === "websocket") {
+			return ws.handleDurableUpgrade(this, request);
+		}
+		// Main handler
+		const url = new URL(request.url);
+		return fetchHandler(request, this.env, this.ctx, url, nitroApp, { durable: this });
+	}
+	alarm() {
+		this.ctx.waitUntil(nitroHooks.callHook("cloudflare:durable:alarm", this));
+	}
+	async webSocketMessage(client, message) {
+		if (hasWebSocket) {
+			return ws.handleDurableMessage(this, client, message);
+		}
+	}
+	async webSocketClose(client, code, reason, wasClean) {
+		if (hasWebSocket) {
+			return ws.handleDurableClose(this, client, code, reason, wasClean);
+		}
+	}
 }

package/dist/presets/cloudflare/runtime/cloudflare-module.d.mts

@@ -1,9 +1,3 @@
 import "#nitro-internal-pollyfills";
-import type { fetch } from "@cloudflare/workers-types";
-interface Env {
-    ASSETS?: {
-        fetch: typeof fetch;
-    };
-}
-declare const _default: import("@cloudflare/workers-types").ExportedHandler<Env, unknown, unknown>;
+declare const _default;
 export default _default;

package/dist/presets/cloudflare/runtime/cloudflare-module.mjs

@@ -1,20 +1,18 @@
 import "#nitro-internal-pollyfills";
 import wsAdapter from "crossws/adapters/cloudflare";
-import { useNitroApp } from "nitro/runtime";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 import { createHandler } from "./_module-handler.mjs";
-const nitroApp = useNitroApp();
-const ws = import.meta._websocket ? (
-  // @ts-expect-error
-  wsAdapter(nitroApp.h3App.websocket)
-) : void 0;
-export default createHandler({
-  fetch(request, env, context, url) {
-    if (env.ASSETS && isPublicAssetURL(url.pathname)) {
-      return env.ASSETS.fetch(request);
-    }
-    if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
-      return ws.handleUpgrade(request, env, context);
-    }
-  }
-});
+import { resolveWebsocketHooks } from "nitro/~internal/runtime/app";
+import { hasWebSocket } from "#nitro-internal-virtual/feature-flags";
+const ws = hasWebSocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+export default createHandler({ fetch(request, env, context, url) {
+	// Static assets fallback (optional binding)
+	if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+		return env.ASSETS.fetch(request);
+	}
+	// Websocket upgrade
+	// https://crossws.unjs.io/adapters/cloudflare
+	if (hasWebSocket && request.headers.get("upgrade") === "websocket") {
+		return ws.handleUpgrade(request, env, context);
+	}
+} });

package/dist/presets/cloudflare/runtime/cloudflare-pages.d.mts

@@ -1,20 +1,20 @@
 import "#nitro-internal-pollyfills";
 import type { Request as CFRequest, EventContext, ExecutionContext } from "@cloudflare/workers-types";
 /**
- * Reference: https://developers.cloudflare.com/workers/runtime-apis/fetch-event/#parameters
- */
+* Reference: https://developers.cloudflare.com/workers/runtime-apis/fetch-event/#parameters
+*/
 interface CFPagesEnv {
-    ASSETS: {
-        fetch: (request: CFRequest) => Promise<Response>;
-    };
-    CF_PAGES: "1";
-    CF_PAGES_BRANCH: string;
-    CF_PAGES_COMMIT_SHA: string;
-    CF_PAGES_URL: string;
-    [key: string]: any;
+	ASSETS: {
+		fetch: (request: CFRequest) => Promise<Response>;
+	};
+	CF_PAGES: "1";
+	CF_PAGES_BRANCH: string;
+	CF_PAGES_COMMIT_SHA: string;
+	CF_PAGES_URL: string;
+	[key: string]: any;
 }
 declare const _default: {
-    fetch(cfReq: CFRequest, env: CFPagesEnv, context: EventContext<CFPagesEnv, string, any>): Promise<any>;
-    scheduled(event: any, env: CFPagesEnv, context: ExecutionContext): void;
+	fetch(cfReq: CFRequest, env: CFPagesEnv, context: EventContext<CFPagesEnv, string, any>);
+	scheduled(event: any, env: CFPagesEnv, context: ExecutionContext);
 };
 export default _default;