nitro 3.0.1-alpha.2 → 3.0.260415-beta

package/dist/runtime/internal/cache.mjs

@@ -1,265 +1,41 @@
-import { defineHandler, handleCacheHeaders, isHTTPEvent, toResponse } from "h3";
+import { defineHandler, handleCacheHeaders, toResponse } from "h3";
 import { FastResponse } from "srvx";
-import { parseURL } from "ufo";
-import { hash } from "ohash";
+import { defineCachedFunction as _defineCachedFunction, defineCachedHandler as _defineCachedHandler, setStorage } from "ocache";
 import { useNitroApp } from "./app.mjs";
 import { useStorage } from "./storage.mjs";
-function defaultCacheOptions() {
-	return {
-		name: "_",
-		base: "/cache",
-		swr: true,
-		maxAge: 1
-	};
-}
-export function defineCachedFunction(fn, opts = {}) {
-	opts = {
-		...defaultCacheOptions(),
-		...opts
-	};
-	const pending = {};
-	// Normalize cache params
-	const group = opts.group || "nitro/functions";
-	const name = opts.name || fn.name || "_";
-	const integrity = opts.integrity || hash([fn, opts]);
-	const validate = opts.validate || ((entry) => entry.value !== undefined);
-	async function get(key, resolver, shouldInvalidateCache, event) {
-		// Use extension for key to avoid conflicting with parent namespace (foo/bar and foo/bar/baz)
-		const cacheKey = [
-			opts.base,
-			group,
-			name,
-			key + ".json"
-		].filter(Boolean).join(":").replace(/:\/$/, ":index");
-		let entry = await useStorage().getItem(cacheKey).catch((error) => {
-			console.error(`[cache] Cache read error.`, error);
-			useNitroApp().captureError?.(error, {
-				event,
-				tags: ["cache"]
-			});
-		}) || {};
-		// https://github.com/nitrojs/nitro/issues/2160
-		if (typeof entry !== "object") {
-			entry = {};
-			const error = new Error("Malformed data read from cache.");
-			console.error("[cache]", error);
-			useNitroApp().captureError?.(error, {
-				event,
-				tags: ["cache"]
-			});
-		}
-		const ttl = (opts.maxAge ?? 0) * 1e3;
-		if (ttl) {
-			entry.expires = Date.now() + ttl;
-		}
-		const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
-		const _resolve = async () => {
-			const isPending = pending[key];
-			if (!isPending) {
-				if (entry.value !== undefined && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
-					// Remove cached entry to prevent using expired cache on concurrent requests
-					entry.value = undefined;
-					entry.integrity = undefined;
-					entry.mtime = undefined;
-					entry.expires = undefined;
-				}
-				pending[key] = Promise.resolve(resolver());
-			}
-			try {
-				entry.value = await pending[key];
-			} catch (error) {
-				// Make sure entries that reject get removed.
-				if (!isPending) {
-					delete pending[key];
-				}
-				// Re-throw error to make sure the caller knows the task failed.
-				throw error;
-			}
-			if (!isPending) {
-				// Update mtime, integrity + validate and set the value in cache only the first time the request is made.
-				entry.mtime = Date.now();
-				entry.integrity = integrity;
-				delete pending[key];
-				if (validate(entry) !== false) {
-					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 (typeof event?.req?.waitUntil === "function") {
-						event.req.waitUntil(promise);
-					}
-				}
-			}
-		};
-		const _resolvePromise = expired ? _resolve() : Promise.resolve();
-		if (entry.value === undefined) {
-			await _resolvePromise;
-		} else if (expired && event && event.req.waitUntil) {
-			event.req.waitUntil(_resolvePromise);
-		}
-		if (opts.swr && validate(entry) !== false) {
-			_resolvePromise.catch((error) => {
-				console.error(`[cache] SWR handler error.`, error);
-				useNitroApp().captureError?.(error, {
-					event,
-					tags: ["cache"]
-				});
-			});
-			return entry;
-		}
-		return _resolvePromise.then(() => entry);
+let _storageReady = false;
+function ensureStorage() {
+	if (_storageReady) {
+		return;
 	}
-	return async (...args) => {
-		const shouldBypassCache = await opts.shouldBypassCache?.(...args);
-		if (shouldBypassCache) {
-			return fn(...args);
-		}
-		const key = await (opts.getKey || getKey)(...args);
-		const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
-		const entry = await get(key, () => fn(...args), shouldInvalidateCache, args[0] && isHTTPEvent(args[0]) ? args[0] : undefined);
-		let value = entry.value;
-		if (opts.transform) {
-			value = await opts.transform(entry, ...args) || value;
-		}
-		return value;
-	};
-}
-export function cachedFunction(fn, opts = {}) {
-	return defineCachedFunction(fn, opts);
+	_storageReady = true;
+	const storage = useStorage();
+	setStorage({
+		get: (key) => storage.getItem(key),
+		set: (key, value, opts) => storage.setItem(key, value, opts?.ttl ? { ttl: opts.ttl } : undefined)
+	});
 }
-function getKey(...args) {
-	return args.length > 0 ? hash(args) : "";
+function defaultOnError(error) {
+	console.error("[cache]", error);
+	useNitroApp().captureError?.(error, { tags: ["cache"] });
 }
-function escapeKey(key) {
-	return String(key).replace(/\W/g, "");
+export function defineCachedFunction(fn, opts = {}) {
+	ensureStorage();
+	return _defineCachedFunction(fn, {
+		group: "nitro/functions",
+		onError: defaultOnError,
+		...opts
+	});
 }
-export function defineCachedHandler(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) => {
-			// Custom user-defined key
-			const customKey = await opts.getKey?.(event);
-			if (customKey) {
-				return escapeKey(customKey);
-			}
-			// Auto-generated key
-			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.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.status >= 400) {
-				return false;
-			}
-			if (entry.value.body === undefined) {
-				return false;
-			}
-			// https://github.com/nitrojs/nitro/pull/1857
-			if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
-				return false;
-			}
-			return true;
-		},
-		group: opts.group || "nitro/handlers",
-		integrity: opts.integrity || hash([handler, opts])
-	};
-	const _cachedHandler = cachedFunction(async (event) => {
-		// Filter non variable headers
-		const filteredHeaders = [...event.req.headers.entries()].filter(([key]) => !variableHeaderNames.includes(key.toLowerCase()));
-		try {
-			const originalReq = event.req;
-			// @ts-expect-error assigning to publicly readonly property
-			event.req = new Request(event.req.url, {
-				method: event.req.method,
-				headers: filteredHeaders
-			});
-			// Inherit srvx context
-			event.req.runtime = originalReq.runtime;
-			event.req.waitUntil = originalReq.waitUntil;
-		} catch (error) {
-			console.error("[cache] Failed to filter headers:", error);
-		}
-		// Call handler
-		const rawValue = await handler(event);
-		const res = await toResponse(rawValue, event);
-		// Stringified body
-		// TODO: support binary responses
-		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", new Date().toUTCString());
-		}
-		const cacheControl = [];
-		if (opts.swr) {
-			if (opts.maxAge) {
-				cacheControl.push(`s-maxage=${opts.maxAge}`);
-			}
-			if (opts.staleMaxAge) {
-				cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
-			} else {
-				cacheControl.push("stale-while-revalidate");
-			}
-		} else if (opts.maxAge) {
-			cacheControl.push(`max-age=${opts.maxAge}`);
-		}
-		if (cacheControl.length > 0) {
-			res.headers.set("cache-control", cacheControl.join(", "));
-		}
-		const cacheEntry = {
-			status: res.status,
-			statusText: res.statusText,
-			headers: Object.fromEntries(res.headers.entries()),
-			body
-		};
-		return cacheEntry;
-	}, _opts);
-	return defineHandler(async (event) => {
-		// Headers-only mode
-		if (opts.headersOnly) {
-			// TODO: Send SWR too
-			if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
-				return;
-			}
-			return handler(event);
-		}
-		// Call with cache
-		const response = await _cachedHandler(event);
-		// Check for cache headers
-		if (handleCacheHeaders(event, {
-			modifiedTime: new Date(response.headers["last-modified"]),
-			etag: response.headers.etag,
-			maxAge: opts.maxAge
-		})) {
-			return;
-		}
-		// Send Response
-		return new FastResponse(response.body, {
-			status: response.status,
-			statusText: response.statusText,
-			headers: response.headers
-		});
+export function defineCachedHandler(handler, opts = {}) {
+	ensureStorage();
+	const ocacheHandler = _defineCachedHandler(handler, {
+		group: "nitro/handlers",
+		onError: defaultOnError,
+		toResponse: (value, event) => toResponse(value, event),
+		createResponse: (body, init) => new FastResponse(body, init),
+		handleCacheHeaders: (event, conditions) => handleCacheHeaders(event, conditions),
+		...opts
 	});
+	return defineHandler((event) => ocacheHandler(event));
 }

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

@@ -1,5 +1,7 @@
+import type { NitroAsyncContext } from "nitro/types";
 import type { ServerRequest } from "srvx";
-export declare const nitroAsyncContext: unknown;
+import { type UseContext } from "unctx";
+export declare const nitroAsyncContext: UseContext<NitroAsyncContext>;
 /**
 *
 * Access to the current Nitro request.

package/dist/runtime/internal/context.mjs

@@ -5,15 +5,7 @@ export const nitroAsyncContext = /* @__PURE__ */ (() => getContext("nitro-app",
 	asyncContext: import.meta._asyncContext,
 	AsyncLocalStorage: import.meta._asyncContext ? AsyncLocalStorage : undefined
 }))();
-/**
-*
-* Access to the current Nitro request.
-*
-* @experimental
-*  - Requires `experimental.asyncContext: true` config to work.
-*  - Works in Node.js and limited runtimes only
-*
-*/
+
 export function useRequest() {
 	try {
 		return nitroAsyncContext.use().request;

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

@@ -1,9 +1,10 @@
-import type { HTTPError, HTTPEvent } from "h3";
+import { HTTPError, type HTTPEvent } from "h3";
 import type { InternalHandlerResponse } from "./utils.mjs";
-declare const _default;
-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;
 }): Promise<InternalHandlerResponse>;
-export declare function loadStackTrace(error: any);
+export declare function loadStackTrace(error: any): Promise<void>;

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

@@ -1,87 +1,84 @@
+import { HTTPError } from "h3";
 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 errorHandler = 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 default errorHandler;
 export async function defaultHandler(error, event, opts) {
-	const isSensitive = error.unhandled;
-	const status = error.status || 500;
-	// prettier-ignore
+	const unhandled = error.unhandled ?? !HTTPError.isError(error);
+	const { status = 500, statusText = "" } = unhandled ? {} : error;
 	const url = getRequestURL(event, {
 		xForwardedHost: true,
 		xForwardedProto: true
 	});
-	// Redirects with base URL
+	
 	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 },
+				headers: new Headers({ location: `${baseURL}${url.pathname.slice(1)}${url.search}` }),
 				body: `Redirecting...`
 			};
 		}
 	}
-	// Load stack trace with source maps
+	
 	await loadStackTrace(error).catch(consola.error);
-	// https://github.com/poppinss/youch
+	const { Youch } = await import("youch");
+	
 	const youch = new Youch();
-	// Console output
-	if (isSensitive && !opts?.silent) {
-		// prettier-ignore
-		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}\n\n`, ansiError);
+	
+	if (unhandled && !opts?.silent) {
+		const ansiError = (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+		consola.error(`[request error] [${event.req.method}] ${url}\n\n`, ansiError);
 	}
-	// Use HTML response only when user-agent expects it (browsers)
+	
 	const useJSON = opts?.json ?? !event.req.headers.get("accept")?.includes("text/html");
-	// Prepare headers
-	const headers = {
-		"content-type": useJSON ? "application/json" : "text/html",
-		"x-content-type-options": "nosniff",
-		"x-frame-options": "DENY",
-		"referrer-policy": "no-referrer",
-		"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 headers = new Headers(unhandled ? {} : error.headers);
+	if (useJSON) {
+		headers.set("Content-Type", "application/json; charset=utf-8");
+		const jsonBody = typeof error.toJSON === "function" ? error.toJSON() : {
+			status,
+			statusText,
+			message: error.message
+		};
+		return {
+			status,
+			statusText,
+			headers,
+			body: {
+				error: true,
+				stack: error.stack?.split("\n").map((line) => line.trim()),
+				...jsonBody
+			}
+		};
 	}
-	// Prepare body
-	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())
-	} });
+	
+	headers.set("Content-Type", "text/html; charset=utf-8");
 	return {
 		status,
-		statusText: error.statusText,
+		statusText: unhandled ? "" : error.statusText,
 		headers,
-		body
+		body: await youch.toHTML(error, { request: {
+			url: url.href,
+			method: event.req.method,
+			headers: Object.fromEntries(event.req.headers.entries())
+		} })
 	};
 }
-// ---- Source Map support ----
+
 export async function loadStackTrace(error) {
 	if (!(error instanceof Error)) {
 		return;
 	}
+	const { ErrorParser } = await import("youch-core");
 	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 });
@@ -94,17 +91,18 @@ async function sourceLoader(frame) {
 		return;
 	}
 	if (frame.type === "app") {
-		// prettier-ignore
+		
 		const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {});
 		if (rawSourceMap) {
+			const { SourceMapConsumer } = await import("source-map");
 			const consumer = await new SourceMapConsumer(rawSourceMap);
-			// prettier-ignore
+			
 			const originalPosition = consumer.originalPositionFor({
 				line: frame.lineNumber,
 				column: frame.columnNumber
 			});
 			if (originalPosition.source && originalPosition.line) {
-				// prettier-ignore
+				
 				frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
 				frame.lineNumber = originalPosition.line;
 				frame.columnNumber = originalPosition.column || 0;

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

@@ -1 +1 @@
-export declare function trapUnhandledErrors();
+export declare function trapUnhandledErrors(): void;

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

@@ -1,9 +1,6 @@
-import type { HTTPError, HTTPEvent } from "h3";
+import { HTTPError, type HTTPEvent } from "h3";
 import type { InternalHandlerResponse } from "./utils.mjs";
 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;
-}): InternalHandlerResponse;
+export declare function defaultHandler(error: HTTPError, event: HTTPEvent): InternalHandlerResponse;

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

@@ -1,54 +1,40 @@
+import { HTTPError } from "h3";
 import { FastResponse } from "srvx";
 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 = event.url || new URL(event.req.url);
+export function defaultHandler(error, event) {
+	const unhandled = error.unhandled ?? !HTTPError.isError(error);
+	const { status = 500, statusText = "" } = unhandled ? {} : error;
 	if (status === 404) {
+		const url = event.url || new URL(event.req.url);
 		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...`
+				headers: new Headers({ location: `${baseURL}${url.pathname.slice(1)}${url.search}` })
 			};
 		}
 	}
-	// Console output
-	if (isSensitive && !opts?.silent) {
-		// prettier-ignore
-		const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
-		console.error(`[request error] ${tags} [${event.req.method}] ${url}\n`, error);
-	}
-	// Send response
-	const headers = {
-		"content-type": "application/json",
-		"x-content-type-options": "nosniff",
-		"x-frame-options": "DENY",
-		"referrer-policy": "no-referrer",
-		"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,
+	const headers = new Headers(unhandled ? {} : error.headers);
+	headers.set("content-type", "application/json; charset=utf-8");
+	const jsonBody = unhandled ? {
 		status,
-		statusText: error.statusText,
-		message: isSensitive ? "Server Error" : error.message,
-		data: isSensitive ? undefined : error.data
+		unhandled: true
+	} : typeof error.toJSON === "function" ? error.toJSON() : {
+		status,
+		statusText,
+		message: error.message
 	};
 	return {
 		status,
-		statusText: error.statusText,
+		statusText,
 		headers,
-		body
+		body: {
+			error: true,
+			...jsonBody
+		}
 	};
 }

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

@@ -1,8 +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>;
+	status?: number;
+	statusText?: string | undefined;
+	headers?: HeadersInit;
+	body?: string | Record<string, any>;
 };

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

@@ -1,2 +1,2 @@
 import type { NitroRouteMeta } from "nitro/types";
-export declare function defineRouteMeta(meta: NitroRouteMeta);
+export declare function defineRouteMeta(meta: NitroRouteMeta): NitroRouteMeta;

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

@@ -1,3 +1,3 @@
 import type { NitroAppPlugin } from "nitro/types";
-export declare function defineNitroPlugin(def: NitroAppPlugin);
-export declare const nitroPlugin: unknown;
+export declare function defineNitroPlugin(def: NitroAppPlugin): NitroAppPlugin;
+export declare const nitroPlugin: (def: NitroAppPlugin) => NitroAppPlugin;

package/dist/runtime/internal/route-rules.d.mts

@@ -1,4 +1,11 @@
-export declare const headers: unknown;
-export declare const redirect: unknown;
-export declare const proxy: unknown;
-export declare const cache: unknown;
+import type { Middleware } from "h3";
+import type { MatchedRouteRule, NitroRouteRules } from "nitro/types";
+type RouteRuleCtor<T extends keyof NitroRouteRules> = ((m: MatchedRouteRule<T>) => Middleware) & {
+	order?: number;
+};
+export declare const headers: RouteRuleCtor<"headers">;
+export declare const redirect: RouteRuleCtor<"redirect">;
+export declare const proxy: RouteRuleCtor<"proxy">;
+export declare const cache: RouteRuleCtor<"cache">;
+export declare const basicAuth: RouteRuleCtor<"auth">;
+export {};