nitro 2.2.28 → 3.0.0

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

@@ -0,0 +1,194 @@
+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>
+    <html lang="en">
+      <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta name="description" content="${description}" />
+        <title>${title}</title>
+        <style>
+          ${scalarConfig.theme ? null : customTheme}
+        </style>
+      </head>
+      <body>
+        <script
+          id="api-reference"
+          data-configuration="${JSON.stringify(scalarConfig).split('"').join("&quot;")}"
+        ><\/script>
+        <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
+      </body>
+    </html>`
+  );
+});
+const customTheme = (
+  /* css */
+  `/* basic theme */
+  .light-mode,
+  .light-mode .dark-mode {
+    --theme-background-1: #fff;
+    --theme-background-2: #fafafa;
+    --theme-background-3: rgb(245 245 245);
+
+    --theme-color-1: #2a2f45;
+    --theme-color-2: #757575;
+    --theme-color-3: #8e8e8e;
+
+    --theme-color-accent: #ef4444;
+    --theme-background-accent: transparent;
+
+    --theme-border-color: rgba(0, 0, 0, 0.1);
+  }
+  .dark-mode {
+    --theme-background-1: #171717;
+    --theme-background-2: #262626;
+    --theme-background-3: #2e2e2e;
+
+    --theme-color-1: rgba(255, 255, 255, 0.9);
+    --theme-color-2: rgba(255, 255, 255, 0.62);
+    --theme-color-3: rgba(255, 255, 255, 0.44);
+
+    --theme-color-accent: #f87171;
+    --theme-background-accent: transparent;
+
+    --theme-border-color: rgba(255, 255, 255, 0.1);
+  }
+
+  /* Document Sidebar */
+  .light-mode .t-doc__sidebar,
+  .dark-mode .t-doc__sidebar {
+    --sidebar-background-1: var(--theme-background-1);
+    --sidebar-color-1: var(--theme-color-1);
+    --sidebar-color-2: var(--theme-color-2);
+    --sidebar-border-color: var(--theme-border-color);
+
+    --sidebar-item-hover-background: transparent;
+    --sidebar-item-hover-color: var(--sidebar-color-1);
+
+    --sidebar-item-active-background: var(--theme-background-accent);
+    --sidebar-color-active: var(--theme-color-accent);
+
+    --sidebar-search-background: transparent;
+    --sidebar-search-color: var(--theme-color-3);
+    --sidebar-search-border-color: var(--theme-border-color);
+  }
+
+  /* advanced */
+  .light-mode .dark-mode,
+  .light-mode {
+    --theme-color-green: #91b859;
+    --theme-color-red: #e53935;
+    --theme-color-yellow: #e2931d;
+    --theme-color-blue: #6182b8;
+    --theme-color-orange: #f76d47;
+    --theme-color-purple: #9c3eda;
+  }
+  .dark-mode {
+    --theme-color-green: #c3e88d;
+    --theme-color-red: #f07178;
+    --theme-color-yellow: #ffcb6b;
+    --theme-color-blue: #82aaff;
+    --theme-color-orange: #f78c6c;
+    --theme-color-purple: #c792ea;
+  }
+  /* custom-theme */
+  .section-container:nth-of-type(2)
+    ~ .section-container
+    .scalar-card
+    .scalar-card-header {
+    --theme-background-2: var(--theme-background-1) !important;
+  }
+  .section-flare {
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    top: 0;
+    left: 0;
+    animation: spin 39s linear infinite;
+    transition: all 0.3s ease-in-out;
+    opacity: 1;
+  }
+  .section-flare-item:nth-of-type(1),
+  .section-flare-item:nth-of-type(2),
+  .section-flare-item:nth-of-type(3) {
+    content: "";
+    width: 1000px;
+    height: 1000px;
+    position: absolute;
+    top: 0;
+    right: 0;
+    border-radius: 50%;
+    background: var(--default-theme-background-1);
+    display: block;
+    opacity: 1;
+    filter: blur(48px);
+    -webkit-backface-visibility: hidden;
+    -webkit-perspective: 1000;
+    -webkit-transform: translate3d(0, 0, 0);
+    -webkit-transform: translateZ(0);
+    perspective: 1000;
+    transform: translate3d(0, 0, 0);
+    transform: translateZ(0);
+  }
+  .section-flare-item:nth-of-type(2) {
+    top: initial;
+    right: initial;
+    background: #ef4444;
+    width: 700px;
+    height: 700px;
+    opacity: 0.3;
+    animation: sectionflare 37s linear infinite;
+  }
+  .section-flare-item:nth-of-type(1) {
+    top: initial;
+    right: initial;
+    bottom: 0;
+    left: -20px;
+    background: #ef4444;
+    width: 500px;
+    height: 500px;
+    opacity: 0.3;
+    animation: sectionflare2 38s linear infinite;
+  }
+  @keyframes sectionflare {
+    0%,
+    100% {
+      transform: translate3d(0, 0, 0);
+    }
+    50% {
+      transform: translate3d(525px, 525px, 0);
+    }
+  }
+  @keyframes sectionflare2 {
+    0%,
+    100% {
+      transform: translate3d(700px, 700px, 0);
+    }
+    50% {
+      transform: translate3d(0, 0, 0);
+    }
+  }
+  @keyframes spin {
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+  .section-container:nth-of-type(2) {
+    overflow: hidden;
+  }`
+);

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

@@ -0,0 +1,44 @@
+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>
+    <html lang="en">
+      <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta name="description" content="${description}" />
+        <title>${title}</title>
+        <link rel="stylesheet" href="${CDN_BASE}/swagger-ui.css" />
+      </head>
+      <body>
+        <div id="swagger-ui"></div>
+        <script src="${CDN_BASE}/swagger-ui-bundle.js" crossorigin><\/script>
+        <script
+          src="${CDN_BASE}/swagger-ui-standalone-preset.js"
+          crossorigin
+        ><\/script>
+        <script>
+          window.onload = () => {
+            window.ui = SwaggerUIBundle({
+              url: ${JSON.stringify(openAPIEndpoint)},
+              dom_id: "#swagger-ui",
+              presets: [
+                SwaggerUIBundle.presets.apis,
+                SwaggerUIStandalonePreset,
+              ],
+              layout2: "StandaloneLayout",
+            });
+          };
+        <\/script>
+      </body>
+    </html> `
+  );
+});

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

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

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

@@ -0,0 +1,49 @@
+import { snakeCase } from "scule";
+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 process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey];
+}
+function _isObject(input) {
+  return typeof input === "object" && !Array.isArray(input);
+}
+export function applyEnv(obj, opts, parentKey = "") {
+  for (const key in obj) {
+    const subKey = parentKey ? `${parentKey}_${key}` : key;
+    const envValue = getEnv(subKey, opts);
+    if (_isObject(obj[key])) {
+      if (_isObject(envValue)) {
+        obj[key] = { ...obj[key], ...envValue };
+        applyEnv(obj[key], opts, subKey);
+      } else if (envValue === void 0) {
+        applyEnv(obj[key], opts, subKey);
+      } else {
+        obj[key] = envValue ?? obj[key];
+      }
+    } else {
+      obj[key] = envValue ?? obj[key];
+    }
+    if (opts.envExpansion && typeof obj[key] === "string") {
+      obj[key] = _expandFromEnv(obj[key]);
+    }
+  }
+  return obj;
+}
+const envExpandRx = /\{\{([^{}]*)\}\}/g;
+function _expandFromEnv(value) {
+  return value.replace(envExpandRx, (match, key) => {
+    return process.env[key] || match;
+  });
+}

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

@@ -0,0 +1,9 @@
+import type { Server as HttpServer } from "node:http";
+import type { NitroApp } from "nitro/types";
+export declare function getGracefulShutdownConfig(): {
+    disabled: boolean;
+    signals: string[];
+    timeout: number;
+    forceExit: boolean;
+};
+export declare function setupGracefulShutdown(listener: HttpServer, nitroApp: NitroApp): void;

package/dist/runtime/internal/shutdown.mjs

@@ -0,0 +1,34 @@
+import gracefulShutdown from "./lib/http-graceful-shutdown.mjs";
+export function getGracefulShutdownConfig() {
+  return {
+    disabled: !!process.env.NITRO_SHUTDOWN_DISABLED,
+    signals: (process.env.NITRO_SHUTDOWN_SIGNALS || "SIGTERM SIGINT").split(" ").map((s) => s.trim()),
+    timeout: Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 3e4,
+    forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT
+  };
+}
+export function setupGracefulShutdown(listener, nitroApp) {
+  const shutdownConfig = getGracefulShutdownConfig();
+  if (shutdownConfig.disabled) {
+    return;
+  }
+  gracefulShutdown(listener, {
+    signals: shutdownConfig.signals.join(" "),
+    timeout: shutdownConfig.timeout,
+    forceExit: shutdownConfig.forceExit,
+    onShutdown: async () => {
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          console.warn("Graceful shutdown timeout, force exiting...");
+          resolve();
+        }, shutdownConfig.timeout);
+        nitroApp.hooks.callHook("close").catch((error) => {
+          console.error(error);
+        }).finally(() => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+    }
+  });
+}

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

@@ -0,0 +1,77 @@
+import { HTTPError, defineHandler } from "h3";
+import {
+  decodePath,
+  joinURL,
+  withLeadingSlash,
+  withoutTrailingSlash
+} from "ufo";
+import {
+  getAsset,
+  isPublicAssetURL,
+  readAsset
+} from "#nitro-internal-virtual/public-assets";
+const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]);
+const EncodingMap = { gzip: ".gz", br: ".br" };
+export default defineHandler((event) => {
+  if (event.req.method && !METHODS.has(event.req.method)) {
+    return;
+  }
+  let id = decodePath(
+    withLeadingSlash(withoutTrailingSlash(event.url.pathname))
+  );
+  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);
+      if (_asset) {
+        asset = _asset;
+        id = _id;
+        break;
+      }
+    }
+  }
+  if (!asset) {
+    if (isPublicAssetURL(id)) {
+      event.res.headers.delete("Cache-Control");
+      throw new HTTPError({ status: 404 });
+    }
+    return;
+  }
+  const ifNotMatch = event.req.headers.get("if-none-match") === asset.etag;
+  if (ifNotMatch) {
+    event.res.status = 304;
+    event.res.statusText = "Not Modified";
+    return "";
+  }
+  const ifModifiedSinceH = event.req.headers.get("if-modified-since");
+  const mtimeDate = new Date(asset.mtime);
+  if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
+    event.res.status = 304;
+    event.res.statusText = "Not Modified";
+    return "";
+  }
+  if (asset.type) {
+    event.res.headers.set("Content-Type", asset.type);
+  }
+  if (asset.etag && !event.res.headers.has("ETag")) {
+    event.res.headers.set("ETag", asset.etag);
+  }
+  if (asset.mtime && !event.res.headers.has("Last-Modified")) {
+    event.res.headers.set("Last-Modified", mtimeDate.toUTCString());
+  }
+  if (asset.encoding && !event.res.headers.has("Content-Encoding")) {
+    event.res.headers.set("Content-Encoding", asset.encoding);
+  }
+  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.d.mts

@@ -0,0 +1,2 @@
+import type { Storage, StorageValue } from "unstorage";
+export declare function useStorage<T extends StorageValue = StorageValue>(base?: string): Storage<T>;

package/dist/runtime/internal/storage.mjs

@@ -0,0 +1,6 @@
+import { prefixStorage } from "unstorage";
+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.d.mts

@@ -0,0 +1,17 @@
+import type { Task, TaskContext, TaskPayload, TaskResult } from "nitro/types";
+/** @experimental */
+export declare function defineTask<RT = unknown>(def: Task<RT>): Task<RT>;
+/** @experimental */
+export declare function runTask<RT = unknown>(name: string, { payload, context, }?: {
+    payload?: TaskPayload;
+    context?: TaskContext;
+}): Promise<TaskResult<RT>>;
+/** @experimental */
+export declare function startScheduleRunner(): void;
+/** @experimental */
+export declare function getCronTasks(cron: string): string[];
+/** @experimental */
+export declare function runCronTasks(cron: string, ctx: {
+    payload?: TaskPayload;
+    context?: TaskContext;
+}): Promise<TaskResult[]>;

package/dist/runtime/internal/task.mjs

@@ -0,0 +1,73 @@
+import { Cron } from "croner";
+import { HTTPError } from "h3";
+import { isTest } from "std-env";
+import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
+export function defineTask(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];
+  }
+}
+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
+            );
+          })
+        )
+      );
+    });
+  }
+}
+export function getCronTasks(cron) {
+  return (scheduledTasks || []).find((task) => task.cron === cron)?.tasks || [];
+}
+export function runCronTasks(cron, ctx) {
+  return Promise.all(getCronTasks(cron).map((name) => runTask(name, ctx)));
+}

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

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

package/dist/runtime/internal/utils.mjs

@@ -0,0 +1,15 @@
+import { useNitroApp } from "./app.mjs";
+function _captureError(error, type) {
+  console.error(`[${type}]`, error);
+  useNitroApp().captureError(error, { tags: [type] });
+}
+export function trapUnhandledNodeErrors() {
+  process.on(
+    "unhandledRejection",
+    (error) => _captureError(error, "unhandledRejection")
+  );
+  process.on(
+    "uncaughtException",
+    (error) => _captureError(error, "uncaughtException")
+  );
+}

package/dist/runtime/internal/vite/dev-entry.d.mts

@@ -0,0 +1 @@
+export const fetch: any;

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

@@ -0,0 +1,6 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+
+const nitroApp = useNitroApp();
+
+export const fetch = nitroApp.fetch;

package/dist/runtime/internal/vite/dev-worker.d.mts

@@ -0,0 +1 @@
+export {};