nitro 3.0.0 → 3.0.1-alpha.1

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";
+/** @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,16 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import wsAdapter from "crossws/adapters/node";
+
+import { useNitroApp } from "nitro/app";
+import { resolveWebsocketHooks } from "nitro/~internal/runtime/app";
+import { hasWebSocket } from "#nitro-internal-virtual/feature-flags";
 
 const nitroApp = useNitroApp();
 
 export const fetch = nitroApp.fetch;
+
+const ws = hasWebSocket
+  ? wsAdapter({ resolve: resolveWebsocketHooks })
+  : undefined;
+
+export const handleUpgrade = ws?.handleUpgrade;

package/dist/runtime/internal/vite/dev-worker.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 }) {
@@ -150,60 +151,6 @@ 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);
-  }
-
-  // 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");
-  }
-
-  // Clone headers and set viteEnv header
-  const headers = new Headers(init?.headers || {});
-  headers.set("x-vite-env", viteEnvName);
-
-  // Normalize to Request
-  if (
-    !(input instanceof Request) ||
-    (init && Object.keys(init).join("") !== "viteEnv")
-  ) {
-    input = new Request(input, init);
-  }
-
-  // Fetch via vite env
-  return viteEnv.fetch(input);
-};
-
-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() {
@@ -240,6 +187,11 @@ 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();

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 version: string;
 export declare const pkgDir: string;
 export declare const runtimeDir: string;
 export declare const presetsDir: string;
-export declare const subpaths: 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 pkgDir = /* @__PURE__ */ resolve("../../");
+export const runtimeDir = /* @__PURE__ */ resolve("./");
+export const presetsDir = /* @__PURE__ */ resolve("../presets/");
+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,12 @@
+// Config
+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">;
+// 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 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__ || 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/vite-runtime.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-runtime.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)));
+}