nitro 3.0.1-alpha.1 → 3.0.260311-beta

package/dist/runtime/internal/vite/dev-worker.mjs

@@ -1,7 +1,28 @@
-import { parentPort, threadId, workerData } from "node:worker_threads";
-import { Agent } from "undici";
 import { ModuleRunner, ESModulesEvaluator } from "vite/module-runner";
-import { getSocketAddress, isSocketSupported } from "get-port-please";
+import { createViteTransport } from "env-runner/vite";
+
+// Custom evaluator for workerd where `new AsyncFunction()` is disallowed.
+// Uses the unsafeEvalBinding exposed by the env-runner miniflare wrapper.
+class WorkerdModuleEvaluator {
+  startOffset = 0;
+
+  async runInlinedModule(context, code) {
+    const unsafeEval = globalThis.__ENV_RUNNER_UNSAFE_EVAL__;
+    const keys = Object.keys(context);
+    const fn = unsafeEval.newAsyncFunction('"use strict";' + code, "runInlinedModule", ...keys);
+    await fn(...keys.map((k) => context[k]));
+    Object.seal(context[Object.keys(context)[0]]);
+  }
+
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+}
+
+// ----- IPC -----
+
+let sendMessage;
+const messageListeners = new Set();
 
 // ----- Environment runners -----
 
@@ -10,7 +31,7 @@ const envs = (globalThis.__nitro_vite_envs__ ??= {
   ssr: undefined,
 });
 
-class EnvRunner {
+class ViteEnvRunner {
   constructor({ name, entry }) {
     this.name = name;
     this.entryPath = entry;
@@ -20,26 +41,14 @@ class EnvRunner {
 
     // Create Vite Module Runner
     // https://vite.dev/guide/api-environment-runtimes.html#modulerunner
-    this.runnerHooks = {};
-    this.runner = new ModuleRunner(
-      {
-        transport: {
-          connect({ onMessage, onDisconnection }) {
-            parentPort.on("message", (payload) => {
-              if (payload?.type === "custom" && payload.viteEnv === name) {
-                onMessage(payload);
-              }
-            });
-            parentPort.on("close", onDisconnection);
-          },
-          send(payload) {
-            parentPort.postMessage({ ...payload, viteEnv: name });
-          },
-        },
-      },
-      new ESModulesEvaluator(),
-      process.env.DEBUG ? console.debug : undefined
-    );
+    const onMessage = (listener) => messageListeners.add(listener);
+    const transport = createViteTransport((data) => sendMessage?.(data), onMessage, name);
+    const evaluator = globalThis.__ENV_RUNNER_UNSAFE_EVAL__
+      ? new WorkerdModuleEvaluator()
+      : new ESModulesEvaluator();
+    const debug =
+      typeof process !== "undefined" && process.env?.NITRO_DEBUG ? console.debug : undefined;
+    this.runner = new ModuleRunner({ transport }, evaluator, debug);
 
     this.reload();
   }
@@ -70,10 +79,7 @@ class EnvRunner {
     try {
       const entryFetch = this.entry.fetch || this.entry.default?.fetch;
       if (!entryFetch) {
-        throw httpError(
-          500,
-          `No fetch handler exported from ${this.entryPath}`
-        );
+        throw httpError(500, `No fetch handler exported from ${this.entryPath}`);
       }
       return await entryFetch(req, init);
     } catch (error) {
@@ -82,84 +88,45 @@ class EnvRunner {
   }
 }
 
-// ----- RPC listeners -----
+// ----- RPC -----
 
-const viteHostRequests = new Map();
+const rpcRequests = new Map();
 
-async function requestToViteHost(
-  name,
-  data,
-  id = Math.random().toString(16).slice(2),
-  timeout = 3000
-) {
-  setTimeout(() => {
-    if (viteHostRequests.has(id)) {
-      viteHostRequests.delete(id);
-      reject(new Error(`Request to vite host timed out (${name}:${id})`));
-    }
-  }, timeout);
-  let resolve, reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = (value) => {
-      viteHostRequests.delete(id);
-      return _resolve(value);
-    };
-    reject = (err) => {
-      viteHostRequests.delete(id);
-      return _reject(err);
-    };
-  });
-  viteHostRequests.set(id, { resolve, reject });
-  parentPort.postMessage({
-    type: "custom",
-    event: "nitro:vite-invoke",
-    data: { name, id, data },
+function rpc(name, data, timeout = 3000) {
+  const id = Math.random().toString(36).slice(2);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      rpcRequests.delete(id);
+      reject(new Error(`RPC "${name}" timed out`));
+    }, timeout);
+    rpcRequests.set(id, { resolve, reject, timer });
+    sendMessage?.({ __rpc: name, __rpc_id: id, data });
   });
-  return promise;
 }
 
-parentPort.on("message", (payload) => {
-  if (payload?.type !== "custom") {
-    return;
-  }
-  switch (payload.event) {
-    case "nitro:vite-server-addr": {
-      viteServerAddr = payload.data;
-      break;
-    }
-    case "nitro:vite-env": {
-      const { name, entry } = payload.data;
-      if (envs[name]) {
-        console.error(`Vite environment "${name}" already registered!`);
-      } else {
-        envs[name] = new EnvRunner({ name, entry });
-      }
-      break;
-    }
-    case "nitro:vite-invoke-response": {
-      const { id, data: response } = payload.data;
-      const req = viteHostRequests.get(id);
-      if (req) {
-        if (response.error) {
-          req.reject(response.error);
-        } else {
-          req.resolve(response.data);
-        }
-      }
-      break;
-    }
+// Trap unhandled errors to avoid worker crash
+if (typeof process !== "undefined" && typeof process.on === "function") {
+  process.on("unhandledRejection", (error) => console.error(error));
+  process.on("uncaughtException", (error) => console.error(error));
+}
+
+// ----- RSC Support -----
+
+// define __VITE_ENVIRONMENT_RUNNER_IMPORT__ for RSC support
+// https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-rsc/README.md#__vite_environment_runner_import__
+
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async function (environmentName, id) {
+  const env = envs[environmentName];
+  if (!env) {
+    throw new Error(`Vite environment "${environmentName}" is not registered`);
   }
-});
+  return env.runner.import(id);
+};
 
-// ----- Server -----
+// ----- Reload -----
 
 async function reload() {
   try {
-    // Apply globals
-    for (const [key, value] of Object.entries(workerData.globals || {})) {
-      globalThis[key] = value;
-    }
-    // Reload all envs
     await Promise.all(Object.values(envs).map((env) => env?.reload()));
   } catch (error) {
     console.error(error);
@@ -169,55 +136,72 @@ async function reload() {
 // eslint-disable-next-line unicorn/prefer-top-level-await
 reload();
 
-if (workerData.server) {
-  const { createServer } = await import("node:http");
-  const { toNodeHandler } = await import("srvx/node");
-  const server = createServer(
-    toNodeHandler(async (req, init) => {
-      const viteEnv =
-        init?.viteEnv || req?.headers.get("x-vite-env") || "nitro"; // TODO
-      const env = envs[viteEnv];
-      if (!env) {
-        return renderError(
-          req,
-          httpError(500, `Unknown vite environment "${viteEnv}"`)
-        );
-      }
-      return env.fetch(req, init);
-    })
-  );
-
-  server.on("upgrade", (req, socket, head) => {
-    const handleUpgrade = envs["nitro"]?.entry?.handleUpgrade;
-    handleUpgrade?.(req, socket, head);
-  });
-
-  parentPort.on("message", async (message) => {
-    if (message?.type === "full-reload") {
-      await reload();
-    }
-  });
-  await listen(server);
-  const address = server.address();
-  parentPort?.postMessage({
-    event: "listen",
-    address:
-      typeof address === "string"
-        ? { socketPath: address }
-        : { host: "localhost", port: address?.port },
-  });
-}
-
 // ----- HTML Transform -----
 
 globalThis.__transform_html__ = async function (html) {
-  html = await requestToViteHost("transformHTML", html).catch((error) => {
+  html = await rpc("transformHTML", html).catch((error) => {
     console.warn("Failed to transform HTML via Vite:", error);
     return html;
   });
   return html;
 };
 
+// ----- Exports (env-runner AppEntry) -----
+
+export function fetch(req) {
+  const viteEnv = req?.headers.get("x-vite-env") || "nitro";
+  const env = envs[viteEnv];
+  if (!env) {
+    return renderError(req, httpError(500, `Unknown vite environment "${viteEnv}"`));
+  }
+  return env.fetch(req);
+}
+
+export function upgrade(context) {
+  const handleUpgrade = envs.nitro?.entry?.handleUpgrade;
+  if (handleUpgrade) {
+    handleUpgrade(context.node.req, context.node.socket, context.node.head);
+  }
+}
+
+export const ipc = {
+  onOpen(ctx) {
+    sendMessage = ctx.sendMessage;
+  },
+  onMessage(message) {
+    if (message?.__rpc_id) {
+      const req = rpcRequests.get(message.__rpc_id);
+      if (req) {
+        clearTimeout(req.timer);
+        rpcRequests.delete(message.__rpc_id);
+        if (message.error) {
+          req.reject(typeof message.error === "string" ? new Error(message.error) : message.error);
+        } else {
+          req.resolve(message.data);
+        }
+      }
+      return;
+    }
+    if (message?.type === "custom") {
+      if (message.event === "nitro:vite-env") {
+        const { name, entry } = message.data;
+        if (!envs[name]) {
+          envs[name] = new ViteEnvRunner({ name, entry });
+        }
+        return;
+      }
+    }
+    if (message?.type === "full-reload") {
+      reload();
+      return;
+    }
+    for (const listener of messageListeners) {
+      listener(message);
+    }
+  },
+  onClose() {},
+};
+
 // ----- Error handling -----
 
 function httpError(status, message) {
@@ -228,87 +212,53 @@ function httpError(status, message) {
 }
 
 async function renderError(req, error) {
-  const { Youch } = await import("youch");
-  const youch = new Youch();
-  return new Response(await youch.toHTML(error), {
-    status: error.status || 500,
-    headers: {
-      "Content-Type": "text/html",
-      "Cache-Control": "no-store, max-age=0, must-revalidate",
-      Pragma: "no-cache",
-      Expires: "0",
-    },
-  });
-}
-
-// ----- Internal Utils -----
-
-async function listen(server) {
-  const listenAddr = (await isSocketSupported())
-    ? getSocketAddress({
-        name: `nitro-vite-${threadId}`,
-        pid: true,
-        random: true,
-      })
-    : { port: 0, host: "localhost" };
-  return new Promise((resolve, reject) => {
-    try {
-      server.listen(listenAddr, () => resolve());
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-
-function fetchAddress(addr, input, inputInit) {
-  let url;
-  let init;
-  if (input instanceof Request) {
-    url = new URL(input.url);
-    init = {
-      method: input.method,
-      headers: input.headers,
-      body: input.body,
-      ...inputInit,
-    };
-  } else {
-    url = new URL(input);
-    init = inputInit;
+  if (req.headers.get("accept")?.includes("application/json")) {
+    return new Response(
+      JSON.stringify(
+        {
+          status: error.status || 500,
+          name: error.name || "Error",
+          message: error.message,
+          stack: (error.stack || "")
+            .split("\n")
+            .splice(1)
+            .map((l) => l.trim()),
+        },
+        null,
+        2
+      ),
+      {
+        status: error.status || 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store, max-age=0, must-revalidate",
+          Pragma: "no-cache",
+          Expires: "0",
+        },
+      }
+    );
   }
-  init = {
-    duplex: "half",
-    redirect: "manual",
-    ...init,
-  };
-  if (addr.socketPath) {
-    url.protocol = "http:";
-    return fetch(url, {
-      ...init,
-      ...fetchSocketOptions(addr.socketPath),
+  try {
+    const { Youch } = await import("youch");
+    const youch = new Youch();
+    return new Response(await youch.toHTML(error), {
+      status: error.status || 500,
+      headers: {
+        "Content-Type": "text/html",
+        "Cache-Control": "no-store, max-age=0, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
+    });
+  } catch {
+    return new Response(`<pre>${error.stack || error.message || error}</pre>`, {
+      status: error.status || 500,
+      headers: {
+        "Content-Type": "text/html",
+        "Cache-Control": "no-store, max-age=0, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
     });
   }
-  const origin = `http://${addr.host}${addr.port ? `:${addr.port}` : ""}`;
-  const outURL = new URL(url.pathname + url.search, origin);
-  return fetch(outURL, init);
-}
-
-function fetchSocketOptions(socketPath) {
-  if ("Bun" in globalThis) {
-    // https://bun.sh/guides/http/fetch-unix
-    return { unix: socketPath };
-  }
-  if ("Deno" in globalThis) {
-    // https://github.com/denoland/deno/pull/29154
-    return {
-      client: Deno.createHttpClient({
-        // @ts-expect-error Missing types?
-        transport: "unix",
-        path: socketPath,
-      }),
-    };
-  }
-  // https://github.com/nodejs/undici/issues/2970
-  return {
-    dispatcher: new Agent({ connect: { socketPath } }),
-  };
 }

package/dist/runtime/meta.d.mts

@@ -1,5 +1,5 @@
 export declare const version: string;
-export declare const pkgDir: string;
 export declare const runtimeDir: string;
 export declare const presetsDir: string;
+export declare const pkgDir: string;
 export declare const runtimeDependencies: string[];

package/dist/runtime/meta.mjs

@@ -2,9 +2,9 @@ import { fileURLToPath } from "node:url";
 import packageJson from "../../package.json" with { type: "json" };
 export const version = packageJson.version;
 const resolve = (path) => fileURLToPath(new URL(path, import.meta.url));
-export const pkgDir = /* @__PURE__ */ resolve("../../");
 export const runtimeDir = /* @__PURE__ */ resolve("./");
 export const presetsDir = /* @__PURE__ */ resolve("../presets/");
+export const pkgDir = /* @__PURE__ */ resolve("../../");
 export const runtimeDependencies = [
 	"crossws",
 	"croner",
@@ -15,6 +15,7 @@ export const runtimeDependencies = [
 	"rou3",
 	"hookable",
 	"ofetch",
+	"ocache",
 	"ohash",
 	"rendu",
 	"scule",

package/dist/runtime/nitro.d.mts

@@ -1,12 +1,11 @@
-// Config
 import type { NitroConfig } from "nitro/types";
 import type { ServerRequestContext } from "srvx";
 import { type H3EventContext } from "h3";
 export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit<NitroConfig, "rootDir">;
-// Type (only) helpers
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
-// Runtime
+export { defineHandler, defineMiddleware, defineWebSocketHandler, html, HTTPError, HTTPResponse } from "h3";
+export type { H3Event } from "h3";
 export declare function serverFetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
 export declare function fetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;

package/dist/runtime/nitro.mjs

@@ -6,9 +6,11 @@ export function defineConfig(config) {
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
+// H3
+export { defineHandler, defineMiddleware, defineWebSocketHandler, html, HTTPError, HTTPResponse } from "h3";
 // Runtime
 export function serverFetch(resource, init, context) {
-	const nitro = globalThis.__nitro__ || globalThis.__nitro_builder__;
+	const nitro = globalThis.__nitro__?.default || globalThis.__nitro__?.prerender || globalThis.__nitro_builder__;
 	if (!nitro) {
 		return Promise.reject(new Error("Nitro instance is not available."));
 	}

package/dist/runtime/virtual/_runtime_warn.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/virtual/_runtime_warn.mjs

@@ -0,0 +1,5 @@
+import consola from "consola";
+import { isTest } from "std-env";
+if (!isTest) {
+	consola.warn("Nitro runtime imports detected without a builder or Nitro plugin. A stub implementation will be used.");
+}

package/dist/runtime/virtual/database.d.mts

@@ -0,0 +1,8 @@
+import "./_runtime_warn.mjs";
+import type { Connector } from "db0";
+export declare const connectionConfigs: {
+	[name: string]: {
+		connector: (options: any) => Connector;
+		options: any;
+	};
+};

package/dist/runtime/virtual/database.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export const connectionConfigs = {};

package/dist/runtime/virtual/error-handler.d.mts

@@ -0,0 +1,6 @@
+import "./_runtime_warn.mjs";
+import type { NitroErrorHandler } from "nitro/types";
+type EParams = Parameters<NitroErrorHandler>;
+type EReturn = ReturnType<NitroErrorHandler>;
+declare const errorHandler: (error: EParams[0], event: EParams[1]) => EReturn;
+export default errorHandler;

package/dist/runtime/virtual/error-handler.mjs

@@ -0,0 +1,9 @@
+import "./_runtime_warn.mjs";
+import { H3Event, toResponse } from "h3";
+const errorHandler = (error, event) => {
+	if (error.status !== 404) {
+		console.error(error);
+	}
+	return toResponse(error, event);
+};
+export default errorHandler;

package/dist/runtime/virtual/feature-flags.d.mts

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+export declare const hasRoutes: boolean;
+export declare const hasRouteRules: boolean;
+export declare const hasGlobalMiddleware: boolean;
+export declare const hasRoutedMiddleware: boolean;
+export declare const hasPlugins: boolean;
+export declare const hasHooks: boolean;

package/dist/runtime/virtual/feature-flags.mjs

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+export const hasRoutes = true;
+export const hasRouteRules = true;
+export const hasGlobalMiddleware = true;
+export const hasRoutedMiddleware = true;
+export const hasPlugins = true;
+export const hasHooks = true;

package/dist/runtime/virtual/plugins.d.mts

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+import type { NitroAppPlugin } from "nitro/types";
+export declare const plugins: NitroAppPlugin[];

package/dist/runtime/virtual/plugins.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export const plugins = [];

package/dist/{presets/_nitro/runtime/nitro-prerenderer.d.mts → runtime/virtual/polyfills.d.mts}

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

package/dist/runtime/virtual/polyfills.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export default {};

package/dist/runtime/virtual/public-assets.d.mts

@@ -0,0 +1,9 @@
+import "./_runtime_warn.mjs";
+import type { PublicAsset } from "nitro/types";
+export declare const publicAssetBases: string[];
+export declare const isPublicAssetURL: (id: string) => boolean;
+export declare const getPublicAssetMeta: (id: string) => {
+	maxAge?: number;
+} | null;
+export declare const readAsset: (id: string) => Promise<Buffer>;
+export declare const getAsset: (id: string) => PublicAsset | null;

package/dist/runtime/virtual/public-assets.mjs

@@ -0,0 +1,8 @@
+import "./_runtime_warn.mjs";
+export const publicAssetBases = [];
+export const isPublicAssetURL = () => false;
+export const getPublicAssetMeta = () => null;
+export const readAsset = async () => {
+	throw new Error("Asset not found");
+};
+export const getAsset = () => null;

package/dist/runtime/virtual/renderer-template.d.mts

@@ -0,0 +1,4 @@
+import "./_runtime_warn.mjs";
+export declare function rendererTemplate(_req: Request): string | Promise<string>;
+export declare const rendererTemplateFile: string | undefined;
+export declare const isStaticTemplate: boolean | undefined;

package/dist/runtime/virtual/renderer-template.mjs

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+export function rendererTemplate(_req) {
+	return `<!-- Renderer template not available -->`;
+}
+// dev only
+export const rendererTemplateFile = undefined;
+export const isStaticTemplate = undefined;

package/dist/runtime/virtual/routing-meta.d.mts

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+import type { NitroRouteMeta } from "nitro/types";
+export declare const handlersMeta: {
+	route?: string;
+	method?: string;
+	meta?: NitroRouteMeta;
+}[];

package/dist/runtime/virtual/routing-meta.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export const handlersMeta = [];

package/dist/runtime/virtual/routing.d.mts

@@ -0,0 +1,8 @@
+import "./_runtime_warn.mjs";
+import type { Middleware, H3Route } from "h3";
+import type { MatchedRoute } from "rou3";
+import type { MatchedRouteRule } from "nitro/types";
+export declare function findRoute(_method: string, _path: string): MatchedRoute<H3Route> | undefined;
+export declare function findRouteRules(_method: string, _path: string): MatchedRoute<MatchedRouteRule[]>[];
+export declare const globalMiddleware: Middleware[];
+export declare function findRoutedMiddleware(_method: string, _path: string): MatchedRoute<Middleware>[];

package/dist/runtime/virtual/routing.mjs

@@ -0,0 +1,11 @@
+import "./_runtime_warn.mjs";
+export function findRoute(_method, _path) {
+	return undefined;
+}
+export function findRouteRules(_method, _path) {
+	return [];
+}
+export const globalMiddleware = [];
+export function findRoutedMiddleware(_method, _path) {
+	return [];
+}

package/dist/runtime/virtual/runtime-config.d.mts

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+import type { NitroRuntimeConfig } from "nitro/types";
+export declare const runtimeConfig: NitroRuntimeConfig;

package/dist/runtime/virtual/runtime-config.mjs

@@ -0,0 +1,5 @@
+import "./_runtime_warn.mjs";
+export const runtimeConfig = {
+	app: {},
+	nitro: {}
+};