feat: make close function as public

The goal is to allow end-user to close the server and trigger
the close promises callbacks.

Issue: #25

Author: gquittet

src/core/improvedServer.ts

@@ -1,16 +1,16 @@
 import type { Server } from "#interface/server";
 import type { IStatus } from "#interface/status";
 import type http from "node:http";
+import { exit } from "node:process";
 import config from "#config/index";
 import SocketsPool from "#core/socketsPool";
+import State from "#core/state";
 import onRequest from "#util/onRequest";
+import sleep from "#util/sleep";
 
 const { livenessEndpoint, readinessEndpoint } = config;
 
-const improvedServer = <TServer extends Server>(
-  server: TServer,
-  serverStatus: IStatus,
-): TServer & { stop: () => Promise<void> } => {
+const improvedServer = <TServer extends Server>(server: TServer, serverStatus: IStatus) => {
   const { healthCheck, kubernetes } = config;
   const socketsPool = SocketsPool();
   const secureSocketsPool = SocketsPool();
@@ -65,28 +65,47 @@ const improvedServer = <TServer extends Server>(
     );
   }
 
-  const stop = async (): Promise<void> => {
+  const stop = async (
+    args: { value: number; body?: Error; type?: string } = { value: 0 },
+  ): Promise<void> => {
     if (!server.listening || stopping) {
       return;
     }
 
     stopping = true;
 
+    const { timeout, closePromises } = config;
+
+    let error: Error | undefined;
+    if (args.body && args.body.message) {
+      error = args.body;
+    } else if (args.type) {
+      error = new Error(args.type);
+    }
+
+    serverStatus.set(State.SHUTTING_DOWN, error);
+
+    await sleep(timeout);
+
+    await Promise.all(closePromises.map((closePromise) => closePromise()));
+
     server.removeAllListeners("request");
     server.on("request", (_: http.IncomingMessage, res: http.ServerResponse) => {
       if (!res.headersSent) res.setHeader("connection", "close");
     });
 
     await Promise.all([socketsPool.closeAll(), secureSocketsPool.closeAll()]);
 
-    return new Promise((resolve, reject) => {
-      server.close((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
+    await new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) {
+          return reject(err);
         }
+        return resolve(error);
       });
+
+      serverStatus.set(State.SHUTDOWN, error);
+      exit(args.value);
     });
   };
 

src/core/index.ts

@@ -4,7 +4,6 @@ import { EventEmitter } from "events";
 import ImprovedServer from "#core/improvedServer";
 import Status from "#core/status";
 import init from "#util/init";
-import shutdown from "#util/shutdown";
 
 const core = (server: Server): ICore => {
   const _emitter = new EventEmitter();
@@ -15,8 +14,8 @@ const core = (server: Server): ICore => {
     init: function () {
       return init(this);
     },
-    shutdown: function (type: string, value: number, error?: Error) {
-      return shutdown(_server, this)(type, value, error);
+    stop: function (args?: { type?: string; value: number; body?: Error }) {
+      return _server.stop(args);
     },
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     on: (name: string, callback: (...args: any[]) => void) => _emitter.on(name, callback),

src/index.ts

@@ -12,6 +12,7 @@ const buildGracefulServer = (server: Server, options?: IGracefulServerOptions):
     isReady: () => gracefulServer.status.isReady(),
     setReady: () => gracefulServer.status.setReady(),
     on: gracefulServer.on,
+    close: () => gracefulServer.stop(),
   };
 };
 

src/interface/core.ts

@@ -4,7 +4,7 @@ import type { EventEmitter } from "events";
 export type ICore = {
   status: IStatus;
   init: () => ICore;
-  shutdown: (type: string, value: number, error?: Error) => Promise<void>;
+  stop: (args?: { type?: string; value: number; body?: Error }) => Promise<void>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   on: (name: string, callback: (...args: any[]) => void) => EventEmitter;
 };

src/interface/gracefulServer.ts

@@ -5,4 +5,5 @@ export type IGracefulServer = {
   setReady: () => void;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   on: (name: string, callback: (...args: any[]) => void) => EventEmitter;
+  close: () => Promise<void>;
 };

src/util/init.ts

@@ -6,7 +6,7 @@ import signals from "#core/signals";
 const init = (parent: ICore) => {
   for (const signal of signals) {
     (process as NodeJS.EventEmitter).on(signal.type, async (body) => {
-      await parent.shutdown(signal.type, signal.code, body);
+      await parent.stop({ type: signal.type, value: signal.code, body });
     });
   }
   return parent;