nitro 3.0.1-alpha.0 → 3.0.1-alpha.2

package/dist/runtime/internal/app.mjs

@@ -1,153 +1,208 @@
 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";
-import {
-  findRoute,
-  findRouteRules,
-  globalMiddleware,
-  findRoutedMiddleware
-} from "#nitro-internal-virtual/routing";
+// IMPORTANT: virtual imports and user code should be imported last to avoid initialization order issues
+import errorHandler from "#nitro/virtual/error-handler";
+import { plugins } from "#nitro/virtual/plugins";
+import { findRoute, findRouteRules, globalMiddleware, findRoutedMiddleware } from "#nitro/virtual/routing";
+import { hasRouteRules, hasRoutedMiddleware, hasGlobalMiddleware, hasRoutes, hasHooks, hasPlugins } from "#nitro/virtual/feature-flags";
+const APP_ID = import.meta.prerender ? "prerender" : "default";
 export function useNitroApp() {
-  return useNitroApp.__instance__ ??= initNitroApp();
+	let instance = useNitroApp._instance;
+	if (instance) {
+		return instance;
+	}
+	instance = useNitroApp._instance = createNitroApp();
+	globalThis.__nitro__ = globalThis.__nitro__ || {};
+	globalThis.__nitro__[APP_ID] = instance;
+	if (hasPlugins) {
+		initNitroPlugins(instance);
+	}
+	return instance;
 }
-function initNitroApp() {
-  const nitroApp = createNitroApp();
-  for (const plugin of plugins) {
-    try {
-      plugin(nitroApp);
-    } catch (error) {
-      nitroApp.captureError(error, { tags: ["plugin"] });
-      throw error;
-    }
-  }
-  return nitroApp;
+export function useNitroHooks() {
+	const nitroApp = useNitroApp();
+	const hooks = nitroApp.hooks;
+	if (hooks) {
+		return hooks;
+	}
+	return nitroApp.hooks = new HookableCore();
+}
+export function serverFetch(resource, init, context) {
+	const req = toRequest(resource, init);
+	req.context = {
+		...req.context,
+		...context
+	};
+	const appHandler = useNitroApp().fetch;
+	try {
+		return Promise.resolve(appHandler(req));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+export async function resolveWebsocketHooks(req) {
+	// https://github.com/h3js/h3/blob/c11ca743d476e583b3b47de1717e6aae92114357/src/utils/ws.ts#L37
+	const hooks = (await serverFetch(req)).crossws;
+	return hooks || {};
+}
+export function fetch(resource, init, context) {
+	if (typeof resource === "string" && resource.charCodeAt(0) === 47) {
+		return serverFetch(resource, init, context);
+	}
+	resource = resource._request || resource;
+	return fetch(resource, init);
 }
 function createNitroApp() {
-  const hooks = createHooks();
-  const captureError = (error, errorCtx) => {
-    const promise = hooks.callHookParallel("error", error, errorCtx).catch((hookError) => {
-      console.error("Error while capturing another error", hookError);
-    });
-    if (errorCtx?.event) {
-      const errors = errorCtx.event.req.context?.nitro?.errors;
-      if (errors) {
-        errors.push({ error, context: errorCtx });
-      }
-      if (typeof errorCtx.event.req.waitUntil === "function") {
-        errorCtx.event.req.waitUntil(promise);
-      }
-    }
-  };
-  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;
+	const hooks = hasHooks ? new HookableCore() : undefined;
+	const captureError = (error, errorCtx) => {
+		const promise = hasHooks && hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {
+			console.error("Error while capturing another error", hookError);
+		});
+		if (errorCtx?.event) {
+			const errors = errorCtx.event.req.context?.nitro?.errors;
+			if (errors) {
+				errors.push({
+					error,
+					context: errorCtx
+				});
+			}
+			if (hasHooks && promise && typeof errorCtx.event.req.waitUntil === "function") {
+				errorCtx.event.req.waitUntil(promise);
+			}
+		}
+	};
+	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: [] };
+		return h3App.fetch(req);
+	};
+	// Experimental async context support
+	if (import.meta._asyncContext) {
+		const originalHandler = appHandler;
+		appHandler = (req) => {
+			const asyncCtx = { request: req };
+			return nitroAsyncContext.callAsync(asyncCtx, () => originalHandler(req));
+		};
+	}
+	const app = {
+		fetch: appHandler,
+		h3: h3App,
+		hooks,
+		captureError
+	};
+	return app;
+}
+function initNitroPlugins(app) {
+	for (const plugin of plugins) {
+		try {
+			plugin(app);
+		} catch (error) {
+			app.captureError?.(error, { tags: ["plugin"] });
+			throw error;
+		}
+	}
+	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);
-  };
-  return h3App;
+function createH3App(config) {
+	// Create H3 app
+	const h3App = new H3Core(config);
+	// Compiled route matching
+	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 : undefined;
+			const method = needsRouting ? event.req.method : undefined;
+			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) {
-  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;
-        }
-        if (typeof currentRule.options === "object" && typeof rule.options === "object") {
-          currentRule.options = { ...currentRule.options, ...rule.options };
-        } else {
-          currentRule.options = rule.options;
-        }
-        currentRule.route = rule.route;
-        currentRule.params = { ...currentRule.params, ...layer.params };
-      } else if (rule.options !== false) {
-        routeRules[rule.name] = { ...rule, params: layer.params };
-      }
-    }
-  }
-  const middleware = [];
-  for (const rule of Object.values(routeRules)) {
-    if (rule.options === false || !rule.handler) {
-      continue;
-    }
-    middleware.push(rule.handler(rule));
-  }
-  return {
-    routeRules,
-    routeRuleMiddleware: middleware
-  };
+export 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) {
+					// Remove/Reset existing rule with `false` value
+					delete routeRules[rule.name];
+					continue;
+				}
+				if (typeof currentRule.options === "object" && typeof rule.options === "object") {
+					// Merge nested rule objects
+					currentRule.options = {
+						...currentRule.options,
+						...rule.options
+					};
+				} else {
+					// Override rule if non object
+					currentRule.options = rule.options;
+				}
+				// Routing (route and params)
+				currentRule.route = rule.route;
+				currentRule.params = {
+					...currentRule.params,
+					...layer.params
+				};
+			} else if (rule.options !== false) {
+				routeRules[rule.name] = {
+					...rule,
+					params: layer.params
+				};
+			}
+		}
+	}
+	const middleware = [];
+	for (const rule of Object.values(routeRules)) {
+		if (rule.options === false || !rule.handler) {
+			continue;
+		}
+		middleware.push(rule.handler(rule));
+	}
+	return {
+		routeRules,
+		routeRuleMiddleware: middleware
+	};
 }

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

@@ -1,7 +1,11 @@
 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;
+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 defineCachedHandler(handler: EventHandler, opts?: CachedEventHandlerOptions): EventHandler;