nitro 2.2.27 → 3.0.0

package/dist/presets/netlify/runtime/netlify-edge.mjs

@@ -0,0 +1,17 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+const nitroApp = useNitroApp();
+export default async function netlifyEdge(netlifyReq, context) {
+  const req = netlifyReq;
+  req.runtime ??= { name: "netlify-edge" };
+  req.runtime.netlify ??= { context };
+  const url = new URL(req.url);
+  if (isPublicAssetURL(url.pathname)) {
+    return;
+  }
+  if (!req.headers.has("x-forwarded-proto") && url.protocol === "https:") {
+    req.headers.set("x-forwarded-proto", "https");
+  }
+  return nitroApp.fetch(req);
+}

package/dist/presets/netlify/runtime/netlify.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+declare const handler: (req: Request) => Promise<Response>;
+export default handler;

package/dist/presets/netlify/runtime/netlify.mjs

@@ -0,0 +1,24 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+const nitroApp = useNitroApp();
+const ONE_YEAR_IN_SECONDS = 365 * 24 * 60 * 60;
+const handler = async (req) => {
+  const response = await nitroApp.fetch(req);
+  const isr = (req.context?.routeRules || {})?.isr?.options;
+  if (isr) {
+    const maxAge = typeof isr === "number" ? isr : ONE_YEAR_IN_SECONDS;
+    const revalidateDirective = typeof isr === "number" ? `stale-while-revalidate=${ONE_YEAR_IN_SECONDS}` : "must-revalidate";
+    if (!response.headers.has("Cache-Control")) {
+      response.headers.set(
+        "Cache-Control",
+        "public, max-age=0, must-revalidate"
+      );
+    }
+    response.headers.set(
+      "Netlify-CDN-Cache-Control",
+      `public, max-age=${maxAge}, ${revalidateDirective}, durable`
+    );
+  }
+  return response;
+};
+export default handler;

package/dist/presets/node/runtime/node-cluster.d.mts

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

package/dist/presets/node/runtime/node-cluster.mjs

@@ -0,0 +1,58 @@
+import cluster from "node:cluster";
+import os from "node:os";
+import {
+  getGracefulShutdownConfig,
+  trapUnhandledNodeErrors
+} from "nitro/runtime/internal";
+function runMaster() {
+  const numberOfWorkers = Number.parseInt(process.env.NITRO_CLUSTER_WORKERS || "") || (os.cpus().length > 0 ? os.cpus().length : 1);
+  for (let i = 0; i < numberOfWorkers; i++) {
+    cluster.fork();
+  }
+  let isShuttingDown = false;
+  cluster.on("exit", () => {
+    if (!isShuttingDown) {
+      cluster.fork();
+    }
+  });
+  const shutdownConfig = getGracefulShutdownConfig();
+  if (!shutdownConfig.disabled) {
+    async function onShutdown() {
+      if (isShuttingDown) {
+        return;
+      }
+      isShuttingDown = true;
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          console.warn("Timeout reached for graceful shutdown. Forcing exit.");
+          resolve();
+        }, shutdownConfig.timeout);
+        cluster.on("exit", () => {
+          if (Object.values(cluster.workers || {}).every((w) => !w || w.isDead())) {
+            clearTimeout(timeout);
+            resolve();
+          } else {
+          }
+        });
+      });
+      if (shutdownConfig.forceExit) {
+        process.exit(0);
+      }
+    }
+    for (const signal of shutdownConfig.signals) {
+      process.once(signal, onShutdown);
+    }
+  }
+}
+function runWorker() {
+  import("./node-server.mjs").catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+trapUnhandledNodeErrors();
+if (cluster.isPrimary) {
+  runMaster();
+} else {
+  runWorker();
+}

package/dist/presets/node/runtime/node-middleware.d.mts

@@ -0,0 +1,4 @@
+import "#nitro-internal-pollyfills";
+export declare const middleware: any;
+/** @experimental */
+export declare const websocket: undefined;

package/dist/presets/node/runtime/node-middleware.mjs

@@ -0,0 +1,14 @@
+import "#nitro-internal-pollyfills";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp } from "nitro/runtime";
+import {
+  startScheduleRunner,
+  trapUnhandledNodeErrors
+} from "nitro/runtime/internal";
+const nitroApp = useNitroApp();
+export const middleware = toNodeHandler(nitroApp.fetch);
+export const websocket = import.meta._websocket ? void 0 : void 0;
+trapUnhandledNodeErrors();
+if (import.meta._tasks) {
+  startScheduleRunner();
+}

package/dist/presets/node/runtime/node-server.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+declare const _default: {};
+export default _default;

package/dist/presets/node/runtime/node-server.mjs

@@ -0,0 +1,44 @@
+import "#nitro-internal-pollyfills";
+import { Server as HttpServer } from "node:http";
+import { Server as HttpsServer } from "node:https";
+import wsAdapter from "crossws/adapters/node";
+import destr from "destr";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp, useRuntimeConfig } from "nitro/runtime";
+import {
+  setupGracefulShutdown,
+  startScheduleRunner,
+  trapUnhandledNodeErrors
+} from "nitro/runtime/internal";
+const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+const nitroApp = useNitroApp();
+const server = cert && key ? new HttpsServer({ key, cert }, toNodeHandler(nitroApp.fetch)) : new HttpServer(toNodeHandler(nitroApp.fetch));
+const port = destr(process.env.NITRO_PORT || process.env.PORT) || 3e3;
+const host = process.env.NITRO_HOST || process.env.HOST;
+const path = process.env.NITRO_UNIX_SOCKET;
+const listener = server.listen(path ? { path } : { port, host }, (err) => {
+  if (err) {
+    console.error(err);
+    process.exit(1);
+  }
+  const protocol = cert && key ? "https" : "http";
+  const addressInfo = listener.address();
+  if (typeof addressInfo === "string") {
+    console.log(`Listening on unix socket ${addressInfo}`);
+    return;
+  }
+  const baseURL = (useRuntimeConfig().app.baseURL || "").replace(/\/$/, "");
+  const url = `${protocol}://${addressInfo.family === "IPv6" ? `[${addressInfo.address}]` : addressInfo.address}:${addressInfo.port}${baseURL}`;
+  console.log(`Listening on ${url}`);
+});
+trapUnhandledNodeErrors();
+setupGracefulShutdown(listener, nitroApp);
+if (import.meta._websocket) {
+  const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
+  server.on("upgrade", handleUpgrade);
+}
+if (import.meta._tasks) {
+  startScheduleRunner();
+}
+export default {};

package/dist/presets/standard/runtime/server.d.mts

@@ -0,0 +1,5 @@
+import "#nitro-internal-pollyfills";
+declare const _default: {
+    fetch: any;
+};
+export default _default;

package/dist/presets/standard/runtime/server.mjs

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

package/dist/presets/stormkit/runtime/stormkit.d.mts

@@ -0,0 +1,21 @@
+import "#nitro-internal-pollyfills";
+import type { Handler } from "aws-lambda";
+type StormkitEvent = {
+    url: string;
+    path: string;
+    method: string;
+    body?: string;
+    query?: Record<string, Array<string>>;
+    headers?: Record<string, string>;
+    rawHeaders?: Array<string>;
+};
+type StormkitResponse = {
+    headers?: Record<string, string>;
+    body?: string;
+    buffer?: string;
+    statusCode: number;
+    errorMessage?: string;
+    errorStack?: string;
+};
+export declare const handler: Handler<StormkitEvent, StormkitResponse>;
+export {};

package/dist/presets/stormkit/runtime/stormkit.mjs

@@ -0,0 +1,28 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { awsResponseBody } from "../../aws-lambda/runtime/_utils.mjs";
+const nitroApp = useNitroApp();
+export const handler = async function(event, context) {
+  const req = new Request(event.url, {
+    method: event.method || "GET",
+    headers: event.headers,
+    body: event.body
+  });
+  req.runtime ??= { name: "stormkit" };
+  req.runtime.stormkit ??= { event, context };
+  const response = await nitroApp.fetch(req);
+  const { body, isBase64Encoded } = await awsResponseBody(response);
+  return {
+    statusCode: response.status,
+    headers: normalizeOutgoingHeaders(response.headers),
+    [isBase64Encoded ? "buffer" : "body"]: body
+  };
+};
+function normalizeOutgoingHeaders(headers) {
+  return Object.fromEntries(
+    Object.entries(headers).map(([k, v]) => [
+      k,
+      Array.isArray(v) ? v.join(",") : String(v)
+    ])
+  );
+}

package/dist/presets/vercel/runtime/vercel.d.mts

@@ -0,0 +1,8 @@
+import "#nitro-internal-pollyfills";
+import type { ServerRequest } from "srvx";
+declare const _default: {
+    fetch(req: ServerRequest, context: {
+        waitUntil: (promise: Promise<any>) => void;
+    }): any;
+};
+export default _default;

package/dist/presets/vercel/runtime/vercel.mjs

@@ -0,0 +1,17 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+const nitroApp = useNitroApp();
+export default {
+  fetch(req, context) {
+    const isrRoute = req.headers.get("x-now-route-matches");
+    if (isrRoute) {
+      const url = new URL(req.url);
+      url.pathname = decodeURIComponent(isrRoute);
+      req = new Request(url.toString(), req);
+    }
+    req.runtime ??= { name: "vercel" };
+    req.runtime.vercel = { context };
+    req.waitUntil = context?.waitUntil;
+    return nitroApp.fetch(req);
+  }
+};

package/dist/presets/winterjs/runtime/winterjs.d.mts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

package/dist/presets/winterjs/runtime/winterjs.mjs

@@ -0,0 +1,87 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { hasProtocol, joinURL } from "ufo";
+const nitroApp = useNitroApp();
+const _handler = toPlainHandler(nitroApp.h3App);
+async function _handleEvent(event) {
+  try {
+    const res = await _handler({
+      path: event.request.url.pathname + (event.request.url.search ? `?${event.request.url.search}` : ""),
+      method: event.request.getMethod() || "GET",
+      body: event.request.body,
+      headers: event.request.headers,
+      context: {
+        waitUntil: (promise) => event.waitUntil(promise),
+        _platform: {
+          winterjs: {
+            event
+          }
+        }
+      }
+    });
+    const body = typeof res.body === "string" ? res.body : await toBuffer(res.body);
+    return new Response(body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: res.headers
+    });
+  } catch (error) {
+    const errString = error?.message + "\n" + error?.stack;
+    console.error(errString);
+    return new Response(errString, { status: 500 });
+  }
+}
+addEventListener("fetch", async (event) => {
+  event.respondWith(await _handleEvent(event));
+});
+function toBuffer(data) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    data.pipeTo(
+      new WritableStream({
+        write(chunk) {
+          chunks.push(chunk);
+        },
+        close() {
+          resolve(Buffer.concat(chunks));
+        },
+        abort(reason) {
+          reject(reason);
+        }
+      })
+    ).catch(reject);
+  });
+}
+if (!Headers.prototype.entries) {
+  Headers.prototype.entries = function() {
+    return [...this];
+  };
+}
+if (!URL.prototype.pathname) {
+  Object.defineProperty(URL.prototype, "pathname", {
+    get() {
+      return this.path || "/";
+    }
+  });
+}
+const _URL = globalThis.URL;
+globalThis.URL = class URL2 extends _URL {
+  constructor(url, base) {
+    if (!base || hasProtocol(url)) {
+      super(url);
+      return;
+    }
+    super(joinURL(base, url));
+  }
+};
+const _Response = globalThis.Response;
+globalThis.Response = class Response2 extends _Response {
+  _body;
+  constructor(body, init) {
+    super(body, init);
+    this._body = body;
+  }
+  get body() {
+    return this._body;
+  }
+};

package/dist/presets/zeabur/runtime/zeabur.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+declare const _default: any;
+export default _default;

package/dist/presets/zeabur/runtime/zeabur.mjs

@@ -0,0 +1,4 @@
+import "#nitro-internal-pollyfills";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp } from "nitro/runtime";
+export default toNodeHandler(useNitroApp().fetch);