@tsed/socketio 8.0.1 → 8.0.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/socketio",
   "description": "Socket.io package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "keywords": [
     "tsed",
     "socket.io",
@@ -16,6 +16,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"
@@ -33,16 +34,16 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/openspec": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/platform-middlewares": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/socketio-testing": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
+    "@tsed/openspec": "8.0.3",
+    "@tsed/platform-http": "8.0.3",
+    "@tsed/platform-middlewares": "8.0.3",
+    "@tsed/schema": "8.0.3",
+    "@tsed/socketio-testing": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "eslint": "9.12.0",
     "express": "^4.21.0",
     "socket.io": "4.8.0",
@@ -51,11 +52,11 @@
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/platform-middlewares": "8.0.1",
-    "@tsed/schema": "8.0.1",
+    "@tsed/platform-middlewares": "8.0.3",
+    "@tsed/schema": "8.0.3",
     "socket.io": ">=4.0.0"
   },
   "peerDependenciesMeta": {

package/src/SocketIOModule.spec.ts

@@ -0,0 +1,87 @@
+import {PlatformConfiguration} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import Http from "http";
+import Https from "https";
+
+import {SocketIOModule, SocketIOServer, SocketIOService} from "./index.js";
+
+async function createModuleFixture() {
+  const serverSettingsService = PlatformTest.get<PlatformConfiguration>(PlatformConfiguration);
+  // GIVEN
+  const socketIOServer = {attach: vi.fn(), adapter: vi.fn()};
+  const httpServer = {type: "http", get: vi.fn().mockReturnValue("httpServer")};
+  const httpsServer = {type: "https", get: vi.fn().mockReturnValue("httpsServer")};
+  const socketIOService = {addSocketProvider: vi.fn()};
+  const socketIOModule = await PlatformTest.invoke<SocketIOModule>(SocketIOModule, [
+    {token: Http.Server, use: httpServer},
+    {token: Https.Server, use: httpsServer},
+    {token: SocketIOServer, use: socketIOServer},
+    {token: SocketIOService, use: socketIOService}
+  ]);
+
+  vi.spyOn(socketIOModule as any, "getWebsocketServices").mockReturnValue([{provider: "provider"}]);
+  vi.spyOn(socketIOModule as any, "printSocketEvents").mockReturnValue(undefined);
+
+  return {
+    socketIOModule,
+    serverSettingsService,
+    httpServer,
+    httpsServer,
+    socketIOService,
+    socketIOServer
+  };
+}
+
+describe("SocketIOModule", () => {
+  describe("$afterListen()", () => {
+    describe("with http server", () => {
+      beforeAll(() =>
+        PlatformTest.create({
+          httpsPort: 8081,
+          socketIO: {config: "config", adapter: vi.fn()} as never
+        })
+      );
+      afterAll(() => {
+        PlatformTest.reset();
+      });
+
+      it("should call attach method", async () => {
+        const {socketIOModule, httpServer, httpsServer, socketIOService, socketIOServer} = await createModuleFixture();
+
+        // WHEN
+        await socketIOModule.$afterListen();
+
+        expect(socketIOServer.attach).toHaveBeenCalledTimes(2);
+
+        expect((socketIOModule as any).getWebsocketServices).toHaveBeenCalledWith();
+        expect(socketIOServer.adapter).toHaveBeenCalled();
+        expect(socketIOService.addSocketProvider).toHaveBeenCalledWith({provider: "provider"});
+      });
+    });
+    describe("with https server", () => {
+      beforeAll(() =>
+        PlatformTest.create({
+          httpsPort: 8081,
+          http: false,
+          socketIO: {config: "config"} as never
+        })
+      );
+
+      afterAll(() => {
+        PlatformTest.reset();
+      });
+
+      it("should call attach method", async () => {
+        const {socketIOModule, httpsServer, serverSettingsService, socketIOService, socketIOServer} = await createModuleFixture();
+
+        // WHEN
+        await socketIOModule.$afterListen();
+
+        expect(socketIOServer.attach).toHaveBeenCalled();
+
+        expect((socketIOModule as any).getWebsocketServices).toHaveBeenCalledWith();
+        expect(socketIOService.addSocketProvider).toHaveBeenCalledWith({provider: "provider"});
+      });
+    });
+  });
+});

package/src/SocketIOModule.ts

@@ -0,0 +1,113 @@
+import {nameOf} from "@tsed/core";
+import {Constant, Inject, InjectorService, Module, OnDestroy, Provider} from "@tsed/di";
+import {$log} from "@tsed/logger";
+import type {AfterListen} from "@tsed/platform-http";
+import Http from "http";
+import Https from "https";
+import {Server, ServerOptions} from "socket.io";
+
+import {SocketProviderMetadata} from "./class/SocketProviderMetadata.js"; // tslint:disable-line: no-unused-variable
+import {PROVIDER_TYPE_SOCKET_SERVICE} from "./constants/constants.js";
+import {IO} from "./decorators/io.js";
+import {SocketIOService} from "./services/SocketIOService.js";
+
+/**
+ * @ignore
+ */
+@Module()
+export class SocketIOModule implements AfterListen, OnDestroy {
+  @Constant("logger.disableRoutesSummary", false)
+  protected disableRoutesSummary: boolean;
+
+  @Constant("socketIO", {})
+  protected settings: Partial<ServerOptions>;
+
+  @Inject()
+  protected injector: InjectorService;
+
+  @Inject(Http.Server)
+  protected httpServer: Http.Server | null;
+
+  @Inject(Https.Server)
+  protected httpsServer: Https.Server | null;
+
+  @IO()
+  private io: Server;
+
+  @Inject()
+  private socketIOService: SocketIOService;
+
+  $afterListen() {
+    if (this.httpServer) {
+      this.io.attach(this.httpServer, {...this.settings});
+    }
+
+    if (this.httpsServer) {
+      this.io.attach(this.httpsServer, {...this.settings});
+    }
+
+    if (this.settings.adapter) {
+      this.io.adapter(this.settings.adapter);
+    }
+
+    this.getWebsocketServices().forEach((provider) => this.socketIOService.addSocketProvider(provider));
+
+    if (!this.disableRoutesSummary) {
+      this.printSocketEvents();
+    }
+
+    return this.injector.emit("$afterSocketListen");
+  }
+
+  $onDestroy() {
+    return this.io?.close && this.io?.engine && new Promise((resolve) => this.io.close(() => resolve(undefined)));
+  }
+
+  /**
+   *
+   * @returns {Provider<any>[]}
+   */
+  protected getWebsocketServices(): Provider<any>[] {
+    return Array.from(this.injector.getProviders(PROVIDER_TYPE_SOCKET_SERVICE));
+  }
+
+  /**
+   *
+   */
+  protected printSocketEvents() {
+    const list = this.getWebsocketServices().reduce((acc: any[], provider) => {
+      const socketProvider = new SocketProviderMetadata(provider.store.get("socketIO"));
+
+      if (socketProvider.namespace) {
+        socketProvider.getHandlers().forEach((handler) => {
+          acc.push({
+            namespace: socketProvider.namespace,
+            inputEvent: handler.eventName,
+            outputEvent: (handler.returns && handler.returns.eventName) || handler.eventName || "",
+            outputType: (handler.returns && handler.returns.type) || "",
+            name: `${nameOf(provider.useClass)}.${handler.methodClassName}`
+          });
+        });
+      }
+
+      return acc;
+    }, []);
+
+    this.injector.logger.info("Socket events mounted:");
+
+    const str = $log.drawTable(list, {
+      padding: 1,
+      header: {
+        namespace: "Namespace",
+        inputEvent: "Input event",
+        outputEvent: "Output event",
+        outputType: "Output type",
+        name: "Class method"
+      }
+    });
+
+    this.injector.logger.info("\n" + str.trim());
+
+    this.injector.logger.info("Socket server started...");
+  }
+}