@znight/http 0.2.2 → 0.3.0

package/README.md

@@ -1622,6 +1622,13 @@ export class StatusPlugin implements Plugin, PluginHttpRoutes {
   needs a decision there too: without one the boot fails (ZNIGHT023), with a hint naming the plugin.
 - An invalid route (method, path grammar, name, handler, meta, body limit) or a collision with another route is
   ZNIGHT007 naming the plugin. `HttpPlugin.routes` lists the routes with `source: '<plugin name>'`.
+- `onHttpDrain()` (optional) is called once when `HttpPlugin` starts draining, in its `onStop`,
+  whatever the plugin order: after it stopped accepting connections and started closing its event
+  streams, before it waits for the requests in flight. A plugin whose routes answer long-lived
+  streams `HttpPlugin` does not know of (a streamed `Response` produced by another server, such as a
+  GraphQL driver's subscriptions) ends them there, so that the drain does not wait for them until
+  `drainTimeoutMs`. The drain waits for a returned promise too (within `drainTimeoutMs`); a failure
+  is logged, never thrown.
 
 ## Adapters
 

package/dist/index.d.mts

@@ -1162,6 +1162,14 @@ interface PluginHttpRoutesContext {
  */
 interface PluginHttpRoutes {
   httpRoutes(context: PluginHttpRoutesContext): readonly PluginRoute[];
+  /**
+   * Called once when `HttpPlugin` starts draining (its `onStop`, whatever the plugin order), after
+   * it stopped accepting connections and started closing its event streams: end the long-lived
+   * responses `HttpPlugin` does not know of (a stream another server produced), so that the drain
+   * does not wait for them until `drainTimeoutMs`. Requests still in flight are served. The drain
+   * waits for a returned promise too (within `drainTimeoutMs`); a failure is logged.
+   */
+  onHttpDrain?(): void | Promise<void>;
 }
 /** A parsed `content-type` header. */
 interface MediaType {

package/dist/index.mjs

@@ -5135,6 +5135,28 @@ function collectPluginRoutes(plugins, self, context) {
 	}
 	return collected;
 }
+/**
+* Calls `onHttpDrain()` on every other plugin implementing it, in plugin order: the promises the
+* drain waits for (they never reject: a failure is logged).
+*/
+function drainPlugins(plugins, self, logger) {
+	const pending = [];
+	for (const plugin of plugins) {
+		if (plugin === self) continue;
+		const drain = plugin.onHttpDrain;
+		if (typeof drain !== "function") continue;
+		const failed = (error) => {
+			logger.error(`HttpPlugin: onHttpDrain() of the plugin "${String(plugin.name)}" failed`, { err: error });
+		};
+		try {
+			const result = drain.call(plugin);
+			if (typeof result?.then === "function") pending.push(Promise.resolve(result).then(void 0, failed));
+		} catch (error) {
+			failed(error);
+		}
+	}
+	return pending;
+}
 function validateRoute(instance, plugin, value, prefix) {
 	if (value === null || typeof value !== "object") throw invalid(plugin, `invalid route ${describe(value)}`);
 	const route = value;
@@ -5827,13 +5849,18 @@ var HttpPlugin = class HttpPlugin {
 		if (runtime === void 0) return;
 		runtime.pipeline.draining = true;
 		runtime.pipeline.closeStreams("shutdown");
+		const drains = drainPlugins(ctx.app.plugins, this, ctx.logger);
 		const timeoutMs = runtime.options.drainTimeoutMs;
 		let timer;
 		const timeout = new Promise((resolve) => {
 			if (timeoutMs !== Number.POSITIVE_INFINITY) timer = setTimeout(() => resolve("timeout"), Math.min(timeoutMs, MAX_TIMER_MS));
 		});
 		try {
-			const drained = Promise.all([runtime.adapter.close(), runtime.pipeline.whenIdle()]).then(() => "drained");
+			const drained = Promise.all([
+				runtime.adapter.close(),
+				runtime.pipeline.whenIdle(),
+				...drains
+			]).then(() => "drained");
 			if (await Promise.race([drained, timeout]) === "timeout") {
 				ctx.logger.warn(`HTTP server: closing ${runtime.pipeline.inflight} in-flight request(s) after ${timeoutMs} ms`);
 				await runtime.adapter.close({ force: true });