nitro-nightly 3.1.0-20251026-222805-a13234bf → 3.1.0-20251027-223403-81bd673d

package/dist/_chunks/index.mjs

@@ -20679,6 +20679,9 @@ class Router {
       addRoute(this.#router, route.method, route.route, route.data);
     }
   }
+  hasRoutes() {
+    return this.#routes.length > 0;
+  }
   compileToString(opts) {
     return this.#compiled || (this.#compiled = compileRouterToString(this.#router, void 0, opts));
   }

package/dist/_chunks/info.mjs

@@ -10350,7 +10350,8 @@ function routing(nitro) {
           "_importHash"
         );
         const h3Imports = [
-          (nitro.options.serverEntry || allHandlers.some((h) => !h.lazy)) && "toEventHandler",
+          allHandlers.some((h) => !h.lazy) && "toEventHandler",
+          nitro.options.serverEntry && "toMiddleware",
           allHandlers.some((h) => h.lazy) && "defineLazyEventHandler"
         ].filter(Boolean);
         return (
@@ -10360,6 +10361,7 @@ import * as __routeRules__ from "nitro/runtime/internal/route-rules";
 ${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
 import {${h3Imports.join(", ")}} from "nitro/deps/h3";
 
+export const hasRouteRules = ${nitro.routing.routeRules.hasRoutes() ? "true" : "false"};
 export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
 
 ${allHandlers.filter((h) => !h.lazy).map((h) => (
@@ -10374,15 +10376,17 @@ ${allHandlers.filter((h) => h.lazy).map(
             )
           ).join("\n")}
 
+export const hasRoutes = ${nitro.routing.routes.hasRoutes() ? "true" : "false"};
 export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
 
+export const hasRoutedMiddleware = ${nitro.routing.routedMiddleware.hasRoutes() ? "true" : "false"};
 export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
 
-export const globalMiddleware = [${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}];
-
-${nitro.options.serverEntry && /* js */
-          `const serverEntry = toEventHandler(__serverEntry__);
-if (serverEntry) { globalMiddleware.push(serverEntry) }`}
+export const hasGlobalMiddleware = ${nitro.routing.globalMiddleware.length > 0 || nitro.options.serverEntry ? "true" : "false"};
+export const globalMiddleware = [
+  ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}
+  ${nitro.options.serverEntry ? `,toMiddleware(__serverEntry__)` : ""}
+].filter(Boolean);
   `
         );
       },

package/dist/presets/standard/runtime/server.d.mts

@@ -1,5 +1,5 @@
 import "#nitro-internal-pollyfills";
 declare const _default: {
-    fetch: any;
+    fetch: (req: Request) => any;
 };
 export default _default;

package/dist/presets/standard/runtime/server.mjs

@@ -2,5 +2,5 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 const nitroApp = useNitroApp();
 export default {
-  fetch: nitroApp.fetch
+  fetch: (req) => nitroApp.fetch(req)
 };

package/dist/runtime/internal/app.mjs

@@ -4,10 +4,14 @@ import { nitroAsyncContext } from "./context.mjs";
 import errorHandler from "#nitro-internal-virtual/error-handler";
 import { plugins } from "#nitro-internal-virtual/plugins";
 import {
+  hasRouteRules,
   findRoute,
   findRouteRules,
   globalMiddleware,
-  findRoutedMiddleware
+  findRoutedMiddleware,
+  hasRoutedMiddleware,
+  hasGlobalMiddleware,
+  hasRoutes
 } from "#nitro-internal-virtual/routing";
 export function useNitroApp() {
   return useNitroApp.__instance__ ??= initNitroApp();
@@ -59,7 +63,7 @@ function createNitroApp() {
   let fetchHandler = (req) => {
     req.context ??= {};
     req.context.nitro = req.context.nitro || { errors: [] };
-    return h3App.request(req, void 0, req.context);
+    return h3App.fetch(req);
   };
   if (import.meta._asyncContext) {
     const originalFetchHandler = fetchHandler;
@@ -97,19 +101,31 @@ function createNitroApp() {
 }
 function createH3App(config) {
   const h3App = new H3Core(config);
-  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);
-  };
+  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/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/types/index.d.mts

@@ -3817,6 +3817,7 @@ declare class Router<T> {
     constructor(matchAll?: boolean);
     get routes(): Route<T>[];
     _update(routes: Route<T>[]): void;
+    hasRoutes(): boolean;
     compileToString(opts?: RouterCompilerOptions): string;
     match(method: string, path: string): undefined | T;
     matchAll(method: string, path: string): T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-nightly",
-  "version": "3.1.0-20251026-222805-a13234bf",
+  "version": "3.1.0-20251027-223403-81bd673d",
   "description": "Build and Deploy Universal JavaScript Servers",
   "homepage": "https://nitro.build",
   "repository": "nitrojs/nitro",
@@ -58,7 +58,7 @@
     "db0": "^0.3.4",
     "esbuild": "^0.25.11",
     "fetchdts": "^0.1.7",
-    "h3": "^2.0.1-rc.4",
+    "h3": "^2.0.1-rc.5",
     "jiti": "^2.6.1",
     "nf3": "^0.1.2",
     "ofetch": "^1.4.1",