nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/runtime/index.d.mts

@@ -5,7 +5,7 @@ export { useRuntimeConfig } from "./internal/runtime-config.mjs";
 export { useRequest } from "./internal/context.mjs";
 export { defineRenderHandler } from "./internal/renderer.mjs";
 export { defineCachedFunction, defineCachedEventHandler, defineCachedHandler, cachedFunction, cachedEventHandler, } from "./internal/cache.mjs";
-export { useNitroApp } from "./internal/app.mjs";
+export { useNitroApp, useNitroHooks } from "./internal/app.mjs";
 export { useStorage } from "./internal/storage.mjs";
 export { useDatabase } from "./internal/database.mjs";
 export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/index.mjs

@@ -11,7 +11,7 @@ export {
   cachedFunction,
   cachedEventHandler
 } from "./internal/cache.mjs";
-export { useNitroApp } from "./internal/app.mjs";
+export { useNitroApp, useNitroHooks } from "./internal/app.mjs";
 export { useStorage } from "./internal/storage.mjs";
 export { useDatabase } from "./internal/database.mjs";
 export { defineTask, runTask } from "./internal/task.mjs";

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

@@ -1,2 +1,4 @@
-import type { NitroApp } from "nitro/types";
+import type { NitroApp, NitroRuntimeHooks } from "nitro/types";
+import { HookableCore } from "hookable";
 export declare function useNitroApp(): NitroApp;
+export declare function useNitroHooks(): HookableCore<NitroRuntimeHooks>;

package/dist/runtime/internal/app.mjs

@@ -1,5 +1,5 @@
 import { H3Core, toRequest } from "h3";
-import { createHooks } from "hookable";
+import { HookableCore } from "hookable";
 import { nitroAsyncContext } from "./context.mjs";
 import errorHandler from "#nitro-internal-virtual/error-handler";
 import { plugins } from "#nitro-internal-virtual/plugins";
@@ -9,25 +9,43 @@ import {
   globalMiddleware,
   findRoutedMiddleware
 } from "#nitro-internal-virtual/routing";
+import {
+  hasRouteRules,
+  hasRoutedMiddleware,
+  hasGlobalMiddleware,
+  hasRoutes,
+  hasHooks,
+  hasPlugins
+} from "#nitro-internal-virtual/feature-flags";
 export function useNitroApp() {
   return useNitroApp.__instance__ ??= initNitroApp();
 }
+export function useNitroHooks() {
+  const nitroApp = useNitroApp();
+  const hooks = nitroApp.hooks;
+  if (hooks) {
+    return hooks;
+  }
+  return nitroApp.hooks = new HookableCore();
+}
 function initNitroApp() {
   const nitroApp = createNitroApp();
-  for (const plugin of plugins) {
-    try {
-      plugin(nitroApp);
-    } catch (error) {
-      nitroApp.captureError(error, { tags: ["plugin"] });
-      throw error;
+  if (hasPlugins) {
+    for (const plugin of plugins) {
+      try {
+        plugin(nitroApp);
+      } catch (error) {
+        nitroApp.captureError(error, { tags: ["plugin"] });
+        throw error;
+      }
     }
   }
   return nitroApp;
 }
 function createNitroApp() {
-  const hooks = createHooks();
+  const hooks = hasHooks ? new HookableCore() : void 0;
   const captureError = (error, errorCtx) => {
-    const promise = hooks.callHookParallel("error", error, errorCtx).catch((hookError) => {
+    const promise = hasHooks && hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {
       console.error("Error while capturing another error", hookError);
     });
     if (errorCtx?.event) {
@@ -35,82 +53,90 @@ function createNitroApp() {
       if (errors) {
         errors.push({ error, context: errorCtx });
       }
-      if (typeof errorCtx.event.req.waitUntil === "function") {
+      if (hasHooks && typeof errorCtx.event.req.waitUntil === "function") {
         errorCtx.event.req.waitUntil(promise);
       }
     }
   };
-  const h3App = createH3App(captureError);
-  let fetchHandler = async (req) => {
-    req.context ??= {};
+  const h3App = createH3App({
+    onError(error, event) {
+      hasHooks && captureError(error, { event });
+      return errorHandler(error, event);
+    }
+  });
+  if (hasHooks) {
+    h3App.config.onRequest = (event) => {
+      return hooks.callHook("request", event)?.catch?.((error) => {
+        captureError(error, { event, tags: ["request"] });
+      });
+    };
+    h3App.config.onResponse = (res, event) => {
+      return hooks.callHook("response", res, event)?.catch?.((error) => {
+        captureError(error, { event, tags: ["response"] });
+      });
+    };
+  }
+  let appHandler = (req) => {
+    req.context ||= {};
     req.context.nitro = req.context.nitro || { errors: [] };
-    const event = { req };
-    const nitroApp = useNitroApp();
-    await nitroApp.hooks.callHook("request", event).catch((error) => {
-      captureError(error, { event, tags: ["request"] });
-    });
-    const response = await h3App.request(req, void 0, req.context);
-    await nitroApp.hooks.callHook("response", response, event).catch((error) => {
-      captureError(error, { event, tags: ["request", "response"] });
-    });
-    return response;
+    return h3App.fetch(req);
   };
   if (import.meta._asyncContext) {
-    const originalFetchHandler = fetchHandler;
-    fetchHandler = (req) => {
+    const originalHandler = appHandler;
+    appHandler = (req) => {
       const asyncCtx = { request: req };
-      return nitroAsyncContext.callAsync(
-        asyncCtx,
-        () => originalFetchHandler(req)
-      );
+      return nitroAsyncContext.callAsync(asyncCtx, () => originalHandler(req));
     };
   }
-  const requestHandler = (input, init, context) => {
+  const request = (input, init, context) => {
     const req = toRequest(input, init);
     req.context = { ...req.context, ...context };
-    return Promise.resolve(fetchHandler(req));
+    return Promise.resolve(appHandler(req));
   };
-  const originalFetch = globalThis.fetch;
-  const nitroFetch = (input, init) => {
-    if (typeof input === "string" && input.startsWith("/")) {
-      return requestHandler(input, init);
-    }
-    if (input instanceof Request && "_request" in input) {
-      input = input._request;
+  const nativeFetch = globalThis.fetch;
+  globalThis.fetch = (input, init) => {
+    if (typeof input === "string" && input.charCodeAt(0) === 47) {
+      return request(input, init);
     }
-    return originalFetch(input, init);
+    input = input._request || input;
+    return nativeFetch(input, init);
   };
-  globalThis.fetch = nitroFetch;
   const app = {
-    _h3: h3App,
+    fetch: appHandler,
+    request,
+    h3: h3App,
     hooks,
-    fetch: requestHandler,
     captureError
   };
   return app;
 }
-function createH3App(captureError) {
-  const DEBUG_MODE = ["1", "true", "TRUE"].includes(process.env.DEBUG + "");
-  const h3App = new H3Core({
-    debug: DEBUG_MODE,
-    onError: (error, event) => {
-      captureError(error, { event, tags: ["request"] });
-      return errorHandler(error, event);
-    }
-  });
-  h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
-  h3App._getMiddleware = (event, route) => {
-    const pathname = event.url.pathname;
-    const method = event.req.method;
-    const { routeRules, routeRuleMiddleware } = getRouteRules(method, pathname);
-    event.context.routeRules = routeRules;
-    return [
-      ...routeRuleMiddleware,
-      ...globalMiddleware,
-      ...findRoutedMiddleware(method, pathname).map((r) => r.data),
-      ...route?.data?.middleware || []
-    ].filter(Boolean);
-  };
+function createH3App(config) {
+  const h3App = new H3Core(config);
+  hasRoutes && (h3App["~findRoute"] = (event) => findRoute(event.req.method, event.url.pathname));
+  hasGlobalMiddleware && h3App["~middleware"].push(...globalMiddleware);
+  if (hasRouteRules || hasRoutedMiddleware) {
+    h3App["~getMiddleware"] = (event, route) => {
+      const needsRouting = hasRouteRules || hasRoutedMiddleware;
+      const pathname = needsRouting ? event.url.pathname : void 0;
+      const method = needsRouting ? event.req.method : void 0;
+      const middleware = [];
+      if (hasRouteRules) {
+        const routeRules = getRouteRules(method, pathname);
+        event.context.routeRules = routeRules?.routeRules;
+        if (routeRules?.routeRuleMiddleware.length) {
+          middleware.push(...routeRules.routeRuleMiddleware);
+        }
+      }
+      hasGlobalMiddleware && middleware.push(...h3App["~middleware"]);
+      hasRoutedMiddleware && middleware.push(
+        ...findRoutedMiddleware(method, pathname).map((r) => r.data)
+      );
+      if (hasRoutes && route?.data?.middleware?.length) {
+        middleware.push(...route.data.middleware);
+      }
+      return middleware;
+    };
+  }
   return h3App;
 }
 function getRouteRules(method, pathname) {

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

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

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

@@ -1,16 +1,16 @@
-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);
-  }
-);
+const errorHandler = (error, event) => {
+  const res = defaultHandler(error, event);
+  return new FastResponse(
+    typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
+    res
+  );
+};
+export default errorHandler;
 export function defaultHandler(error, event, opts) {
   const isSensitive = error.unhandled;
   const status = error.status || 500;
-  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  const url = event.url || new URL(event.req.url);
   if (status === 404) {
     const baseURL = import.meta.baseURL || "/";
     if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
@@ -33,13 +33,9 @@ export function defaultHandler(error, event, opts) {
   }
   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")) {

package/dist/runtime/internal/renderer.mjs

@@ -1,12 +1,12 @@
 import { defineHandler } from "h3";
-import { useNitroApp } from "./app.mjs";
+import { useNitroHooks } from "./app.mjs";
 import { useRuntimeConfig } from "./runtime-config.mjs";
 export function defineRenderHandler(render) {
   const runtimeConfig = useRuntimeConfig();
   return defineHandler(async (event) => {
-    const nitroApp = useNitroApp();
+    const nitroHooks = useNitroHooks();
     const ctx = { event, render, response: void 0 };
-    await nitroApp.hooks.callHook("render:before", ctx);
+    await nitroHooks.callHook("render:before", ctx);
     if (!ctx.response) {
       if (event.url.pathname === `${runtimeConfig.app.baseURL}favicon.ico`) {
         event.res.headers.set("Content-Type", "image/x-icon");
@@ -21,7 +21,7 @@ export function defineRenderHandler(render) {
         return "No response returned from render handler: " + event.url.pathname;
       }
     }
-    await nitroApp.hooks.callHook("render:response", ctx.response, ctx);
+    await nitroHooks.callHook("render:response", ctx.response, ctx);
     if (ctx.response.headers) {
       for (const [key, value] of Object.entries(ctx.response.headers)) {
         event.res.headers.set(key, value);

package/dist/runtime/internal/routes/dev-tasks.d.mts

@@ -1,3 +1,31 @@
-import { H3 } from "h3";
-declare const _default: H3;
+declare const _default: {
+    "~rou3": import("h3").RouterContext;
+    request(request: import("srvx").ServerRequest | URL | string, options?: RequestInit, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    use(route: string, handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    use(handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    on(method: import("h3").HTTPMethod | Lowercase<import("h3").HTTPMethod> | "", route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    register(plugin: import("h3").H3Plugin): /*elided*/ any;
+    mount(base: string, input: import("srvx").FetchHandler | {
+        fetch: import("srvx").FetchHandler;
+    } | /*elided*/ any): /*elided*/ any;
+    all(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    get(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    post(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    put(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    delete(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    patch(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    head(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    options(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    connect(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    trace(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    readonly config: import("h3").H3Config;
+    "~middleware": import("h3").Middleware[];
+    "~routes": import("h3").H3Route[];
+    fetch(_request: import("srvx").ServerRequest): Response | Promise<Response>;
+    handler(event: import("h3").H3Event): unknown | Promise<unknown>;
+    "~request"(request: import("srvx").ServerRequest, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    "~findRoute"(_event: import("h3").H3Event): import("h3").MatchedRoute<import("h3").H3Route> | void;
+    "~getMiddleware"(event: import("h3").H3Event, route: import("h3").MatchedRoute<import("h3").H3Route> | undefined): import("h3").Middleware[];
+    "~addRoute"(_route: import("h3").H3Route): void;
+};
 export default _default;

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

@@ -1,9 +1,8 @@
 import type { Server as HttpServer } from "node:http";
-import type { NitroApp } from "nitro/types";
 export declare function getGracefulShutdownConfig(): {
     disabled: boolean;
     signals: string[];
     timeout: number;
     forceExit: boolean;
 };
-export declare function setupGracefulShutdown(listener: HttpServer, nitroApp: NitroApp): void;
+export declare function setupGracefulShutdown(listener: HttpServer): void;

package/dist/runtime/internal/shutdown.mjs

@@ -1,4 +1,5 @@
 import gracefulShutdown from "./lib/http-graceful-shutdown.mjs";
+import { useNitroHooks } from "./app.mjs";
 export function getGracefulShutdownConfig() {
   return {
     disabled: !!process.env.NITRO_SHUTDOWN_DISABLED,
@@ -7,7 +8,7 @@ export function getGracefulShutdownConfig() {
     forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT
   };
 }
-export function setupGracefulShutdown(listener, nitroApp) {
+export function setupGracefulShutdown(listener) {
   const shutdownConfig = getGracefulShutdownConfig();
   if (shutdownConfig.disabled) {
     return;
@@ -22,7 +23,7 @@ export function setupGracefulShutdown(listener, nitroApp) {
           console.warn("Graceful shutdown timeout, force exiting...");
           resolve();
         }, shutdownConfig.timeout);
-        nitroApp.hooks.callHook("close").catch((error) => {
+        Promise.resolve(useNitroHooks().callHook("close")).catch((error) => {
           console.error(error);
         }).finally(() => {
           clearTimeout(timeout);

package/dist/runtime/internal/task.mjs

@@ -1,6 +1,5 @@
 import { Cron } from "croner";
 import { HTTPError } from "h3";
-import { isTest } from "std-env";
 import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
 export function defineTask(def) {
   if (typeof def.run !== "function") {
@@ -41,7 +40,7 @@ export async function runTask(name, {
   }
 }
 export function startScheduleRunner() {
-  if (!scheduledTasks || scheduledTasks.length === 0 || isTest) {
+  if (!scheduledTasks || scheduledTasks.length === 0 || process.env.TEST) {
     return;
   }
   const payload = {