@tsed/socketio 8.0.1 → 8.0.3

package/src/class/SocketHandlersBuilder.ts

@@ -0,0 +1,266 @@
+import {isFunction, Store} from "@tsed/core";
+import {DIContext, InjectorService, Provider, runInContext} from "@tsed/di";
+import {deserialize} from "@tsed/json-mapper";
+import {$log} from "@tsed/logger";
+import {Namespace, Socket} from "socket.io";
+import {v4} from "uuid";
+
+import {SocketFilters} from "../interfaces/SocketFilters.js";
+import {SocketHandlerMetadata} from "../interfaces/SocketHandlerMetadata.js";
+import {SocketInjectableNsp} from "../interfaces/SocketInjectableNsp.js";
+import {SocketParamMetadata} from "../interfaces/SocketParamMetadata.js";
+import {SocketProviderTypes} from "../interfaces/SocketProviderTypes.js";
+import {SocketReturnsTypes} from "../interfaces/SocketReturnsTypes.js";
+import {SocketProviderMetadata} from "./SocketProviderMetadata.js";
+import {SocketSessionData} from "./SocketSessionData.js";
+
+/**
+ * @ignore
+ */
+export class SocketHandlersBuilder {
+  private readonly socketProviderMetadata: SocketProviderMetadata;
+
+  constructor(
+    private readonly provider: Provider,
+    private readonly injector: InjectorService
+  ) {
+    this.socketProviderMetadata = new SocketProviderMetadata(this.provider.store.get("socketIO"));
+  }
+
+  /**
+   *
+   * @param {SocketHandlerMetadata} handlerMetadata
+   * @param scope
+   * @returns {(data) => void}
+   */
+  private static bindResponseMiddleware(handlerMetadata: SocketHandlerMetadata, scope: any) {
+    const {returns} = handlerMetadata;
+
+    return (response: any): void => {
+      if (returns) {
+        switch (returns.type) {
+          case SocketReturnsTypes.BROADCAST:
+            scope.nsp.emit(returns.eventName, response);
+            break;
+          case SocketReturnsTypes.BROADCAST_OTHERS:
+            scope.socket.broadcast.emit(returns.eventName, response);
+            break;
+          case SocketReturnsTypes.EMIT:
+            scope.socket.emit(returns.eventName, response);
+            break;
+        }
+      } else {
+        const cb = scope.args.at(-1);
+        if (cb && isFunction(cb)) {
+          cb(response);
+        }
+      }
+    };
+  }
+
+  /**
+   *
+   * @returns {any}
+   */
+  public build(nsps: Map<string | RegExp, Namespace>) {
+    const instance = this.injector.get(this.provider.token);
+    const {injectNamespaces, namespace} = this.socketProviderMetadata;
+    const nsp = nsps.get(namespace);
+
+    instance.$onConnection && this.socketProviderMetadata.createHook("$onConnection", "connection");
+    instance.$onDisconnect && this.socketProviderMetadata.createHook("$onDisconnect", "disconnect");
+
+    injectNamespaces.forEach((setting: SocketInjectableNsp) => {
+      instance[setting.propertyKey] = nsps.get(setting.nsp || namespace);
+    });
+
+    instance["nsp"] = nsp;
+
+    if (instance.$onNamespaceInit) {
+      instance.$onNamespaceInit(nsp);
+    }
+
+    return this;
+  }
+
+  /**
+   *
+   * @param {Socket} socket
+   * @param {Namespace} nsp
+   */
+  public async onConnection(socket: Socket, nsp: Namespace) {
+    const {socketProviderMetadata} = this;
+    const instance = this.injector.get(this.provider.token);
+
+    this.buildHandlers(socket, nsp);
+
+    if (instance.$onConnection) {
+      const ctx = this.createContext(socket, nsp);
+      await runInContext(ctx, () => this.invoke(instance, socketProviderMetadata.$onConnection, {socket, nsp}), this.injector);
+    }
+  }
+
+  public async onDisconnect(socket: Socket, nsp: Namespace, reason?: string) {
+    const instance = this.injector.get(this.provider.token);
+    const {socketProviderMetadata} = this;
+
+    if (instance.$onDisconnect) {
+      const ctx = this.createContext(socket, nsp);
+      await runInContext(ctx, () => this.invoke(instance, socketProviderMetadata.$onDisconnect, {socket, nsp, reason}), this.injector);
+    }
+  }
+
+  private buildHandlers(socket: Socket, nsp: Namespace) {
+    const {socketProviderMetadata} = this;
+
+    socketProviderMetadata.getHandlers().forEach((handler) => {
+      const {eventName} = handler;
+
+      if (eventName) {
+        socket.on(eventName, async (...args) => {
+          const ctx = this.createContext(socket, nsp);
+          await runInContext(ctx, () => this.runQueue(handler, args, socket, nsp), this.injector);
+        });
+      }
+    });
+  }
+
+  private runQueue(handlerMetadata: SocketHandlerMetadata, args: any[], socket: Socket, nsp: Namespace) {
+    const instance = this.injector.get(this.provider.token);
+    const {useBefore, useAfter} = this.socketProviderMetadata;
+    const scope = {
+      args,
+      socket,
+      nsp,
+      eventName: handlerMetadata.eventName
+    };
+
+    let promise = Promise.resolve().then(() => this.deserialize(handlerMetadata, scope));
+
+    if (useBefore) {
+      useBefore.forEach((target: any) => (promise = this.bindMiddleware(target, scope, promise)));
+    }
+
+    if (handlerMetadata.useBefore) {
+      handlerMetadata.useBefore.forEach((target) => (promise = this.bindMiddleware(target, scope, promise)));
+    }
+
+    promise = promise
+      .then(() => this.invoke(instance, handlerMetadata, scope))
+      .then(SocketHandlersBuilder.bindResponseMiddleware(handlerMetadata, scope));
+
+    if (handlerMetadata.useAfter) {
+      handlerMetadata.useAfter.forEach((target) => (promise = this.bindMiddleware(target, scope, promise)));
+    }
+
+    if (useAfter) {
+      useAfter.forEach((target: any) => (promise = this.bindMiddleware(target, scope, promise)));
+    }
+
+    return promise.catch((er: any) => {
+      /* istanbul ignore next */
+      $log.error(handlerMetadata.eventName, er);
+    });
+  }
+
+  private deserialize(handlerMetadata: SocketHandlerMetadata, scope: any) {
+    const {parameters} = handlerMetadata;
+    Object.keys(parameters || []).forEach((index: any) => {
+      const {filter, useMapper, mapIndex, type, collectionType} = parameters![index];
+      let value = scope.args[mapIndex!];
+
+      if (filter === SocketFilters.ARGS) {
+        if (useMapper && typeof value !== "function") {
+          value = deserialize(value, {
+            type,
+            collectionType,
+            useAlias: true
+          });
+        }
+        scope.args[mapIndex!] = value;
+      }
+    });
+  }
+
+  private bindMiddleware(target: any, scope: any, promise: Promise<any>): Promise<any> {
+    const instance = this.injector.get(target);
+
+    if (instance) {
+      const handlerMetadata: SocketProviderMetadata = new SocketProviderMetadata(Store.from(instance).get("socketIO"));
+
+      if (handlerMetadata.type === SocketProviderTypes.MIDDLEWARE) {
+        if (handlerMetadata.error) {
+          return promise.catch((error: any) => this.invoke(instance, handlerMetadata.useHandler, {error, ...scope}));
+        }
+
+        return promise
+          .then(() => this.invoke(instance, handlerMetadata.useHandler, scope))
+          .then((result: any) => {
+            if (result) {
+              scope.args = [].concat(result);
+            }
+          });
+      }
+    }
+
+    return promise;
+  }
+
+  private invoke(instance: any, handlerMetadata: SocketHandlerMetadata, scope: any): Promise<any> {
+    const {methodClassName, parameters} = handlerMetadata;
+
+    return instance[methodClassName](...this.buildParameters(parameters!, scope));
+  }
+
+  private buildParameters(parameters: {[key: number]: SocketParamMetadata}, scope: any): any[] {
+    return Object.keys(parameters || []).map((index: any) => {
+      const param: SocketParamMetadata = parameters[index];
+
+      switch (param.filter) {
+        case SocketFilters.ARGS:
+          if (param.mapIndex !== undefined) {
+            return scope.args[param.mapIndex];
+          }
+
+          return scope.args;
+
+        case SocketFilters.EVENT_NAME:
+          return scope.eventName;
+
+        case SocketFilters.SOCKET:
+          return scope.socket;
+
+        case SocketFilters.NSP:
+          return scope.nsp;
+
+        case SocketFilters.ERR:
+          return scope.error;
+
+        case SocketFilters.SESSION:
+          return new SocketSessionData(scope.socket.data);
+
+        case SocketFilters.RAW_SESSION:
+          return scope.socket.data;
+
+        case SocketFilters.SOCKET_NSP:
+          return scope.socket.nsp;
+
+        case SocketFilters.REASON:
+          return scope.reason;
+      }
+    });
+  }
+
+  private createContext(socket: Socket, nsp: Namespace): DIContext {
+    return new DIContext({
+      injector: this.injector,
+      id: v4().split("-").join(""),
+      logger: this.injector.logger,
+      additionalProps: {
+        module: "socket.io",
+        sid: socket.id,
+        namespace: nsp.name
+      }
+    });
+  }
+}

package/src/class/SocketProviderMetadata.ts

@@ -0,0 +1,57 @@
+import {SocketHandlerMetadata} from "../interfaces/SocketHandlerMetadata.js";
+import {SocketInjectableNsp} from "../interfaces/SocketInjectableNsp.js";
+import {SocketProviderTypes} from "../interfaces/SocketProviderTypes.js";
+
+export class SocketProviderMetadata {
+  public type: SocketProviderTypes;
+  public namespace: string | RegExp;
+  public error: boolean = false;
+  public injectNamespaces: SocketInjectableNsp[] = [];
+  public useBefore: any[] = [];
+  public useAfter: any[] = [];
+  public handlers: Record<string, SocketHandlerMetadata> = {};
+
+  constructor(options: Partial<SocketProviderMetadata> = {}) {
+    options.type && (this.type = options.type);
+    options.namespace && (this.namespace = options.namespace);
+    options.error && (this.error = options.error);
+    options.injectNamespaces && (this.injectNamespaces = options.injectNamespaces);
+    options.useBefore && (this.useBefore = options.useBefore);
+    options.useAfter && (this.useAfter = options.useAfter);
+    options.handlers && (this.handlers = options.handlers);
+  }
+
+  get useHandler() {
+    return this.get("use");
+  }
+
+  get $onConnection() {
+    return this.get("$onConnection");
+  }
+
+  get $onDisconnect() {
+    return this.get("$onDisconnect");
+  }
+
+  get(key: string): SocketHandlerMetadata {
+    return this.handlers[key];
+  }
+
+  set(key: string, metadata: SocketHandlerMetadata): void {
+    this.handlers[key] = metadata;
+  }
+
+  getHandlers() {
+    return Object.entries(this.handlers)
+      .filter(([key]) => ["$onConnection", "$onDisconnect"].indexOf(key) === -1)
+      .map(([, handler]) => handler);
+  }
+
+  createHook(hook: string, eventName: string): void {
+    this.set(hook, {
+      ...(this.get(hook) || {}),
+      eventName,
+      methodClassName: hook
+    });
+  }
+}

package/src/class/SocketSessionData.spec.ts

@@ -0,0 +1,190 @@
+import {SocketSessionData} from "./SocketSessionData.js";
+
+describe("SocketSessionData", () => {
+  let socketSessionData!: SocketSessionData;
+  let data!: Record<string, unknown>;
+
+  beforeEach(() => {
+    data = {
+      key1: "value1",
+      key2: "value2"
+    };
+    socketSessionData = new SocketSessionData(data);
+  });
+
+  describe("Symbol.species", () => {
+    it("should return Map constructor", () => {
+      // act
+      const result = SocketSessionData[Symbol.species];
+
+      // assert
+      expect(result).toBe(Map);
+    });
+  });
+
+  describe("instanceof", () => {
+    it("should return true when right side is an reference ot Map type", () => {
+      // act
+      const result = socketSessionData instanceof Map;
+
+      // assert
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("size", () => {
+    it("should return the size of session data", () => {
+      // act
+      const size = socketSessionData.size;
+
+      // assert
+      expect(size).toBe(2);
+    });
+  });
+
+  describe("clear", () => {
+    it("should remove all entries from session data", () => {
+      // act
+      socketSessionData.clear();
+
+      // assert
+      expect(socketSessionData.size).toBe(0);
+      expect(data).toEqual({});
+    });
+  });
+
+  describe("delete", () => {
+    it("should remove an entry from session data if it exists", () => {
+      // arrange
+      const keyToDelete = "key1";
+
+      // act
+      const deleted = socketSessionData.delete(keyToDelete);
+
+      // assert
+      expect(deleted).toBe(true);
+      expect(socketSessionData.size).toBe(1);
+      expect(socketSessionData.has(keyToDelete)).toBe(false);
+      expect(data).not.toHaveProperty(keyToDelete);
+    });
+
+    it("should return false if the entry does not exist in session data", () => {
+      // arrange
+      const keyToDelete = "nonExistentKey";
+      const expected = {...data};
+
+      // act
+      const deleted = socketSessionData.delete(keyToDelete);
+
+      // assert
+      expect(deleted).toBe(false);
+      expect(socketSessionData.size).toBe(2);
+      expect(data).toEqual(expected);
+    });
+  });
+
+  describe("get", () => {
+    it("should return the value associated with the given key", () => {
+      // arrange
+      const key = "key2";
+
+      // act
+      const value = socketSessionData.get(key);
+
+      // assert
+      expect(value).toBe("value2");
+    });
+
+    it("should return undefined if the key does not exist", () => {
+      // arrange
+      const key = "nonExistentKey";
+
+      // act
+      const value = socketSessionData.get(key);
+
+      // assert
+      expect(value).toBeUndefined();
+    });
+  });
+
+  describe("set", () => {
+    it("should return this", () => {
+      // act
+      const result = socketSessionData.set("key3", "value3");
+
+      // assert
+      expect(result).toBe(socketSessionData);
+    });
+
+    it("should set the value by the key", () => {
+      // arrange
+      const key = "key3";
+      const value = "value3";
+
+      // act
+      socketSessionData.set(key, value);
+
+      // assert
+      expect([...socketSessionData]).toMatchObject(expect.arrayContaining([[key, value]]));
+    });
+  });
+
+  describe("forEach", () => {
+    it("should call the callback function for each key-value pair", () => {
+      // arrange
+      const callbackFn = vi.fn();
+
+      // act
+      socketSessionData.forEach(callbackFn);
+
+      // assert
+      expect(callbackFn).toHaveBeenCalledTimes(2);
+      expect(callbackFn).toHaveBeenCalledWith("value1", "key1", socketSessionData);
+      expect(callbackFn).toHaveBeenCalledWith("value2", "key2", socketSessionData);
+    });
+
+    it("should call the callback function with the specified thisArg", () => {
+      // arrange
+      const thisArg = {customProp: "customValue"};
+      const callbackFn = vi.fn(function () {
+        expect(this).toBe(thisArg);
+      });
+
+      // act
+      socketSessionData.forEach(callbackFn, thisArg);
+    });
+  });
+
+  describe("values", () => {
+    it("should return an iterator for the values", () => {
+      // act
+      const values = socketSessionData.values();
+
+      // assert
+      expect([...values]).toEqual(["value1", "value2"]);
+    });
+  });
+
+  describe("keys", () => {
+    it("should return an iterator for the keys", () => {
+      // act
+      const keys = socketSessionData.keys();
+
+      // assert
+      expect([...keys]).toEqual(["key1", "key2"]);
+    });
+  });
+
+  describe("entries", () => {
+    it("should return an iterator for the key-value pairs", () => {
+      // act
+      const entries = [...socketSessionData.entries()];
+
+      // assert
+      expect(entries).toEqual([
+        ["key1", "value1"],
+        ["key2", "value2"]
+      ]);
+    });
+  });
+});

package/src/class/SocketSessionData.ts

@@ -0,0 +1,81 @@
+/**
+ * Represents session data associated with a socket connection, providing a compatibility layer with Ts.ED v7 by wrapping a `socket.data` which is used to archive recoverability and resiliency to a `Map` instance.
+ *
+ * This class implements the `Map<string, unknown>` interface and provides methods and properties to manage and manipulate session data.
+ *
+ * @internal This class is designed for internal use.
+ */
+export class SocketSessionData extends Map<string, unknown> {
+  readonly #data: Record<string, unknown>;
+
+  get size(): number {
+    return Object.keys(this.#data).length;
+  }
+
+  static get [Symbol.species]() {
+    return Map;
+  }
+
+  constructor(data: Record<string, unknown>) {
+    super();
+    this.#data = data;
+  }
+
+  public *[Symbol.iterator](): IterableIterator<[string, unknown]> {
+    for (const key in this.#data) {
+      yield [key, this.#data[key]];
+    }
+  }
+
+  public clear(): void {
+    for (const key in this.#data) {
+      delete this.#data[key];
+    }
+  }
+
+  public delete(key: string): boolean {
+    const hasKey = key in this.#data;
+    if (hasKey) {
+      delete this.#data[key];
+      return true;
+    }
+    return false;
+  }
+
+  public *entries(): IterableIterator<[string, unknown]> {
+    for (const key in this.#data) {
+      yield [key, this.#data[key]];
+    }
+  }
+
+  public forEach(callbackfn: (value: unknown, key: string, map: Map<string, unknown>) => void, thisArg?: any): void {
+    for (const key in this.#data) {
+      callbackfn.call(thisArg, this.#data[key], key, this);
+    }
+  }
+
+  public get(key: string): unknown | undefined {
+    return this.#data[key];
+  }
+
+  public has(key: string): boolean {
+    return key in this.#data;
+  }
+
+  public *keys(): IterableIterator<string> {
+    for (const key in this.#data) {
+      yield key;
+    }
+  }
+
+  public set(key: string, value: unknown): this {
+    this.#data[key] = value;
+    return this;
+  }
+
+  public *values(): IterableIterator<unknown> {
+    for (const key in this.#data) {
+      yield this.#data[key];
+    }
+  }
+}

package/src/constants/constants.ts

@@ -0,0 +1 @@
+export const PROVIDER_TYPE_SOCKET_SERVICE = "socketService";

package/src/decorators/args.spec.ts

@@ -0,0 +1,57 @@
+import {Store} from "@tsed/core";
+
+import {Args} from "../index.js";
+
+describe("Args", () => {
+  describe("without parameters", () => {
+    beforeAll(() => {});
+
+    it("should set metadata", () => {
+      class Test {}
+
+      Args()(Test, "test", 0);
+
+      const store = Store.from(Test);
+
+      expect(store.get("socketIO")).toEqual({
+        handlers: {
+          test: {
+            parameters: {
+              "0": {
+                filter: "args",
+                useMapper: false
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+
+  describe("with parameters", () => {
+    beforeAll(() => {});
+
+    it("should set metadata", () => {
+      class Test {}
+
+      Args(1)(Test, "test", 1);
+      const store = Store.from(Test);
+
+      expect(store.get("socketIO")).toEqual({
+        handlers: {
+          test: {
+            parameters: {
+              "1": {
+                collectionType: undefined,
+                filter: "args",
+                mapIndex: 1,
+                type: undefined,
+                useMapper: true
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+});