nitro 2.2.27 → 3.0.0-alpha.0

package/dist/runtime/internal/error/prod.mjs

@@ -0,0 +1,62 @@
+import { getRequestURL } from "h3";
+import { defineNitroErrorHandler } from "./utils.mjs";
+import { FastResponse } from "srvx";
+export default defineNitroErrorHandler(
+  function defaultNitroErrorHandler(error, event) {
+    const res = defaultHandler(error, event);
+    return new FastResponse(JSON.stringify(res.body, null, 2), res);
+  }
+);
+export function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled;
+  const status = error.status || 500;
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (status === 404) {
+    const baseURL = import.meta.baseURL || "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
+    console.error(
+      `[request error] ${tags} [${event.req.method}] ${url}
+`,
+      error
+    );
+  }
+  const headers = {
+    "content-type": "application/json",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'none'; frame-ancestors 'none';"
+  };
+  if (status === 404 || !event.res.headers.has("cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = {
+    error: true,
+    url: url.href,
+    status,
+    statusText: error.statusText,
+    message: isSensitive ? "Server Error" : error.message,
+    data: isSensitive ? void 0 : error.data
+  };
+  return {
+    status,
+    statusText: error.statusText,
+    headers,
+    body
+  };
+}

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

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

package/dist/runtime/internal/error/utils.mjs

@@ -0,0 +1,3 @@
+export function defineNitroErrorHandler(handler) {
+  return handler;
+}

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

@@ -0,0 +1,3 @@
+export { trapUnhandledNodeErrors } from "./utils.mjs";
+export { startScheduleRunner, runCronTasks } from "./task.mjs";
+export { getGracefulShutdownConfig, setupGracefulShutdown } from "./shutdown.mjs";

package/dist/runtime/internal/index.mjs

@@ -0,0 +1,3 @@
+export { trapUnhandledNodeErrors } from "./utils.mjs";
+export { startScheduleRunner, runCronTasks } from "./task.mjs";
+export { getGracefulShutdownConfig, setupGracefulShutdown } from "./shutdown.mjs";

package/dist/runtime/internal/lib/http-graceful-shutdown.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Gracefully shuts down `server` when the process receives
+ * the passed signals
+ *
+ * @param {http.Server} server
+ * @param {object} opts
+ *        signals: string (each signal separated by SPACE)
+ *        timeout: timeout value for forceful shutdown in ms
+ *        forceExit: force process.exit() - otherwise just let event loop clear
+ *        development: boolean value (if true, no graceful shutdown to speed up development
+ *        preShutdown: optional function. Needs to return a promise. - HTTP sockets are still available and untouched
+ *        onShutdown: optional function. Needs to return a promise.
+ *        finally: optional function, handled at the end of the shutdown.
+ */
+declare function GracefulShutdown(server: any, opts: any): () => any;
+export default GracefulShutdown;

package/dist/runtime/internal/lib/http-graceful-shutdown.mjs

@@ -0,0 +1,213 @@
+import http from "node:http";
+const debug = (...args) => {
+};
+function GracefulShutdown(server, opts) {
+  opts = opts || {};
+  const options = Object.assign(
+    {
+      signals: "SIGINT SIGTERM",
+      timeout: 3e4,
+      development: false,
+      forceExit: true,
+      onShutdown: (signal) => Promise.resolve(signal),
+      preShutdown: (signal) => Promise.resolve(signal)
+    },
+    opts
+  );
+  let isShuttingDown = false;
+  const connections = {};
+  let connectionCounter = 0;
+  const secureConnections = {};
+  let secureConnectionCounter = 0;
+  let failed = false;
+  let finalRun = false;
+  function onceFactory() {
+    let called = false;
+    return (emitter, events, callback) => {
+      function call() {
+        if (!called) {
+          called = true;
+          return Reflect.apply(callback, this, arguments);
+        }
+      }
+      for (const e of events) {
+        emitter.on(e, call);
+      }
+    };
+  }
+  const signals = options.signals.split(" ").map((s) => s.trim()).filter((s) => s.length > 0);
+  const once = onceFactory();
+  once(process, signals, (signal) => {
+    debug("received shut down signal", signal);
+    shutdown(signal).then(() => {
+      if (options.forceExit) {
+        process.exit(failed ? 1 : 0);
+      }
+    }).catch((error) => {
+      debug("server shut down error occurred", error);
+      process.exit(1);
+    });
+  });
+  function isFunction(functionToCheck) {
+    const getType = Object.prototype.toString.call(functionToCheck);
+    return /^\[object\s([A-Za-z]+)?Function]$/.test(getType);
+  }
+  function destroy(socket, force = false) {
+    if (socket._isIdle && isShuttingDown || force) {
+      socket.destroy();
+      if (socket.server instanceof http.Server) {
+        delete connections[socket._connectionId];
+      } else {
+        delete secureConnections[socket._connectionId];
+      }
+    }
+  }
+  function destroyAllConnections(force = false) {
+    debug("Destroy Connections : " + (force ? "forced close" : "close"));
+    let counter = 0;
+    let secureCounter = 0;
+    for (const key of Object.keys(connections)) {
+      const socket = connections[key];
+      const serverResponse = socket._httpMessage;
+      if (serverResponse && !force) {
+        if (!serverResponse.headersSent) {
+          serverResponse.setHeader("connection", "close");
+        }
+      } else {
+        counter++;
+        destroy(socket);
+      }
+    }
+    debug("Connections destroyed : " + counter);
+    debug("Connection Counter    : " + connectionCounter);
+    for (const key of Object.keys(secureConnections)) {
+      const socket = secureConnections[key];
+      const serverResponse = socket._httpMessage;
+      if (serverResponse && !force) {
+        if (!serverResponse.headersSent) {
+          serverResponse.setHeader("connection", "close");
+        }
+      } else {
+        secureCounter++;
+        destroy(socket);
+      }
+    }
+    debug("Secure Connections destroyed : " + secureCounter);
+    debug("Secure Connection Counter    : " + secureConnectionCounter);
+  }
+  server.on("request", (req, res) => {
+    req.socket._isIdle = false;
+    if (isShuttingDown && !res.headersSent) {
+      res.setHeader("connection", "close");
+    }
+    res.on("finish", () => {
+      req.socket._isIdle = true;
+      destroy(req.socket);
+    });
+  });
+  server.on("connection", (socket) => {
+    if (isShuttingDown) {
+      socket.destroy();
+    } else {
+      const id = connectionCounter++;
+      socket._isIdle = true;
+      socket._connectionId = id;
+      connections[id] = socket;
+      socket.once("close", () => {
+        delete connections[socket._connectionId];
+      });
+    }
+  });
+  server.on("secureConnection", (socket) => {
+    if (isShuttingDown) {
+      socket.destroy();
+    } else {
+      const id = secureConnectionCounter++;
+      socket._isIdle = true;
+      socket._connectionId = id;
+      secureConnections[id] = socket;
+      socket.once("close", () => {
+        delete secureConnections[socket._connectionId];
+      });
+    }
+  });
+  process.on("close", () => {
+    debug("closed");
+  });
+  function shutdown(sig) {
+    function cleanupHttp() {
+      destroyAllConnections();
+      debug("Close http server");
+      return new Promise((resolve, reject) => {
+        server.close((err) => {
+          if (err) {
+            return reject(err);
+          }
+          return resolve(true);
+        });
+      });
+    }
+    debug("shutdown signal - " + sig);
+    if (options.development) {
+      debug("DEV-Mode - immediate forceful shutdown");
+      return process.exit(0);
+    }
+    function finalHandler() {
+      if (!finalRun) {
+        finalRun = true;
+        if (options.finally && isFunction(options.finally)) {
+          debug("executing finally()");
+          options.finally();
+        }
+      }
+      return Promise.resolve();
+    }
+    function waitForReadyToShutDown(totalNumInterval) {
+      debug(`waitForReadyToShutDown... ${totalNumInterval}`);
+      if (totalNumInterval === 0) {
+        debug(
+          `Could not close connections in time (${options.timeout}ms), will forcefully shut down`
+        );
+        return Promise.resolve(true);
+      }
+      const allConnectionsClosed = Object.keys(connections).length === 0 && Object.keys(secureConnections).length === 0;
+      if (allConnectionsClosed) {
+        debug("All connections closed. Continue to shutting down");
+        return Promise.resolve(false);
+      }
+      debug("Schedule the next waitForReadyToShutdown");
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(waitForReadyToShutDown(totalNumInterval - 1));
+        }, 250);
+      });
+    }
+    if (isShuttingDown) {
+      return Promise.resolve();
+    }
+    debug("shutting down");
+    return options.preShutdown(sig).then(() => {
+      isShuttingDown = true;
+      cleanupHttp();
+    }).then(() => {
+      const pollIterations = options.timeout ? Math.round(options.timeout / 250) : 0;
+      return waitForReadyToShutDown(pollIterations);
+    }).then((force) => {
+      debug("Do onShutdown now");
+      if (force) {
+        destroyAllConnections(force);
+      }
+      return options.onShutdown(sig);
+    }).then(finalHandler).catch((error) => {
+      const errString = typeof error === "string" ? error : JSON.stringify(error);
+      debug(errString);
+      failed = true;
+      throw errString;
+    });
+  }
+  function shutdownManual() {
+    return shutdown("manual");
+  }
+  return shutdownManual;
+}
+export default GracefulShutdown;

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

@@ -0,0 +1,2 @@
+import type { NitroRouteMeta } from "nitro/types";
+export declare function defineRouteMeta(meta: NitroRouteMeta): NitroRouteMeta;

package/dist/runtime/internal/meta.mjs

@@ -0,0 +1,3 @@
+export function defineRouteMeta(meta) {
+  return meta;
+}

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

@@ -0,0 +1,3 @@
+import type { NitroAppPlugin } from "nitro/types";
+export declare function defineNitroPlugin(def: NitroAppPlugin): NitroAppPlugin;
+export declare const nitroPlugin: typeof defineNitroPlugin;

package/dist/runtime/internal/plugin.mjs

@@ -0,0 +1,4 @@
+export function defineNitroPlugin(def) {
+  return def;
+}
+export const nitroPlugin = defineNitroPlugin;

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

@@ -0,0 +1,3 @@
+import { type EventHandler } from "h3";
+import type { RenderHandler } from "nitro/types";
+export declare function defineRenderHandler(render: RenderHandler): EventHandler;

package/dist/runtime/internal/renderer.mjs

@@ -0,0 +1,36 @@
+import { defineHandler } from "h3";
+import { useNitroApp } from "./app.mjs";
+import { useRuntimeConfig } from "./runtime-config.mjs";
+export function defineRenderHandler(render) {
+  const runtimeConfig = useRuntimeConfig();
+  return defineHandler(async (event) => {
+    const nitroApp = useNitroApp();
+    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 (ctx.response.status || ctx.response.statusText) {
+      event.res.status = ctx.response.status;
+      event.res.statusText = ctx.response.statusText;
+    }
+    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

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

@@ -0,0 +1,100 @@
+import { defineHandler, getRequestURL } from "h3";
+import { joinURL } from "ufo";
+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: {
+      title: meta?.title,
+      version: meta?.version,
+      description: meta?.description
+    },
+    servers: [
+      {
+        url,
+        description: "Local Development Server",
+        variables: {}
+      }
+    ],
+    paths,
+    components,
+    ...extensible
+  };
+});
+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,
+        parameters,
+        responses: {
+          200: { description: "OK" }
+        },
+        ...openAPI
+      }
+    };
+    if ($global) {
+      globals = defu($global, globals);
+    }
+    if (paths[route] === void 0) {
+      paths[route] = item;
+    } else {
+      Object.assign(paths[route], item);
+    }
+  }
+  return { paths, globals };
+}
+function normalizeRoute(_route) {
+  const parameters = [];
+  let anonymousCtr = 0;
+  const route = _route.replace(/:(\w+)/g, (_, name) => `{${name}}`).replace(/\/(\*)\//g, () => `/{param${++anonymousCtr}}/`).replace(/\*\*{/, "{").replace(/\/(\*\*)$/g, () => `/{*param${++anonymousCtr}}`);
+  const paramMatches = route.matchAll(/{(\*?\w+)}/g);
+  for (const match of paramMatches) {
+    const name = match[1];
+    if (!parameters.some((p) => p.name === name)) {
+      parameters.push({
+        name,
+        in: "path",
+        required: true,
+        schema: { type: "string" }
+      });
+    }
+  }
+  return {
+    route,
+    parameters
+  };
+}
+function defaultTags(route) {
+  const tags = [];
+  if (route.startsWith("/api/")) {
+    tags.push("API Routes");
+  } else if (route.startsWith("/_")) {
+    tags.push("Internal");
+  } else {
+    tags.push("App Routes");
+  }
+  return tags;
+}

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;