@tsed/socketio 6.88.1 → 6.89.0

package/lib/types/class/SocketHandlersBuilder.d.ts

@@ -0,0 +1,47 @@
+import { ConverterService, InjectorService, Provider } from "@tsed/common";
+import { Namespace, Socket } from "socket.io";
+/**
+ * @ignore
+ */
+export declare class SocketHandlersBuilder {
+    private provider;
+    private converterService;
+    private injector;
+    private socketProviderMetadata;
+    constructor(provider: Provider<any>, converterService: ConverterService, injector: InjectorService);
+    /**
+     *
+     * @param {SocketHandlerMetadata} handlerMetadata
+     * @param scope
+     * @returns {(data) => void}
+     */
+    private static bindResponseMiddleware;
+    /**
+     *
+     * @returns {any}
+     */
+    build(nsps: Map<string, Namespace>): this;
+    /**
+     *
+     * @param {Socket} socket
+     * @param {Namespace} nsp
+     */
+    onConnection(socket: Socket, nsp: Namespace): void;
+    onDisconnect(socket: Socket, nsp: Namespace): void;
+    /**
+     *
+     * @param {Socket} socket
+     */
+    private createSession;
+    /**
+     *
+     * @param {Socket} socket
+     */
+    private destroySession;
+    private buildHandlers;
+    private runQueue;
+    private deserialize;
+    private bindMiddleware;
+    private invoke;
+    private buildParameters;
+}

package/lib/types/class/SocketProviderMetadata.d.ts

@@ -0,0 +1,19 @@
+import { SocketHandlerMetadata, SocketInjectableNsp } from "../interfaces";
+import { SocketProviderTypes } from "../interfaces/SocketProviderTypes";
+export declare class SocketProviderMetadata {
+    type: SocketProviderTypes;
+    namespace: string;
+    error: boolean;
+    injectNamespaces: SocketInjectableNsp[];
+    useBefore: any[];
+    useAfter: any[];
+    handlers: Record<string, SocketHandlerMetadata>;
+    constructor(options?: Partial<SocketProviderMetadata>);
+    get useHandler(): SocketHandlerMetadata;
+    get $onConnection(): SocketHandlerMetadata;
+    get $onDisconnect(): SocketHandlerMetadata;
+    get(key: string): SocketHandlerMetadata;
+    set(key: string, metadata: SocketHandlerMetadata): void;
+    getHandlers(): SocketHandlerMetadata[];
+    createHook(hook: string, eventName: string): void;
+}

package/lib/types/constants/index.d.ts

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

package/lib/types/decorators/args.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 declare function Args(mapIndex?: number, useType?: any): any;

package/lib/types/decorators/broadcast.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 declare function Broadcast(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/broadcastOthers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 declare function BroadcastOthers(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/emit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 declare function Emit(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/input.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 declare function Input(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/inputAndBroadcast.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 declare function InputAndBroadcast(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/inputAndBroadcastOthers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 declare function InputAndBroadcastOthers(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/inputAndEmit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 declare function InputAndEmit(eventName: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/io.d.ts

@@ -0,0 +1,19 @@
+import { Type } from "@tsed/core";
+/**
+ * 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 declare function IO(target: Type<any>, targetKey: string, descriptor: TypedPropertyDescriptor<Function> | number): any;

package/lib/types/decorators/nsp.d.ts

@@ -0,0 +1,64 @@
+import { Namespace as NamespaceType } from "socket.io";
+export declare type Namespace = NamespaceType;
+export declare type Nsp = NamespaceType;
+/**
+ * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.
+ *
+ * ### 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
+ *
+ *   @Input("event")
+ *   myMethod(@Nsp namespace: SocketIO.Namespace) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export declare function Nsp(target: any, propertyKey?: string, index?: number): any;
+/**
+ * Inject the [SocketIO.Namespace](https://socket.io/docs/rooms-and-namespaces/#namespaces) instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {Namespace, SocketService, Input} from "@tsed/socketio";
+ *
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Nsp
+ *   nsp: Namespace; // will inject SocketIO.Namespace (not available on constructor)
+ *
+ *   @Nsp("/my-other-namespace")
+ *   nspOther: Namespace; // communication between two namespace
+ *
+ *   @Input("event")
+ *   myMethod(@Namespace namespace: Namespace) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @alias {Nsp}
+ * @decorator
+ */
+export declare function Namespace(target: any, propertyKey?: string, index?: number): any;

package/lib/types/decorators/socket.d.ts

@@ -0,0 +1,25 @@
+import { Socket as SocketType } from "socket.io";
+export declare type Socket = SocketType;
+/**
+ * Inject the Socket instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@Socket socket) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @experimental
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export declare function Socket(target: any, propertyKey: string, index: number): any;

package/lib/types/decorators/socketErr.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Inject the error in the parameters
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketMiddlewareError()
+ * export class MyMiddleware {
+ *
+ *   myMethod(@SocketErr err: any, @Args() arguments: any[]) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @param target
+ * @param propertyKey
+ * @param index
+ */
+export declare function SocketErr(target: any, propertyKey: string, index: number): any;

package/lib/types/decorators/socketEventName.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Inject the Socket instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketMiddleware("/nsp")
+ * export class MyMiddleware {
+ *   use(@SocketEventName eventName: string) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @experimental
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export declare function SocketEventName(target: any, propertyKey: string, index: number): any;

package/lib/types/decorators/socketFilter.d.ts

@@ -0,0 +1,9 @@
+import { SocketFilters } from "../interfaces/SocketFilters";
+/**
+ *
+ * @param {SocketFilters} filter
+ * @param {number} mapIndex
+ * @returns {(target: any, propertyKey: string, index: number) => Store}
+ * @decorator
+ */
+export declare function SocketFilter(filter: SocketFilters, mapIndex?: number): (target: any, propertyKey: string, index: number) => void;

package/lib/types/decorators/socketMiddleware.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Declare a new SocketMiddleware.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * @SocketMiddleware()
+ * export class UserConverterSocketMiddleware {
+ *     constructor(private converterService: ConverterService) {
+ *     }
+ *     async use(@Args() args: any[]) {
+ *
+ *         let [user] = args;
+ *         // update Arguments
+ *         user = this.converterService.deserialize(user, User);
+ *
+ *         return [user];
+ *     }
+ * }
+ * ```
+ * > The user instance will be forwarded to the next middleware and to your decorated method.
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {UserConverterSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseBefore(UserConverterSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseBefore(UserConverterSocketMiddleware)
+ *    async myMethod(@Args(0) user: User) {
+ *
+ *        console.log(user);
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ * @experimental
+ */
+export declare function SocketMiddleware(): Function;

package/lib/types/decorators/socketMiddlewareError.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Declare a new SocketMiddlewareError.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * import {SocketMiddlewareError, SocketErr, Socket, Args} from "@tsed/socketio";
+ *
+ * @SocketMiddlewareError()
+ * export class ErrorHandlerSocketMiddleware {
+ *    async use(@SocketEventName, @SocketErr err: any, @Socket socket: SocketIO.Socket) {
+ *        console.error(err);
+ *        socket.emit("error", {message: "An error has occured"})
+ *    }
+ * }
+ * ```
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {ErrorHandlerSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseAfter(ErrorHandlerSocketMiddleware)
+ *    async myMethod(@Args(0) userName: User) {
+ *
+ *        console.log(user);
+ *        throw new Error("Error");
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ * @experimental
+ */
+export declare function SocketMiddlewareError(): Function;

package/lib/types/decorators/socketReturns.d.ts

@@ -0,0 +1,9 @@
+import { SocketReturnsTypes } from "../interfaces/SocketReturnsTypes";
+/**
+ *
+ * @param {string} eventName
+ * @param {SocketReturnsTypes} type
+ * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => void}
+ * @decorator
+ */
+export declare function SocketReturns(eventName: string, type: SocketReturnsTypes): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/lib/types/decorators/socketService.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The decorators `@SocketService()` declare a new socket service (and service) can be injected in other service or controller on there `constructor`.
+ * All services annotated with `@SocketService()` are constructed one time.
+ *
+ * > `@SocketService()` use the `reflect-metadata` to collect and inject service on controllers or other services.
+ *
+ * @param {string} namespace
+ * @returns {Function}
+ * @decorator
+ */
+export declare function SocketService(namespace?: string): any;

package/lib/types/decorators/socketSession.d.ts

@@ -0,0 +1,23 @@
+export declare type SocketSession = Map<string, any>;
+/**
+ * Inject the Socket instance in the decorated parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @SocketService("/nsp")
+ * export class MyWS {
+ *
+ *   @Input("event")
+ *   myMethod(@SocketSession session: Map) {
+ *     console.log(session);
+ *   }
+ * }
+ * ```
+ *
+ * @param target
+ * @param {string} propertyKey
+ * @param {number} index
+ * @decorator
+ */
+export declare function SocketSession(target: any, propertyKey: string, index: number): any;

package/lib/types/decorators/socketUseAfter.d.ts

@@ -0,0 +1,52 @@
+import { Type } from "@tsed/core";
+/**
+ * Attach a Socket Middleware to a method or a class.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * import {SocketMiddlewareError, SocketErr, Socket, Args} from "@tsed/socketio";
+ *
+ * @SocketMiddlewareError()
+ * export class ErrorHandlerSocketMiddleware {
+ *    async use(@SocketErr() err: any, @Socket socket: SocketIO.Socket) {
+ *        console.error(err);
+ *        socket.emit("error", {message: "An error has occured"})
+ *    }
+ * }
+ * ```
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {ErrorHandlerSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseAfter(ErrorHandlerSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseAfter(ErrorHandlerSocketMiddleware)
+ *    async myMethod(@Args(0) userName: User) {
+ *
+ *        console.log(user);
+ *        throw new Error("Error");
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {(target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void}
+ * @decorator
+ * @experimental
+ * @param middlewares
+ */
+export declare function SocketUseAfter(...middlewares: Type<any>[]): (target: any, propertyKey?: string | undefined, descriptor?: PropertyDescriptor | undefined) => void;

package/lib/types/decorators/socketUseBefore.d.ts

@@ -0,0 +1,56 @@
+import { Type } from "@tsed/core";
+/**
+ * Attach a Socket Middleware to a method or a class.
+ *
+ * ### Example
+ *
+ * A middleware can be also used on a `SocketService` either on a class or on a method.
+ *
+ * Here an example of a middleware:
+ *
+ * ```typescript
+ * @SocketMiddleware()
+ * export class UserConverterSocketMiddleware {
+ *     constructor(private converterService: ConverterService) {
+ *     }
+ *     async use(@Args() args: any[]) {
+ *
+ *         let [user] = args;
+ *         // update Arguments
+ *         user = ConverterService.deserialize(user, User);
+ *
+ *         return [user];
+ *     }
+ * }
+ * ```
+ * > The user instance will be forwarded to the next middleware and to your decorated method.
+ *
+ * Then:
+ *
+ * ```typescript
+ * import {SocketService, SocketUseAfter, SocketUseBefore, Emit, Input, Args} from "@tsed/socketio";
+ * import {UserConverterSocketMiddleware} from "../middlewares";
+ * import {User} from "../models/User";
+ *
+ * @SocketService("/my-namespace")
+ * @SocketUseBefore(UserConverterSocketMiddleware) // global version
+ * export class MySocketService {
+ *
+ *    @Input("eventName")
+ *    @Emit("responseEventName") // or Broadcast or BroadcastOthers
+ *    @SocketUseBefore(UserConverterSocketMiddleware)
+ *    async myMethod(@Args(0) user: User) {
+ *
+ *        console.log(user);
+ *
+ *        return user;
+ *    }
+ * }
+ * ```
+ *
+ * @returns {(target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void}
+ * @decorator
+ * @experimental
+ * @param middlewares
+ */
+export declare function SocketUseBefore(...middlewares: Type<any>[]): (target: any, propertyKey?: string | undefined, descriptor?: PropertyDescriptor | undefined) => void;