nitro-nightly 3.0.0-beta-28969273.f7aa9de6 → 4.0.0-20251010-091516-7cafddba

package/dist/runtime/internal/utils.mjs

@@ -1,61 +1,6 @@
-import { getRequestHeader, splitCookiesString } from "h3";
 import { useNitroApp } from "./app.mjs";
-const METHOD_WITH_BODY_RE = /post|put|patch/i;
-const TEXT_MIME_RE = /application\/text|text\/html/;
-const JSON_MIME_RE = /application\/json/;
-export function requestHasBody(request) {
-  return METHOD_WITH_BODY_RE.test(request.method);
-}
-export async function useRequestBody(request) {
-  const contentType = request.headers.get("content-type") || "";
-  if (contentType.includes("form")) {
-    const formData = await request.formData();
-    const body = /* @__PURE__ */ Object.create(null);
-    for (const entry of formData.entries()) {
-      body[entry[0]] = entry[1];
-    }
-    return body;
-  }
-  if (JSON_MIME_RE.test(contentType)) {
-    return request.json();
-  }
-  if (TEXT_MIME_RE.test(contentType)) {
-    return request.text();
-  }
-  const blob = await request.blob();
-  return URL.createObjectURL(blob);
-}
-export function hasReqHeader(event, name, includes) {
-  const value = getRequestHeader(event, name);
-  return value && typeof value === "string" && value.toLowerCase().includes(includes);
-}
-export function isJsonRequest(event) {
-  if (hasReqHeader(event, "accept", "text/html")) {
-    return false;
-  }
-  return hasReqHeader(event, "accept", "application/json") || hasReqHeader(event, "user-agent", "curl/") || hasReqHeader(event, "user-agent", "httpie/") || hasReqHeader(event, "sec-fetch-mode", "cors") || event.path.startsWith("/api/") || event.path.endsWith(".json");
-}
-export function normalizeError(error, isDev) {
-  const cwd = typeof process.cwd === "function" ? process.cwd() : "/";
-  const stack = !isDev && (error.unhandled || error.fatal) ? [] : (error.stack || "").split("\n").splice(1).filter((line) => line.includes("at ")).map((line) => {
-    const text = line.replace(cwd + "/", "./").replace("webpack:/", "").replace("file://", "").trim();
-    return {
-      text,
-      internal: line.includes("node_modules") && !line.includes(".cache") || line.includes("internal") || line.includes("new Promise")
-    };
-  });
-  const statusCode = error.statusCode || 500;
-  const statusMessage = error.statusMessage ?? (statusCode === 404 ? "Not Found" : "");
-  const message = !isDev && error.unhandled ? "internal server error" : error.message || error.toString();
-  return {
-    stack,
-    statusCode,
-    statusMessage,
-    message
-  };
-}
 function _captureError(error, type) {
-  console.error(`[nitro] [${type}]`, error);
+  console.error(`[${type}]`, error);
   useNitroApp().captureError(error, { tags: [type] });
 }
 export function trapUnhandledNodeErrors() {
@@ -68,63 +13,3 @@ export function trapUnhandledNodeErrors() {
     (error) => _captureError(error, "uncaughtException")
   );
 }
-export function joinHeaders(value) {
-  return Array.isArray(value) ? value.join(", ") : String(value);
-}
-export function normalizeFetchResponse(response) {
-  if (!response.headers.has("set-cookie")) {
-    return response;
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: normalizeCookieHeaders(response.headers)
-  });
-}
-export function normalizeCookieHeader(header = "") {
-  return splitCookiesString(joinHeaders(header));
-}
-export function normalizeCookieHeaders(headers) {
-  const outgoingHeaders = new Headers();
-  for (const [name, header] of headers) {
-    if (name === "set-cookie") {
-      for (const cookie of normalizeCookieHeader(header)) {
-        outgoingHeaders.append("set-cookie", cookie);
-      }
-    } else {
-      outgoingHeaders.set(name, joinHeaders(header));
-    }
-  }
-  return outgoingHeaders;
-}
-export function toBuffer(data) {
-  if ("pipeTo" in data && typeof data.pipeTo === "function") {
-    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);
-    });
-  }
-  if ("pipe" in data && typeof data.pipe === "function") {
-    return new Promise((resolve, reject) => {
-      const chunks = [];
-      data.on("data", (chunk) => {
-        chunks.push(chunk);
-      }).on("end", () => {
-        resolve(Buffer.concat(chunks));
-      }).on("error", reject);
-    });
-  }
-  return Buffer.from(data);
-}

package/dist/runtime/internal/vite/dev-entry.d.mts

@@ -0,0 +1 @@
+export const fetch: any;

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

@@ -0,0 +1,6 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+
+const nitroApp = useNitroApp();
+
+export const fetch = nitroApp.fetch;

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

@@ -0,0 +1,362 @@
+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";
+
+// ----- Environment runners -----
+
+const envs = { nitro: undefined, ssr: undefined };
+
+globalThis.__nitro_vite_envs__ = envs;
+
+class EnvRunner {
+  constructor({ name, entry }) {
+    this.name = name;
+    this.entryPath = entry;
+
+    this.entry = undefined;
+    this.entryError = undefined;
+
+    // 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
+    );
+
+    this.reload();
+  }
+
+  async reload() {
+    try {
+      this.entry = await this.runner.import(this.entryPath);
+      this.entryError = undefined;
+    } catch (error) {
+      console.error(error);
+      this.entryError = error;
+    }
+  }
+
+  async fetch(req, init) {
+    if (this.entryError) {
+      return renderError(req, this.entryError);
+    }
+    for (let i = 0; i < 5 && !(this.entry || this.entryError); i++) {
+      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
+    }
+    if (this.entryError) {
+      return renderError(req, this.entryError);
+    }
+    if (!this.entry) {
+      throw httpError(503, `Vite environment "${this.name}" is unavailable`);
+    }
+    try {
+      const entryFetch = this.entry.fetch || this.entry.default?.fetch;
+      if (!entryFetch) {
+        throw httpError(
+          500,
+          `No fetch handler exported from ${this.entryPath}`
+        );
+      }
+      return await entryFetch(req, init);
+    } catch (error) {
+      return renderError(req, error);
+    }
+  }
+}
+
+// ----- RPC listeners -----
+
+const viteHostRequests = 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 },
+  });
+  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;
+    }
+  }
+});
+
+// ----- Fetch Handler -----
+
+const originalFetch = globalThis.fetch;
+globalThis.fetch = function nitroViteFetch(input, init) {
+  // Only override if viteEnvName is specified
+  const viteEnvName = getViteEnv(init) || getViteEnv(input);
+  if (!viteEnvName) {
+    return originalFetch(input, init);
+  }
+
+  // Validate viteEnv
+  const viteEnv = envs[viteEnvName];
+  if (!viteEnv) {
+    throw httpError(404, `Unknown vite environment "${viteEnvName}"`);
+  }
+
+  // Normalize input (relative urls)
+  if (typeof input === "string" && input[0] === "/") {
+    input = new URL(input, "http://localhost");
+  }
+
+  // Clone headers and set viteEnv header
+  const headers = new Headers(init?.headers || {});
+  headers.set("x-vite-env", viteEnvName);
+
+  // Normalize to Request
+  if (
+    !(input instanceof Request) ||
+    (init && Object.keys(init).join("") !== "viteEnv")
+  ) {
+    input = new Request(input, init);
+  }
+
+  // Fetch via vite env
+  return viteEnv.fetch(input);
+};
+
+function getViteEnv(input) {
+  if (!input || typeof input !== "object") {
+    return;
+  }
+  if ("viteEnv" in input) {
+    return input.viteEnv;
+  }
+  if (input.headers) {
+    return (
+      input.headers["x-vite-env"] ||
+      input.headers.get?.("x-vite-env") ||
+      (Array.isArray(input.headers) &&
+        input.headers.find((h) => h[0].toLowerCase() === "x-vite-env")?.[1])
+    );
+  }
+}
+
+// ----- Server -----
+
+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);
+  }
+}
+
+// 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);
+    })
+  );
+
+  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) => {
+    console.warn("Failed to transform HTML via Vite:", error);
+    return html;
+  });
+  return html;
+};
+
+// ----- Error handling -----
+
+function httpError(status, message) {
+  const error = new Error(message || `HTTP Error ${status}`);
+  error.status = status;
+  error.name = "NitroViteError";
+  return error;
+}
+
+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;
+  }
+  init = {
+    duplex: "half",
+    redirect: "manual",
+    ...init,
+  };
+  if (addr.socketPath) {
+    url.protocol = "http:";
+    return fetch(url, {
+      ...init,
+      ...fetchSocketOptions(addr.socketPath),
+    });
+  }
+  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/internal/vite/prod-setup.d.mts

@@ -0,0 +1,4 @@
+export function setupVite({ manifest, services }: {
+    manifest: any;
+    services: any;
+}): void;

package/dist/runtime/internal/vite/prod-setup.mjs

@@ -0,0 +1,55 @@
+export function setupVite({ manifest, services }) {
+  globalThis.__VITE_MANIFEST__ = manifest;
+
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = function nitroViteFetch(input, init) {
+    // Only override if viteEnvName is specified
+    const viteEnvName = getViteEnv(init) || getViteEnv(input);
+    if (!viteEnvName) {
+      return originalFetch(input, init);
+    }
+
+    // Validate viteEnv
+    const viteEnv = services[viteEnvName];
+    if (!viteEnv) {
+      throw httpError(404);
+    }
+
+    // Normalize input (relative urls)
+    if (typeof input === "string" && input[0] === "/") {
+      input = new URL(input, "http://localhost");
+    }
+
+    // Clone headers and set viteEnv header
+    const headers = new Headers(init?.headers || {});
+    headers.set("x-vite-env", viteEnvName);
+
+    // Normalize to Request
+    if (
+      !(input instanceof Request) ||
+      (init && Object.keys(init).join("") !== "viteEnv")
+    ) {
+      input = new Request(input, init);
+    }
+
+    // Fetch via vite env
+    return viteEnv.fetch(input);
+  };
+}
+
+function getViteEnv(input) {
+  if (!input || typeof input !== "object") {
+    return;
+  }
+  if ("viteEnv" in input) {
+    return input.viteEnv;
+  }
+  if (input.headers) {
+    return (
+      input.headers["x-vite-env"] ||
+      input.headers.get?.("x-vite-env") ||
+      (Array.isArray(input.headers) &&
+        input.headers.find((h) => h[0].toLowerCase() === "x-vite-env")?.[1])
+    );
+  }
+}

package/dist/runtime/internal/vite/ssr-renderer.d.mts

@@ -0,0 +1,4 @@
+/** @param {{ req: Request }} HTTPEvent */
+export default function ssrRenderer({ req }: {
+    req: Request;
+}): Promise<Response>;

package/dist/runtime/internal/vite/ssr-renderer.mjs

@@ -0,0 +1,4 @@
+/** @param {{ req: Request }} HTTPEvent */
+export default function ssrRenderer({ req }) {
+  return fetch(req, { viteEnv: "ssr" });
+}