@tsed/socketio 8.0.0 → 8.0.2

package/src/decorators/args.ts

@@ -0,0 +1,60 @@
+import {isCollection, Metadata, Store} from "@tsed/core";
+
+import {SocketFilters} from "../interfaces/SocketFilters.js";
+
+/**
+ * Inject the list of arguments in the decorated parameter.
+ *
+ * `@Args` accept an index parameter to pick up directly the item in the arguments list.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@Args() arguments: any[]) {
+ *
+ *   }
+ *
+ *   @Input("event2")
+ *   myMethod2(@Args(0) data: any) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param mapIndex
+ * @param useType
+ */
+export function Args(mapIndex?: number, useType?: any): any {
+  return (target: any, propertyKey: string, index: number) => {
+    const store = Store.from(target);
+    const type = Metadata.getParamTypes(target, propertyKey)[index];
+    const param = {
+      filter: SocketFilters.ARGS,
+      useMapper: false
+    };
+
+    if (mapIndex !== undefined) {
+      Object.assign(param, {
+        mapIndex,
+        useMapper: true,
+        type: useType || type,
+        collectionType: isCollection(type) ? type : undefined
+      });
+    }
+
+    store.merge("socketIO", {
+      handlers: {
+        [propertyKey]: {
+          parameters: {
+            [index]: param
+          }
+        }
+      }
+    });
+  };
+}

package/src/decorators/broadcast.spec.ts

@@ -0,0 +1,23 @@
+import {Store} from "@tsed/core";
+
+import {Broadcast} from "../index.js";
+
+describe("Broadcast", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    Broadcast("eventName")(Test, "test", {} as any);
+    const store = Store.from(Test);
+
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          returns: {
+            eventName: "eventName",
+            type: "broadcast"
+          }
+        }
+      }
+    });
+  });
+});

package/src/decorators/broadcast.ts

@@ -0,0 +1,28 @@
+import {SocketReturnsTypes} from "../interfaces/SocketReturnsTypes.js";
+import {SocketReturns} from "./socketReturns.js";
+
+/**
+ * Broadcast the response for all client registered in the same namespace.
+ *
+ * With the `@Broadcast` decorator, the method will accept a return type (Promise or not).
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   @Broadcast("returnEvent")
+ *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {
+ *      return Promise.resolve({data})
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function Broadcast(eventName: string) {
+  return SocketReturns(eventName, SocketReturnsTypes.BROADCAST);
+}

package/src/decorators/broadcastOthers.spec.ts

@@ -0,0 +1,23 @@
+import {Store} from "@tsed/core";
+
+import {BroadcastOthers} from "../index.js";
+
+describe("BroadcastOthers", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    BroadcastOthers("eventName")(Test, "test", {} as any);
+    const store = Store.from(Test);
+
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          returns: {
+            eventName: "eventName",
+            type: "broadcastOthers"
+          }
+        }
+      }
+    });
+  });
+});

package/src/decorators/broadcastOthers.ts

@@ -0,0 +1,28 @@
+import {SocketReturnsTypes} from "../interfaces/SocketReturnsTypes.js";
+import {SocketReturns} from "./socketReturns.js";
+
+/**
+ * Broadcast the response for all client registered in the same namespace except to the current client.
+ *
+ * With the `@BroadcastOthers` decorator, the method will accept a return type (Promise or not).
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   @BroadcastOthers("returnEvent")
+ *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {
+ *      return Promise.resolve({data})
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function BroadcastOthers(eventName: string) {
+  return SocketReturns(eventName, SocketReturnsTypes.BROADCAST_OTHERS);
+}

package/src/decorators/emit.spec.ts

@@ -0,0 +1,23 @@
+import {Store} from "@tsed/core";
+
+import {Emit} from "../index.js";
+
+describe("Emit", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    Emit("eventName")(Test, "test", {} as any);
+
+    const store = Store.from(Test);
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          returns: {
+            eventName: "eventName",
+            type: "emit"
+          }
+        }
+      }
+    });
+  });
+});

package/src/decorators/emit.ts

@@ -0,0 +1,28 @@
+import {SocketReturnsTypes} from "../interfaces/SocketReturnsTypes.js";
+import {SocketReturns} from "./socketReturns.js";
+
+/**
+ * Emit the response to the client.
+ *
+ * With the `@Emit` decorator, the method will accept a return type (Promise or not).
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   @Emit("returnEvent")
+ *   async myMethod(@Args(0) data: any, @Nsp socket): Promise<any> {
+ *      return Promise.resolve({data})
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function Emit(eventName: string) {
+  return SocketReturns(eventName, SocketReturnsTypes.EMIT);
+}

package/src/decorators/input.spec.ts

@@ -0,0 +1,22 @@
+import {Store} from "@tsed/core";
+
+import {Input} from "../index.js";
+
+describe("Input", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    Input("eventName")(Test, "test", {} as any);
+
+    const store = Store.from(Test);
+
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          eventName: "eventName",
+          methodClassName: "test"
+        }
+      }
+    });
+  });
+});

package/src/decorators/input.ts

@@ -0,0 +1,33 @@
+import {Store} from "@tsed/core";
+
+/**
+ * Attach the decorated method to the socket event.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@Args(0) data: any, @Nsp socket) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function Input(eventName: string) {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    Store.from(target).merge("socketIO", {
+      handlers: {
+        [propertyKey]: {
+          eventName,
+          methodClassName: propertyKey
+        }
+      }
+    });
+  };
+}

package/src/decorators/inputAndBroadcast.spec.ts

@@ -0,0 +1,25 @@
+import {Store} from "@tsed/core";
+
+import {InputAndBroadcast} from "../index.js";
+
+describe("InputAndBroadcast", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    InputAndBroadcast("eventName")(Test, "test", {} as any);
+    const store = Store.from(Test);
+
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          eventName: "eventName",
+          methodClassName: "test",
+          returns: {
+            eventName: "eventName",
+            type: "broadcast"
+          }
+        }
+      }
+    });
+  });
+});

package/src/decorators/inputAndBroadcast.ts

@@ -0,0 +1,28 @@
+import {Broadcast} from "./broadcast.js";
+import {Input} from "./input.js";
+
+/**
+ * Attach the decorated method to the socket event and broadcast the response to all clients.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @InputAndBroadcast("event")
+ *   async myMethod(@Args(0) data: any, @Nsp socket) {
+ *      return {data: "data"};
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function InputAndBroadcast(eventName: string) {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    Input(eventName)(target, propertyKey, descriptor);
+    Broadcast(eventName)(target, propertyKey, descriptor);
+  };
+}

package/src/decorators/inputAndBroadcastOthers.spec.ts

@@ -0,0 +1,24 @@
+import {Store} from "@tsed/core";
+
+import {InputAndBroadcastOthers} from "../index.js";
+
+describe("InputAndBroadcastOthers", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    InputAndBroadcastOthers("eventName")(Test, "test", {} as any);
+    const store = Store.from(Test);
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          eventName: "eventName",
+          methodClassName: "test",
+          returns: {
+            eventName: "eventName",
+            type: "broadcastOthers"
+          }
+        }
+      }
+    });
+  });
+});

package/src/decorators/inputAndBroadcastOthers.ts

@@ -0,0 +1,28 @@
+import {BroadcastOthers} from "./broadcastOthers.js";
+import {Input} from "./input.js";
+
+/**
+ * Attach the decorated method to the socket event and broadcast the response to all clients with the exception of the connected customer.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @InputAndBroadcastOthers("event")
+ *   async myMethod(@Args(0) data: any, @Nsp socket) {
+ *      return {data: "data"};
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function InputAndBroadcastOthers(eventName: string) {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    Input(eventName)(target, propertyKey, descriptor);
+    BroadcastOthers(eventName)(target, propertyKey, descriptor);
+  };
+}

package/src/decorators/inputAndEmit.spec.ts

@@ -0,0 +1,24 @@
+import {Store} from "@tsed/core";
+
+import {InputAndEmit} from "../index.js";
+
+describe("InputAndEmit", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    InputAndEmit("eventName")(Test, "test", {} as any);
+    const store = Store.from(Test);
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          eventName: "eventName",
+          methodClassName: "test",
+          returns: {
+            eventName: "eventName",
+            type: "emit"
+          }
+        }
+      }
+    });
+  });
+});

package/src/decorators/inputAndEmit.ts

@@ -0,0 +1,28 @@
+import {Emit} from "./emit.js";
+import {Input} from "./input.js";
+
+/**
+ * Attach the decorated method to the socket event and emit the response to the client.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @InputAndEmit("event")
+ *   async myMethod(@Args(0) data: any, @Nsp socket) {
+ *      return {data: "data"};
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param eventName
+ */
+export function InputAndEmit(eventName: string) {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    Input(eventName)(target, propertyKey, descriptor);
+    Emit(eventName)(target, propertyKey, descriptor);
+  };
+}

package/src/decorators/io.ts

@@ -0,0 +1,34 @@
+import {Type} from "@tsed/core";
+import {Inject} from "@tsed/di";
+
+import {Server} from "../services/SocketIOServer.js";
+
+/**
+ * Inject the [SocketIO.Server](https://socket.io/docs/server-api/) instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *   constructor(@IO private io: Server) {}
+ * }
+ * ```
+ *
+ * @param target
+ * @param targetKey
+ * @param descriptor
+ * @decorator
+ */
+export function IO(): (...args: any[]) => any;
+export function IO(target: Type<any>, targetKey: string | symbol | undefined, descriptor: TypedPropertyDescriptor<Function> | number): any;
+export function IO(
+  target?: Type<any>,
+  targetKey?: string | symbol | undefined,
+  descriptor?: TypedPropertyDescriptor<Function> | number
+): any {
+  if (target) {
+    return Inject(Server)(target, targetKey, descriptor);
+  }
+  return Inject(Server);
+}

package/src/decorators/nsp.spec.ts

@@ -0,0 +1,70 @@
+import {Store} from "@tsed/core";
+
+import {Nsp} from "../index.js";
+
+describe("Nsp", () => {
+  describe("when it used as param decorator", () => {
+    class Test {}
+
+    it("should set metadata", () => {
+      Nsp(Test, "test", 0);
+      const store = Store.from(Test);
+
+      expect(store.get("socketIO")).toEqual({
+        handlers: {
+          test: {
+            parameters: {
+              "0": {
+                filter: "nsp",
+                mapIndex: undefined
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+
+  describe("when it used as property decorator", () => {
+    class Test {}
+
+    beforeAll(() => {});
+
+    it("should set metadata", () => {
+      Nsp(Test.prototype, "test");
+
+      const store = Store.from(Test);
+      expect(store.get("socketIO")).toEqual({
+        injectNamespaces: [{propertyKey: "test"}]
+      });
+    });
+  });
+
+  describe("when it used as property decorator with parameters", () => {
+    it("should set metadata (string)", () => {
+      class Test {
+        @Nsp("/test")
+        property: any;
+      }
+
+      const store = Store.from(Test);
+      expect(store.get("socketIO")).toEqual({
+        injectNamespaces: [{propertyKey: "property", nsp: "/test"}]
+      });
+    });
+
+    it("should set metadata (RegExp)", () => {
+      const regexp = new RegExp(/test/);
+
+      class Test {
+        @Nsp(regexp)
+        property: any;
+      }
+
+      const store = Store.from(Test);
+      expect(store.get("socketIO")).toEqual({
+        injectNamespaces: [{propertyKey: "property", nsp: regexp}]
+      });
+    });
+  });
+});

package/src/decorators/nsp.ts

@@ -0,0 +1,101 @@
+import {decoratorTypeOf, DecoratorTypes, isRegExp, Store} from "@tsed/core";
+import {Namespace as NamespaceType} from "socket.io";
+
+import {SocketFilters} from "../interfaces/SocketFilters.js";
+import {SocketFilter} from "./socketFilter.js";
+
+export type Namespace = NamespaceType;
+export type Nsp = NamespaceType;
+
+/**
+ * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.
+ * Note that when using dynamic namespaces, when injecting a parameter, you may want to consider using @SocketNsp instead.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {Nsp, SocketService, Input} from "@tsed/socketio";
+ *
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Nsp
+ *   nsp: SocketIO.Namespace; // will inject SocketIO.Namespace (not available on constructor)
+ *
+ *   @Nsp("/my-other-namespace")
+ *   nspOther: SocketIO.Namespace; // communication between two namespace
+ *
+ *   @Nsp(/regexp/)
+ *   nspDynamic: SocketIO.Namespace; // will inject a dynamic namespace (not available on constructor)
+ *
+ *   @Input("event")
+ *   myMethod(@Nsp namespace: SocketIO.Namespace) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export function Nsp(target: any, propertyKey?: string, index?: number): any {
+  return Namespace(target, propertyKey, index);
+}
+
+/**
+ * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.
+ * Note that when using dynamic namespaces, when injecting a parameter, you may want to consider using @SocketNsp instead.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {Namespace, SocketService, Input} from "@tsed/socketio";
+ *
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Namespace
+ *   nsp: SocketIO.Namespace; // will inject SocketIO.Namespace (not available on constructor)
+ *
+ *   @Namespace("/my-other-namespace")
+ *   nspOther: SocketIO.Namespace; // communication between two namespace
+ *
+ *   @Namespace(/regexp/)
+ *   nspDynamic: SocketIO.Namespace; // will inject a dynamic namespace (not available on constructor)
+ *
+ *   @Input("event")
+ *   myMethod(@Namespace namespace: Namespace) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @alias {Nsp}
+ * @decorator
+ */
+export function Namespace(target: any, propertyKey?: string, index?: number): any {
+  if (typeof target === "string" || isRegExp(target)) {
+    const nsp = target as string | RegExp;
+
+    return (target: any, propertyKey: string) => {
+      Store.from(target).merge("socketIO", {
+        injectNamespaces: [{propertyKey, nsp}]
+      });
+    };
+  }
+
+  if (decoratorTypeOf([target, propertyKey, index]) === DecoratorTypes.PROP) {
+    Store.from(target).merge("socketIO", {
+      injectNamespaces: [{propertyKey}]
+    });
+
+    return;
+  }
+
+  return SocketFilter(SocketFilters.NSP)(target, propertyKey!, index!);
+}

package/src/decorators/reason.spec.ts

@@ -0,0 +1,26 @@
+import {Store} from "@tsed/core";
+
+import {Nsp, SocketErr} from "../index.js";
+import {Reason} from "./reason.js";
+
+describe("Reason", () => {
+  it("should set metadata", () => {
+    class Test {}
+
+    Reason(Test, "test", 0);
+    const store = Store.from(Test);
+
+    expect(store.get("socketIO")).toEqual({
+      handlers: {
+        test: {
+          parameters: {
+            "0": {
+              filter: "reason",
+              mapIndex: undefined
+            }
+          }
+        }
+      }
+    });
+  });
+});