@tsed/socketio 8.11.1 → 8.11.2-rc.1

package/src/class/SocketHandlersBuilder.ts

@@ -1,266 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1,81 +0,0 @@
-/**
- * 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

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

package/src/decorators/args.spec.ts

@@ -1,57 +0,0 @@
-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
-              }
-            }
-          }
-        }
-      });
-    });
-  });
-});