nitro 3.0.0 → 3.0.1-alpha.1

package/dist/runtime/internal/cache.mjs

@@ -5,232 +5,261 @@ import { hash } from "ohash";
 import { useNitroApp } from "./app.mjs";
 import { useStorage } from "./storage.mjs";
 function defaultCacheOptions() {
-  return {
-    name: "_",
-    base: "/cache",
-    swr: true,
-    maxAge: 1
-  };
+	return {
+		name: "_",
+		base: "/cache",
+		swr: true,
+		maxAge: 1
+	};
 }
 export function defineCachedFunction(fn, opts = {}) {
-  opts = { ...defaultCacheOptions(), ...opts };
-  const pending = {};
-  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 !== void 0);
-  async function get(key, resolver, shouldInvalidateCache, event) {
-    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"] });
-    }) || {};
-    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 !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
-          entry.value = void 0;
-          entry.integrity = void 0;
-          entry.mtime = void 0;
-          entry.expires = void 0;
-        }
-        pending[key] = Promise.resolve(resolver());
-      }
-      try {
-        entry.value = await pending[key];
-      } catch (error) {
-        if (!isPending) {
-          delete pending[key];
-        }
-        throw error;
-      }
-      if (!isPending) {
-        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 === void 0) {
-      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);
-  }
-  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] : void 0
-    );
-    let value = entry.value;
-    if (opts.transform) {
-      value = await opts.transform(entry, ...args) || value;
-    }
-    return value;
-  };
+	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);
+	}
+	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);
+	return defineCachedFunction(fn, opts);
 }
 function getKey(...args) {
-  return args.length > 0 ? hash(args) : "";
+	return args.length > 0 ? hash(args) : "";
 }
 function escapeKey(key) {
-  return String(key).replace(/\W/g, "");
+	return String(key).replace(/\W/g, "");
 }
-export function defineCachedEventHandler(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) => {
-      const customKey = await opts.getKey?.(event);
-      if (customKey) {
-        return escapeKey(customKey);
-      }
-      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 === void 0) {
-        return false;
-      }
-      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) => {
-      const filteredHeaders = [...event.req.headers.entries()].filter(
-        ([key]) => !variableHeaderNames.includes(key.toLowerCase())
-      );
-      try {
-        const originalReq = event.req;
-        event.req = new Request(event.req.url, {
-          method: event.req.method,
-          headers: filteredHeaders
-        });
-        event.req.runtime = originalReq.runtime;
-        event.req.waitUntil = originalReq.waitUntil;
-      } catch (error) {
-        console.error("[cache] Failed to filter headers:", error);
-      }
-      const rawValue = await handler(event);
-      const res = await toResponse(rawValue, event);
-      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", (/* @__PURE__ */ 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) => {
-    if (opts.headersOnly) {
-      if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
-        return;
-      }
-      return handler(event);
-    }
-    const response = await _cachedHandler(event);
-    if (handleCacheHeaders(event, {
-      modifiedTime: new Date(response.headers["last-modified"]),
-      etag: response.headers.etag,
-      maxAge: opts.maxAge
-    })) {
-      return;
-    }
-    return new FastResponse(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  });
+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 const cachedEventHandler = defineCachedEventHandler;
-export const defineCachedHandler = defineCachedEventHandler;

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

@@ -1,12 +1,12 @@
 import type { ServerRequest } from "srvx";
-export declare const nitroAsyncContext: import("unctx/index").UseContext<NitroAsyncContext>;
+export declare const nitroAsyncContext: unknown;
 /**
- *
- * Access to the current Nitro request.
- *
- * @experimental
- *  - Requires `experimental.asyncContext: true` config to work.
- *  - Works in Node.js and limited runtimes only
- *
- */
+*
+* Access to the current Nitro request.
+*
+* @experimental
+*  - Requires `experimental.asyncContext: true` config to work.
+*  - Works in Node.js and limited runtimes only
+*
+*/
 export declare function useRequest(): ServerRequest;

package/dist/runtime/internal/context.mjs

@@ -2,16 +2,23 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { HTTPError } from "h3";
 import { getContext } from "unctx";
 export const nitroAsyncContext = /* @__PURE__ */ (() => getContext("nitro-app", {
-  asyncContext: import.meta._asyncContext,
-  AsyncLocalStorage: import.meta._asyncContext ? AsyncLocalStorage : void 0
+	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;
-  } catch {
-    const hint = import.meta._asyncContext ? "Note: This is an experimental feature and might be broken on non-Node.js environments." : "Enable the experimental flag using `experimental.asyncContext: true`.";
-    throw new HTTPError({
-      message: `Nitro request context is not available. ${hint}`
-    });
-  }
+	try {
+		return nitroAsyncContext.use().request;
+	} catch {
+		const hint = import.meta._asyncContext ? "Note: This is an experimental feature and might be broken on non-Node.js environments." : "Enable the experimental flag using `experimental.asyncContext: true`.";
+		throw new HTTPError({ message: `Nitro request context is not available. ${hint}` });
+	}
 }

package/dist/runtime/internal/database.mjs

@@ -1,14 +1,12 @@
 import { createDatabase } from "db0";
 import { connectionConfigs } from "#nitro-internal-virtual/database";
-const instances = /* @__PURE__ */ Object.create(null);
+const instances = Object.create(null);
 export function useDatabase(name = "default") {
-  if (instances[name]) {
-    return instances[name];
-  }
-  if (!connectionConfigs[name]) {
-    throw new Error(`Database connection "${name}" not configured.`);
-  }
-  return instances[name] = createDatabase(
-    connectionConfigs[name].connector(connectionConfigs[name].options || {})
-  );
+	if (instances[name]) {
+		return instances[name];
+	}
+	if (!connectionConfigs[name]) {
+		throw new Error(`Database connection "${name}" not configured.`);
+	}
+	return instances[name] = createDatabase(connectionConfigs[name].connector(connectionConfigs[name].options || {}));
 }

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

@@ -1,9 +1,10 @@
 import type { HTTPError, HTTPEvent } from "h3";
 import type { InternalHandlerResponse } from "./utils.mjs";
-declare const _default: NitroErrorHandler;
+declare const _default;
 export default _default;
 export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?: {
-    silent?: boolean;
-    json?: boolean;
+	silent?: boolean;
+	json?: boolean;
 }): Promise<InternalHandlerResponse>;
-export declare function loadStackTrace(error: any): Promise<void>;
+// ---- Source Map support ----
+export declare function loadStackTrace(error: any);