nitro-nightly 3.0.0-beta-28969273.f7aa9de6 → 4.0.0-20251010-091516-7cafddba

package/dist/runtime/internal/renderer.mjs

@@ -1,40 +1,36 @@
-import {
-  eventHandler,
-  getResponseStatus,
-  send,
-  setResponseHeader,
-  setResponseHeaders,
-  setResponseStatus
-} from "h3";
+import { defineHandler } from "h3";
 import { useNitroApp } from "./app.mjs";
-import { useRuntimeConfig } from "./config.mjs";
-export function defineRenderHandler(handler) {
+import { useRuntimeConfig } from "./runtime-config.mjs";
+export function defineRenderHandler(render) {
   const runtimeConfig = useRuntimeConfig();
-  return eventHandler(async (event) => {
-    if (event.path === `${runtimeConfig.app.baseURL}favicon.ico`) {
-      setResponseHeader(event, "Content-Type", "image/x-icon");
-      return send(
-        event,
-        "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
-      );
-    }
-    const response = await handler(event);
-    if (!response) {
-      const _currentStatus = getResponseStatus(event);
-      setResponseStatus(event, _currentStatus === 200 ? 500 : _currentStatus);
-      return send(
-        event,
-        "No response returned from render handler: " + event.path
-      );
-    }
+  return defineHandler(async (event) => {
     const nitroApp = useNitroApp();
-    await nitroApp.hooks.callHook("render:response", response, { event });
-    if (response.headers) {
-      setResponseHeaders(event, response.headers);
+    const ctx = { event, render, response: void 0 };
+    await nitroApp.hooks.callHook("render:before", ctx);
+    if (!ctx.response) {
+      if (event.url.pathname === `${runtimeConfig.app.baseURL}favicon.ico`) {
+        event.res.headers.set("Content-Type", "image/x-icon");
+        return "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
+      }
+      ctx.response = await ctx.render(event);
+      if (!ctx.response) {
+        const _currentStatus = event.res.status;
+        event.res.statusText = String(
+          _currentStatus === 200 ? 500 : _currentStatus
+        );
+        return "No response returned from render handler: " + event.url.pathname;
+      }
+    }
+    await nitroApp.hooks.callHook("render:response", ctx.response, ctx);
+    if (ctx.response.headers) {
+      for (const [key, value] of Object.entries(ctx.response.headers)) {
+        event.res.headers.set(key, value);
+      }
     }
-    if (response.statusCode || response.statusMessage) {
-      setResponseStatus(event, response.statusCode, response.statusMessage);
+    if (ctx.response.status || ctx.response.statusText) {
+      event.res.status = ctx.response.status;
+      event.res.statusText = ctx.response.statusText;
     }
-    return response.body;
+    return ctx.response.body;
   });
 }

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

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

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

@@ -1,67 +1,62 @@
-import defu from "defu";
-import {
-  eventHandler,
-  proxyRequest,
-  sendRedirect,
-  setHeaders
-} from "h3";
-import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
-import { getQuery, joinURL, withQuery, withoutBase } from "ufo";
-import { useRuntimeConfig } from "./config.mjs";
-const config = useRuntimeConfig();
-const _routeRulesMatcher = toRouteMatcher(
-  createRadixRouter({ routes: config.nitro.routeRules })
-);
-export function createRouteRulesHandler(ctx) {
-  return eventHandler((event) => {
-    const routeRules = getRouteRules(event);
-    if (routeRules.headers) {
-      setHeaders(event, routeRules.headers);
-    }
-    if (routeRules.redirect) {
-      let target = routeRules.redirect.to;
-      if (target.endsWith("/**")) {
-        let targetPath = event.path;
-        const strpBase = routeRules.redirect._redirectStripBase;
-        if (strpBase) {
-          targetPath = withoutBase(targetPath, strpBase);
-        }
-        target = joinURL(target.slice(0, -3), targetPath);
-      } else if (event.path.includes("?")) {
-        const query = getQuery(event.path);
-        target = withQuery(target, query);
-      }
-      return sendRedirect(event, target, routeRules.redirect.statusCode);
+import { proxyRequest, redirect as sendRedirect } from "h3";
+import { joinURL, withQuery, withoutBase } from "ufo";
+import { defineCachedEventHandler } from "./cache.mjs";
+export const headers = ((m) => function headersRouteRule(event) {
+  for (const [key, value] of Object.entries(m.options || {})) {
+    event.res.headers.set(key, value);
+  }
+});
+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);
     }
-    if (routeRules.proxy) {
-      let target = routeRules.proxy.to;
-      if (target.endsWith("/**")) {
-        let targetPath = event.path;
-        const strpBase = routeRules.proxy._proxyStripBase;
-        if (strpBase) {
-          targetPath = withoutBase(targetPath, strpBase);
-        }
-        target = joinURL(target.slice(0, -3), targetPath);
-      } else if (event.path.includes("?")) {
-        const query = getQuery(event.path);
-        target = withQuery(target, query);
-      }
-      return proxyRequest(event, target, {
-        fetch: ctx.localFetch,
-        ...routeRules.proxy
-      });
+    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);
+});
+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
   });
-}
-export function getRouteRules(event) {
-  event.context._nitro = event.context._nitro || {};
-  if (!event.context._nitro.routeRules) {
-    event.context._nitro.routeRules = getRouteRulesForPath(
-      withoutBase(event.path.split("?")[0], useRuntimeConfig().app.baseURL)
-    );
+});
+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 event.context._nitro.routeRules;
-}
-export function getRouteRulesForPath(path) {
-  return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
-}
+  return cachedHandler(event);
+});

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

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

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

@@ -0,0 +1,23 @@
+import { H3 } from "h3";
+import { runTask } from "nitro/runtime";
+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
+  };
+}).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 });
+});

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

@@ -0,0 +1,3 @@
+import type { EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;

package/dist/runtime/internal/routes/openapi.mjs

@@ -1,15 +1,23 @@
-import { eventHandler, getRequestURL } from "h3";
+import { defineHandler, getRequestURL } from "h3";
 import { joinURL } from "ufo";
-import { handlersMeta } from "#nitro-internal-virtual/server-handlers-meta";
-import { useRuntimeConfig } from "../config.mjs";
-export default eventHandler((event) => {
-  const runtimeConfig = useRuntimeConfig(event);
+import { defu } from "defu";
+import { handlersMeta } from "#nitro-internal-virtual/routing-meta";
+import { useRuntimeConfig } from "../runtime-config.mjs";
+export default defineHandler((event) => {
+  const runtimeConfig = useRuntimeConfig();
   const base = runtimeConfig.app?.baseURL;
   const url = joinURL(getRequestURL(event).origin, base);
   const meta = {
     title: "Nitro Server Routes",
     ...runtimeConfig.nitro?.openAPI?.meta
   };
+  const {
+    paths,
+    globals: { components, ...globalsRest }
+  } = getHandlersMeta();
+  const extensible = Object.fromEntries(
+    Object.entries(globalsRest).filter(([key]) => key.startsWith("x-"))
+  );
   return {
     openapi: "3.1.0",
     info: {
@@ -24,15 +32,19 @@ export default eventHandler((event) => {
         variables: {}
       }
     ],
-    paths: getPaths()
+    paths,
+    components,
+    ...extensible
   };
 });
-function getPaths() {
+function getHandlersMeta() {
   const paths = {};
+  let globals = {};
   for (const h of handlersMeta) {
     const { route, parameters } = normalizeRoute(h.route || "");
     const tags = defaultTags(h.route || "");
     const method = (h.method || "get").toLowerCase();
+    const { $global, ...openAPI } = h.meta?.openAPI || {};
     const item = {
       [method]: {
         tags,
@@ -40,16 +52,19 @@ function getPaths() {
         responses: {
           200: { description: "OK" }
         },
-        ...h.meta?.openAPI
+        ...openAPI
       }
     };
+    if ($global) {
+      globals = defu($global, globals);
+    }
     if (paths[route] === void 0) {
       paths[route] = item;
     } else {
       Object.assign(paths[route], item);
     }
   }
-  return paths;
+  return { paths, globals };
 }
 function normalizeRoute(_route) {
   const parameters = [];

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

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

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

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

package/dist/runtime/internal/routes/renderer-template.dev.mjs

@@ -0,0 +1,21 @@
+import {
+  rendererTemplate,
+  rendererTemplateFile
+} from "#nitro-internal-virtual/renderer-template";
+import { HTTPResponse } from "h3";
+import { hasTemplateSyntax, renderToResponse, compileTemplate } from "rendu";
+export default async function renderIndexHTML(event) {
+  let html = await rendererTemplate(event.req);
+  if (globalThis.__transform_html__) {
+    html = await globalThis.__transform_html__(html);
+  }
+  if (!hasTemplateSyntax(html)) {
+    return new HTTPResponse(html, {
+      headers: { "content-type": "text/html; charset=utf-8" }
+    });
+  }
+  const template = compileTemplate(html, { filename: rendererTemplateFile });
+  return renderToResponse(template, {
+    request: event.req
+  });
+}

package/dist/runtime/internal/routes/renderer-template.mjs

@@ -0,0 +1,4 @@
+import { rendererTemplate } from "#nitro-internal-virtual/renderer-template";
+export default function renderIndexHTML(event) {
+  return rendererTemplate(event.req);
+}

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

@@ -0,0 +1,3 @@
+import { type EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;

package/dist/runtime/internal/routes/scalar.mjs

@@ -1,15 +1,18 @@
-import { eventHandler } from "h3";
-import { useRuntimeConfig } from "../config.mjs";
-export default eventHandler((event) => {
-  const runtimeConfig = useRuntimeConfig(event);
+import { defineHandler } from "h3";
+import { useRuntimeConfig } from "../runtime-config.mjs";
+export default defineHandler((event) => {
+  const runtimeConfig = useRuntimeConfig();
   const title = runtimeConfig.nitro.openAPI?.meta?.title || "API Reference";
   const description = runtimeConfig.nitro.openAPI?.meta?.description || "";
   const openAPIEndpoint = runtimeConfig.nitro.openAPI?.route || "./_openapi.json";
   const _config = runtimeConfig.nitro.openAPI?.ui?.scalar;
   const scalarConfig = {
     ..._config,
+    url: openAPIEndpoint,
+    // @ts-expect-error (missing types?)
     spec: { url: openAPIEndpoint, ..._config?.spec }
   };
+  event.res.headers.set("Content-Type", "text/html");
   return (
     /* html */
     `<!doctype html>

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

@@ -0,0 +1,3 @@
+import type { EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;

package/dist/runtime/internal/routes/swagger.mjs

@@ -1,11 +1,12 @@
-import { eventHandler } from "h3";
-import { useRuntimeConfig } from "../config.mjs";
-export default eventHandler((event) => {
-  const runtimeConfig = useRuntimeConfig(event);
+import { defineHandler } from "h3";
+import { useRuntimeConfig } from "../runtime-config.mjs";
+export default defineHandler((event) => {
+  const runtimeConfig = useRuntimeConfig();
   const title = runtimeConfig.nitro.openAPI?.meta?.title || "API Reference";
   const description = runtimeConfig.nitro.openAPI?.meta?.description || "";
   const openAPIEndpoint = runtimeConfig.nitro.openAPI?.route || "./_openapi.json";
   const CDN_BASE = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@^5";
+  event.res.headers.set("Content-Type", "text/html");
   return (
     /* html */
     `<!doctype html>

package/dist/runtime/internal/{utils.env.d.ts → runtime-config.d.mts}

@@ -1,7 +1,9 @@
-export type EnvOptions = {
+import type { NitroRuntimeConfig } from "nitro/types";
+export declare function useRuntimeConfig(): NitroRuntimeConfig;
+type EnvOptions = {
     prefix?: string;
     altPrefix?: string;
     envExpansion?: boolean;
 };
-export declare function getEnv(key: string, opts: EnvOptions): unknown;
 export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string): Record<string, any>;
+export {};

package/dist/runtime/internal/{utils.env.mjs → runtime-config.mjs}

@@ -1,10 +1,20 @@
-import destr from "destr";
 import { snakeCase } from "scule";
-export function getEnv(key, opts) {
+export function useRuntimeConfig() {
+  return useRuntimeConfig._cached ||= getRuntimeConfig();
+}
+function getRuntimeConfig() {
+  const runtimeConfig = globalThis.__NITRO_RUNTIME_CONFIG__ || process.env.RUNTIME_CONFIG || {};
+  const env = globalThis.process?.env || {};
+  applyEnv(runtimeConfig, {
+    prefix: "NITRO_",
+    altPrefix: runtimeConfig.nitro?.envPrefix ?? env?.NITRO_ENV_PREFIX ?? "_",
+    envExpansion: runtimeConfig.nitro?.envExpansion ?? env?.NITRO_ENV_EXPANSION ?? false
+  });
+  return runtimeConfig;
+}
+function getEnv(key, opts) {
   const envKey = snakeCase(key).toUpperCase();
-  return destr(
-    process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey]
-  );
+  return process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey];
 }
 function _isObject(input) {
   return typeof input === "object" && !Array.isArray(input);
@@ -31,7 +41,7 @@ export function applyEnv(obj, opts, parentKey = "") {
   }
   return obj;
 }
-const envExpandRx = /{{(.*?)}}/g;
+const envExpandRx = /\{\{([^{}]*)\}\}/g;
 function _expandFromEnv(value) {
   return value.replace(envExpandRx, (match, key) => {
     return process.env[key] || match;

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

@@ -0,0 +1,3 @@
+import type { EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;

package/dist/runtime/internal/static.mjs

@@ -1,16 +1,7 @@
-import {
-  createError,
-  eventHandler,
-  getRequestHeader,
-  getResponseHeader,
-  removeResponseHeader,
-  setResponseHeader,
-  setResponseStatus
-} from "h3";
+import { HTTPError, defineHandler } from "h3";
 import {
   decodePath,
   joinURL,
-  parseURL,
   withLeadingSlash,
   withoutTrailingSlash
 } from "ufo";
@@ -21,23 +12,21 @@ import {
 } from "#nitro-internal-virtual/public-assets";
 const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]);
 const EncodingMap = { gzip: ".gz", br: ".br" };
-export default eventHandler((event) => {
-  if (event.method && !METHODS.has(event.method)) {
+export default defineHandler((event) => {
+  if (event.req.method && !METHODS.has(event.req.method)) {
     return;
   }
   let id = decodePath(
-    withLeadingSlash(withoutTrailingSlash(parseURL(event.path).pathname))
+    withLeadingSlash(withoutTrailingSlash(event.url.pathname))
   );
   let asset;
-  const encodingHeader = String(
-    getRequestHeader(event, "accept-encoding") || ""
-  );
+  const encodingHeader = event.req.headers.get("accept-encoding") || "";
   const encodings = [
     ...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(),
     ""
   ];
   if (encodings.length > 1) {
-    setResponseHeader(event, "Vary", "Accept-Encoding");
+    event.res.headers.append("Vary", "Accept-Encoding");
   }
   for (const encoding of encodings) {
     for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
@@ -51,39 +40,38 @@ export default eventHandler((event) => {
   }
   if (!asset) {
     if (isPublicAssetURL(id)) {
-      removeResponseHeader(event, "Cache-Control");
-      throw createError({
-        statusMessage: "Cannot find static asset " + id,
-        statusCode: 404
-      });
+      event.res.headers.delete("Cache-Control");
+      throw new HTTPError({ status: 404 });
     }
     return;
   }
-  const ifNotMatch = getRequestHeader(event, "if-none-match") === asset.etag;
+  const ifNotMatch = event.req.headers.get("if-none-match") === asset.etag;
   if (ifNotMatch) {
-    setResponseStatus(event, 304, "Not Modified");
+    event.res.status = 304;
+    event.res.statusText = "Not Modified";
     return "";
   }
-  const ifModifiedSinceH = getRequestHeader(event, "if-modified-since");
+  const ifModifiedSinceH = event.req.headers.get("if-modified-since");
   const mtimeDate = new Date(asset.mtime);
   if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
-    setResponseStatus(event, 304, "Not Modified");
+    event.res.status = 304;
+    event.res.statusText = "Not Modified";
     return "";
   }
-  if (asset.type && !getResponseHeader(event, "Content-Type")) {
-    setResponseHeader(event, "Content-Type", asset.type);
+  if (asset.type) {
+    event.res.headers.set("Content-Type", asset.type);
   }
-  if (asset.etag && !getResponseHeader(event, "ETag")) {
-    setResponseHeader(event, "ETag", asset.etag);
+  if (asset.etag && !event.res.headers.has("ETag")) {
+    event.res.headers.set("ETag", asset.etag);
   }
-  if (asset.mtime && !getResponseHeader(event, "Last-Modified")) {
-    setResponseHeader(event, "Last-Modified", mtimeDate.toUTCString());
+  if (asset.mtime && !event.res.headers.has("Last-Modified")) {
+    event.res.headers.set("Last-Modified", mtimeDate.toUTCString());
   }
-  if (asset.encoding && !getResponseHeader(event, "Content-Encoding")) {
-    setResponseHeader(event, "Content-Encoding", asset.encoding);
+  if (asset.encoding && !event.res.headers.has("Content-Encoding")) {
+    event.res.headers.set("Content-Encoding", asset.encoding);
   }
-  if (asset.size > 0 && !getResponseHeader(event, "Content-Length")) {
-    setResponseHeader(event, "Content-Length", asset.size);
+  if (asset.size > 0 && !event.res.headers.has("Content-Length")) {
+    event.res.headers.set("Content-Length", asset.size.toString());
   }
   return readAsset(id);
 });

package/dist/runtime/internal/storage.mjs

@@ -1,5 +1,6 @@
 import { prefixStorage } from "unstorage";
-import { storage } from "#nitro-internal-virtual/storage";
+import { initStorage } from "#nitro-internal-virtual/storage";
 export function useStorage(base = "") {
+  const storage = useStorage._storage ??= initStorage();
   return base ? prefixStorage(storage, base) : storage;
 }

package/dist/runtime/internal/task.mjs

@@ -1,5 +1,5 @@
 import { Cron } from "croner";
-import { createError } from "h3";
+import { HTTPError } from "h3";
 import { isTest } from "std-env";
 import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
 export function defineTask(def) {
@@ -19,15 +19,15 @@ export async function runTask(name, {
     return __runningTasks__[name];
   }
   if (!(name in tasks)) {
-    throw createError({
+    throw new HTTPError({
       message: `Task \`${name}\` is not available!`,
-      statusCode: 404
+      status: 404
     });
   }
   if (!tasks[name].resolve) {
-    throw createError({
+    throw new HTTPError({
       message: `Task \`${name}\` is not implemented!`,
-      statusCode: 501
+      status: 501
     });
   }
   const handler = await tasks[name].resolve();
@@ -56,7 +56,7 @@ export function startScheduleRunner() {
             context: {}
           }).catch((error) => {
             console.error(
-              `[nitro] Error while running scheduled task "${name}"`,
+              `Error while running scheduled task "${name}"`,
               error
             );
           })

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

@@ -0,0 +1 @@
+export declare function trapUnhandledNodeErrors(): void;