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

package/dist/runtime/index.d.mts

@@ -0,0 +1,11 @@
+export { defineNitroPlugin } from "./internal/plugin.mjs";
+export { defineRouteMeta } from "./internal/meta.mjs";
+export { defineNitroErrorHandler } from "./internal/error/utils.mjs";
+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 { useStorage } from "./internal/storage.mjs";
+export { useDatabase } from "./internal/database.mjs";
+export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/index.mjs

@@ -1,17 +1,17 @@
-export { useNitroApp } from "./internal/app.mjs";
-export { useRuntimeConfig } from "./internal/config.mjs";
-export { useStorage } from "./internal/storage.mjs";
 export { defineNitroPlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
-export { defineNitroErrorHandler } from "./internal/error.mjs";
+export { defineNitroErrorHandler } from "./internal/error/utils.mjs";
+export { useRuntimeConfig } from "./internal/runtime-config.mjs";
+export { useRequest } from "./internal/context.mjs";
 export { defineRenderHandler } from "./internal/renderer.mjs";
-export { getRouteRules } from "./internal/route-rules.mjs";
-export { useEvent } from "./internal/context.mjs";
-export { defineTask, runTask } from "./internal/task.mjs";
-export { useDatabase } from "./internal/database.mjs";
 export {
   defineCachedFunction,
   defineCachedEventHandler,
+  defineCachedHandler,
   cachedFunction,
   cachedEventHandler
 } from "./internal/cache.mjs";
+export { useNitroApp } 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

@@ -0,0 +1,2 @@
+import type { NitroApp } from "nitro/types";
+export declare function useNitroApp(): NitroApp;

package/dist/runtime/internal/app.mjs

@@ -1,152 +1,153 @@
-import destr from "destr";
-import {
-  createApp,
-  createRouter,
-  eventHandler,
-  fetchWithEvent,
-  isEvent,
-  lazyEventHandler,
-  toNodeListener
-} from "h3";
+import { H3Core, toRequest } from "h3";
 import { createHooks } from "hookable";
-import { Headers, createFetch } from "ofetch";
-import {
-  createCall,
-  createFetch as createLocalFetch
-} from "unenv/runtime/fetch/index";
+import { nitroAsyncContext } from "./context.mjs";
 import errorHandler from "#nitro-internal-virtual/error-handler";
 import { plugins } from "#nitro-internal-virtual/plugins";
-import { handlers } from "#nitro-internal-virtual/server-handlers";
-import { cachedEventHandler } from "./cache.mjs";
-import { useRuntimeConfig } from "./config.mjs";
-import { nitroAsyncContext } from "./context.mjs";
-import { createRouteRulesHandler, getRouteRulesForPath } from "./route-rules.mjs";
-import { normalizeFetchResponse } from "./utils.mjs";
+import {
+  findRoute,
+  findRouteRules,
+  globalMiddleware,
+  findRoutedMiddleware
+} from "#nitro-internal-virtual/routing";
+export function useNitroApp() {
+  return useNitroApp.__instance__ ??= initNitroApp();
+}
+function initNitroApp() {
+  const nitroApp = createNitroApp();
+  for (const plugin of plugins) {
+    try {
+      plugin(nitroApp);
+    } catch (error) {
+      nitroApp.captureError(error, { tags: ["plugin"] });
+      throw error;
+    }
+  }
+  return nitroApp;
+}
 function createNitroApp() {
-  const config = useRuntimeConfig();
   const hooks = createHooks();
-  const captureError = (error, context = {}) => {
-    const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
-      console.error("Error while capturing another error", error_);
+  const captureError = (error, errorCtx) => {
+    const promise = hooks.callHookParallel("error", error, errorCtx).catch((hookError) => {
+      console.error("Error while capturing another error", hookError);
     });
-    if (context.event && isEvent(context.event)) {
-      const errors = context.event.context.nitro?.errors;
+    if (errorCtx?.event) {
+      const errors = errorCtx.event.req.context?.nitro?.errors;
       if (errors) {
-        errors.push({ error, context });
+        errors.push({ error, context: errorCtx });
       }
-      if (context.event.waitUntil) {
-        context.event.waitUntil(promise);
+      if (typeof errorCtx.event.req.waitUntil === "function") {
+        errorCtx.event.req.waitUntil(promise);
       }
     }
   };
-  const h3App = createApp({
-    debug: destr(process.env.DEBUG),
+  const h3App = createH3App(captureError);
+  let fetchHandler = async (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;
+  };
+  if (import.meta._asyncContext) {
+    const originalFetchHandler = fetchHandler;
+    fetchHandler = (req) => {
+      const asyncCtx = { request: req };
+      return nitroAsyncContext.callAsync(
+        asyncCtx,
+        () => originalFetchHandler(req)
+      );
+    };
+  }
+  const requestHandler = (input, init, context) => {
+    const req = toRequest(input, init);
+    req.context = { ...req.context, ...context };
+    return Promise.resolve(fetchHandler(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;
+    }
+    return originalFetch(input, init);
+  };
+  globalThis.fetch = nitroFetch;
+  const app = {
+    _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);
-    },
-    onRequest: async (event) => {
-      await nitroApp.hooks.callHook("request", event).catch((error) => {
-        captureError(error, { event, tags: ["request"] });
-      });
-    },
-    onBeforeResponse: async (event, response) => {
-      await nitroApp.hooks.callHook("beforeResponse", event, response).catch((error) => {
-        captureError(error, { event, tags: ["request", "response"] });
-      });
-    },
-    onAfterResponse: async (event, response) => {
-      await nitroApp.hooks.callHook("afterResponse", event, response).catch((error) => {
-        captureError(error, { event, tags: ["request", "response"] });
-      });
     }
   });
-  const router = createRouter({
-    preemptive: true
-  });
-  const localCall = createCall(toNodeListener(h3App));
-  const _localFetch = createLocalFetch(localCall, globalThis.fetch);
-  const localFetch = (input, init) => _localFetch(input, init).then(
-    (response) => normalizeFetchResponse(response)
-  );
-  const $fetch = createFetch({
-    fetch: localFetch,
-    Headers,
-    defaults: { baseURL: config.app.baseURL }
-  });
-  globalThis.$fetch = $fetch;
-  h3App.use(createRouteRulesHandler({ localFetch }));
-  h3App.use(
-    eventHandler((event) => {
-      event.context.nitro = event.context.nitro || { errors: [] };
-      const envContext = event.node.req?.__unenv__;
-      if (envContext) {
-        Object.assign(event.context, envContext);
-      }
-      event.fetch = (req, init) => fetchWithEvent(event, req, init, { fetch: localFetch });
-      event.$fetch = (req, init) => fetchWithEvent(event, req, init, {
-        fetch: $fetch
-      });
-      event.waitUntil = (promise) => {
-        if (!event.context.nitro._waitUntilPromises) {
-          event.context.nitro._waitUntilPromises = [];
+  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);
+  };
+  return h3App;
+}
+function getRouteRules(method, pathname) {
+  const m = findRouteRules(method, pathname);
+  if (!m?.length) {
+    return { routeRuleMiddleware: [] };
+  }
+  const routeRules = {};
+  for (const layer of m) {
+    for (const rule of layer.data) {
+      const currentRule = routeRules[rule.name];
+      if (currentRule) {
+        if (rule.options === false) {
+          delete routeRules[rule.name];
+          continue;
         }
-        event.context.nitro._waitUntilPromises.push(promise);
-        if (envContext?.waitUntil) {
-          envContext.waitUntil(promise);
+        if (typeof currentRule.options === "object" && typeof rule.options === "object") {
+          currentRule.options = { ...currentRule.options, ...rule.options };
+        } else {
+          currentRule.options = rule.options;
         }
-      };
-      event.captureError = (error, context) => {
-        captureError(error, { event, ...context });
-      };
-    })
-  );
-  for (const h of handlers) {
-    let handler = h.lazy ? lazyEventHandler(h.handler) : h.handler;
-    if (h.middleware || !h.route) {
-      const middlewareBase = (config.app.baseURL + (h.route || "/")).replace(
-        /\/+/g,
-        "/"
-      );
-      h3App.use(middlewareBase, handler);
-    } else {
-      const routeRules = getRouteRulesForPath(
-        h.route.replace(/:\w+|\*\*/g, "_")
-      );
-      if (routeRules.cache) {
-        handler = cachedEventHandler(handler, {
-          group: "nitro/routes",
-          ...routeRules.cache
-        });
+        currentRule.route = rule.route;
+        currentRule.params = { ...currentRule.params, ...layer.params };
+      } else if (rule.options !== false) {
+        routeRules[rule.name] = { ...rule, params: layer.params };
       }
-      router.use(h.route, handler, h.method);
     }
   }
-  h3App.use(config.app.baseURL, router.handler);
-  if (import.meta._asyncContext) {
-    const _handler = h3App.handler;
-    h3App.handler = (event) => {
-      const ctx = { event };
-      return nitroAsyncContext.callAsync(ctx, () => _handler(event));
-    };
-  }
-  const app = {
-    hooks,
-    h3App,
-    router,
-    localCall,
-    localFetch,
-    captureError
-  };
-  for (const plugin of plugins) {
-    try {
-      plugin(app);
-    } catch (error) {
-      captureError(error, { tags: ["plugin"] });
-      throw error;
+  const middleware = [];
+  for (const rule of Object.values(routeRules)) {
+    if (rule.options === false || !rule.handler) {
+      continue;
     }
+    middleware.push(rule.handler(rule));
   }
-  return app;
+  return {
+    routeRules,
+    routeRuleMiddleware: middleware
+  };
 }
-export const nitroApp = createNitroApp();
-export const useNitroApp = () => nitroApp;

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

@@ -0,0 +1,7 @@
+import type { EventHandler } from "h3";
+import type { CacheOptions, CachedEventHandlerOptions } from "nitro/types";
+export declare function defineCachedFunction<T, ArgsT extends unknown[] = any[]>(fn: (...args: ArgsT) => T | Promise<T>, opts?: CacheOptions<T, ArgsT>): (...args: ArgsT) => Promise<T>;
+export declare function cachedFunction<T, ArgsT extends unknown[] = any[]>(fn: (...args: ArgsT) => T | Promise<T>, opts?: CacheOptions<T>): (...args: ArgsT) => Promise<T | undefined>;
+export declare function defineCachedEventHandler(handler: EventHandler, opts?: CachedEventHandlerOptions): EventHandler;
+export declare const cachedEventHandler: typeof defineCachedEventHandler;
+export declare const defineCachedHandler: typeof defineCachedEventHandler;