@eleven-am/pondsocket 0.1.91 → 0.1.93

package/nest.d.ts

@@ -1,33 +1,16 @@
-import  {
+export  {
     OnJoinRequest,
     ChannelInstance,
     DChannel as Channel,
-    Channels,
     OnConnectionRequest,
     DEndpoint as Endpoint,
     OnEvent, PondSocketModule,
     GetEventParams, GetEventQuery,
     GetEventRequest, GetEventResponse,
-    GetJoinParams, GetJoinRequest,
     GetJoinResponse, GetConnectionParams,
-    GetConnectionRequest, GetConnectionResponse,
     GetConnectionQuery, GetConnectionHeaders,
-    GetConnectionRequestId, GetEventPayload,
+    GetConnectionRequest, GetConnectionResponse,
     GetUserData, GetUserPresences, GetInternalChannel,
+    GetConnectionRequestId, GetEventPayload, PondGuards,
+    GetJoinParams, GetJoinRequest, createParamDecorator,
 } from './types';
-
-export {
-    OnJoinRequest,
-    ChannelInstance,
-    OnConnectionRequest,
-    Endpoint, PondSocketModule,
-    OnEvent, Channel, Channels,
-    GetEventQuery, GetJoinParams,
-    GetEventParams, GetJoinResponse,
-    GetEventRequest, GetJoinRequest,
-    GetEventResponse, GetConnectionQuery,
-    GetConnectionRequestId, GetEventPayload,
-    GetConnectionParams, GetConnectionRequest,
-    GetConnectionResponse, GetConnectionHeaders,
-    GetUserData, GetUserPresences, GetInternalChannel,
-}

package/nest.js

@@ -20,29 +20,13 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondSocketModule = exports.Endpoint = exports.Channel = exports.EndpointInstance = exports.ChannelInstance = exports.OnConnectionRequest = exports.OnEvent = exports.OnLeaveEvent = exports.OnJoinRequest = exports.GetConnectionQuery = exports.GetConnectionHeaders = exports.GetConnectionParams = exports.GetConnectionRequestId = exports.GetConnectionResponse = exports.GetConnectionRequest = exports.GetEventRequest = exports.GetEventResponse = exports.GetEventQuery = exports.GetEventParams = exports.GetEventPayload = exports.GetUserPresences = exports.GetInternalChannel = exports.GetUserData = exports.GetJoinParams = exports.GetJoinResponse = exports.GetJoinRequest = void 0;
+exports.PondSocketModule = exports.Endpoint = exports.Channel = exports.EndpointInstance = exports.ChannelInstance = exports.OnEvent = exports.OnLeaveEvent = exports.OnJoinRequest = exports.OnConnectionRequest = exports.GetLeaveEvent = exports.GetEventRequest = exports.GetEventResponse = exports.GetEventQuery = exports.GetEventParams = exports.GetEventPayload = exports.GetJoinParams = exports.GetJoinResponse = exports.GetJoinRequest = exports.GetConnectionQuery = exports.GetConnectionHeaders = exports.GetConnectionParams = exports.GetConnectionRequestId = exports.GetConnectionResponse = exports.GetConnectionRequest = exports.GetUserPresences = exports.GetInternalChannel = exports.GetUserData = exports.createParamDecorator = exports.PondGuards = void 0;
 const http_1 = require("http");
 const common_1 = require("@nestjs/common");
+// eslint-disable-next-line import/no-unresolved
 const core_1 = require("@nestjs/core");
 require("reflect-metadata");
 const pondSocket_1 = require("./server/pondSocket");
-const joinRequestKey = Symbol('joinRequestKey');
-const joinResponseKey = Symbol('joinResponseKey');
-const joinParamsKey = Symbol('joinParamsKey');
-const userDataKey = Symbol('userDataKey');
-const internalChannelKey = Symbol('internalChannelKey');
-const userPresenceKey = Symbol('userPresenceKey');
-const eventRequestKey = Symbol('eventRequestKey');
-const eventPayloadKey = Symbol('eventPayloadKey');
-const eventParamsKey = Symbol('eventParamsKey');
-const eventQueryKey = Symbol('eventQueryKey');
-const eventResponseKey = Symbol('eventResponseKey');
-const connectionRequestKey = Symbol('connectionRequestKey');
-const connectionResponseKey = Symbol('connectionResponseKey');
-const connectionRequestIdKey = Symbol('connectionRequestIdKey');
-const connectionParamsKey = Symbol('connectionParamsKey');
-const connectionQueryKey = Symbol('connectionQueryKey');
-const connectionHeadersKey = Symbol('connectionHeadersKey');
 const onJoinHandlerKey = Symbol('onJoinHandlerKey');
 const onEventHandlerKey = Symbol('onEventHandlerKey');
 const onConnectionHandlerKey = Symbol('onConnectionHandlerKey');
@@ -51,6 +35,8 @@ const endpointInstanceKey = Symbol('endpointInstanceKey');
 const channelClassKey = Symbol('channel');
 const endpointClassKey = Symbol('endpoint');
 const channelsClassKey = Symbol('channels');
+const parametersKey = Symbol('generalParametersKey');
+const pondGuardsKey = Symbol('pondGuardsKey');
 function isNotEmpty(value) {
     return value !== null &&
         value !== undefined &&
@@ -65,22 +51,6 @@ function getClassMetadata(key, target) {
     var _a;
     return (_a = Reflect.getMetadata(key, target)) !== null && _a !== void 0 ? _a : null;
 }
-function createParamDecorator(key, error) {
-    return (target, propertyKey, parameterIndex) => {
-        const existingParams = Reflect.getMetadata(key, target, propertyKey);
-        if (existingParams) {
-            throw new Error(error);
-        }
-        Reflect.defineMetadata(key, parameterIndex, target, propertyKey);
-    };
-}
-function resolveParamDecorator(key, target, propertyKey) {
-    const index = Reflect.getMetadata(key, target, propertyKey);
-    if (typeof index !== 'number') {
-        return null;
-    }
-    return index;
-}
 function manageClassData(key, target) {
     return {
         get() {
@@ -91,6 +61,16 @@ function manageClassData(key, target) {
         },
     };
 }
+function manageMethodData(key, target, propertyKey) {
+    return {
+        get() {
+            return Reflect.getMetadata(key, target, propertyKey);
+        },
+        set(value) {
+            Reflect.defineMetadata(key, value, target, propertyKey);
+        },
+    };
+}
 function manageHandlers(key, target) {
     const { get, set } = manageClassData(key, target);
     return {
@@ -109,6 +89,25 @@ function manageHandlers(key, target) {
         },
     };
 }
+function manageParameters(target, propertyKey) {
+    function getter() {
+        var _a;
+        return (_a = Reflect.getMetadata(parametersKey, target, propertyKey)) !== null && _a !== void 0 ? _a : [];
+    }
+    return {
+        get: getter,
+        set(index, callback) {
+            const handlers = getter();
+            Reflect.defineMetadata(parametersKey, [
+                ...handlers,
+                {
+                    index,
+                    callback,
+                },
+            ], target, propertyKey);
+        },
+    };
+}
 function managePropertyData(key, target) {
     function build(propertyKey, callback) {
         Object.defineProperty(target, propertyKey, {
@@ -134,15 +133,41 @@ function managePropertyData(key, target) {
         set,
     };
 }
+function PondGuards(...guards) {
+    return (target, propertyKey) => {
+        if (propertyKey) {
+            const { get, set } = manageMethodData(pondGuardsKey, target, propertyKey);
+            set([...get(), ...guards]);
+        }
+        else {
+            const { get, set } = manageClassData(pondGuardsKey, target);
+            set([...get(), ...guards]);
+        }
+    };
+}
+exports.PondGuards = PondGuards;
+function resolveGuards(moduleRef, request, target, propertyKey) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { get: getClassGuards } = manageClassData(pondGuardsKey, target);
+        const { get: getMethodGuards } = manageMethodData(pondGuardsKey, target, propertyKey.toString());
+        const classGuards = (_a = getClassGuards()) !== null && _a !== void 0 ? _a : [];
+        const methodGuards = (_b = getMethodGuards()) !== null && _b !== void 0 ? _b : [];
+        const instances = [...classGuards, ...methodGuards].map((guard) => moduleRef.get(guard, { strict: false }));
+        const promises = instances.map((instance) => instance.canActivate(request));
+        const results = yield Promise.all(promises);
+        return results.every((result) => result);
+    });
+}
+function manageConnectionHandlers(target) {
+    return manageHandlers(onConnectionHandlerKey, target);
+}
 function manageJoinHandlers(target) {
     return manageHandlers(onJoinHandlerKey, target);
 }
 function manageEventHandlers(target) {
     return manageHandlers(onEventHandlerKey, target);
 }
-function manageConnectionHandlers(target) {
-    return manageHandlers(onConnectionHandlerKey, target);
-}
 function manageOnLeaveHandlers(target) {
     return manageHandlers(onConnectionHandlerKey, target);
 }
@@ -152,326 +177,293 @@ function manageChannelInstance(target) {
 function manageEndpointInstance(target) {
     return managePropertyData(endpointInstanceKey, target);
 }
-function GetJoinRequest() {
-    return createParamDecorator(joinRequestKey, 'JoinRequest decorator already applied');
+function createParamDecorator(callback) {
+    return (data) => (target, propertyKey, index) => {
+        const { set } = manageParameters(target, propertyKey);
+        set(index, (request, response) => callback(data, request, response));
+    };
 }
-exports.GetJoinRequest = GetJoinRequest;
-function GetJoinResponse() {
-    return createParamDecorator(joinResponseKey, 'JoinResponse decorator already applied');
+exports.createParamDecorator = createParamDecorator;
+function resolveParameters(request, response, target, propertyKey) {
+    const { get } = manageParameters(target, propertyKey);
+    const values = get()
+        .map(({ callback, index }) => ({
+        value: callback(request, response),
+        index,
+    }));
+    return values
+        .sort((a, b) => a.index - b.index)
+        .map(({ value }) => value);
 }
-exports.GetJoinResponse = GetJoinResponse;
-function GetJoinParams() {
-    return createParamDecorator(joinParamsKey, 'JoinParams decorator already applied');
-}
-exports.GetJoinParams = GetJoinParams;
 function GetUserData() {
-    return createParamDecorator(userDataKey, 'UserData decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { joinRequest, eventRequest } = request;
+        if (joinRequest) {
+            return joinRequest.user;
+        }
+        else if (eventRequest) {
+            return eventRequest.user;
+        }
+        throw new Error('Invalid decorator usage: GetUserData');
+    })(null);
 }
 exports.GetUserData = GetUserData;
 function GetInternalChannel() {
-    return createParamDecorator(internalChannelKey, 'InternalChannel decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { joinRequest, eventRequest } = request;
+        if (joinRequest) {
+            return joinRequest.channel;
+        }
+        else if (eventRequest) {
+            return eventRequest.channel;
+        }
+        throw new Error('Invalid decorator usage: GetInternalChannel');
+    })(null);
 }
 exports.GetInternalChannel = GetInternalChannel;
 function GetUserPresences() {
-    return createParamDecorator(userPresenceKey, 'UserPresence decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { joinRequest, eventRequest } = request;
+        if (joinRequest) {
+            return joinRequest.presence;
+        }
+        else if (eventRequest) {
+            return eventRequest.presence;
+        }
+        throw new Error('Invalid decorator usage: GetUserPresences');
+    })(null);
 }
 exports.GetUserPresences = GetUserPresences;
-function GetEventPayload() {
-    return createParamDecorator(eventPayloadKey, 'EventPayload decorator already applied');
-}
-exports.GetEventPayload = GetEventPayload;
-function GetEventParams() {
-    return createParamDecorator(eventParamsKey, 'EventParams decorator already applied');
-}
-exports.GetEventParams = GetEventParams;
-function GetEventQuery() {
-    return createParamDecorator(eventQueryKey, 'EventQuery decorator already applied');
-}
-exports.GetEventQuery = GetEventQuery;
-function GetEventResponse() {
-    return createParamDecorator(eventResponseKey, 'EventResponse decorator already applied');
-}
-exports.GetEventResponse = GetEventResponse;
-function GetEventRequest() {
-    return createParamDecorator(eventRequestKey, 'EventRequest decorator already applied');
-}
-exports.GetEventRequest = GetEventRequest;
 function GetConnectionRequest() {
-    return createParamDecorator(connectionRequestKey, 'ConnectionRequest decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { connection } = request;
+        if (connection) {
+            return connection;
+        }
+        throw new Error('Invalid decorator usage: GetConnectionRequest');
+    })(null);
 }
 exports.GetConnectionRequest = GetConnectionRequest;
 function GetConnectionResponse() {
-    return createParamDecorator(connectionResponseKey, 'ConnectionResponse decorator already applied');
+    return createParamDecorator((_, __, response) => {
+        const { connection } = response;
+        if (connection) {
+            return connection;
+        }
+        throw new Error('Invalid decorator usage: GetConnectionResponse');
+    })(null);
 }
 exports.GetConnectionResponse = GetConnectionResponse;
 function GetConnectionRequestId() {
-    return createParamDecorator(connectionRequestIdKey, 'ConnectionRequestId decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { connection } = request;
+        if (connection) {
+            return connection.id;
+        }
+        throw new Error('Invalid decorator usage: GetConnectionRequestId');
+    })(null);
 }
 exports.GetConnectionRequestId = GetConnectionRequestId;
 function GetConnectionParams() {
-    return createParamDecorator(connectionParamsKey, 'ConnectionParams decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { connection } = request;
+        if (connection) {
+            return connection.params;
+        }
+        throw new Error('Invalid decorator usage: GetConnectionParams');
+    })(null);
 }
 exports.GetConnectionParams = GetConnectionParams;
 function GetConnectionHeaders() {
-    return createParamDecorator(connectionHeadersKey, 'ConnectionHeaders decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { connection } = request;
+        if (connection) {
+            return connection.headers;
+        }
+        throw new Error('Invalid decorator usage: GetConnectionHeaders');
+    })(null);
 }
 exports.GetConnectionHeaders = GetConnectionHeaders;
 function GetConnectionQuery() {
-    return createParamDecorator(connectionQueryKey, 'ConnectionQuery decorator already applied');
+    return createParamDecorator((_, request) => {
+        const { connection } = request;
+        if (connection) {
+            return connection.query;
+        }
+        throw new Error('Invalid decorator usage: GetConnectionQuery');
+    })(null);
 }
 exports.GetConnectionQuery = GetConnectionQuery;
-function manageRejectedKeys(rejectedKeys, target, propertyKey) {
-    function symbolToString(symbol) {
-        switch (symbol) {
-            case joinRequestKey:
-                return 'GetJoinRequest';
-            case joinResponseKey:
-                return 'GetJoinResponse';
-            case joinParamsKey:
-                return 'GetJoinParams';
-            case userDataKey:
-                return 'GetUserData';
-            case internalChannelKey:
-                return 'GetInternalChannel';
-            case userPresenceKey:
-                return 'GetUserPresences';
-            case eventPayloadKey:
-                return 'GetEventPayload';
-            case eventParamsKey:
-                return 'GetEventParams';
-            case eventQueryKey:
-                return 'GetEventQuery';
-            case eventResponseKey:
-                return 'GetEventResponse';
-            case eventRequestKey:
-                return 'GetEventRequest';
-            case connectionRequestKey:
-                return 'GetConnectionRequest';
-            case connectionResponseKey:
-                return 'GetConnectionResponse';
-            case connectionRequestIdKey:
-                return 'GetConnectionRequestId';
-            case connectionParamsKey:
-                return 'GetConnectionParams';
-            case connectionQueryKey:
-                return 'GetConnectionQuery';
-            case connectionHeadersKey:
-                return 'GetConnectionHeaders';
-            default:
-                throw new Error('Invalid parameter decorator');
+function GetJoinRequest() {
+    return createParamDecorator((_, request) => {
+        const { joinRequest } = request;
+        if (joinRequest) {
+            return joinRequest;
         }
-    }
-    const rejected = rejectedKeys
-        .map((key) => ({
-        key,
-        name: symbolToString(key),
-    }))
-        .filter(({ key }) => resolveParamDecorator(key, target, propertyKey) !== null);
-    if (rejected.length) {
-        throw new Error(`Invalid parameter decorators: ${rejected.map(({ name }) => name).join(', ')}`);
-    }
+        throw new Error('Invalid decorator usage: GetJoinRequest');
+    })(null);
 }
-function resolveJoinParameters(request, response, target, propertyKey) {
-    const joinRequestIndex = resolveParamDecorator(joinRequestKey, target, propertyKey);
-    const joinParamsIndex = resolveParamDecorator(joinParamsKey, target, propertyKey);
-    const userDataIndex = resolveParamDecorator(userDataKey, target, propertyKey);
-    const internalChannelIndex = resolveParamDecorator(internalChannelKey, target, propertyKey);
-    const eventParamsIndex = resolveParamDecorator(eventParamsKey, target, propertyKey);
-    const eventQueryIndex = resolveParamDecorator(eventQueryKey, target, propertyKey);
-    const JoinResponseIndex = resolveParamDecorator(joinResponseKey, target, propertyKey);
-    const array = [
-        joinRequestIndex,
-        joinParamsIndex,
-        userDataIndex,
-        internalChannelIndex,
-        eventParamsIndex,
-        eventQueryIndex,
-        JoinResponseIndex,
-    ].filter((index) => typeof index === 'number');
-    manageRejectedKeys([
-        eventPayloadKey,
-        eventRequestKey,
-        eventResponseKey,
-        userPresenceKey,
-        connectionRequestKey,
-        connectionResponseKey,
-        connectionRequestIdKey,
-        connectionParamsKey,
-        connectionQueryKey,
-    ], target, propertyKey);
-    return array
-        .sort((a, b) => a - b)
-        .map((index) => {
-        switch (index) {
-            case joinRequestIndex:
-                return request;
-            case joinParamsIndex:
-                return request.joinParams;
-            case userDataIndex:
-                return request.user;
-            case internalChannelIndex:
-                return request.channel;
-            case eventParamsIndex:
-                return request.event.params;
-            case eventQueryIndex:
-                return request.event.query;
-            case JoinResponseIndex:
-                return response;
-            default:
-                throw new Error('Invalid parameter decorator');
+exports.GetJoinRequest = GetJoinRequest;
+function GetJoinResponse() {
+    return createParamDecorator((_, __, response) => {
+        const { joinResponse } = response;
+        if (joinResponse) {
+            return joinResponse;
         }
-    });
+        throw new Error('Invalid decorator usage: GetJoinResponse');
+    })(null);
 }
-function resolveEventParameters(request, response, target, propertyKey) {
-    const userDataIndex = resolveParamDecorator(userDataKey, target, propertyKey);
-    const userPresenceIndex = resolveParamDecorator(userPresenceKey, target, propertyKey);
-    const internalChannelIndex = resolveParamDecorator(internalChannelKey, target, propertyKey);
-    const eventParamsIndex = resolveParamDecorator(eventParamsKey, target, propertyKey);
-    const eventQueryIndex = resolveParamDecorator(eventQueryKey, target, propertyKey);
-    const eventPayloadIndex = resolveParamDecorator(eventPayloadKey, target, propertyKey);
-    const eventResponseIndex = resolveParamDecorator(eventResponseKey, target, propertyKey);
-    const eventRequestIndex = resolveParamDecorator(eventRequestKey, target, propertyKey);
-    const array = [
-        userDataIndex,
-        internalChannelIndex,
-        eventParamsIndex,
-        eventQueryIndex,
-        eventPayloadIndex,
-        eventResponseIndex,
-        eventRequestIndex,
-        userPresenceIndex,
-    ].filter((index) => typeof index === 'number');
-    manageRejectedKeys([
-        joinRequestKey,
-        joinResponseKey,
-        joinParamsKey,
-        connectionRequestKey,
-        connectionResponseKey,
-        connectionRequestIdKey,
-        connectionParamsKey,
-        connectionQueryKey,
-    ], target, propertyKey);
-    return array
-        .sort((a, b) => a - b)
-        .map((index) => {
-        switch (index) {
-            case userDataIndex:
-                return request.user;
-            case internalChannelIndex:
-                return request.channel;
-            case eventParamsIndex:
-                return request.event.params;
-            case eventQueryIndex:
-                return request.event.query;
-            case eventPayloadIndex:
-                return request.event.payload;
-            case eventResponseIndex:
-                return response;
-            case eventRequestIndex:
-                return request;
-            case userPresenceIndex:
-                return request.presence;
-            default:
-                throw new Error('Invalid parameter decorator');
+exports.GetJoinResponse = GetJoinResponse;
+function GetJoinParams() {
+    return createParamDecorator((_, request) => {
+        const { joinRequest } = request;
+        if (joinRequest) {
+            return joinRequest.joinParams;
         }
-    });
+        throw new Error('Invalid decorator usage: GetJoinParams');
+    })(null);
 }
-function resolveLeaveParameters(event, target, propertyKey) {
-    const userDataIndex = resolveParamDecorator(userDataKey, target, propertyKey);
-    manageRejectedKeys([
-        joinRequestKey,
-        joinResponseKey,
-        joinParamsKey,
-        connectionRequestKey,
-        connectionResponseKey,
-        connectionRequestIdKey,
-        connectionParamsKey,
-        connectionQueryKey,
-        eventParamsKey,
-        eventQueryKey,
-        eventPayloadKey,
-        eventResponseKey,
-        eventRequestKey,
-        userPresenceKey,
-        internalChannelKey,
-    ], target, propertyKey);
-    if (userDataIndex === null) {
-        return [];
-    }
-    return [event.assigns];
-}
-function resolveConnectionParameters(request, response, target, propertyKey) {
-    const connectionRequestIndex = resolveParamDecorator(connectionRequestKey, target, propertyKey);
-    const connectionResponseIndex = resolveParamDecorator(connectionResponseKey, target, propertyKey);
-    const connectionRequestIdIndex = resolveParamDecorator(connectionRequestIdKey, target, propertyKey);
-    const connectionParamsIndex = resolveParamDecorator(connectionParamsKey, target, propertyKey);
-    const connectionQueryIndex = resolveParamDecorator(connectionQueryKey, target, propertyKey);
-    const connectionHeadersIndex = resolveParamDecorator(connectionHeadersKey, target, propertyKey);
-    const array = [
-        connectionRequestIndex,
-        connectionResponseIndex,
-        connectionRequestIdIndex,
-        connectionParamsIndex,
-        connectionQueryIndex,
-        connectionHeadersIndex,
-    ].filter((index) => typeof index === 'number');
-    manageRejectedKeys([
-        joinRequestKey,
-        joinResponseKey,
-        joinParamsKey,
-        userDataKey,
-        internalChannelKey,
-        eventParamsKey,
-        eventQueryKey,
-        eventPayloadKey,
-        eventResponseKey,
-        userPresenceKey,
-        eventRequestKey,
-    ], target, propertyKey);
-    return array
-        .sort((a, b) => a - b)
-        .map((index) => {
-        switch (index) {
-            case connectionRequestIndex:
-                return request;
-            case connectionResponseIndex:
-                return response;
-            case connectionRequestIdIndex:
-                return request.id;
-            case connectionParamsIndex:
-                return request.params;
-            case connectionQueryIndex:
-                return request.query;
-            case connectionHeadersIndex:
-                return request.headers;
-            default:
-                throw new Error('Invalid parameter decorator');
+exports.GetJoinParams = GetJoinParams;
+function GetEventPayload() {
+    return createParamDecorator((_, request) => {
+        const { eventRequest } = request;
+        if (eventRequest) {
+            return eventRequest.event.payload;
         }
-    });
+        throw new Error('Invalid decorator usage: GetEventPayload');
+    })(null);
+}
+exports.GetEventPayload = GetEventPayload;
+function GetEventParams() {
+    return createParamDecorator((_, request) => {
+        const { eventRequest } = request;
+        if (eventRequest) {
+            return eventRequest.event.params;
+        }
+        throw new Error('Invalid decorator usage: GetEventParams');
+    })(null);
+}
+exports.GetEventParams = GetEventParams;
+function GetEventQuery() {
+    return createParamDecorator((_, request) => {
+        const { eventRequest } = request;
+        if (eventRequest) {
+            return eventRequest.event.query;
+        }
+        throw new Error('Invalid decorator usage: GetEventQuery');
+    })(null);
+}
+exports.GetEventQuery = GetEventQuery;
+function GetEventResponse() {
+    return createParamDecorator((_, __, response) => {
+        const { eventResponse } = response;
+        if (eventResponse) {
+            return eventResponse;
+        }
+        throw new Error('Invalid decorator usage: GetEventResponse');
+    })(null);
+}
+exports.GetEventResponse = GetEventResponse;
+function GetEventRequest() {
+    return createParamDecorator((_, request) => {
+        const { eventRequest } = request;
+        if (eventRequest) {
+            return eventRequest;
+        }
+        throw new Error('Invalid decorator usage: GetEventRequest');
+    })(null);
+}
+exports.GetEventRequest = GetEventRequest;
+function GetLeaveEvent() {
+    return createParamDecorator((_, request) => {
+        const { leveeEvent } = request;
+        if (leveeEvent) {
+            return leveeEvent;
+        }
+        throw new Error('Invalid decorator usage: GetLeaveEvent');
+    })(null);
+}
+exports.GetLeaveEvent = GetLeaveEvent;
+function OnConnectionRequest() {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        const { set } = manageConnectionHandlers(target);
+        set('', (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const req = {
+                    connection: request,
+                };
+                const res = {
+                    connection: response,
+                };
+                const canProceed = yield resolveGuards(moduleRef, req, target, propertyKey);
+                if (canProceed) {
+                    const data = yield originalMethod.apply(instance, resolveParameters(req, res, target, propertyKey));
+                    if (!response.hasResponded) {
+                        if (data) {
+                            const { event, assigns } = data, rest = __rest(data, ["event", "assigns"]);
+                            if (typeof event === 'string' && isNotEmpty(rest)) {
+                                response.send(event, rest, assigns);
+                            }
+                            else {
+                                response.accept(typeof assigns === 'object' ? assigns : {});
+                            }
+                        }
+                        else {
+                            response.accept();
+                        }
+                    }
+                }
+                else {
+                    response.reject('Unauthorized', 401);
+                }
+            }
+            catch (error) {
+                if (!response.hasResponded && error instanceof Error) {
+                    response.reject(error.message);
+                }
+            }
+        }));
+    };
 }
+exports.OnConnectionRequest = OnConnectionRequest;
 function OnJoinRequest() {
     return (target, propertyKey, descriptor) => {
         const originalMethod = descriptor.value;
         const { set } = manageJoinHandlers(target);
-        set('', (instance, request, response) => __awaiter(this, void 0, void 0, function* () {
+        set('', (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const data = yield originalMethod.apply(instance, resolveJoinParameters(request, response, target, propertyKey));
-                if (!response.hasResponded) {
-                    if (data) {
-                        const { event, presence, assigns } = data, rest = __rest(data, ["event", "presence", "assigns"]);
-                        if (typeof event === 'string' && isNotEmpty(rest)) {
-                            response.send(event, rest, assigns);
+                const req = {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-expect-error
+                    joinRequest: request,
+                };
+                const res = {
+                    joinResponse: response,
+                };
+                const canProceed = yield resolveGuards(moduleRef, req, target, propertyKey);
+                if (canProceed) {
+                    const data = yield originalMethod.apply(instance, resolveParameters(req, res, target, propertyKey));
+                    if (!response.hasResponded) {
+                        if (data) {
+                            const { event, presence, assigns } = data, rest = __rest(data, ["event", "presence", "assigns"]);
+                            if (typeof event === 'string' && isNotEmpty(rest)) {
+                                response.send(event, rest, assigns);
+                            }
+                            else {
+                                response.accept(typeof assigns === 'object' ? assigns : {});
+                            }
+                            if (presence) {
+                                response.trackPresence(presence);
+                            }
                         }
                         else {
-                            response.accept(typeof assigns === 'object' ? assigns : {});
-                        }
-                        if (presence) {
-                            response.trackPresence(presence);
+                            response.accept();
                         }
                     }
-                    else {
-                        response.accept();
-                    }
+                }
+                else {
+                    response.reject('Unauthorized', 401);
                 }
             }
             catch (error) {
@@ -487,9 +479,11 @@ function OnLeaveEvent() {
     return (target, propertyKey, descriptor) => {
         const originalMethod = descriptor.value;
         const { set } = manageOnLeaveHandlers(target);
-        set('', (instance, event) => __awaiter(this, void 0, void 0, function* () {
+        set('', (instance, _, event) => __awaiter(this, void 0, void 0, function* () {
             try {
-                yield originalMethod.apply(instance, resolveLeaveParameters(event, target, propertyKey));
+                yield originalMethod.apply(instance, resolveParameters({
+                    leveeEvent: event,
+                }, {}, target, propertyKey));
             }
             catch (error) {
                 if (error instanceof Error) {
@@ -504,59 +498,42 @@ function OnEvent(event = '*') {
     return (target, propertyKey, descriptor) => {
         const originalMethod = descriptor.value;
         const { set } = manageEventHandlers(target);
-        set(event, (instance, request, response) => __awaiter(this, void 0, void 0, function* () {
+        set(event, (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const data = yield originalMethod.apply(instance, resolveEventParameters(request, response, target, propertyKey));
-                if (!response.hasResponded) {
-                    if (data) {
-                        const { event, presence, updatePresence, assigns } = data, rest = __rest(data, ["event", "presence", "updatePresence", "assigns"]);
-                        if (typeof event === 'string' && isNotEmpty(rest)) {
-                            response.send(event, rest, assigns);
+                const req = {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-expect-error
+                    eventRequest: request,
+                };
+                const res = {
+                    eventResponse: response,
+                };
+                const canProceed = yield resolveGuards(moduleRef, req, target, propertyKey);
+                if (canProceed) {
+                    const data = yield originalMethod.apply(instance, resolveParameters(req, res, target, propertyKey));
+                    if (!response.hasResponded) {
+                        if (data) {
+                            const { event, presence, updatePresence, assigns } = data, rest = __rest(data, ["event", "presence", "updatePresence", "assigns"]);
+                            if (typeof event === 'string' && isNotEmpty(rest)) {
+                                response.send(event, rest, assigns);
+                            }
+                            else {
+                                response.accept(typeof assigns === 'object' ? assigns : {});
+                            }
+                            if (presence) {
+                                response.trackPresence(presence);
+                            }
+                            else if (updatePresence) {
+                                response.updatePresence(updatePresence);
+                            }
                         }
                         else {
-                            response.accept(typeof assigns === 'object' ? assigns : {});
-                        }
-                        if (presence) {
-                            response.trackPresence(presence);
+                            response.accept();
                         }
-                        else if (updatePresence) {
-                            response.updatePresence(updatePresence);
-                        }
-                    }
-                    else {
-                        response.accept();
                     }
                 }
-            }
-            catch (error) {
-                if (!response.hasResponded && error instanceof Error) {
-                    response.reject(error.message);
-                }
-            }
-        }));
-    };
-}
-exports.OnEvent = OnEvent;
-function OnConnectionRequest() {
-    return (target, propertyKey, descriptor) => {
-        const originalMethod = descriptor.value;
-        const { set } = manageConnectionHandlers(target);
-        set('', (instance, request, response) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const data = yield originalMethod.apply(instance, resolveConnectionParameters(request, response, target, propertyKey));
-                if (!response.hasResponded) {
-                    if (data) {
-                        const { event, assigns } = data, rest = __rest(data, ["event", "assigns"]);
-                        if (typeof event === 'string' && isNotEmpty(rest)) {
-                            response.send(event, rest, assigns);
-                        }
-                        else {
-                            response.accept(typeof assigns === 'object' ? assigns : {});
-                        }
-                    }
-                    else {
-                        response.accept();
-                    }
+                else {
+                    response.reject('Unauthorized', 401);
                 }
             }
             catch (error) {
@@ -567,7 +544,7 @@ function OnConnectionRequest() {
         }));
     };
 }
-exports.OnConnectionRequest = OnConnectionRequest;
+exports.OnEvent = OnEvent;
 function ChannelInstance(name) {
     return (target, propertyKey) => {
         const { build } = manageChannelInstance(target);
@@ -589,14 +566,13 @@ function EndpointInstance() {
 exports.EndpointInstance = EndpointInstance;
 const Channel = (path = '*') => createClassDecorator(channelClassKey, path);
 exports.Channel = Channel;
-const SetEndpoint = (path = '*') => createClassDecorator(endpointClassKey, path);
-const SetChannels = (channels) => createClassDecorator(channelsClassKey, channels);
+const setEndpoint = (path = '*') => createClassDecorator(endpointClassKey, path);
+const setChannels = (channels) => createClassDecorator(channelsClassKey, channels);
 const getChannels = (target) => {
     var _a;
     return (_a = getClassMetadata(channelsClassKey, target)) !== null && _a !== void 0 ? _a : [];
 };
-// eslint-disable-next-line new-cap
-const Endpoint = (metadata) => (0, common_1.applyDecorators)(SetChannels(metadata.channels), SetEndpoint(metadata.path));
+const Endpoint = (metadata) => (0, common_1.applyDecorators)(setChannels(metadata.channels), setEndpoint(metadata.path));
 exports.Endpoint = Endpoint;
 class PondSocketService {
     constructor(moduleRef, adapterHost, endpoints) {
@@ -623,7 +599,7 @@ class PondSocketService {
             const { get } = manageConnectionHandlers(instance);
             const [handler] = get();
             if (handler) {
-                yield handler.value(instance, request, response);
+                yield handler.value(instance, this.moduleRef, request, response);
             }
             else {
                 response.accept();
@@ -644,7 +620,7 @@ class PondSocketService {
             const { get } = manageJoinHandlers(instance);
             const [handler] = get();
             if (handler) {
-                yield handler.value(instance, request, response);
+                yield handler.value(instance, this.moduleRef, request, response);
             }
             else {
                 response.accept();
@@ -655,13 +631,13 @@ class PondSocketService {
         const { set } = manageChannelInstance(instance);
         getEventHandlers().forEach((handler) => {
             channelInstance.onEvent(handler.path, (request, response) => __awaiter(this, void 0, void 0, function* () {
-                yield handler.value(instance, request, response);
+                yield handler.value(instance, this.moduleRef, request, response);
             }));
         });
         const [leaveHandler] = getLeaveHandlers();
         if (leaveHandler) {
             channelInstance.onLeave((event) => __awaiter(this, void 0, void 0, function* () {
-                yield leaveHandler.value(instance, event);
+                yield leaveHandler.value(instance, this.moduleRef, event);
             }));
         }
         set(channelInstance);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/types.d.ts

@@ -1,6 +1,6 @@
 import { Server as HTTPServer, IncomingHttpHeaders } from 'http';
 
-import { ModuleMetadata, DynamicModule } from '@nestjs/common';
+import type { ModuleMetadata, DynamicModule } from '@nestjs/common';
 import type { Express } from 'express';
 import { WebSocketServer } from 'ws';
 
@@ -87,12 +87,36 @@ interface LeaveEvent {
 
 type LeaveCallback = (event: LeaveEvent) => void;
 
+interface NestRequest {
+    connection?: IncomingConnection<string>;
+    joinRequest?: JoinRequest<string>;
+    eventRequest?: EventRequest<string>;
+    leveeEvent?: LeaveEvent;
+}
+
+interface NestResponse {
+    connection?: ConnectionResponse;
+    joinResponse?: JoinResponse;
+    eventResponse?: EventResponse;
+}
+
+type ParamDecoratorCallback<Input> = (data: Input, request: NestRequest, response: NestResponse) => unknown;
+
 interface UserData {
     assigns: PondAssigns;
     presence: PondPresence;
     id: string;
 }
 
+export interface CanActivate {
+
+    /**
+     * @desc Whether the client can continue with the request
+     * @param request - the request to check
+     */
+    canActivate(request: NestRequest): boolean | Promise<boolean>;
+}
+
 export enum ChannelState {
     IDLE = 'IDLE',
     JOINING = 'JOINING',
@@ -750,6 +774,19 @@ declare function GetConnectionHeaders(): ParameterDecorator;
  */
 declare function GetConnectionQuery(): ParameterDecorator;
 
+/**
+ * @desc The Decorator for retrieving the LeaveEvent in a handler
+ * @returns {LeaveEvent}
+ */
+declare function GetLeaveEvent(): ParameterDecorator;
+
+/**
+ * @desc Function to create a param decorator
+ * @param callback - The callback to call when the decorator is used
+ * @returns {ReturnType<callback>}
+ */
+declare function createParamDecorator<Input> (callback: ParamDecoratorCallback<Input>): ParameterDecorator;
+
 /**
  * @desc Marks a method as a handler for JoinRequest events. Throwing an error will reject the request with the error message.
  */
@@ -789,18 +826,18 @@ declare function ChannelInstance(name?: string): PropertyDecorator;
  */
 declare function EndpointInstance (): PropertyDecorator;
 
-/**
- * Decorator to mark a class as having multiple channels.
- * @param channels - The array of channels.
- */
-declare function Channels(channels: Constructor<NonNullable<unknown>>[]): ClassDecorator;
-
 /**
  * Decorator to mark a class as an endpoint.
  * @param metadata - The metadata for the endpoint.
  */
 declare function DEndpoint(metadata: EndpointMetadata): ClassDecorator;
 
+/**
+ * Decorator to add a guard to a class or method.
+ * @param guards - The guards to add.
+ */
+declare function PondGuards (...guards: Constructor<CanActivate>[]): ClassDecorator | MethodDecorator;
+
 declare class PondSocketModule {
     /**
      * @desc Creates a new PondSocketModule