nitro 3.0.1-alpha.2 → 3.0.260311-beta

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,9 @@
-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;
+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 {};

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

@@ -1,4 +1,4 @@
-import { proxyRequest, redirect as sendRedirect } from "h3";
+import { proxyRequest, redirect as sendRedirect, requireBasicAuth } from "h3";
 import { joinURL, withQuery, withoutBase } from "ufo";
 import { defineCachedHandler } from "./cache.mjs";
 // Headers route rule
@@ -62,3 +62,11 @@ export const cache = ((m) => function cacheRouteRule(event, next) {
 	}
 	return cachedHandler(event);
 });
+// basicAuth auth route rule
+export const basicAuth = ((m) => async function authRouteRule(event, next) {
+	if (!m.options) {
+		return;
+	}
+	await requireBasicAuth(event, m.options);
+	return next();
+});

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

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

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

@@ -1,7 +1,7 @@
 import { H3 } from "h3";
 import { runTask } from "../task.mjs";
 import { scheduledTasks, tasks } from "#nitro/virtual/tasks";
-export default new H3().get("/_nitro/tasks", async () => {
+const app = 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 }];
@@ -17,5 +17,9 @@ export default new H3().get("/_nitro/tasks", async () => {
 		...Object.fromEntries(event.url.searchParams.entries()),
 		...body
 	};
-	return await runTask(name, { payload });
+	return await runTask(name, {
+		context: { waitUntil: event.req.waitUntil },
+		payload
+	});
 });
+export default app;

package/dist/runtime/internal/routes/renderer-template.d.mts

@@ -1,2 +1,2 @@
 import type { H3Event } from "h3";
-export default function renderIndexHTML(event: H3Event);
+export default function renderIndexHTML(event: H3Event): any;

package/dist/runtime/internal/routes/renderer-template.dev.d.mts

@@ -1,2 +1,3 @@
 import type { H3Event } from "h3";
-export default function renderIndexHTML(event: H3Event);
+import { HTTPResponse } from "h3";
+export default function renderIndexHTML(event: H3Event): Promise<HTTPResponse | Response>;

package/dist/runtime/internal/runtime-config.d.mts

@@ -5,5 +5,5 @@ type EnvOptions = {
 	altPrefix?: string;
 	envExpansion?: boolean;
 };
-export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string);
+export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string): Record<string, any>;
 export {};

package/dist/runtime/internal/static.mjs

@@ -4,7 +4,8 @@ import { getAsset, isPublicAssetURL, readAsset } from "#nitro/virtual/public-ass
 const METHODS = new Set(["HEAD", "GET"]);
 const EncodingMap = {
 	gzip: ".gz",
-	br: ".br"
+	br: ".br",
+	zstd: ".zst"
 };
 export default defineHandler((event) => {
 	if (event.req.method && !METHODS.has(event.req.method)) {
@@ -14,9 +15,6 @@ export default defineHandler((event) => {
 	let asset;
 	const encodingHeader = event.req.headers.get("accept-encoding") || "";
 	const encodings = [...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(), ""];
-	if (encodings.length > 1) {
-		event.res.headers.append("Vary", "Accept-Encoding");
-	}
 	for (const encoding of encodings) {
 		for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
 			const _asset = getAsset(_id);
@@ -34,6 +32,9 @@ export default defineHandler((event) => {
 		}
 		return;
 	}
+	if (encodings.length > 1) {
+		event.res.headers.append("Vary", "Accept-Encoding");
+	}
 	const ifNotMatch = event.req.headers.get("if-none-match") === asset.etag;
 	if (ifNotMatch) {
 		event.res.status = 304;

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

@@ -7,7 +7,9 @@ export declare function runTask<RT = unknown>(name: string, { payload, context }
 	context?: TaskContext;
 }): Promise<TaskResult<RT>>;
 /** @experimental */
-export declare function startScheduleRunner();
+export declare function startScheduleRunner({ waitUntil }?: {
+	waitUntil?: ((promise: Promise<unknown>) => void) | undefined;
+}): void;
 /** @experimental */
 export declare function getCronTasks(cron: string): string[];
 /** @experimental */

package/dist/runtime/internal/task.mjs

@@ -43,7 +43,7 @@ export async function runTask(name, { payload = {}, context = {} } = {}) {
 	}
 }
 /** @experimental */
-export function startScheduleRunner() {
+export function startScheduleRunner({ waitUntil } = {}) {
 	if (!scheduledTasks || scheduledTasks.length === 0 || process.env.TEST) {
 		return;
 	}
@@ -52,7 +52,7 @@ export function startScheduleRunner() {
 		new Cron(schedule.cron, async () => {
 			await Promise.all(schedule.tasks.map((name) => runTask(name, {
 				payload,
-				context: {}
+				context: { waitUntil }
 			}).catch((error) => {
 				console.error(`Error while running scheduled task "${name}"`, error);
 			})));

package/dist/runtime/internal/vite/dev-entry.mjs

@@ -3,13 +3,16 @@ import wsAdapter from "crossws/adapters/node";
 
 import { useNitroApp } from "nitro/app";
 import { resolveWebsocketHooks } from "#nitro/runtime/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
 
 const nitroApp = useNitroApp();
 
 export const fetch = nitroApp.fetch;
 
-const ws = import.meta._websocket
-  ? wsAdapter({ resolve: resolveWebsocketHooks })
-  : undefined;
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+
+if (import.meta._tasks) {
+  startScheduleRunner({});
+}
 
 export const handleUpgrade = ws?.handleUpgrade;

package/dist/runtime/internal/vite/dev-worker.mjs

@@ -0,0 +1,264 @@
+import { ModuleRunner, ESModulesEvaluator } from "vite/module-runner";
+import { createViteTransport } from "env-runner/vite";
+
+// Custom evaluator for workerd where `new AsyncFunction()` is disallowed.
+// Uses the unsafeEvalBinding exposed by the env-runner miniflare wrapper.
+class WorkerdModuleEvaluator {
+  startOffset = 0;
+
+  async runInlinedModule(context, code) {
+    const unsafeEval = globalThis.__ENV_RUNNER_UNSAFE_EVAL__;
+    const keys = Object.keys(context);
+    const fn = unsafeEval.newAsyncFunction('"use strict";' + code, "runInlinedModule", ...keys);
+    await fn(...keys.map((k) => context[k]));
+    Object.seal(context[Object.keys(context)[0]]);
+  }
+
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+}
+
+// ----- IPC -----
+
+let sendMessage;
+const messageListeners = new Set();
+
+// ----- Environment runners -----
+
+const envs = (globalThis.__nitro_vite_envs__ ??= {
+  nitro: undefined,
+  ssr: undefined,
+});
+
+class ViteEnvRunner {
+  constructor({ name, entry }) {
+    this.name = name;
+    this.entryPath = entry;
+
+    this.entry = undefined;
+    this.entryError = undefined;
+
+    // Create Vite Module Runner
+    // https://vite.dev/guide/api-environment-runtimes.html#modulerunner
+    const onMessage = (listener) => messageListeners.add(listener);
+    const transport = createViteTransport((data) => sendMessage?.(data), onMessage, name);
+    const evaluator = globalThis.__ENV_RUNNER_UNSAFE_EVAL__
+      ? new WorkerdModuleEvaluator()
+      : new ESModulesEvaluator();
+    const debug =
+      typeof process !== "undefined" && process.env?.NITRO_DEBUG ? console.debug : undefined;
+    this.runner = new ModuleRunner({ transport }, evaluator, debug);
+
+    this.reload();
+  }
+
+  async reload() {
+    try {
+      this.entry = await this.runner.import(this.entryPath);
+      this.entryError = undefined;
+    } catch (error) {
+      console.error(error);
+      this.entryError = error;
+    }
+  }
+
+  async fetch(req, init) {
+    if (this.entryError) {
+      return renderError(req, this.entryError);
+    }
+    for (let i = 0; i < 5 && !(this.entry || this.entryError); i++) {
+      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
+    }
+    if (this.entryError) {
+      return renderError(req, this.entryError);
+    }
+    if (!this.entry) {
+      throw httpError(503, `Vite environment "${this.name}" is unavailable`);
+    }
+    try {
+      const entryFetch = this.entry.fetch || this.entry.default?.fetch;
+      if (!entryFetch) {
+        throw httpError(500, `No fetch handler exported from ${this.entryPath}`);
+      }
+      return await entryFetch(req, init);
+    } catch (error) {
+      return renderError(req, error);
+    }
+  }
+}
+
+// ----- RPC -----
+
+const rpcRequests = new Map();
+
+function rpc(name, data, timeout = 3000) {
+  const id = Math.random().toString(36).slice(2);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      rpcRequests.delete(id);
+      reject(new Error(`RPC "${name}" timed out`));
+    }, timeout);
+    rpcRequests.set(id, { resolve, reject, timer });
+    sendMessage?.({ __rpc: name, __rpc_id: id, data });
+  });
+}
+
+// Trap unhandled errors to avoid worker crash
+if (typeof process !== "undefined" && typeof process.on === "function") {
+  process.on("unhandledRejection", (error) => console.error(error));
+  process.on("uncaughtException", (error) => console.error(error));
+}
+
+// ----- RSC Support -----
+
+// define __VITE_ENVIRONMENT_RUNNER_IMPORT__ for RSC support
+// https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-rsc/README.md#__vite_environment_runner_import__
+
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async function (environmentName, id) {
+  const env = envs[environmentName];
+  if (!env) {
+    throw new Error(`Vite environment "${environmentName}" is not registered`);
+  }
+  return env.runner.import(id);
+};
+
+// ----- Reload -----
+
+async function reload() {
+  try {
+    await Promise.all(Object.values(envs).map((env) => env?.reload()));
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+// eslint-disable-next-line unicorn/prefer-top-level-await
+reload();
+
+// ----- HTML Transform -----
+
+globalThis.__transform_html__ = async function (html) {
+  html = await rpc("transformHTML", html).catch((error) => {
+    console.warn("Failed to transform HTML via Vite:", error);
+    return html;
+  });
+  return html;
+};
+
+// ----- Exports (env-runner AppEntry) -----
+
+export function fetch(req) {
+  const viteEnv = req?.headers.get("x-vite-env") || "nitro";
+  const env = envs[viteEnv];
+  if (!env) {
+    return renderError(req, httpError(500, `Unknown vite environment "${viteEnv}"`));
+  }
+  return env.fetch(req);
+}
+
+export function upgrade(context) {
+  const handleUpgrade = envs.nitro?.entry?.handleUpgrade;
+  if (handleUpgrade) {
+    handleUpgrade(context.node.req, context.node.socket, context.node.head);
+  }
+}
+
+export const ipc = {
+  onOpen(ctx) {
+    sendMessage = ctx.sendMessage;
+  },
+  onMessage(message) {
+    if (message?.__rpc_id) {
+      const req = rpcRequests.get(message.__rpc_id);
+      if (req) {
+        clearTimeout(req.timer);
+        rpcRequests.delete(message.__rpc_id);
+        if (message.error) {
+          req.reject(typeof message.error === "string" ? new Error(message.error) : message.error);
+        } else {
+          req.resolve(message.data);
+        }
+      }
+      return;
+    }
+    if (message?.type === "custom") {
+      if (message.event === "nitro:vite-env") {
+        const { name, entry } = message.data;
+        if (!envs[name]) {
+          envs[name] = new ViteEnvRunner({ name, entry });
+        }
+        return;
+      }
+    }
+    if (message?.type === "full-reload") {
+      reload();
+      return;
+    }
+    for (const listener of messageListeners) {
+      listener(message);
+    }
+  },
+  onClose() {},
+};
+
+// ----- Error handling -----
+
+function httpError(status, message) {
+  const error = new Error(message || `HTTP Error ${status}`);
+  error.status = status;
+  error.name = "NitroViteError";
+  return error;
+}
+
+async function renderError(req, error) {
+  if (req.headers.get("accept")?.includes("application/json")) {
+    return new Response(
+      JSON.stringify(
+        {
+          status: error.status || 500,
+          name: error.name || "Error",
+          message: error.message,
+          stack: (error.stack || "")
+            .split("\n")
+            .splice(1)
+            .map((l) => l.trim()),
+        },
+        null,
+        2
+      ),
+      {
+        status: error.status || 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store, max-age=0, must-revalidate",
+          Pragma: "no-cache",
+          Expires: "0",
+        },
+      }
+    );
+  }
+  try {
+    const { Youch } = await import("youch");
+    const youch = new Youch();
+    return new Response(await youch.toHTML(error), {
+      status: error.status || 500,
+      headers: {
+        "Content-Type": "text/html",
+        "Cache-Control": "no-store, max-age=0, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
+    });
+  } catch {
+    return new Response(`<pre>${error.stack || error.message || error}</pre>`, {
+      status: error.status || 500,
+      headers: {
+        "Content-Type": "text/html",
+        "Cache-Control": "no-store, max-age=0, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
+    });
+  }
+}

package/dist/runtime/meta.mjs

@@ -15,6 +15,7 @@ export const runtimeDependencies = [
 	"rou3",
 	"hookable",
 	"ofetch",
+	"ocache",
 	"ohash",
 	"rendu",
 	"scule",

package/dist/runtime/nitro.d.mts

@@ -5,5 +5,7 @@ export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
+export { defineHandler, defineMiddleware, defineWebSocketHandler, html, HTTPError, HTTPResponse } from "h3";
+export type { H3Event } from "h3";
 export declare function serverFetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
 export declare function fetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;

package/dist/runtime/nitro.mjs

@@ -6,6 +6,8 @@ export function defineConfig(config) {
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
+// H3
+export { defineHandler, defineMiddleware, defineWebSocketHandler, html, HTTPError, HTTPResponse } from "h3";
 // Runtime
 export function serverFetch(resource, init, context) {
 	const nitro = globalThis.__nitro__?.default || globalThis.__nitro__?.prerender || globalThis.__nitro_builder__;

package/dist/runtime/virtual/error-handler.mjs

@@ -1,5 +1,5 @@
 import "./_runtime_warn.mjs";
-import { toResponse } from "h3";
+import { H3Event, toResponse } from "h3";
 const errorHandler = (error, event) => {
 	if (error.status !== 404) {
 		console.error(error);

package/dist/runtime/virtual/server-assets.d.mts

@@ -1,6 +1,7 @@
 import "./_runtime_warn.mjs";
+import { type Storage } from "unstorage";
 import type { AssetMeta } from "nitro/types";
-export declare const assets: unknown;
+export declare const assets: Storage;
 export declare function readAsset<T = any>(_id: string): Promise<T>;
 export declare function statAsset(_id: string): Promise<AssetMeta>;
 export declare function getKeys(): Promise<string[]>;

package/dist/runtime/vite.d.mts

@@ -4,5 +4,5 @@ type FetchableEnv = {
 declare global {
 	var __nitro_vite_envs__: Record<string, FetchableEnv>;
 }
-export declare function fetchViteEnv(viteEnvName: string, input: RequestInfo | URL, init?: RequestInit);
+export declare function fetchViteEnv(viteEnvName: string, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 export {};