nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

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

@@ -1,213 +1,252 @@
+// @ts-nocheck
+// =============================================================================
+// gracefully shuts downs http server
+// can be used with http, express, koa, ...
+// (c) 2023 Sebastian Hildebrandt
+// License: MIT
+// https://github.com/sebhildebrandt/http-graceful-shutdown/blob/master/LICENSE
+// https://github.com/sebhildebrandt/http-graceful-shutdown/blob/master/lib/index.js
+// =============================================================================
 import http from "node:http";
-const debug = (...args) => {
-};
+const debug = (...args) => {};
+/**
+* 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.
+*/
 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;
+	// option handling
+	// ----------------------------------
+	opts = opts || {};
+	// merge opts with default options
+	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;
+					// eslint-disable-next-line prefer-rest-params
+					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) {
+				// eslint-disable-next-line unicorn/no-process-exit
+				process.exit(failed ? 1 : 0);
+			}
+		}).catch((error) => {
+			debug("server shut down error occurred", error);
+			// eslint-disable-next-line unicorn/no-process-exit
+			process.exit(1);
+		});
+	});
+	// helper function
+	// ----------------------------------
+	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) {
+		// destroy empty and idle connections / all connections (if force = true)
+		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;
+			// send connection close header to open connections
+			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;
+			// send connection close header to open connections
+			if (serverResponse && !force) {
+				if (!serverResponse.headersSent) {
+					serverResponse.setHeader("connection", "close");
+				}
+			} else {
+				secureCounter++;
+				destroy(socket);
+			}
+		}
+		debug("Secure Connections destroyed : " + secureCounter);
+		debug("Secure Connection Counter    : " + secureConnectionCounter);
+	}
+	// set up server/process events
+	// ----------------------------------
+	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");
+	});
+	// shutdown event (per signal)
+	// ----------------------------------
+	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);
+		// Don't bother with graceful shutdown on development to speed up round trip
+		if (options.development) {
+			debug("DEV-Mode - immediate forceful shutdown");
+			// eslint-disable-next-line unicorn/no-process-exit
+			return process.exit(0);
+		}
+		function finalHandler() {
+			if (!finalRun) {
+				finalRun = true;
+				if (options.finally && isFunction(options.finally)) {
+					debug("executing finally()");
+					options.finally();
+				}
+			}
+			return Promise.resolve();
+		}
+		// returns true if should force shut down. returns false for shut down without force
+		function waitForReadyToShutDown(totalNumInterval) {
+			debug(`waitForReadyToShutDown... ${totalNumInterval}`);
+			if (totalNumInterval === 0) {
+				// timeout reached
+				debug(`Could not close connections in time (${options.timeout}ms), will forcefully shut down`);
+				return Promise.resolve(true);
+			}
+			// test all connections closed already?
+			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 after waiting for connections to drain within timeout period
+			// or if timeout has reached, we forcefully disconnect all sockets
+			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

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

package/dist/runtime/internal/meta.mjs

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

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

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

package/dist/runtime/internal/plugin.mjs

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

package/dist/runtime/internal/renderer.mjs

@@ -1,36 +1,44 @@
 import { defineHandler } from "h3";
-import { useNitroApp } from "./app.mjs";
+import { useNitroHooks } 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;
-  });
+	const runtimeConfig = useRuntimeConfig();
+	return defineHandler(async (event) => {
+		const nitroHooks = useNitroHooks();
+		// Create shared context for hooks
+		const ctx = {
+			event,
+			render,
+			response: undefined
+		};
+		// Call initial hook to prepare and optionally custom render
+		await nitroHooks.callHook("render:before", ctx);
+		if (!ctx.response) {
+			// TODO: Use serve-placeholder
+			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;
+			}
+		}
+		// Allow  modifying response
+		await nitroHooks.callHook("render:response", ctx.response, ctx);
+		// Send headers
+		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;
+		}
+		// Send response body
+		return ctx.response.body;
+	});
 }

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

@@ -1,8 +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 {};
+// Headers route rule
+export declare const headers: unknown;
+// Redirect route rule
+export declare const redirect: unknown;
+// Proxy route rule
+export declare const proxy: unknown;
+// Cache route rule
+export declare const cache: unknown;