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

package/dist/presets/cloudflare/runtime/plugin.dev.mjs

@@ -1,89 +1,96 @@
-const _proxy = _getPlatformProxy().catch((error) => {
-  console.error("Failed to initialize wrangler bindings proxy", error);
-  return _createStubProxy();
-}).then((proxy) => {
-  globalThis.__env__ = proxy.env;
-  return proxy;
-});
-globalThis.__env__ = _proxy.then((proxy) => proxy.env);
-export default (function(nitroApp) {
-  nitroApp.hooks.hook("request", async (event) => {
-    event.req.context ??= {};
-    const proxy = await _proxy;
-    event.req.context.cf = proxy.cf;
-    event.req.context.waitUntil = proxy.ctx.waitUntil.bind(proxy.ctx);
-    const request = new Request(event.req.url);
-    request.cf = proxy.cf;
-    event.req.context.cloudflare = {
-      ...event.req.context.cloudflare,
-      request,
-      env: proxy.env,
-      context: proxy.ctx
-    };
-  });
-  nitroApp.hooks._hooks.request.unshift(nitroApp.hooks._hooks.request.pop());
-  nitroApp.hooks.hook("close", () => {
-    return _proxy?.then((proxy) => proxy.dispose);
-  });
+import { useRuntimeConfig } from "nitro/runtime-config";
+const proxy = await _getPlatformProxy().catch((error) => {
+	console.error("Failed to initialize wrangler bindings proxy", error);
+	return _createStubProxy();
 });
+globalThis.__env__ = proxy.env;
+globalThis.__wait_until__ = proxy.ctx.waitUntil.bind(proxy.ctx);
+const cloudflareDevPlugin = function(nitroApp) {
+	nitroApp.hooks.hook("request", async (event) => {
+		event.req.context ??= {};
+		// Inject the various cf values from the proxy in event and event.context
+		event.req.context.cf = proxy.cf;
+		event.req.context.waitUntil = proxy.ctx.waitUntil.bind(proxy.ctx);
+		const request = event.req;
+		request.cf = proxy.cf;
+		event.req.context.cloudflare = {
+			...event.req.context.cloudflare,
+			request,
+			env: proxy.env,
+			context: proxy.ctx
+		};
+		// Replicate Nitro production behavior
+		// https://github.com/unjs/nitro/blob/main/src/runtime/entries/cloudflare-pages.ts#L55
+		// https://github.com/unjs/nitro/blob/main/src/runtime/app.ts#L120
+		// TODO: Update for v3
+		// (event.node.req as any).__unenv__ = {
+		//   ...(event.node.req as any).__unenv__,
+		//   waitUntil: event.context.waitUntil,
+		// };
+	});
+	// https://github.com/pi0/nitro-cloudflare-dev/issues/5
+	// https://github.com/unjs/hookable/issues/98
+	// @ts-expect-error
+	nitroApp.hooks._hooks.request.unshift(nitroApp.hooks._hooks.request.pop());
+	// Dispose proxy when Nitro is closed
+	nitroApp.hooks.hook("close", () => {
+		return proxy?.dispose();
+	});
+};
+export default cloudflareDevPlugin;
 async function _getPlatformProxy() {
-  const { useRuntimeConfig } = await import("nitro/runtime");
-  const pkg = "wrangler";
-  const { getPlatformProxy } = await import(
-    /* @vite-ignore */
-    pkg
-  ).catch(
-    () => {
-      throw new Error(
-        "Package `wrangler` not found, please install it with: `npx nypm@latest add -D wrangler`"
-      );
-    }
-  );
-  const runtimeConfig = useRuntimeConfig();
-  const proxyOptions = {
-    configPath: runtimeConfig.wrangler.configPath,
-    persist: { path: runtimeConfig.wrangler.persistDir }
-  };
-  if (runtimeConfig.wrangler.environment) {
-    proxyOptions.environment = runtimeConfig.wrangler.environment;
-  }
-  const proxy = await getPlatformProxy(proxyOptions);
-  return proxy;
+	const pkg = "wrangler";
+	const { getPlatformProxy } = await import(
+		/* @vite-ignore */
+		pkg
+).catch(() => {
+		throw new Error("Package `wrangler` not found, please install it with: `npx nypm@latest add -D wrangler`");
+	});
+	const runtimeConfig = useRuntimeConfig();
+	const proxyOptions = {
+		configPath: runtimeConfig.wrangler.configPath,
+		persist: { path: runtimeConfig.wrangler.persistDir }
+	};
+	// TODO: investigate why
+	// https://github.com/pi0/nitro-cloudflare-dev/issues/51
+	if (runtimeConfig.wrangler.environment) {
+		proxyOptions.environment = runtimeConfig.wrangler.environment;
+	}
+	const proxy = await getPlatformProxy(proxyOptions);
+	return proxy;
 }
 function _createStubProxy() {
-  return {
-    env: {},
-    cf: {},
-    ctx: {
-      waitUntil() {
-      },
-      passThroughOnException() {
-      },
-      props: {}
-    },
-    caches: {
-      open() {
-        const result = Promise.resolve(new _CacheStub());
-        return result;
-      },
-      get default() {
-        return new _CacheStub();
-      }
-    },
-    dispose: () => Promise.resolve()
-  };
+	return {
+		env: {},
+		cf: {},
+		ctx: {
+			waitUntil() {},
+			passThroughOnException() {},
+			props: {}
+		},
+		caches: {
+			open() {
+				const result = Promise.resolve(new _CacheStub());
+				return result;
+			},
+			get default() {
+				return new _CacheStub();
+			}
+		},
+		dispose: () => Promise.resolve()
+	};
 }
 class _CacheStub {
-  delete() {
-    const result = Promise.resolve(false);
-    return result;
-  }
-  match() {
-    const result = Promise.resolve(void 0);
-    return result;
-  }
-  put() {
-    const result = Promise.resolve();
-    return result;
-  }
+	delete() {
+		const result = Promise.resolve(false);
+		return result;
+	}
+	match() {
+		const result = Promise.resolve(undefined);
+		return result;
+	}
+	put() {
+		const result = Promise.resolve();
+		return result;
+	}
 }

package/dist/presets/cloudflare/runtime/shims/workers.dev.mjs

@@ -0,0 +1,27 @@
+// Shim for "cloudflare:workers" import in dev environment
+
+// unenv shim respects __env__
+export { env } from "unenv/node/internal/process/env";
+
+export async function waitUntil(promise) {
+  await globalThis.__wait_until__?.(promise);
+}
+
+export function withEnv(newEnv, fn) {
+  throw new Error("cf.withEnv is not implemented in dev env currently.");
+}
+
+class NotImplemented {
+  constructor() {
+    throw new Error("Not implemented in dev env currently.");
+  }
+}
+
+export class DurableObject extends NotImplemented {}
+export class RpcPromise extends NotImplemented {}
+export class RpcProperty extends NotImplemented {}
+export class RpcStub extends NotImplemented {}
+export class RpcTarget extends NotImplemented {}
+export class ServiceStub extends NotImplemented {}
+export class WorkerEntrypoint extends NotImplemented {}
+export class WorkflowEntrypoint extends NotImplemented {}

package/dist/presets/deno/runtime/deno-deploy.d.mts

@@ -1 +1,5 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
+import type { Deno as _Deno } from "@deno/types";
+declare global {
+	var Deno: typeof _Deno;
+}

package/dist/presets/deno/runtime/deno-deploy.mjs

@@ -1,17 +1,19 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
 import wsAdapter from "crossws/adapters/deno";
+import { useNitroApp } from "nitro/app";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
 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;
+// TODO: Migrate to srvx to provide request IP
 Deno.serve((denoReq, info) => {
-  const req = denoReq;
-  req.runtime ??= { name: "deno" };
-  req.runtime.deno ??= { info };
-  if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
-    return ws.handleUpgrade(req, info);
-  }
-  return nitroApp.fetch(req);
+	// srvx compatibility
+	const req = denoReq;
+	req.runtime ??= { name: "deno" };
+	req.runtime.deno ??= { info };
+	// TODO: Support remoteAddr
+	// https://crossws.unjs.io/adapters/deno
+	if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
+		return ws.handleUpgrade(req, info);
+	}
+	return nitroApp.fetch(req);
 });

package/dist/presets/deno/runtime/deno-server.d.mts

@@ -1,6 +1,3 @@
-import "#nitro-internal-pollyfills";
-declare global {
-    const Deno: typeof import("@deno/types").Deno;
-}
+import "#nitro/virtual/polyfills";
 declare const _default: {};
 export default _default;

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

@@ -1,59 +1,38 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { useRuntimeConfig } from "nitro/runtime";
-import { startScheduleRunner } from "nitro/runtime/internal";
+import "#nitro/virtual/polyfills";
+import { serve } from "srvx/deno";
 import wsAdapter from "crossws/adapters/deno";
-import destr from "destr";
+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();
-if (Deno.env.get("DEBUG")) {
-  addEventListener(
-    "unhandledrejection",
-    (event) => console.error("[unhandledRejection]", event.reason)
-  );
-  addEventListener(
-    "error",
-    (event) => console.error("[uncaughtException]", event.error)
-  );
-} else {
-  addEventListener(
-    "unhandledrejection",
-    (err) => console.error("[unhandledRejection] " + err)
-  );
-  addEventListener(
-    "error",
-    (event) => console.error("[uncaughtException] " + event.error)
-  );
-}
-const serveOptions = {
-  key: Deno.env.get("NITRO_SSL_KEY"),
-  cert: Deno.env.get("NITRO_SSL_CERT"),
-  port: destr(Deno.env.get("NITRO_PORT") || Deno.env.get("PORT")) || 3e3,
-  hostname: Deno.env.get("NITRO_HOST") || Deno.env.get("HOST"),
-  onListen: (opts) => {
-    const baseURL = (useRuntimeConfig().app.baseURL || "").replace(/\/$/, "");
-    const url = `${opts.hostname}:${opts.port}${baseURL}`;
-    console.log(`Listening ${url}`);
-  }
-};
-if (!serveOptions.key || !serveOptions.cert) {
-  delete serveOptions.key;
-  delete serveOptions.cert;
-}
-Deno.serve(serveOptions, handler);
-const ws = import.meta._websocket ? (
-  // @ts-expect-error
-  wsAdapter(nitroApp.h3App.websocket)
-) : void 0;
-async function handler(denoReq, info) {
-  const req = denoReq;
-  req.runtime ??= { name: "deno" };
-  req.runtime.deno ??= { info };
-  if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
-    return ws.handleUpgrade(req, info);
-  }
-  return nitroApp.fetch(req);
+let _fetch = nitroApp.fetch;
+if (import.meta._websocket) {
+	const { handleUpgrade } = wsAdapter({ resolve: resolveWebsocketHooks });
+	_fetch = (req) => {
+		if (req.headers.get("upgrade") === "websocket") {
+			return handleUpgrade(req, req.runtime.deno.info);
+		}
+		return nitroApp.fetch(req);
+	};
 }
+serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	fetch: _fetch
+});
+trapUnhandledErrors();
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }
 export default {};

package/dist/presets/netlify/runtime/netlify-edge.d.mts

@@ -1,3 +1,3 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import type { Context } from "@netlify/edge-functions";
-export default function netlifyEdge(netlifyReq: Request, context: Context): Promise<any>;
+export default function netlifyEdge(netlifyReq: Request, context: Context);

package/dist/presets/netlify/runtime/netlify-edge.mjs

@@ -1,17 +1,21 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
 const nitroApp = useNitroApp();
+// https://docs.netlify.com/edge-functions/api/
 export default async function netlifyEdge(netlifyReq, context) {
-  const req = netlifyReq;
-  req.runtime ??= { name: "netlify-edge" };
-  req.runtime.netlify ??= { context };
-  const url = new URL(req.url);
-  if (isPublicAssetURL(url.pathname)) {
-    return;
-  }
-  if (!req.headers.has("x-forwarded-proto") && url.protocol === "https:") {
-    req.headers.set("x-forwarded-proto", "https");
-  }
-  return nitroApp.fetch(req);
+	// srvx compatibility
+	const req = netlifyReq;
+	req.ip = context.ip;
+	req.runtime ??= { name: "netlify-edge" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.netlify ??= { context };
+	const url = new URL(req.url);
+	if (isPublicAssetURL(url.pathname)) {
+		return;
+	}
+	if (!req.headers.has("x-forwarded-proto") && url.protocol === "https:") {
+		req.headers.set("x-forwarded-proto", "https");
+	}
+	return nitroApp.fetch(req);
 }

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

@@ -1,3 +1,4 @@
-import "#nitro-internal-pollyfills";
-declare const handler: (req: Request) => Promise<Response>;
+import "#nitro/virtual/polyfills";
+import type { ServerRequest } from "srvx";
+declare const handler: (req: ServerRequest) => Promise<Response>;
 export default handler;

package/dist/presets/netlify/runtime/netlify.mjs

@@ -1,24 +1,20 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
 const nitroApp = useNitroApp();
 const ONE_YEAR_IN_SECONDS = 365 * 24 * 60 * 60;
 const handler = async (req) => {
-  const response = await nitroApp.fetch(req);
-  const isr = (req.context?.routeRules || {})?.isr?.options;
-  if (isr) {
-    const maxAge = typeof isr === "number" ? isr : ONE_YEAR_IN_SECONDS;
-    const revalidateDirective = typeof isr === "number" ? `stale-while-revalidate=${ONE_YEAR_IN_SECONDS}` : "must-revalidate";
-    if (!response.headers.has("Cache-Control")) {
-      response.headers.set(
-        "Cache-Control",
-        "public, max-age=0, must-revalidate"
-      );
-    }
-    response.headers.set(
-      "Netlify-CDN-Cache-Control",
-      `public, max-age=${maxAge}, ${revalidateDirective}, durable`
-    );
-  }
-  return response;
+	req.runtime ??= { name: "netlify" };
+	req.ip = req.headers.get("x-nf-client-connection-ip") || undefined;
+	const response = await nitroApp.fetch(req);
+	const isr = (req.context?.routeRules || {})?.isr?.options;
+	if (isr) {
+		const maxAge = typeof isr === "number" ? isr : ONE_YEAR_IN_SECONDS;
+		const revalidateDirective = typeof isr === "number" ? `stale-while-revalidate=${ONE_YEAR_IN_SECONDS}` : "must-revalidate";
+		if (!response.headers.has("Cache-Control")) {
+			response.headers.set("Cache-Control", "public, max-age=0, must-revalidate");
+		}
+		response.headers.set("Netlify-CDN-Cache-Control", `public, max-age=${maxAge}, ${revalidateDirective}, durable`);
+	}
+	return response;
 };
 export default handler;

package/dist/presets/node/runtime/node-cluster.d.mts

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

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

@@ -1,58 +1,53 @@
+import "#nitro/virtual/polyfills";
 import cluster from "node:cluster";
-import os from "node:os";
-import {
-  getGracefulShutdownConfig,
-  trapUnhandledNodeErrors
-} from "nitro/runtime/internal";
-function runMaster() {
-  const numberOfWorkers = Number.parseInt(process.env.NITRO_CLUSTER_WORKERS || "") || (os.cpus().length > 0 ? os.cpus().length : 1);
-  for (let i = 0; i < numberOfWorkers; i++) {
-    cluster.fork();
-  }
-  let isShuttingDown = false;
-  cluster.on("exit", () => {
-    if (!isShuttingDown) {
-      cluster.fork();
-    }
-  });
-  const shutdownConfig = getGracefulShutdownConfig();
-  if (!shutdownConfig.disabled) {
-    async function onShutdown() {
-      if (isShuttingDown) {
-        return;
-      }
-      isShuttingDown = true;
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          console.warn("Timeout reached for graceful shutdown. Forcing exit.");
-          resolve();
-        }, shutdownConfig.timeout);
-        cluster.on("exit", () => {
-          if (Object.values(cluster.workers || {}).every((w) => !w || w.isDead())) {
-            clearTimeout(timeout);
-            resolve();
-          } else {
-          }
-        });
-      });
-      if (shutdownConfig.forceExit) {
-        process.exit(0);
-      }
-    }
-    for (const signal of shutdownConfig.signals) {
-      process.once(signal, onShutdown);
-    }
-  }
+import { NodeRequest, serve } from "srvx/node";
+import wsAdapter from "crossws/adapters/node";
+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 clusterId = cluster.isWorker && process.env.WORKER_ID;
+if (clusterId) {
+	console.log(`Worker #${clusterId} started`);
 }
-function runWorker() {
-  import("./node-server.mjs").catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
+const nitroApp = useNitroApp();
+const server = serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	node: { exclusive: false },
+	silent: clusterId ? clusterId !== "1" : undefined,
+	fetch: nitroApp.fetch
+});
+if (import.meta._websocket) {
+	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
+				}
+			})
+		);
+	});
 }
-trapUnhandledNodeErrors();
-if (cluster.isPrimary) {
-  runMaster();
-} else {
-  runWorker();
+trapUnhandledErrors();
+// Scheduled tasks
+if (import.meta._tasks) {
+	startScheduleRunner();
 }
+export default {};

package/dist/presets/node/runtime/node-middleware.d.mts

@@ -1,4 +1,3 @@
-import "#nitro-internal-pollyfills";
-export declare const middleware: any;
-/** @experimental */
-export declare const websocket: undefined;
+import "#nitro/virtual/polyfills";
+export declare const middleware: unknown;
+export declare const handleUpgrade: unknown;

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

@@ -1,14 +1,14 @@
-import "#nitro-internal-pollyfills";
+import "#nitro/virtual/polyfills";
 import { toNodeHandler } from "srvx/node";
-import { useNitroApp } from "nitro/runtime";
-import {
-  startScheduleRunner,
-  trapUnhandledNodeErrors
-} from "nitro/runtime/internal";
+import wsAdapter from "crossws/adapters/node";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
 const nitroApp = useNitroApp();
 export const middleware = toNodeHandler(nitroApp.fetch);
-export const websocket = import.meta._websocket ? void 0 : void 0;
-trapUnhandledNodeErrors();
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+export const handleUpgrade = ws?.handleUpgrade;
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }

package/dist/presets/node/runtime/node-server.d.mts

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