nitro 3.0.0 → 3.0.1-alpha.1

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

@@ -7,116 +7,117 @@ 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 res = await defaultHandler(error, event);
-    return new FastResponse(
-      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
-      res
-    );
-  }
-);
+export default 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 async function defaultHandler(error, event, opts) {
-  const isSensitive = error.unhandled;
-  const status = error.status || 500;
-  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
-  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 },
-        body: `Redirecting...`
-      };
-    }
-  }
-  await loadStackTrace(error).catch(consola.error);
-  const youch = new Youch();
-  if (isSensitive && !opts?.silent) {
-    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}
-
-`,
-      ansiError
-    );
-  }
-  const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
-  const headers = {
-    "content-type": useJSON ? "application/json" : "text/html",
-    // 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 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
-  };
-  if (status === 404 || !event.res.headers.has("cache-control")) {
-    headers["cache-control"] = "no-cache";
-  }
-  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())
-    }
-  });
-  return {
-    status,
-    statusText: error.statusText,
-    headers,
-    body
-  };
+	const isSensitive = error.unhandled;
+	const status = error.status || 500;
+	// prettier-ignore
+	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 },
+				body: `Redirecting...`
+			};
+		}
+	}
+	// Load stack trace with source maps
+	await loadStackTrace(error).catch(consola.error);
+	// https://github.com/poppinss/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);
+	}
+	// 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";
+	}
+	// 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())
+	} });
+	return {
+		status,
+		statusText: error.statusText,
+		headers,
+		body
+	};
 }
+// ---- Source Map support ----
 export async function loadStackTrace(error) {
-  if (!(error instanceof Error)) {
-    return;
-  }
-  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 });
-  if (error.cause) {
-    await loadStackTrace(error.cause).catch(consola.error);
-  }
+	if (!(error instanceof Error)) {
+		return;
+	}
+	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 });
+	if (error.cause) {
+		await loadStackTrace(error.cause).catch(consola.error);
+	}
 }
 async function sourceLoader(frame) {
-  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
-    return;
-  }
-  if (frame.type === "app") {
-    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
-    });
-    if (rawSourceMap) {
-      const consumer = await new SourceMapConsumer(rawSourceMap);
-      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
-      if (originalPosition.source && originalPosition.line) {
-        frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
-        frame.lineNumber = originalPosition.line;
-        frame.columnNumber = originalPosition.column || 0;
-      }
-    }
-  }
-  const contents = await readFile(frame.fileName, "utf8").catch(() => {
-  });
-  return contents ? { contents } : void 0;
+	if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+		return;
+	}
+	if (frame.type === "app") {
+		// prettier-ignore
+		const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {});
+		if (rawSourceMap) {
+			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;
+			}
+		}
+	}
+	const contents = await readFile(frame.fileName, "utf8").catch(() => {});
+	return contents ? { contents } : undefined;
 }
 function fmtFrame(frame) {
-  if (frame.type === "native") {
-    return frame.raw;
-  }
-  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
-  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+	if (frame.type === "native") {
+		return frame.raw;
+	}
+	const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+	return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
 }

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

@@ -0,0 +1 @@
+export declare function trapUnhandledErrors();

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

@@ -0,0 +1,9 @@
+import { useNitroApp } from "../app.mjs";
+function _captureError(error, type) {
+	console.error(`[${type}]`, error);
+	useNitroApp().captureError?.(error, { tags: [type] });
+}
+export function trapUnhandledErrors() {
+	process.on("unhandledRejection", (error) => _captureError(error, "unhandledRejection"));
+	process.on("uncaughtException", (error) => _captureError(error, "uncaughtException"));
+}

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

@@ -1,8 +1,9 @@
 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;
+	silent?: boolean;
+	json?: boolean;
 }): InternalHandlerResponse;

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

@@ -1,62 +1,54 @@
-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 });
-  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 },
-        body: `Redirecting...`
-      };
-    }
-  }
-  if (isSensitive && !opts?.silent) {
-    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
-    console.error(
-      `[request error] ${tags} [${event.req.method}] ${url}
-`,
-      error
-    );
-  }
-  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")) {
-    headers["cache-control"] = "no-cache";
-  }
-  const body = {
-    error: true,
-    url: url.href,
-    status,
-    statusText: error.statusText,
-    message: isSensitive ? "Server Error" : error.message,
-    data: isSensitive ? void 0 : error.data
-  };
-  return {
-    status,
-    statusText: error.statusText,
-    headers,
-    body
-  };
+	const isSensitive = error.unhandled;
+	const status = error.status || 500;
+	const url = event.url || new URL(event.req.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 },
+				body: `Redirecting...`
+			};
+		}
+	}
+	// 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,
+		status,
+		statusText: error.statusText,
+		message: isSensitive ? "Server Error" : error.message,
+		data: isSensitive ? undefined : error.data
+	};
+	return {
+		status,
+		statusText: error.statusText,
+		headers,
+		body
+	};
 }

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: Record<string, string>;
+	body: string | Record<string, any>;
 };

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

@@ -1,3 +1,3 @@
 export function defineNitroErrorHandler(handler) {
-  return handler;
+	return handler;
 }

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

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

package/dist/runtime/internal/meta.mjs

@@ -1,3 +1,3 @@
 export function defineRouteMeta(meta) {
-  return meta;
+	return meta;
 }

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

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

package/dist/runtime/internal/plugin.mjs

@@ -1,4 +1,4 @@
 export function defineNitroPlugin(def) {
-  return def;
+	return def;
 }
 export const nitroPlugin = defineNitroPlugin;

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

@@ -1,8 +1,8 @@
-import type { Middleware } from "h3";
-import type { MatchedRouteRule, NitroRouteRules } from "nitro/types";
-type RouteRuleCtor<T extends keyof NitroRouteRules> = (m: MatchedRouteRule<T>) => Middleware;
-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 {};
+// Headers route rule
+export declare const headers: unknown;
+// Redirect route rule
+export declare const redirect: unknown;
+// Proxy route rule
+export declare const proxy: unknown;
+// Cache route rule
+export declare const cache: unknown;

package/dist/runtime/internal/route-rules.mjs

@@ -1,62 +1,64 @@
 import { proxyRequest, redirect as sendRedirect } from "h3";
 import { joinURL, withQuery, withoutBase } from "ufo";
-import { defineCachedEventHandler } from "./cache.mjs";
+import { defineCachedHandler } from "./cache.mjs";
+// Headers route rule
 export const headers = ((m) => function headersRouteRule(event) {
-  for (const [key, value] of Object.entries(m.options || {})) {
-    event.res.headers.set(key, value);
-  }
+	for (const [key, value] of Object.entries(m.options || {})) {
+		event.res.headers.set(key, value);
+	}
 });
+// Redirect route rule
 export const redirect = ((m) => function redirectRouteRule(event) {
-  let target = m.options?.to;
-  if (!target) {
-    return;
-  }
-  if (target.endsWith("/**")) {
-    let targetPath = event.url.pathname + event.url.search;
-    const strpBase = m.options._redirectStripBase;
-    if (strpBase) {
-      targetPath = withoutBase(targetPath, strpBase);
-    }
-    target = joinURL(target.slice(0, -3), targetPath);
-  } else if (event.url.search) {
-    target = withQuery(target, Object.fromEntries(event.url.searchParams));
-  }
-  return sendRedirect(target, m.options?.status);
+	let target = m.options?.to;
+	if (!target) {
+		return;
+	}
+	if (target.endsWith("/**")) {
+		let targetPath = event.url.pathname + event.url.search;
+		const strpBase = m.options._redirectStripBase;
+		if (strpBase) {
+			targetPath = withoutBase(targetPath, strpBase);
+		}
+		target = joinURL(target.slice(0, -3), targetPath);
+	} else if (event.url.search) {
+		target = withQuery(target, Object.fromEntries(event.url.searchParams));
+	}
+	return sendRedirect(target, m.options?.status);
 });
+// Proxy route rule
 export const proxy = ((m) => function proxyRouteRule(event) {
-  let target = m.options?.to;
-  if (!target) {
-    return;
-  }
-  if (target.endsWith("/**")) {
-    let targetPath = event.url.pathname + event.url.search;
-    const strpBase = m.options._proxyStripBase;
-    if (strpBase) {
-      targetPath = withoutBase(targetPath, strpBase);
-    }
-    target = joinURL(target.slice(0, -3), targetPath);
-  } else if (event.url.search) {
-    target = withQuery(target, Object.fromEntries(event.url.searchParams));
-  }
-  return proxyRequest(event, target, {
-    ...m.options
-  });
+	let target = m.options?.to;
+	if (!target) {
+		return;
+	}
+	if (target.endsWith("/**")) {
+		let targetPath = event.url.pathname + event.url.search;
+		const strpBase = m.options._proxyStripBase;
+		if (strpBase) {
+			targetPath = withoutBase(targetPath, strpBase);
+		}
+		target = joinURL(target.slice(0, -3), targetPath);
+	} else if (event.url.search) {
+		target = withQuery(target, Object.fromEntries(event.url.searchParams));
+	}
+	return proxyRequest(event, target, { ...m.options });
 });
+// Cache route rule
 export const cache = ((m) => function cacheRouteRule(event, next) {
-  if (!event.context.matchedRoute) {
-    return next();
-  }
-  const cachedHandlers = globalThis.__nitroCachedHandlers ??= /* @__PURE__ */ new Map();
-  const { handler, route } = event.context.matchedRoute;
-  const key = `${m.route}:${route}`;
-  let cachedHandler = cachedHandlers.get(key);
-  if (!cachedHandler) {
-    cachedHandler = defineCachedEventHandler(handler, {
-      group: "nitro/route-rules",
-      name: key,
-      ...m.options
-    });
-    cachedHandlers.set(key, cachedHandler);
-  }
-  return cachedHandler(event);
+	if (!event.context.matchedRoute) {
+		return next();
+	}
+	const cachedHandlers = globalThis.__nitroCachedHandlers ??= new Map();
+	const { handler, route } = event.context.matchedRoute;
+	const key = `${m.route}:${route}`;
+	let cachedHandler = cachedHandlers.get(key);
+	if (!cachedHandler) {
+		cachedHandler = defineCachedHandler(handler, {
+			group: "nitro/route-rules",
+			name: key,
+			...m.options
+		});
+		cachedHandlers.set(key, cachedHandler);
+	}
+	return cachedHandler(event);
 });

package/dist/runtime/internal/routes/dev-tasks.d.mts

@@ -1,3 +1,2 @@
-import { H3 } from "h3";
-declare const _default: H3;
+declare const _default;
 export default _default;

package/dist/runtime/internal/routes/dev-tasks.mjs

@@ -1,23 +1,21 @@
 import { H3 } from "h3";
-import { runTask } from "nitro/runtime";
+import { runTask } from "../task.mjs";
 import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
 export default new H3().get("/_nitro/tasks", async () => {
-  const _tasks = await Promise.all(
-    Object.entries(tasks).map(async ([name, task]) => {
-      const _task = await task.resolve?.();
-      return [name, { description: _task?.meta?.description }];
-    })
-  );
-  return {
-    tasks: Object.fromEntries(_tasks),
-    scheduledTasks
-  };
+	const _tasks = await Promise.all(Object.entries(tasks).map(async ([name, task]) => {
+		const _task = await task.resolve?.();
+		return [name, { description: _task?.meta?.description }];
+	}));
+	return {
+		tasks: Object.fromEntries(_tasks),
+		scheduledTasks
+	};
 }).get("/_nitro/tasks/:name", async (event) => {
-  const name = event.context.params?.name;
-  const body = await event.req.json().catch(() => ({}));
-  const payload = {
-    ...Object.fromEntries(event.url.searchParams.entries()),
-    ...body
-  };
-  return await runTask(name, { payload });
+	const name = event.context.params?.name;
+	const body = await event.req.json().catch(() => ({}));
+	const payload = {
+		...Object.fromEntries(event.url.searchParams.entries()),
+		...body
+	};
+	return await runTask(name, { payload });
 });

package/dist/runtime/internal/routes/openapi.d.mts

@@ -1,3 +1,4 @@
 import type { EventHandler } from "h3";
+// Served as /_openapi.json
 declare const _default: EventHandler;
 export default _default;