nitro 3.0.1-alpha.0 → 3.0.1-alpha.2

package/dist/runtime/internal/task.mjs

@@ -1,73 +1,69 @@
 import { Cron } from "croner";
 import { HTTPError } from "h3";
-import { isTest } from "std-env";
-import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
+import { scheduledTasks, tasks } from "#nitro/virtual/tasks";
+/** @experimental */
 export function defineTask(def) {
-  if (typeof def.run !== "function") {
-    def.run = () => {
-      throw new TypeError("Task must implement a `run` method!");
-    };
-  }
-  return def;
+	if (typeof def.run !== "function") {
+		def.run = () => {
+			throw new TypeError("Task must implement a `run` method!");
+		};
+	}
+	return def;
 }
 const __runningTasks__ = {};
-export async function runTask(name, {
-  payload = {},
-  context = {}
-} = {}) {
-  if (__runningTasks__[name]) {
-    return __runningTasks__[name];
-  }
-  if (!(name in tasks)) {
-    throw new HTTPError({
-      message: `Task \`${name}\` is not available!`,
-      status: 404
-    });
-  }
-  if (!tasks[name].resolve) {
-    throw new HTTPError({
-      message: `Task \`${name}\` is not implemented!`,
-      status: 501
-    });
-  }
-  const handler = await tasks[name].resolve();
-  const taskEvent = { name, payload, context };
-  __runningTasks__[name] = handler.run(taskEvent);
-  try {
-    const res = await __runningTasks__[name];
-    return res;
-  } finally {
-    delete __runningTasks__[name];
-  }
+/** @experimental */
+export async function runTask(name, { payload = {}, context = {} } = {}) {
+	if (__runningTasks__[name]) {
+		return __runningTasks__[name];
+	}
+	if (!(name in tasks)) {
+		throw new HTTPError({
+			message: `Task \`${name}\` is not available!`,
+			status: 404
+		});
+	}
+	if (!tasks[name].resolve) {
+		throw new HTTPError({
+			message: `Task \`${name}\` is not implemented!`,
+			status: 501
+		});
+	}
+	const handler = await tasks[name].resolve();
+	const taskEvent = {
+		name,
+		payload,
+		context
+	};
+	__runningTasks__[name] = handler.run(taskEvent);
+	try {
+		const res = await __runningTasks__[name];
+		return res;
+	} finally {
+		delete __runningTasks__[name];
+	}
 }
+/** @experimental */
 export function startScheduleRunner() {
-  if (!scheduledTasks || scheduledTasks.length === 0 || isTest) {
-    return;
-  }
-  const payload = {
-    scheduledTime: Date.now()
-  };
-  for (const schedule of scheduledTasks) {
-    const cron = new Cron(schedule.cron, async () => {
-      await Promise.all(
-        schedule.tasks.map(
-          (name) => runTask(name, {
-            payload,
-            context: {}
-          }).catch((error) => {
-            console.error(
-              `Error while running scheduled task "${name}"`,
-              error
-            );
-          })
-        )
-      );
-    });
-  }
+	if (!scheduledTasks || scheduledTasks.length === 0 || process.env.TEST) {
+		return;
+	}
+	const payload = { scheduledTime: Date.now() };
+	for (const schedule of scheduledTasks) {
+		new Cron(schedule.cron, async () => {
+			await Promise.all(schedule.tasks.map((name) => runTask(name, {
+				payload,
+				context: {}
+			}).catch((error) => {
+				console.error(`Error while running scheduled task "${name}"`, error);
+			})));
+		});
+	}
 }
+/** @experimental */
 export function getCronTasks(cron) {
-  return (scheduledTasks || []).find((task) => task.cron === cron)?.tasks || [];
+	return (scheduledTasks || []).find((task) => task.cron === cron)?.tasks || [];
 }
+/** @experimental */
 export function runCronTasks(cron, ctx) {
-  return Promise.all(getCronTasks(cron).map((name) => runTask(name, ctx)));
+	return Promise.all(getCronTasks(cron).map((name) => runTask(name, ctx)));
 }

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

@@ -1,6 +1,15 @@
-import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import "#nitro/virtual/polyfills";
+import wsAdapter from "crossws/adapters/node";
+
+import { useNitroApp } from "nitro/app";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
 
 const nitroApp = useNitroApp();
 
 export const fetch = nitroApp.fetch;
+
+const ws = import.meta._websocket
+  ? wsAdapter({ resolve: resolveWebsocketHooks })
+  : undefined;
+
+export const handleUpgrade = ws?.handleUpgrade;

package/dist/runtime/internal/vite/{dev-worker.mjs → node-runner.mjs}

@@ -5,9 +5,10 @@ import { getSocketAddress, isSocketSupported } from "get-port-please";
 
 // ----- Environment runners -----
 
-const envs = { nitro: undefined, ssr: undefined };
-
-globalThis.__nitro_vite_envs__ = envs;
+const envs = (globalThis.__nitro_vite_envs__ ??= {
+  nitro: undefined,
+  ssr: undefined,
+});
 
 class EnvRunner {
   constructor({ name, entry }) {
@@ -37,7 +38,7 @@ class EnvRunner {
         },
       },
       new ESModulesEvaluator(),
-      process.env.DEBUG ? console.debug : undefined
+      process.env.NITRO_DEBUG ? console.debug : undefined
     );
 
     this.reload();
@@ -150,69 +151,30 @@ parentPort.on("message", (payload) => {
   }
 });
 
-// ----- Fetch Handler -----
-
-const originalFetch = globalThis.fetch;
-globalThis.fetch = function nitroViteFetch(input, init) {
-  // Only override if viteEnvName is specified
-  const viteEnvName = getViteEnv(init) || getViteEnv(input);
-  if (!viteEnvName) {
-    return originalFetch(input, init);
-  }
+// Trap unhandled errors to avoid worker crash
+process.on("unhandledRejection", (error) => console.error(error));
+process.on("uncaughtException", (error) => console.error(error));
 
-  // Validate viteEnv
-  const viteEnv = envs[viteEnvName];
-  if (!viteEnv) {
-    throw httpError(404, `Unknown vite environment "${viteEnvName}"`);
-  }
-
-  // Normalize input (relative urls)
-  if (typeof input === "string" && input[0] === "/") {
-    input = new URL(input, "http://localhost");
-  }
+// ----- RSC Support -----
 
-  // Clone headers and set viteEnv header
-  const headers = new Headers(init?.headers || {});
-  headers.set("x-vite-env", viteEnvName);
+// 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__
 
-  // Normalize to Request
-  if (
-    !(input instanceof Request) ||
-    (init && Object.keys(init).join("") !== "viteEnv")
-  ) {
-    input = new Request(input, init);
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async function (
+  environmentName,
+  id
+) {
+  const env = envs[environmentName];
+  if (!env) {
+    throw new Error(`Vite environment "${environmentName}" is not registered`);
   }
-
-  // Fetch via vite env
-  return viteEnv.fetch(input);
+  return env.runner.import(id);
 };
 
-function getViteEnv(input) {
-  if (!input || typeof input !== "object") {
-    return;
-  }
-  if ("viteEnv" in input) {
-    return input.viteEnv;
-  }
-  if (input.headers) {
-    return (
-      input.headers["x-vite-env"] ||
-      input.headers.get?.("x-vite-env") ||
-      (Array.isArray(input.headers) &&
-        input.headers.find((h) => h[0].toLowerCase() === "x-vite-env")?.[1])
-    );
-  }
-}
-
 // ----- Server -----
 
 async function reload() {
   try {
-    // Apply globals
-    for (const [key, value] of Object.entries(workerData.globals || {})) {
-      globalThis[key] = value;
-    }
-    // Reload all envs
     await Promise.all(Object.values(envs).map((env) => env?.reload()));
   } catch (error) {
     console.error(error);
@@ -240,9 +202,18 @@ if (workerData.server) {
     })
   );
 
+  server.on("upgrade", (req, socket, head) => {
+    const handleUpgrade = envs["nitro"]?.entry?.handleUpgrade;
+    handleUpgrade?.(req, socket, head);
+  });
+
   parentPort.on("message", async (message) => {
     if (message?.type === "full-reload") {
       await reload();
+    } else if (message?.event === "shutdown") {
+      server.close(() => {
+        parentPort.postMessage({ event: "exit" });
+      });
     }
   });
   await listen(server);
@@ -276,6 +247,32 @@ function httpError(status, message) {
 }
 
 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",
+        },
+      }
+    );
+  }
   const { Youch } = await import("youch");
   const youch = new Youch();
   return new Response(await youch.toHTML(error), {

package/dist/runtime/internal/vite/ssr-renderer.mjs

@@ -1,4 +1,6 @@
+import { fetchViteEnv } from "nitro/vite/runtime";
+
 /** @param {{ req: Request }} HTTPEvent */
 export default function ssrRenderer({ req }) {
-  return fetch(req, { viteEnv: "ssr" });
+  return fetchViteEnv("ssr", req);
 }

package/{lib/runtime-meta.d.mts → dist/runtime/meta.d.mts}

@@ -1,5 +1,5 @@
-export declare const pkgDir: string;
+export declare const version: string;
 export declare const runtimeDir: string;
 export declare const presetsDir: string;
-export declare const subpaths: string[];
+export declare const pkgDir: string;
 export declare const runtimeDependencies: string[];

package/dist/runtime/meta.mjs

@@ -0,0 +1,26 @@
+import { fileURLToPath } from "node:url";
+import packageJson from "../../package.json" with { type: "json" };
+export const version = packageJson.version;
+const resolve = (path) => fileURLToPath(new URL(path, import.meta.url));
+export const runtimeDir = /* @__PURE__ */ resolve("./");
+export const presetsDir = /* @__PURE__ */ resolve("../presets/");
+export const pkgDir = /* @__PURE__ */ resolve("../../");
+export const runtimeDependencies = [
+	"crossws",
+	"croner",
+	"db0",
+	"defu",
+	"destr",
+	"h3",
+	"rou3",
+	"hookable",
+	"ofetch",
+	"ohash",
+	"rendu",
+	"scule",
+	"srvx",
+	"ufo",
+	"unctx",
+	"unenv",
+	"unstorage"
+];

package/dist/runtime/nitro.d.mts

@@ -0,0 +1,9 @@
+import type { NitroConfig } from "nitro/types";
+import type { ServerRequestContext } from "srvx";
+import { type H3EventContext } from "h3";
+export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit<NitroConfig, "rootDir">;
+export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
+export { defineRouteMeta } from "./internal/meta.mjs";
+export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
+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

@@ -0,0 +1,32 @@
+import { toRequest } from "h3";
+export function defineConfig(config) {
+	return config;
+}
+// Type (only) helpers
+export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
+export { defineRouteMeta } from "./internal/meta.mjs";
+export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
+// Runtime
+export function serverFetch(resource, init, context) {
+	const nitro = globalThis.__nitro__?.default || globalThis.__nitro__?.prerender || globalThis.__nitro_builder__;
+	if (!nitro) {
+		return Promise.reject(new Error("Nitro instance is not available."));
+	}
+	const req = toRequest(resource, init);
+	req.context = {
+		...req.context,
+		...context
+	};
+	try {
+		return Promise.resolve(nitro.fetch(req));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+export function fetch(resource, init, context) {
+	if (typeof resource === "string" && resource.charCodeAt(0) === 47) {
+		return serverFetch(resource, init, context);
+	}
+	resource = resource._request || resource;
+	return globalThis.fetch(resource, init);
+}

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

@@ -0,0 +1 @@
+export { useRuntimeConfig } from "./internal/runtime-config.mjs";

package/dist/runtime/runtime-config.mjs

@@ -0,0 +1 @@
+export { useRuntimeConfig } from "./internal/runtime-config.mjs";

package/dist/runtime/storage.d.mts

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

package/dist/runtime/storage.mjs

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

package/dist/runtime/task.d.mts

@@ -0,0 +1 @@
+export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/task.mjs

@@ -0,0 +1 @@
+export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/virtual/_runtime_warn.mjs

@@ -0,0 +1,5 @@
+import consola from "consola";
+import { isTest } from "std-env";
+if (!isTest) {
+	consola.warn("Nitro runtime imports detected without a builder or Nitro plugin. A stub implementation will be used.");
+}

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

@@ -0,0 +1,8 @@
+import "./_runtime_warn.mjs";
+import type { Connector } from "db0";
+export declare const connectionConfigs: {
+	[name: string]: {
+		connector: (options: any) => Connector;
+		options: any;
+	};
+};

package/dist/runtime/virtual/database.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export const connectionConfigs = {};

package/dist/runtime/virtual/error-handler.d.mts

@@ -0,0 +1,6 @@
+import "./_runtime_warn.mjs";
+import type { NitroErrorHandler } from "nitro/types";
+type EParams = Parameters<NitroErrorHandler>;
+type EReturn = ReturnType<NitroErrorHandler>;
+declare const errorHandler: (error: EParams[0], event: EParams[1]) => EReturn;
+export default errorHandler;

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

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

package/dist/runtime/virtual/feature-flags.d.mts

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+export declare const hasRoutes: boolean;
+export declare const hasRouteRules: boolean;
+export declare const hasGlobalMiddleware: boolean;
+export declare const hasRoutedMiddleware: boolean;
+export declare const hasPlugins: boolean;
+export declare const hasHooks: boolean;

package/dist/runtime/virtual/feature-flags.mjs

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+export const hasRoutes = true;
+export const hasRouteRules = true;
+export const hasGlobalMiddleware = true;
+export const hasRoutedMiddleware = true;
+export const hasPlugins = true;
+export const hasHooks = true;

package/dist/runtime/virtual/plugins.d.mts

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+import type { NitroAppPlugin } from "nitro/types";
+export declare const plugins: NitroAppPlugin[];

package/dist/runtime/virtual/plugins.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export const plugins = [];

package/dist/runtime/virtual/polyfills.d.mts

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+declare const _default: {};
+export default _default;

package/dist/runtime/virtual/polyfills.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export default {};

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

@@ -0,0 +1,9 @@
+import "./_runtime_warn.mjs";
+import type { PublicAsset } from "nitro/types";
+export declare const publicAssetBases: string[];
+export declare const isPublicAssetURL: (id: string) => boolean;
+export declare const getPublicAssetMeta: (id: string) => {
+	maxAge?: number;
+} | null;
+export declare const readAsset: (id: string) => Promise<Buffer>;
+export declare const getAsset: (id: string) => PublicAsset | null;

package/dist/runtime/virtual/public-assets.mjs

@@ -0,0 +1,8 @@
+import "./_runtime_warn.mjs";
+export const publicAssetBases = [];
+export const isPublicAssetURL = () => false;
+export const getPublicAssetMeta = () => null;
+export const readAsset = async () => {
+	throw new Error("Asset not found");
+};
+export const getAsset = () => null;

package/dist/runtime/virtual/renderer-template.d.mts

@@ -0,0 +1,4 @@
+import "./_runtime_warn.mjs";
+export declare function rendererTemplate(_req: Request): string | Promise<string>;
+export declare const rendererTemplateFile: string | undefined;
+export declare const isStaticTemplate: boolean | undefined;

package/dist/runtime/virtual/renderer-template.mjs

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+export function rendererTemplate(_req) {
+	return `<!-- Renderer template not available -->`;
+}
+// dev only
+export const rendererTemplateFile = undefined;
+export const isStaticTemplate = undefined;

package/dist/runtime/virtual/routing-meta.d.mts

@@ -0,0 +1,7 @@
+import "./_runtime_warn.mjs";
+import type { NitroRouteMeta } from "nitro/types";
+export declare const handlersMeta: {
+	route?: string;
+	method?: string;
+	meta?: NitroRouteMeta;
+}[];

package/dist/runtime/virtual/routing-meta.mjs

@@ -0,0 +1,2 @@
+import "./_runtime_warn.mjs";
+export const handlersMeta = [];

package/dist/runtime/virtual/routing.d.mts

@@ -0,0 +1,8 @@
+import "./_runtime_warn.mjs";
+import type { Middleware, H3Route } from "h3";
+import type { MatchedRoute } from "rou3";
+import type { MatchedRouteRule } from "nitro/types";
+export declare function findRoute(_method: string, _path: string): MatchedRoute<H3Route> | undefined;
+export declare function findRouteRules(_method: string, _path: string): MatchedRoute<MatchedRouteRule[]>[];
+export declare const globalMiddleware: Middleware[];
+export declare function findRoutedMiddleware(_method: string, _path: string): MatchedRoute<Middleware>[];

package/dist/runtime/virtual/routing.mjs

@@ -0,0 +1,11 @@
+import "./_runtime_warn.mjs";
+export function findRoute(_method, _path) {
+	return undefined;
+}
+export function findRouteRules(_method, _path) {
+	return [];
+}
+export const globalMiddleware = [];
+export function findRoutedMiddleware(_method, _path) {
+	return [];
+}

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

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+import type { NitroRuntimeConfig } from "nitro/types";
+export declare const runtimeConfig: NitroRuntimeConfig;

package/dist/runtime/virtual/runtime-config.mjs

@@ -0,0 +1,5 @@
+import "./_runtime_warn.mjs";
+export const runtimeConfig = {
+	app: {},
+	nitro: {}
+};

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

@@ -0,0 +1,6 @@
+import "./_runtime_warn.mjs";
+import type { AssetMeta } from "nitro/types";
+export declare const assets: unknown;
+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/virtual/server-assets.mjs

@@ -0,0 +1,12 @@
+import "./_runtime_warn.mjs";
+import { createStorage } from "unstorage";
+export const assets = createStorage();
+export function readAsset(_id) {
+	return Promise.resolve({});
+}
+export function statAsset(_id) {
+	return Promise.resolve({});
+}
+export function getKeys() {
+	return Promise.resolve([]);
+}

package/dist/runtime/virtual/storage.d.mts

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+import { type Storage } from "unstorage";
+export declare function initStorage(): Storage;

package/dist/runtime/virtual/storage.mjs

@@ -0,0 +1,5 @@
+import "./_runtime_warn.mjs";
+import { createStorage } from "unstorage";
+export function initStorage() {
+	return createStorage();
+}

package/dist/runtime/virtual/tasks.d.mts

@@ -0,0 +1,10 @@
+import "./_runtime_warn.mjs";
+import type { Task, TaskMeta } from "nitro/types";
+export declare const tasks: Record<string, {
+	resolve?: () => Promise<Task>;
+	meta: TaskMeta;
+}>;
+export declare const scheduledTasks: false | {
+	cron: string;
+	tasks: string[];
+}[];

package/dist/runtime/virtual/tasks.mjs

@@ -0,0 +1,3 @@
+import "./_runtime_warn.mjs";
+export const tasks = {};
+export const scheduledTasks = [];

package/dist/runtime/vite.d.mts

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

package/dist/runtime/vite.mjs

@@ -0,0 +1,9 @@
+import { HTTPError, toRequest } from "h3";
+export function fetchViteEnv(viteEnvName, input, init) {
+	const envs = globalThis.__nitro_vite_envs__ || {};
+	const viteEnv = envs[viteEnvName];
+	if (!viteEnv) {
+		throw HTTPError.status(404);
+	}
+	return Promise.resolve(viteEnv.fetch(toRequest(input, init)));
+}