@tsed/socketio 8.11.1 → 8.11.2-rc.1

package/src/decorators/args.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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