@eleven-am/pondsocket-nest 0.0.2

package/context.d.ts

@@ -0,0 +1,263 @@
+import type {
+    UserData,
+    JoinRequest,
+    EventRequest,
+    IncomingConnection,
+    Channel as PondChannel,
+    LeaveEvent,
+    JoinResponse, EventResponse,
+    ConnectionResponse, UserPresences,
+    PondEvenType, PondEvent,
+} from '@eleven-am/pondsocket/types';
+import type { DynamicModule, ModuleMetadata } from '@nestjs/common';
+
+export type Constructor<T> = new (...args: any[]) => T;
+
+export type ParamDecoratorCallback<Input> = (data: Input, context: Context) => unknown | Promise<unknown>;
+
+export interface CanActivate {
+
+    /**
+     * @desc Whether the client can continue with the request
+     * @param context - The context of the request
+     */
+    canActivate(context: Context): boolean | Promise<boolean>;
+}
+
+export interface Metadata extends Omit<ModuleMetadata, 'controllers'> {
+    guards?: Constructor<CanActivate>[];
+    appModuleName?: string;
+    isGlobal?: boolean;
+}
+
+export declare class Context<Path extends string = string, Event extends PondEvenType = PondEvenType> {
+    /**
+     * @desc The request object, available in onJoin handlers
+     */
+    get joinRequest (): JoinRequest<Path> | null;
+
+    /**
+     * @desc The request object, available in onEvent handlers
+     */
+    get eventRequest (): EventRequest<Path> | null;
+
+    /**
+     * @desc The request object, available in onConnection handlers
+     */
+    get connection (): IncomingConnection<Path> | null;
+
+    /**
+     * @desc The request object, available in onLeave handlers
+     */
+    get leaveEvent (): LeaveEvent | null;
+
+    /**
+     * @desc The response object, available in onJoin handlers
+     */
+    get joinResponse (): JoinResponse<Event> | null;
+
+    /**
+     * @desc The response object, available in onEvent handlers
+     */
+    get eventResponse (): EventResponse<Event> | null;
+
+    /**
+     * @desc The response object, available in onConnection handlers
+     */
+    get connectionResponse (): ConnectionResponse | null;
+
+    /**
+     * @desc The presence object, available on the channel
+     */
+    get presence (): UserPresences | null;
+
+    /**
+     * @desc The user object, assigned to the current user
+     */
+    get user (): UserData | null;
+
+    /**
+     * @desc The channel object handling the request
+     */
+    get channel (): PondChannel<Event> | null;
+
+    /**
+     * @desc The event object of the current the request
+     */
+    get event (): PondEvent<Path> | null;
+
+    /**
+     * @desc The class reference of the current context
+     */
+    getClass (): any;
+
+    /**
+     * @desc The method reference of the current context
+     */
+    getHandler (): any;
+
+    /**
+     * @desc Saves data to the current context
+     */
+    addData <Type> (key: string, value: Type): void;
+
+    /**
+     * @desc Retrieves data from the current context
+     */
+    getData <Type> (key: string): Type | null;
+}
+
+/**
+ * @desc Decorator that marks a class as a channel
+ */
+export declare function Channel(path?: string): ClassDecorator
+
+/**
+ * @desc Decorator that marks a property on a class as the channel instance
+ * @returns {Channel | PondChannel}
+ */
+export declare function ChannelInstance(channel?: string): PropertyDecorator;
+
+/**
+ * @desc Decorator that marks a class as an endpoint
+ */
+export declare function Endpoint(path?: string): ClassDecorator;
+
+/**
+ * @desc Decorator that marks a property on a class as the endpoint instance
+ * @returns {Endpoint}
+ */
+export declare function EndpointInstance(): PropertyDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current channel
+ * @returns {Channel}
+ */
+export declare const GetChannel: () => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current connection headers
+ * @returns {IncomingHttpHeaders}
+ */
+export declare const GetConnectionHeaders: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current connection request
+ * @returns {IncomingConnection}
+ */
+export declare const GetConnectionRequest: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current connection response
+ * @returns {ConnectionResponse}
+ */
+export declare const GetConnectionResponse: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current context
+ * @returns {Context}
+ */
+export declare const GetContext: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current event params
+ * @returns {Params}
+ */
+export declare const GetEventParams: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current event payload
+ * @returns {PondMessage}
+ */
+export declare const GetEventPayload: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current event query
+ * @returns {Record<string, string>}
+ */
+export declare const GetEventQuery: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current event request
+ * @returns {EventRequest}
+ */
+export declare const GetEventRequest: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current event response
+ * @returns {EventResponse}
+ */
+export declare const GetEventResponse: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current join params
+ * @returns {JoinParams}
+ */
+export declare const GetJoinParams: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current join request
+ * @returns {JoinRequest}
+ */
+export declare const GetJoinRequest: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current join response
+ * @returns {JoinResponse}
+ */
+export declare const GetJoinResponse: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current leave event
+ * @returns {LeaveEvent}
+ */
+export declare const GetLeaveEvent: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current user
+ * @returns {UserData}
+ */
+export declare const GetUserData: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Parameter decorator that retrieves the current user presences
+ * @returns {UserPresences}
+ */
+export declare const GetUserPresences: (data: void) => ParameterDecorator;
+
+/**
+ * @desc Method decorator that marks a method as an onConnection handler
+ */
+export declare function OnConnectionRequest(): MethodDecorator;
+
+/**
+ * @desc Method decorator that marks a method as an onEvent handler
+ */
+export declare function OnEvent(path?: string): MethodDecorator;
+
+/**
+ * @desc Method decorator that marks a method as an onJoin handler
+ */
+export declare function OnJoinRequest(): MethodDecorator;
+
+/**
+ * @desc Method decorator that marks a method as an onLeave handler
+ */
+export declare function OnLeave(): MethodDecorator;
+
+/**
+ * @desc Decorator that adds guards to a channel's or endpoint's class or method
+ * @param guards - The guards to add. It is important to add the guards to a providers array in any module (only necessary if the guards inject dependencies)
+ */
+export declare function PondGuards (...guards: Constructor<CanActivate>[]): ClassDecorator | MethodDecorator;
+
+/**
+ * @desc Helper function that creates a parameter decorator
+ * @param callback - The callback to run when the parameter is being retrieved
+ */
+export declare function createParamDecorator<Input>(callback: ParamDecoratorCallback<Input>): (data: Input) => ParameterDecorator;
+
+export declare class PondSocketModule {
+    static forRoot({ guards, providers, imports, exports, isGlobal, appModuleName }: Metadata): DynamicModule;
+}
+

package/decorators/channel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+const channel_1 = require("../managers/channel");
+function Channel(path = '*') {
+    return (target) => {
+        const { set } = (0, channel_1.manageChannel)(target);
+        set(path);
+    };
+}
+exports.Channel = Channel;

package/decorators/channelInstance.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelInstance = void 0;
+const channelInstance_1 = require("../managers/channelInstance");
+function ChannelInstance(channel) {
+    return (target, propertyKey) => {
+        const { build } = (0, channelInstance_1.manageChannelInstance)(target);
+        build(propertyKey, (value) => {
+            if (channel) {
+                return value.getChannel(channel);
+            }
+            return value;
+        });
+    };
+}
+exports.ChannelInstance = ChannelInstance;

package/decorators/endpoint.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoint = void 0;
+const endpoint_1 = require("../managers/endpoint");
+function Endpoint(path = '*') {
+    return (target) => {
+        const { set } = (0, endpoint_1.manageEndpoint)(target);
+        set(path);
+    };
+}
+exports.Endpoint = Endpoint;

package/decorators/endpointInstance.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointInstance = void 0;
+const endpointInstance_1 = require("../managers/endpointInstance");
+function EndpointInstance() {
+    return (target, propertyKey) => {
+        const { build } = (0, endpointInstance_1.manageEndpointInstance)(target);
+        build(propertyKey);
+    };
+}
+exports.EndpointInstance = EndpointInstance;

package/decorators/getChannel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetChannel = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetChannel = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const channel = context.channel;
+    if (!channel) {
+        throw new Error('Invalid decorator usage: GetChannel');
+    }
+    return channel;
+});

package/decorators/getConnectionHeaders.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetConnectionHeaders = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetConnectionHeaders = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const connection = context.connection;
+    if (!connection) {
+        throw new Error('Invalid decorator usage: GetConnectionHeaders');
+    }
+    return connection.headers;
+});

package/decorators/getConnectionRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetConnectionRequest = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetConnectionRequest = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const connectionRequest = context.connection;
+    if (!connectionRequest) {
+        throw new Error('Invalid decorator usage: GetConnectionRequest');
+    }
+    return connectionRequest;
+});

package/decorators/getConnectionResponse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetConnectionResponse = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetConnectionResponse = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const connectionResponse = context.connectionResponse;
+    if (!connectionResponse) {
+        throw new Error('Invalid decorator usage: GetConnectionResponse');
+    }
+    return connectionResponse;
+});

package/decorators/getContext.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetContext = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetContext = (0, createParamDecorator_1.createParamDecorator)((data, context) => context);

package/decorators/getEventParams.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetEventParams = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetEventParams = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const event = context.event;
+    if (!event) {
+        throw new Error('Invalid decorator usage: GetEventParams');
+    }
+    return event.params;
+});

package/decorators/getEventPayload.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetEventPayload = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetEventPayload = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const event = context.event;
+    if (!event) {
+        throw new Error('Invalid decorator usage: GetEventPayload');
+    }
+    return event.payload;
+});

package/decorators/getEventQuery.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetEventQuery = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetEventQuery = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const event = context.event;
+    if (!event) {
+        throw new Error('Invalid decorator usage: GetEventQuery');
+    }
+    return event.query;
+});

package/decorators/getEventRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetEventRequest = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetEventRequest = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const joinRequest = context.joinRequest;
+    if (!joinRequest) {
+        throw new Error('Invalid decorator usage: GetJoinRequest');
+    }
+    return joinRequest;
+});

package/decorators/getEventResponse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetEventResponse = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetEventResponse = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const eventResponse = context.eventResponse;
+    if (!eventResponse) {
+        throw new Error('Invalid decorator usage: GetEventResponse');
+    }
+    return eventResponse;
+});

package/decorators/getJoinParams.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetJoinParams = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetJoinParams = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const joinRequest = context.joinRequest;
+    if (!joinRequest) {
+        throw new Error('Invalid decorator usage: GetJoinParams');
+    }
+    return joinRequest.joinParams;
+});

package/decorators/getJoinRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetJoinRequest = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetJoinRequest = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const joinRequest = context.joinRequest;
+    if (!joinRequest) {
+        throw new Error('Invalid decorator usage: GetJoinRequest');
+    }
+    return joinRequest;
+});

package/decorators/getJoinResponse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetJoinResponse = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetJoinResponse = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const joinResponse = context.joinResponse;
+    if (!joinResponse) {
+        throw new Error('Invalid decorator usage: GetJoinResponse');
+    }
+    return joinResponse;
+});

package/decorators/getLeaveEvent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetLeaveEvent = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetLeaveEvent = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const leaveEvent = context.leaveEvent;
+    if (!leaveEvent) {
+        throw new Error('Invalid decorator usage: GetLeaveEvent');
+    }
+    return leaveEvent;
+});

package/decorators/getUserData.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUserData = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetUserData = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const userData = context.user;
+    if (!userData) {
+        throw new Error('Invalid decorator usage: GetUserData');
+    }
+    return userData;
+});

package/decorators/getUserPresences.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUserPresences = void 0;
+const createParamDecorator_1 = require("../helpers/createParamDecorator");
+exports.GetUserPresences = (0, createParamDecorator_1.createParamDecorator)((data, context) => {
+    const userPresences = context.presence;
+    if (!userPresences) {
+        throw new Error('Invalid decorator usage: GetUserPresences');
+    }
+    return userPresences;
+});

package/decorators/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./channel"), exports);
+__exportStar(require("./channelInstance"), exports);
+__exportStar(require("./endpoint"), exports);
+__exportStar(require("./endpointInstance"), exports);
+__exportStar(require("./getChannel"), exports);
+__exportStar(require("./getConnectionHeaders"), exports);
+__exportStar(require("./getConnectionRequest"), exports);
+__exportStar(require("./getConnectionResponse"), exports);
+__exportStar(require("./getContext"), exports);
+__exportStar(require("./getEventParams"), exports);
+__exportStar(require("./getEventPayload"), exports);
+__exportStar(require("./getEventQuery"), exports);
+__exportStar(require("./getEventRequest"), exports);
+__exportStar(require("./getEventResponse"), exports);
+__exportStar(require("./getJoinParams"), exports);
+__exportStar(require("./getJoinRequest"), exports);
+__exportStar(require("./getJoinResponse"), exports);
+__exportStar(require("./getLeaveEvent"), exports);
+__exportStar(require("./getUserData"), exports);
+__exportStar(require("./getUserPresences"), exports);
+__exportStar(require("./onConnectionRequest"), exports);
+__exportStar(require("./onJoinRequest"), exports);
+__exportStar(require("./onLeave"), exports);
+__exportStar(require("./onEvent"), exports);
+__exportStar(require("./pondGuards"), exports);

package/decorators/onConnectionRequest.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnConnectionRequest = void 0;
+const connection_1 = require("../managers/connection");
+const action_1 = require("../performers/action");
+const errors_1 = require("../performers/errors");
+function OnConnectionRequest() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = (0, connection_1.manageConnection)(target);
+        set('', (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, action_1.performAction)(instance, moduleRef, originalMethod, propertyKey, null, request, response);
+            }
+            catch (error) {
+                (0, errors_1.performErrors)(error, response);
+            }
+        }));
+    };
+}
+exports.OnConnectionRequest = OnConnectionRequest;

package/decorators/onEvent.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnEvent = void 0;
+const event_1 = require("../managers/event");
+const action_1 = require("../performers/action");
+const errors_1 = require("../performers/errors");
+function OnEvent(event = '*') {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = (0, event_1.manageEvent)(target);
+        set(event, (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, action_1.performAction)(instance, moduleRef, originalMethod, propertyKey, null, request, response);
+            }
+            catch (error) {
+                (0, errors_1.performErrors)(error, response);
+            }
+        }));
+    };
+}
+exports.OnEvent = OnEvent;

package/decorators/onJoinRequest.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnJoinRequest = void 0;
+const join_1 = require("../managers/join");
+const action_1 = require("../performers/action");
+const errors_1 = require("../performers/errors");
+function OnJoinRequest() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = (0, join_1.manageJoin)(target);
+        set('', (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, action_1.performAction)(instance, moduleRef, originalMethod, propertyKey, null, request, response);
+            }
+            catch (error) {
+                (0, errors_1.performErrors)(error, response);
+            }
+        }));
+    };
+}
+exports.OnJoinRequest = OnJoinRequest;