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

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

@@ -1,93 +1,87 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { runCronTasks } from "nitro/runtime/internal";
+import "#nitro/virtual/polyfills";
+import { runCronTasks } from "#nitro/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) {
+			globalThis.__env__ = env;
+			augmentReq(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 await nitroApp.fetch(request);
+		},
+		scheduled(controller, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:scheduled", {
+				controller,
+				env,
+				context
+			}) || Promise.resolve());
+			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
+			}) || Promise.resolve());
+		},
+		queue(batch, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:queue", {
+				batch,
+				event: batch,
+				env,
+				context
+			}) || Promise.resolve());
+		},
+		tail(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:tail", {
+				traces,
+				env,
+				context
+			}) || Promise.resolve());
+		},
+		trace(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:trace", {
+				traces,
+				env,
+				context
+			}) || Promise.resolve());
+		}
+	};
 }
-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);
+export function augmentReq(cfReq, ctx) {
+	const req = cfReq;
+	req.ip = cfReq.headers.get("cf-connecting-ip") || undefined;
+	req.runtime ??= { name: "cloudflare" };
+	req.runtime.cloudflare = {
+		...req.runtime.cloudflare,
+		...ctx
+	};
+	req.waitUntil = ctx.context?.waitUntil.bind(ctx.context);
 }

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 "#nitro/virtual/polyfills";
 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,72 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 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 { createHandler, augmentReq } from "./_module-handler.mjs";
+import { useNitroApp, useNitroHooks } from "nitro/app";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
 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);
-    }
-  }
-});
+	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 (import.meta._websocket && 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
+		}) || Promise.resolve());
+		if (import.meta._websocket) {
+			ws.handleDurableInit(this, state, env);
+		}
+	}
+	fetch(request) {
+		augmentReq(request, {
+			env: this.env,
+			context: this.ctx
+		});
+		if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+			return ws.handleDurableUpgrade(this, request);
+		}
+		return nitroApp.fetch(request);
+	}
+	alarm() {
+		this.ctx.waitUntil(nitroHooks.callHook("cloudflare:durable:alarm", this) || Promise.resolve());
+	}
+	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);
+		}
+	}
 }

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>;
+import "#nitro/virtual/polyfills";
+declare const _default;
 export default _default;

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

@@ -1,20 +1,17 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import wsAdapter from "crossws/adapters/cloudflare";
-import { useNitroApp } from "nitro/runtime";
-import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+import { isPublicAssetURL } from "#nitro/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/runtime/app";
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+export default createHandler({ fetch(cfRequest, env, context, url) {
+	// Static assets fallback (optional binding)
+	if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+		return env.ASSETS.fetch(cfRequest);
+	}
+	// Websocket upgrade
+	// https://crossws.unjs.io/adapters/cloudflare
+	if (import.meta._websocket && cfRequest.headers.get("upgrade") === "websocket") {
+		return ws.handleUpgrade(cfRequest, env, context);
+	}
+} });

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

@@ -1,20 +1,20 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 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;

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

@@ -1,47 +1,39 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { runCronTasks } from "nitro/runtime/internal";
-import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+import "#nitro/virtual/polyfills";
 import wsAdapter from "crossws/adapters/cloudflare";
+import { useNitroApp } from "nitro/app";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
+import { runCronTasks } from "#nitro/runtime/task";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+import { augmentReq } from "./_module-handler.mjs";
 const nitroApp = useNitroApp();
-const ws = import.meta._websocket ? (
-  // @ts-expect-error
-  wsAdapter(nitroApp.h3App.websocket)
-) : void 0;
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
 export default {
-  async fetch(cfReq, env, context) {
-    const req = cfReq;
-    req.runtime ??= { name: "cloudflare" };
-    req.runtime.cloudflare ??= { context, env };
-    req.waitUntil = context.waitUntil.bind(context);
-    if (import.meta._websocket && cfReq.headers.get("upgrade") === "websocket") {
-      return ws.handleUpgrade(
-        cfReq,
-        env,
-        context
-      );
-    }
-    const url = new URL(cfReq.url);
-    if (env.ASSETS && isPublicAssetURL(url.pathname)) {
-      return env.ASSETS.fetch(cfReq);
-    }
-    globalThis.__env__ = env;
-    return nitroApp.fetch(req);
-  },
-  scheduled(event, env, context) {
-    if (import.meta._tasks) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        runCronTasks(event.cron, {
-          context: {
-            cloudflare: {
-              env,
-              context
-            }
-          },
-          payload: {}
-        })
-      );
-    }
-  }
+	async fetch(cfReq, env, context) {
+		augmentReq(cfReq, {
+			env,
+			context
+		});
+		// Websocket upgrade
+		// https://crossws.unjs.io/adapters/cloudflare
+		if (import.meta._websocket && cfReq.headers.get("upgrade") === "websocket") {
+			return ws.handleUpgrade(cfReq, env, context);
+		}
+		const url = new URL(cfReq.url);
+		if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+			return env.ASSETS.fetch(cfReq);
+		}
+		return nitroApp.fetch(cfReq);
+	},
+	scheduled(event, env, context) {
+		if (import.meta._tasks) {
+			globalThis.__env__ = env;
+			context.waitUntil(runCronTasks(event.cron, {
+				context: { cloudflare: {
+					env,
+					context
+				} },
+				payload: {}
+			}));
+		}
+	}
 };

package/dist/presets/cloudflare/runtime/plugin.dev.d.mts

@@ -1,3 +1,3 @@
 import type { NitroAppPlugin } from "nitro/types";
-declare const _default: NitroAppPlugin;
-export default _default;
+declare const cloudflareDevPlugin: NitroAppPlugin;
+export default cloudflareDevPlugin;