@tsed/terminus 8.0.1 → 8.0.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/terminus",
   "description": "Adds graceful shutdown and Kubernetes readiness / liveness checks for any HTTP applications.",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "author": "Romain Lenzotti",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
@@ -10,6 +10,7 @@
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -28,22 +29,22 @@
   },
   "devDependencies": {
     "@godaddy/terminus": "^4.12.1",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/platform-http": "8.0.2",
+    "@tsed/schema": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
     "@godaddy/terminus": "^4.7.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/schema": "8.0.1"
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/platform-http": "8.0.2",
+    "@tsed/schema": "8.0.2"
   },
   "peerDependenciesMeta": {
     "@godaddy/terminus": {

package/src/TerminusModule.spec.ts

@@ -0,0 +1,91 @@
+import {Injectable} from "@tsed/di";
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {Health} from "./decorators/health.js";
+import {TerminusModule} from "./TerminusModule.js";
+
+@Injectable()
+class MyService {
+  @Health("mongo")
+  mongo() {
+    return Promise.resolve("OK");
+  }
+
+  @Health("/redis/health")
+  redis() {
+    return Promise.resolve("OK");
+  }
+
+  $beforeShutdown() {}
+}
+
+describe("TerminusModule", () => {
+  beforeEach(() =>
+    PlatformTest.create({
+      terminus: {
+        path: "/health"
+      }
+    })
+  );
+  afterEach(() => PlatformTest.reset());
+
+  it("should load health providers", async () => {
+    const terminusModule = PlatformTest.get<TerminusModule>(TerminusModule);
+
+    const {logger, ...props} = terminusModule.getConfiguration();
+
+    expect(props).toEqual({
+      beforeShutdown: expect.any(Function),
+      healthChecks: {
+        "/mongo/health": expect.any(Function),
+        "/redis/health": expect.any(Function),
+        "/health": expect.any(Function)
+      },
+      onSendFailureDuringShutdown: expect.any(Function),
+      onShutdown: expect.any(Function),
+      onSignal: expect.any(Function)
+    });
+
+    const result = await props.healthChecks["/health"]({});
+
+    expect(result).toEqual([
+      {mongo: "OK"},
+      {"/redis/health": "OK"} // legacy
+    ]);
+
+    logger("event", {message: "message"});
+
+    expect(await terminusModule.$logRoutes([])).toEqual([
+      {
+        method: "GET",
+        name: "TerminusModule.dispatch()",
+        url: "/health"
+      },
+      {
+        method: "GET",
+        name: "MyService.mongo()",
+        url: "/mongo/health"
+      },
+      {
+        method: "GET",
+        name: "MyService.redis()",
+        url: "/redis/health"
+      }
+    ]);
+
+    await props.onSignal();
+  });
+
+  it("should emit event", async () => {
+    const terminusModule = PlatformTest.get<TerminusModule>(TerminusModule);
+    const service = PlatformTest.get<MyService>(MyService);
+
+    vi.spyOn(service, "$beforeShutdown");
+
+    const {beforeShutdown} = terminusModule.getConfiguration();
+
+    await beforeShutdown();
+
+    expect(service.$beforeShutdown).toHaveBeenCalledWith();
+  });
+});

package/src/TerminusModule.ts

@@ -0,0 +1,146 @@
+import {createTerminus} from "@godaddy/terminus";
+import {Constant, Inject, InjectorService, Module, OnInit, Provider} from "@tsed/di";
+import type {PlatformRouteDetails} from "@tsed/platform-http";
+import {concatPath} from "@tsed/schema";
+import Http from "http";
+import Https from "https";
+
+import {TerminusSettings} from "./interfaces/TerminusSettings.js";
+
+@Module()
+export class TerminusModule implements OnInit {
+  @Constant("terminus", {})
+  private settings: TerminusSettings;
+
+  @Constant("terminus.path", "/health")
+  private basePath: string;
+
+  @Inject()
+  private injector: InjectorService;
+
+  @Inject(Http.Server)
+  private httpServer: Http.Server | null;
+
+  @Inject(Https.Server)
+  private httpsServer: Https.Server | null;
+
+  public $onInit() {
+    this.mount();
+  }
+
+  getConfiguration() {
+    const {path, ...props} = this.settings;
+
+    return {
+      logger: (event: string, error: any) =>
+        this.injector.logger.info({
+          event: event.toUpperCase(),
+          error_message: error.message
+        }),
+      healthChecks: this.getHealths(),
+      onSignal: this.createEmitter("$onSignal"),
+      onShutdown: this.createEmitter("$onShutdown"),
+      beforeShutdown: this.createEmitter("$beforeShutdown"),
+      onSendFailureDuringShutdown: this.createEmitter("$onSendFailureDuringShutdown"),
+      ...props
+    };
+  }
+
+  $logRoutes(routes: PlatformRouteDetails[]): Promise<PlatformRouteDetails[]> {
+    return Promise.resolve([
+      ...routes,
+      {
+        url: this.basePath,
+        method: "GET",
+        name: `TerminusModule.dispatch()`
+      },
+      ...this.getAll<{name: string}>("health").map(({provider, propertyKey, options}) => {
+        const path = this.getPath(provider, options.name);
+
+        return {
+          method: "GET",
+          name: `${provider.className}.${propertyKey}()`,
+          url: path
+        } as any;
+      })
+    ]);
+  }
+
+  private mount() {
+    const terminusConfig = this.getConfiguration();
+
+    if (this.httpServer) {
+      createTerminus(this.httpServer, terminusConfig);
+    }
+
+    if (this.httpsServer) {
+      createTerminus(this.httpsServer, terminusConfig);
+    }
+  }
+
+  private getAll<Opts = any>(
+    name: string
+  ): {
+    provider: Provider;
+    propertyKey: string;
+    options: Opts;
+  }[] {
+    return this.injector.getProviders().flatMap((provider) => {
+      const metadata = provider.store.get(`terminus:${name}`);
+
+      if (metadata) {
+        return Object.entries(metadata).map(([propertyKey, options]: [string, Opts]) => {
+          return {
+            provider,
+            propertyKey,
+            options
+          };
+        });
+      }
+      return [];
+    });
+  }
+
+  private getHealths() {
+    const subHealths = this.getAll<{name: string}>("health").reduce(
+      (healths, {provider, propertyKey, options: {name}}) => {
+        const instance = this.injector.get<any>(provider.token)!;
+        const callback = async (...args: any[]) => {
+          const result = await instance[propertyKey](...args);
+
+          return {[name]: result};
+        };
+
+        let path = this.getPath(provider, name);
+
+        return {
+          ...healths,
+          [path]: callback
+        };
+      },
+      {} as Record<string, (state: any) => Promise<any>>
+    );
+
+    const healths: Record<string, any> = {
+      ...subHealths,
+      [this.basePath]: (state: any) => {
+        const promises = Object.entries(subHealths).map(([path, callback]) => callback(state));
+
+        return Promise.all(promises);
+      }
+    };
+
+    return healths;
+  }
+
+  private getPath(provider: Provider<any>, name: string) {
+    let path = concatPath(provider.path, name);
+    return path.includes("health") ? path : concatPath(path, this.basePath);
+  }
+
+  private createEmitter(name: string) {
+    return (...args: any[]) => {
+      return this.injector.emit(name, ...args);
+    };
+  }
+}

package/src/decorators/health.ts

@@ -0,0 +1,28 @@
+import {Store} from "@tsed/core";
+
+/**
+ * Create a readiness / liveness checks.
+ *
+ * ```ts
+ * import { Health } from "@tsed/terminus";
+ *
+ * @Controller("/mongo")
+ * class MongoCtrl {
+ *   @Health("/health")
+ *   health() {
+ *     // Here check the mongo health
+ *     return Promise.resolve();
+ *   }
+ * }
+ *
+ * @param name
+ * @decorator
+ * @terminus
+ */
+export function Health(name: string): MethodDecorator {
+  return <Function>(target: Object, propertyKey: string) => {
+    Store.from(target).merge(`terminus:health`, {
+      [propertyKey]: {name}
+    });
+  };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./decorators/health.js";
+export * from "./interfaces/interfaces.js";
+export * from "./interfaces/TerminusSettings.js";
+export * from "./TerminusModule.js";

package/src/interfaces/TerminusSettings.ts

@@ -0,0 +1,6 @@
+import {TerminusOptions} from "@godaddy/terminus";
+
+export type TerminusSettings = Omit<
+  TerminusOptions,
+  "healthChecks" | "onSignal" | "onSendFailureDuringShutdown" | "onShutdown" | "beforeShutdown" | "onSigterm"
+> & {path?: string};

package/src/interfaces/interfaces.ts

@@ -0,0 +1,9 @@
+import {TerminusSettings} from "./TerminusSettings.js";
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      terminus: TerminusSettings;
+    }
+  }
+}