@depup/nitro 3.0.260311-beta-depup.0

package/dist/presets/standard/runtime/server.mjs

@@ -0,0 +1,4 @@
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
+const nitroApp = useNitroApp();
+export default { fetch: nitroApp.fetch };

package/dist/presets/stormkit/runtime/stormkit.mjs

@@ -0,0 +1,27 @@
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
+import { awsResponseBody } from "../../aws-lambda/runtime/_utils.mjs";
+const nitroApp = useNitroApp();
+export const handler = async function(event, context) {
+	const req = new Request(event.url, {
+		method: event.method || "GET",
+		headers: event.headers,
+		body: event.body
+	});
+	// srvx compatibility
+	req.runtime ??= { name: "stormkit" };
+	req.runtime.stormkit ??= {
+		event,
+		context
+	};
+	const response = await nitroApp.fetch(req);
+	const { body, isBase64Encoded } = await awsResponseBody(response);
+	return {
+		statusCode: response.status,
+		headers: normalizeOutgoingHeaders(response.headers),
+		[isBase64Encoded ? "buffer" : "body"]: body
+	};
+};
+function normalizeOutgoingHeaders(headers) {
+	return Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : String(v)]));
+}

package/dist/presets/vercel/runtime/cron-handler.mjs

@@ -0,0 +1,25 @@
+import { timingSafeEqual } from "node:crypto";
+import { defineHandler, HTTPError } from "nitro/h3";
+import { runCronTasks } from "#nitro/runtime/task";
+export default defineHandler(async (event) => {
+	// Validate CRON_SECRET if set - https://vercel.com/docs/cron-jobs/manage-cron-jobs#securing-cron-jobs
+	const cronSecret = process.env.CRON_SECRET;
+	if (cronSecret) {
+		const authHeader = event.req.headers.get("authorization") || "";
+		const expected = `Bearer ${cronSecret}`;
+		const a = Buffer.from(authHeader);
+		const b = Buffer.from(expected);
+		if (a.length !== b.length || !timingSafeEqual(a, b)) {
+			throw new HTTPError("Unauthorized", { status: 401 });
+		}
+	}
+	const cron = event.req.headers.get("x-vercel-cron-schedule");
+	if (!cron) {
+		throw new HTTPError("Missing x-vercel-cron-schedule header", { status: 400 });
+	}
+	await runCronTasks(cron, {
+		context: { waitUntil: event.req.waitUntil },
+		payload: { scheduledTime: Date.now() }
+	});
+	return { success: true };
+});

package/dist/presets/vercel/runtime/isr.mjs

@@ -0,0 +1,19 @@
+export const ISR_URL_PARAM = "__isr_route";
+export function isrRouteRewrite(reqUrl, xNowRouteMatches) {
+	if (xNowRouteMatches) {
+		const isrURL = new URLSearchParams(xNowRouteMatches).get(ISR_URL_PARAM);
+		if (isrURL) {
+			return [decodeURIComponent(isrURL), ""];
+		}
+	} else {
+		const queryIndex = reqUrl.indexOf("?");
+		if (queryIndex !== -1) {
+			const params = new URLSearchParams(reqUrl.slice(queryIndex + 1));
+			const isrURL = params.get(ISR_URL_PARAM);
+			if (isrURL) {
+				params.delete(ISR_URL_PARAM);
+				return [decodeURIComponent(isrURL), params.toString()];
+			}
+		}
+	}
+}

package/dist/presets/vercel/runtime/vercel.node.mjs

@@ -0,0 +1,24 @@
+import "#nitro/virtual/polyfills";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp, getRouteRules } from "nitro/app";
+import { isrRouteRewrite } from "./isr.mjs";
+const nitroApp = useNitroApp();
+const handler = toNodeHandler(nitroApp.fetch);
+export default function nodeHandler(req, res) {
+	// https://vercel.com/docs/headers/request-headers#x-forwarded-for
+	// srvx node adapter uses req.socket.remoteAddress for req.ip
+	let ip;
+	Object.defineProperty(req.socket, "remoteAddress", { get() {
+		const h = req.headers["x-forwarded-for"];
+		return ip ??= h?.split?.(",").shift()?.trim();
+	} });
+	// ISR route rewrite
+	const isrURL = isrRouteRewrite(req.url, req.headers["x-now-route-matches"]);
+	if (isrURL) {
+		const { routeRules } = getRouteRules("", isrURL[0]);
+		if (routeRules?.isr) {
+			req.url = isrURL[0] + (isrURL[1] ? `?${isrURL[1]}` : "");
+		}
+	}
+	return handler(req, res);
+}

package/dist/presets/vercel/runtime/vercel.web.mjs

@@ -0,0 +1,23 @@
+import "#nitro/virtual/polyfills";
+import { useNitroApp, getRouteRules } from "nitro/app";
+import { isrRouteRewrite } from "./isr.mjs";
+const nitroApp = useNitroApp();
+export default { fetch(req, context) {
+	// ISR route rewrite
+	const isrURL = isrRouteRewrite(req.url, req.headers.get("x-now-route-matches"));
+	if (isrURL) {
+		const { routeRules } = getRouteRules("", isrURL[0]);
+		if (routeRules?.isr) {
+			req = new Request(new URL(isrURL[0] + (isrURL[1] ? `?${isrURL[1]}` : ""), req.url).href, req);
+		}
+	}
+	req.runtime ??= { name: "vercel" };
+	req.runtime.vercel = { context };
+	let ip;
+	Object.defineProperty(req, "ip", { get() {
+		const h = req.headers.get("x-forwarded-for");
+		return ip ??= h?.split(",").shift()?.trim();
+	} });
+	req.waitUntil = context?.waitUntil;
+	return nitroApp.fetch(req);
+} };

package/dist/presets/winterjs/runtime/winterjs.mjs

@@ -0,0 +1,91 @@
+// @ts-nocheck TODO: Remove after removing polyfills
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
+import { hasProtocol, joinURL } from "ufo";
+const nitroApp = useNitroApp();
+// Use plain handler as winterjs Web API is incomplete
+// TODO: Migrate to toWebHandler
+const _handler = toPlainHandler(nitroApp.h3App);
+async function _handleEvent(event) {
+	try {
+		const res = await _handler({
+			path: event.request.url.pathname + (event.request.url.search ? `?${event.request.url.search}` : ""),
+			method: event.request.getMethod() || "GET",
+			body: event.request.body,
+			headers: event.request.headers,
+			context: {
+				waitUntil: (promise) => event.waitUntil(promise),
+				_platform: { winterjs: { event } }
+			}
+		});
+		const body = typeof res.body === "string" ? res.body : await toBuffer(res.body);
+		return new Response(body, {
+			status: res.status,
+			statusText: res.statusText,
+			headers: res.headers
+		});
+	} catch (error) {
+		const errString = error?.message + "\n" + error?.stack;
+		console.error(errString);
+		return new Response(errString, { status: 500 });
+	}
+}
+addEventListener("fetch", async (event) => {
+	event.respondWith(await _handleEvent(event));
+});
+// ------------------------------
+// Polyfills for missing APIs
+// ------------------------------
+function toBuffer(data) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		data.pipeTo(new WritableStream({
+			write(chunk) {
+				chunks.push(chunk);
+			},
+			close() {
+				resolve(Buffer.concat(chunks));
+			},
+			abort(reason) {
+				reject(reason);
+			}
+		})).catch(reject);
+	});
+}
+// Headers.entries
+if (!Headers.prototype.entries) {
+	// @ts-ignore
+	Headers.prototype.entries = function() {
+		return [...this];
+	};
+}
+// URL.pathname
+if (!URL.prototype.pathname) {
+	Object.defineProperty(URL.prototype, "pathname", { get() {
+		return this.path || "/";
+	} });
+}
+// URL constructor (relative support)
+const _URL = globalThis.URL;
+globalThis.URL = class URL extends _URL {
+	constructor(url, base) {
+		if (!base || hasProtocol(url)) {
+			super(url);
+			return;
+		}
+		super(joinURL(base, url));
+	}
+};
+// Response (avoid Promise body)
+const _Response = globalThis.Response;
+globalThis.Response = class Response extends _Response {
+	_body;
+	constructor(body, init) {
+		super(body, init);
+		this._body = body;
+	}
+	get body() {
+		// TODO: Return ReadableStream (should be iterable)
+		return this._body;
+	}
+};

package/dist/presets/zeabur/runtime/zeabur.mjs

@@ -0,0 +1,4 @@
+import "#nitro/virtual/polyfills";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp } from "nitro/app";
+export default toNodeHandler(useNitroApp().fetch);

package/dist/presets/zephyr/runtime/server.mjs

@@ -0,0 +1,3 @@
+import "#nitro/virtual/polyfills";
+import { createHandler } from "../../cloudflare/runtime/_module-handler.mjs";
+export default createHandler({ fetch() {} });

package/dist/runtime/app.d.mts

@@ -0,0 +1 @@
+export { useNitroApp, useNitroHooks, serverFetch, getRouteRules, fetch } from "./internal/app.mjs";

package/dist/runtime/app.mjs

@@ -0,0 +1 @@
+export { useNitroApp, useNitroHooks, serverFetch, getRouteRules, fetch } from "./internal/app.mjs";

package/dist/runtime/cache.d.mts

@@ -0,0 +1 @@
+export { defineCachedFunction, defineCachedHandler } from "./internal/cache.mjs";

package/dist/runtime/cache.mjs

@@ -0,0 +1 @@
+export { defineCachedFunction, defineCachedHandler } from "./internal/cache.mjs";

package/dist/runtime/config.d.mts

@@ -0,0 +1,3 @@
+import type { NitroConfig } from "nitro/types";
+export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit<NitroConfig, "rootDir">;
+export { defineConfig as defineNitroConfig };

package/dist/runtime/config.mjs

@@ -0,0 +1,4 @@
+export function defineConfig(config) {
+	return config;
+}
+export { defineConfig as defineNitroConfig };

package/dist/runtime/context.d.mts

@@ -0,0 +1 @@
+export { useRequest } from "./internal/context.mjs";

package/dist/runtime/context.mjs

@@ -0,0 +1 @@
+export { useRequest } from "./internal/context.mjs";

package/dist/runtime/database.d.mts

@@ -0,0 +1 @@
+export { useDatabase } from "./internal/database.mjs";

package/dist/runtime/database.mjs

@@ -0,0 +1 @@
+export { useDatabase } from "./internal/database.mjs";

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

@@ -0,0 +1,16 @@
+import type { MatchedRouteRules, NitroApp, NitroRuntimeHooks } from "nitro/types";
+import type { ServerRequest, ServerRequestContext } from "srvx";
+import type { H3EventContext, Middleware, WebSocketHooks } from "h3";
+import { HookableCore } from "hookable";
+declare global {
+	var __nitro__: Partial<Record<"default" | "prerender" | (string & {}), NitroApp | undefined>> | undefined;
+}
+export declare function useNitroApp(): NitroApp;
+export declare function useNitroHooks(): HookableCore<NitroRuntimeHooks>;
+export declare function serverFetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
+export declare function resolveWebsocketHooks(req: ServerRequest): Promise<Partial<WebSocketHooks>>;
+export declare function fetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
+export declare function getRouteRules(method: string, pathname: string): {
+	routeRules?: MatchedRouteRules;
+	routeRuleMiddleware: Middleware[];
+};

package/dist/runtime/internal/app.mjs

@@ -0,0 +1,208 @@
+import { H3Core, toRequest } from "h3";
+import { HookableCore } from "hookable";
+import { nitroAsyncContext } from "./context.mjs";
+// 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() {
+	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;
+}
+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 = 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(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;
+}
+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

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

package/dist/runtime/internal/cache.mjs

@@ -0,0 +1,41 @@
+import { defineHandler, handleCacheHeaders, toResponse } from "h3";
+import { FastResponse } from "srvx";
+import { defineCachedFunction as _defineCachedFunction, defineCachedHandler as _defineCachedHandler, setStorage } from "ocache";
+import { useNitroApp } from "./app.mjs";
+import { useStorage } from "./storage.mjs";
+let _storageReady = false;
+function ensureStorage() {
+	if (_storageReady) {
+		return;
+	}
+	_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 defaultOnError(error) {
+	console.error("[cache]", error);
+	useNitroApp().captureError?.(error, { tags: ["cache"] });
+}
+export function defineCachedFunction(fn, opts = {}) {
+	ensureStorage();
+	return _defineCachedFunction(fn, {
+		group: "nitro/functions",
+		onError: defaultOnError,
+		...opts
+	});
+}
+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

@@ -0,0 +1,14 @@
+import type { NitroAsyncContext } from "nitro/types";
+import type { ServerRequest } from "srvx";
+import { type UseContext } from "unctx";
+export declare const nitroAsyncContext: UseContext<NitroAsyncContext>;
+/**
+*
+* 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

@@ -0,0 +1,24 @@
+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 : 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}` });
+	}
+}

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

@@ -0,0 +1,2 @@
+import type { Database } from "db0";
+export declare function useDatabase(name?: string): Database;

package/dist/runtime/internal/database.mjs

@@ -0,0 +1,12 @@
+import { createDatabase } from "db0";
+import { connectionConfigs } from "#nitro/virtual/database";
+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 || {}));
+}

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

@@ -0,0 +1,10 @@
+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;
+}): Promise<InternalHandlerResponse>;
+export declare function loadStackTrace(error: any): Promise<void>;