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

package/dist/runtime/internal/cache.mjs

@@ -1,23 +1,19 @@
-import {
-  createEvent,
-  defineEventHandler,
-  fetchWithEvent,
-  handleCacheHeaders,
-  isEvent,
-  splitCookiesString
-} from "h3";
-import { hash } from "ohash";
+import { defineHandler, handleCacheHeaders, isHTTPEvent, toResponse } from "h3";
+import { FastResponse } from "srvx";
 import { parseURL } from "ufo";
+import { hash } from "ohash";
 import { useNitroApp } from "./app.mjs";
 import { useStorage } from "./storage.mjs";
-const defaultCacheOptions = {
-  name: "_",
-  base: "/cache",
-  swr: true,
-  maxAge: 1
-};
+function defaultCacheOptions() {
+  return {
+    name: "_",
+    base: "/cache",
+    swr: true,
+    maxAge: 1
+  };
+}
 export function defineCachedFunction(fn, opts = {}) {
-  opts = { ...defaultCacheOptions, ...opts };
+  opts = { ...defaultCacheOptions(), ...opts };
   const pending = {};
   const group = opts.group || "nitro/functions";
   const name = opts.name || fn.name || "_";
@@ -25,14 +21,17 @@ export function defineCachedFunction(fn, opts = {}) {
   const validate = opts.validate || ((entry) => entry.value !== void 0);
   async function get(key, resolver, shouldInvalidateCache, event) {
     const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
-    let entry = await useStorage().getItem(cacheKey) || {};
+    let entry = await useStorage().getItem(cacheKey).catch((error) => {
+      console.error(`[cache] Cache read error.`, error);
+      useNitroApp().captureError(error, { event, tags: ["cache"] });
+    }) || {};
     if (typeof entry !== "object") {
       entry = {};
       const error = new Error("Malformed data read from cache.");
-      console.error("[nitro] [cache]", error);
+      console.error("[cache]", error);
       useNitroApp().captureError(error, { event, tags: ["cache"] });
     }
-    const ttl = (opts.maxAge ?? opts.maxAge ?? 0) * 1e3;
+    const ttl = (opts.maxAge ?? 0) * 1e3;
     if (ttl) {
       entry.expires = Date.now() + ttl;
     }
@@ -61,12 +60,16 @@ export function defineCachedFunction(fn, opts = {}) {
         entry.integrity = integrity;
         delete pending[key];
         if (validate(entry) !== false) {
-          const promise = useStorage().setItem(cacheKey, entry).catch((error) => {
-            console.error(`[nitro] [cache] Cache write error.`, error);
+          let setOpts;
+          if (opts.maxAge && !opts.swr) {
+            setOpts = { ttl: opts.maxAge };
+          }
+          const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => {
+            console.error(`[cache] Cache write error.`, error);
             useNitroApp().captureError(error, { event, tags: ["cache"] });
           });
-          if (event?.waitUntil) {
-            event.waitUntil(promise);
+          if (typeof event?.req?.waitUntil === "function") {
+            event.req.waitUntil(promise);
           }
         }
       }
@@ -74,12 +77,12 @@ export function defineCachedFunction(fn, opts = {}) {
     const _resolvePromise = expired ? _resolve() : Promise.resolve();
     if (entry.value === void 0) {
       await _resolvePromise;
-    } else if (expired && event && event.waitUntil) {
-      event.waitUntil(_resolvePromise);
+    } else if (expired && event && event.req.waitUntil) {
+      event.req.waitUntil(_resolvePromise);
     }
     if (opts.swr && validate(entry) !== false) {
       _resolvePromise.catch((error) => {
-        console.error(`[nitro] [cache] SWR handler error.`, error);
+        console.error(`[cache] SWR handler error.`, error);
         useNitroApp().captureError(error, { event, tags: ["cache"] });
       });
       return entry;
@@ -97,7 +100,7 @@ export function defineCachedFunction(fn, opts = {}) {
       key,
       () => fn(...args),
       shouldInvalidateCache,
-      args[0] && isEvent(args[0]) ? args[0] : void 0
+      args[0] && isHTTPEvent(args[0]) ? args[0] : void 0
     );
     let value = entry.value;
     if (opts.transform) {
@@ -106,33 +109,43 @@ export function defineCachedFunction(fn, opts = {}) {
     return value;
   };
 }
-export const cachedFunction = defineCachedFunction;
+export function cachedFunction(fn, opts = {}) {
+  return defineCachedFunction(fn, opts);
+}
 function getKey(...args) {
-  return args.length > 0 ? hash(args, {}) : "";
+  return args.length > 0 ? hash(args) : "";
 }
 function escapeKey(key) {
   return String(key).replace(/\W/g, "");
 }
-export function defineCachedEventHandler(handler, opts = defaultCacheOptions) {
+export function defineCachedEventHandler(handler, opts = defaultCacheOptions()) {
   const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
   const _opts = {
     ...opts,
+    shouldBypassCache: (event) => {
+      return event.req.method !== "GET" && event.req.method !== "HEAD";
+    },
     getKey: async (event) => {
       const customKey = await opts.getKey?.(event);
       if (customKey) {
         return escapeKey(customKey);
       }
-      const _path = event.node.req.originalUrl || event.node.req.url || event.path;
-      const _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
+      const _path = event.url.pathname + event.url.search;
+      let _pathname;
+      try {
+        _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
+      } catch {
+        _pathname = "-";
+      }
       const _hashedPath = `${_pathname}.${hash(_path)}`;
-      const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
+      const _headers = variableHeaderNames.map((header) => [header, event.req.headers.get(header)]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
       return [_hashedPath, ..._headers].join(":");
     },
     validate: (entry) => {
       if (!entry.value) {
         return false;
       }
-      if (entry.value.code >= 400) {
+      if (entry.value.status >= 400) {
         return false;
       }
       if (entry.value.body === void 0) {
@@ -147,106 +160,30 @@ export function defineCachedEventHandler(handler, opts = defaultCacheOptions) {
     integrity: opts.integrity || hash([handler, opts])
   };
   const _cachedHandler = cachedFunction(
-    async (incomingEvent) => {
-      const variableHeaders = {};
-      for (const header of variableHeaderNames) {
-        const value = incomingEvent.node.req.headers[header];
-        if (value !== void 0) {
-          variableHeaders[header] = value;
-        }
-      }
-      const reqProxy = cloneWithProxy(incomingEvent.node.req, {
-        headers: variableHeaders
-      });
-      const resHeaders = {};
-      let _resSendBody;
-      const resProxy = cloneWithProxy(incomingEvent.node.res, {
-        statusCode: 200,
-        writableEnded: false,
-        writableFinished: false,
-        headersSent: false,
-        closed: false,
-        getHeader(name) {
-          return resHeaders[name];
-        },
-        setHeader(name, value) {
-          resHeaders[name] = value;
-          return this;
-        },
-        getHeaderNames() {
-          return Object.keys(resHeaders);
-        },
-        hasHeader(name) {
-          return name in resHeaders;
-        },
-        removeHeader(name) {
-          delete resHeaders[name];
-        },
-        getHeaders() {
-          return resHeaders;
-        },
-        end(chunk, arg2, arg3) {
-          if (typeof chunk === "string") {
-            _resSendBody = chunk;
-          }
-          if (typeof arg2 === "function") {
-            arg2();
-          }
-          if (typeof arg3 === "function") {
-            arg3();
-          }
-          return this;
-        },
-        write(chunk, arg2, arg3) {
-          if (typeof chunk === "string") {
-            _resSendBody = chunk;
-          }
-          if (typeof arg2 === "function") {
-            arg2(void 0);
-          }
-          if (typeof arg3 === "function") {
-            arg3();
-          }
-          return true;
-        },
-        writeHead(statusCode, headers2) {
-          this.statusCode = statusCode;
-          if (headers2) {
-            if (Array.isArray(headers2) || typeof headers2 === "string") {
-              throw new TypeError("Raw headers  is not supported.");
-            }
-            for (const header in headers2) {
-              const value = headers2[header];
-              if (value !== void 0) {
-                this.setHeader(
-                  header,
-                  value
-                );
-              }
-            }
-          }
-          return this;
-        }
-      });
-      const event = createEvent(reqProxy, resProxy);
-      event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
-        fetch: useNitroApp().localFetch
-      });
-      event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
-        fetch: globalThis.$fetch
-      });
-      event.context = incomingEvent.context;
-      event.context.cache = {
-        options: _opts
-      };
-      const body = await handler(event) || _resSendBody;
-      const headers = event.node.res.getHeaders();
-      headers.etag = String(
-        headers.Etag || headers.etag || `W/"${hash(body)}"`
-      );
-      headers["last-modified"] = String(
-        headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ new Date()).toUTCString()
+    async (event) => {
+      const filteredHeaders = [...event.req.headers.entries()].filter(
+        ([key]) => !variableHeaderNames.includes(key.toLowerCase())
       );
+      try {
+        const originalReq = event.req;
+        event.req = new Request(event.req.url, {
+          method: event.req.method,
+          headers: filteredHeaders
+        });
+        event.req.runtime = originalReq.runtime;
+        event.req.waitUntil = originalReq.waitUntil;
+      } catch (error) {
+        console.error("[cache] Failed to filter headers:", error);
+      }
+      const rawValue = await handler(event);
+      const res = await toResponse(rawValue, event);
+      const body = await res.text();
+      if (!res.headers.has("etag")) {
+        res.headers.set("etag", `W/"${hash(body)}"`);
+      }
+      if (!res.headers.has("last-modified")) {
+        res.headers.set("last-modified", (/* @__PURE__ */ new Date()).toUTCString());
+      }
       const cacheControl = [];
       if (opts.swr) {
         if (opts.maxAge) {
@@ -261,30 +198,26 @@ export function defineCachedEventHandler(handler, opts = defaultCacheOptions) {
         cacheControl.push(`max-age=${opts.maxAge}`);
       }
       if (cacheControl.length > 0) {
-        headers["cache-control"] = cacheControl.join(", ");
+        res.headers.set("cache-control", cacheControl.join(", "));
       }
       const cacheEntry = {
-        code: event.node.res.statusCode,
-        headers,
+        status: res.status,
+        statusText: res.statusText,
+        headers: Object.fromEntries(res.headers.entries()),
         body
       };
       return cacheEntry;
     },
     _opts
   );
-  return defineEventHandler(async (event) => {
+  return defineHandler(async (event) => {
     if (opts.headersOnly) {
       if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
         return;
       }
       return handler(event);
     }
-    const response = await _cachedHandler(
-      event
-    );
-    if (event.node.res.headersSent || event.node.res.writableEnded) {
-      return response.body;
-    }
+    const response = await _cachedHandler(event);
     if (handleCacheHeaders(event, {
       modifiedTime: new Date(response.headers["last-modified"]),
       etag: response.headers.etag,
@@ -292,38 +225,12 @@ export function defineCachedEventHandler(handler, opts = defaultCacheOptions) {
     })) {
       return;
     }
-    event.node.res.statusCode = response.code;
-    for (const name in response.headers) {
-      const value = response.headers[name];
-      if (name === "set-cookie") {
-        event.node.res.appendHeader(
-          name,
-          splitCookiesString(value)
-        );
-      } else {
-        if (value !== void 0) {
-          event.node.res.setHeader(name, value);
-        }
-      }
-    }
-    return response.body;
-  });
-}
-function cloneWithProxy(obj, overrides) {
-  return new Proxy(obj, {
-    get(target, property, receiver) {
-      if (property in overrides) {
-        return overrides[property];
-      }
-      return Reflect.get(target, property, receiver);
-    },
-    set(target, property, value, receiver) {
-      if (property in overrides) {
-        overrides[property] = value;
-        return true;
-      }
-      return Reflect.set(target, property, value, receiver);
-    }
+    return new FastResponse(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
   });
 }
 export const cachedEventHandler = defineCachedEventHandler;
+export const defineCachedHandler = defineCachedEventHandler;

package/dist/runtime/internal/{context.d.ts → context.d.mts}

@@ -1,12 +1,12 @@
-import { type H3Event } from "h3";
+import type { ServerRequest } from "srvx";
 export declare const nitroAsyncContext: import("unctx/index").UseContext<NitroAsyncContext>;
 /**
  *
- * Access to the current Nitro request event.
+ * Access to the current Nitro request.
  *
  * @experimental
  *  - Requires `experimental.asyncContext: true` config to work.
  *  - Works in Node.js and limited runtimes only
  *
  */
-export declare function useEvent(): H3Event;
+export declare function useRequest(): ServerRequest;

package/dist/runtime/internal/context.mjs

@@ -1,16 +1,16 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createError } from "h3";
+import { HTTPError } from "h3";
 import { getContext } from "unctx";
-export const nitroAsyncContext = getContext("nitro-app", {
+export const nitroAsyncContext = /* @__PURE__ */ (() => getContext("nitro-app", {
   asyncContext: import.meta._asyncContext,
   AsyncLocalStorage: import.meta._asyncContext ? AsyncLocalStorage : void 0
-});
-export function useEvent() {
+}))();
+export function useRequest() {
   try {
-    return nitroAsyncContext.use().event;
+    return nitroAsyncContext.use().request;
   } catch {
     const hint = import.meta._asyncContext ? "Note: This is an experimental feature and might be broken on non-Node.js environments." : "Enable the experimental flag using `experimental.asyncContext: true`.";
-    throw createError({
+    throw new HTTPError({
       message: `Nitro request context is not available. ${hint}`
     });
   }

package/dist/runtime/internal/error/dev.d.mts

@@ -0,0 +1,9 @@
+import type { HTTPError, HTTPEvent } from "h3";
+import type { InternalHandlerResponse } from "./utils.mjs";
+declare const _default: NitroErrorHandler;
+export default _default;
+export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?: {
+    silent?: boolean;
+    json?: boolean;
+}): Promise<InternalHandlerResponse>;
+export declare function loadStackTrace(error: any): Promise<void>;

package/dist/runtime/internal/error/dev.mjs

@@ -0,0 +1,122 @@
+import { getRequestURL } from "h3";
+import { readFile } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import consola from "consola";
+import { ErrorParser } from "youch-core";
+import { Youch } from "youch";
+import { SourceMapConsumer } from "source-map";
+import { defineNitroErrorHandler } from "./utils.mjs";
+import { FastResponse } from "srvx";
+export default defineNitroErrorHandler(
+  async function defaultNitroErrorHandler(error, event) {
+    const res = await defaultHandler(error, event);
+    return new FastResponse(
+      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
+      res
+    );
+  }
+);
+export async function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled;
+  const status = error.status || 500;
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (status === 404) {
+    const baseURL = import.meta.baseURL || "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  await loadStackTrace(error).catch(consola.error);
+  const youch = new Youch();
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
+    const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+    consola.error(
+      `[request error] ${tags} [${event.req.method}] ${url}
+
+`,
+      ansiError
+    );
+  }
+  const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
+  const headers = {
+    "content-type": useJSON ? "application/json" : "text/html",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
+  };
+  if (status === 404 || !event.res.headers.has("cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = useJSON ? {
+    error: true,
+    url,
+    status,
+    statusText: error.statusText,
+    message: error.message,
+    data: error.data,
+    stack: error.stack?.split("\n").map((line) => line.trim())
+  } : await youch.toHTML(error, {
+    request: {
+      url: url.href,
+      method: event.req.method,
+      headers: Object.fromEntries(event.req.headers.entries())
+    }
+  });
+  return {
+    status,
+    statusText: error.statusText,
+    headers,
+    body
+  };
+}
+export async function loadStackTrace(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
+  const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
+  Object.defineProperty(error, "stack", { value: stack });
+  if (error.cause) {
+    await loadStackTrace(error.cause).catch(consola.error);
+  }
+}
+async function sourceLoader(frame) {
+  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+    return;
+  }
+  if (frame.type === "app") {
+    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
+    });
+    if (rawSourceMap) {
+      const consumer = await new SourceMapConsumer(rawSourceMap);
+      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
+      if (originalPosition.source && originalPosition.line) {
+        frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
+        frame.lineNumber = originalPosition.line;
+        frame.columnNumber = originalPosition.column || 0;
+      }
+    }
+  }
+  const contents = await readFile(frame.fileName, "utf8").catch(() => {
+  });
+  return contents ? { contents } : void 0;
+}
+function fmtFrame(frame) {
+  if (frame.type === "native") {
+    return frame.raw;
+  }
+  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+}

package/dist/runtime/internal/error/prod.d.mts

@@ -0,0 +1,8 @@
+import type { HTTPError, HTTPEvent } from "h3";
+import type { InternalHandlerResponse } from "./utils.mjs";
+declare const _default: NitroErrorHandler;
+export default _default;
+export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?: {
+    silent?: boolean;
+    json?: boolean;
+}): InternalHandlerResponse;

package/dist/runtime/internal/error/prod.mjs

@@ -0,0 +1,62 @@
+import { getRequestURL } from "h3";
+import { defineNitroErrorHandler } from "./utils.mjs";
+import { FastResponse } from "srvx";
+export default defineNitroErrorHandler(
+  function defaultNitroErrorHandler(error, event) {
+    const res = defaultHandler(error, event);
+    return new FastResponse(JSON.stringify(res.body, null, 2), res);
+  }
+);
+export function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled;
+  const status = error.status || 500;
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (status === 404) {
+    const baseURL = import.meta.baseURL || "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
+    console.error(
+      `[request error] ${tags} [${event.req.method}] ${url}
+`,
+      error
+    );
+  }
+  const headers = {
+    "content-type": "application/json",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'none'; frame-ancestors 'none';"
+  };
+  if (status === 404 || !event.res.headers.has("cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = {
+    error: true,
+    url: url.href,
+    status,
+    statusText: error.statusText,
+    message: isSensitive ? "Server Error" : error.message,
+    data: isSensitive ? void 0 : error.data
+  };
+  return {
+    status,
+    statusText: error.statusText,
+    headers,
+    body
+  };
+}

package/dist/runtime/internal/error/utils.d.mts

@@ -0,0 +1,8 @@
+import type { NitroErrorHandler } from "nitro/types";
+export declare function defineNitroErrorHandler(handler: NitroErrorHandler): NitroErrorHandler;
+export type InternalHandlerResponse = {
+    status: number;
+    statusText: string | undefined;
+    headers: Record<string, string>;
+    body: string | Record<string, any>;
+};

package/dist/runtime/internal/error/utils.mjs

@@ -0,0 +1,3 @@
+export function defineNitroErrorHandler(handler) {
+  return handler;
+}

package/dist/runtime/internal/index.d.mts

@@ -0,0 +1,3 @@
+export { trapUnhandledNodeErrors } from "./utils.mjs";
+export { startScheduleRunner, runCronTasks } from "./task.mjs";
+export { getGracefulShutdownConfig, setupGracefulShutdown } from "./shutdown.mjs";

package/dist/runtime/internal/index.mjs

@@ -1,16 +1,3 @@
-export {
-  trapUnhandledNodeErrors,
-  normalizeCookieHeader,
-  requestHasBody,
-  joinHeaders,
-  toBuffer
-} from "./utils.mjs";
-export {
-  normalizeLambdaIncomingHeaders,
-  normalizeLambdaOutgoingHeaders,
-  normalizeLambdaOutgoingBody
-} from "./utils.lambda.mjs";
+export { trapUnhandledNodeErrors } from "./utils.mjs";
 export { startScheduleRunner, runCronTasks } from "./task.mjs";
-export { getAzureParsedCookiesFromHeaders } from "./utils.azure.mjs";
 export { getGracefulShutdownConfig, setupGracefulShutdown } from "./shutdown.mjs";
-export { getRouteRulesForPath } from "./route-rules.mjs";

package/dist/runtime/internal/renderer.d.mts

@@ -0,0 +1,3 @@
+import { type EventHandler } from "h3";
+import type { RenderHandler } from "nitro/types";
+export declare function defineRenderHandler(render: RenderHandler): EventHandler;