@eleven-am/pondsocket 0.1.95 → 0.1.96

package/nest.js

@@ -37,6 +37,72 @@ const endpointClassKey = Symbol('endpoint');
 const channelsClassKey = Symbol('channels');
 const parametersKey = Symbol('generalParametersKey');
 const pondGuardsKey = Symbol('pondGuardsKey');
+class Context {
+    constructor(request, response, instance, propertyKey) {
+        this.request = request;
+        this.response = response;
+        this.instance = instance;
+        this.propertyKey = propertyKey;
+        this.data = {};
+    }
+    get joinRequest() {
+        var _a;
+        return (_a = this.request.joinRequest) !== null && _a !== void 0 ? _a : null;
+    }
+    get eventRequest() {
+        var _a;
+        return (_a = this.request.eventRequest) !== null && _a !== void 0 ? _a : null;
+    }
+    get connection() {
+        var _a;
+        return (_a = this.request.connection) !== null && _a !== void 0 ? _a : null;
+    }
+    get leveeEvent() {
+        var _a;
+        return (_a = this.request.leveeEvent) !== null && _a !== void 0 ? _a : null;
+    }
+    get joinResponse() {
+        var _a;
+        return (_a = this.response.joinResponse) !== null && _a !== void 0 ? _a : null;
+    }
+    get eventResponse() {
+        var _a;
+        return (_a = this.response.eventResponse) !== null && _a !== void 0 ? _a : null;
+    }
+    get connectionResponse() {
+        var _a;
+        return (_a = this.response.connection) !== null && _a !== void 0 ? _a : null;
+    }
+    get user() {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this.joinRequest) === null || _a === void 0 ? void 0 : _a.user) !== null && _b !== void 0 ? _b : (_c = this.eventRequest) === null || _c === void 0 ? void 0 : _c.user) !== null && _d !== void 0 ? _d : null;
+    }
+    get channel() {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this.joinRequest) === null || _a === void 0 ? void 0 : _a.channel) !== null && _b !== void 0 ? _b : (_c = this.eventRequest) === null || _c === void 0 ? void 0 : _c.channel) !== null && _d !== void 0 ? _d : null;
+    }
+    get presence() {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this.joinRequest) === null || _a === void 0 ? void 0 : _a.presence) !== null && _b !== void 0 ? _b : (_c = this.eventRequest) === null || _c === void 0 ? void 0 : _c.presence) !== null && _d !== void 0 ? _d : null;
+    }
+    get event() {
+        var _a, _b, _c;
+        return (_c = (_b = ((_a = this.joinRequest) !== null && _a !== void 0 ? _a : this.eventRequest)) === null || _b === void 0 ? void 0 : _b.event) !== null && _c !== void 0 ? _c : null;
+    }
+    retrieveClassData(key) {
+        return manageClassData(key, this.instance.constructor).get();
+    }
+    retrieveMethodData(key) {
+        return manageMethodData(key, this.instance, this.propertyKey).get();
+    }
+    addData(key, value) {
+        this.data[key] = value;
+    }
+    getData(key) {
+        var _a;
+        return (_a = this.data[key]) !== null && _a !== void 0 ? _a : null;
+    }
+}
 function isNotEmpty(value) {
     return value !== null &&
         value !== undefined &&
@@ -145,7 +211,7 @@ function PondGuards(...guards) {
     };
 }
 exports.PondGuards = PondGuards;
-function resolveGuards(moduleRef, request, target, propertyKey) {
+function resolveGuards(moduleRef, context) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const retrieveGuard = (Guard) => {
@@ -157,12 +223,11 @@ function resolveGuards(moduleRef, request, target, propertyKey) {
                 return new Guard();
             }
         };
-        const { get: getClassGuards } = manageClassData(pondGuardsKey, target.constructor);
-        const { get: getMethodGuards } = manageMethodData(pondGuardsKey, target, propertyKey);
-        const classGuards = (_a = getClassGuards()) !== null && _a !== void 0 ? _a : [];
-        const methodGuards = (_b = getMethodGuards()) !== null && _b !== void 0 ? _b : [];
+        const classGuards = (_a = context.retrieveClassData(pondGuardsKey)) !== null && _a !== void 0 ? _a : [];
+        const methodGuards = (_b = context.retrieveMethodData(pondGuardsKey)) !== null && _b !== void 0 ? _b : [];
         const instances = [...classGuards, ...methodGuards].map((guard) => retrieveGuard(guard));
-        const promises = instances.map((instance) => instance.canActivate(request));
+        // @ts-ignore
+        const promises = instances.map((instance) => instance.canActivate(context));
         const results = yield Promise.all(promises);
         return results.every((result) => result);
     });
@@ -188,15 +253,17 @@ function manageEndpointInstance(target) {
 function createParamDecorator(callback) {
     return (data) => (target, propertyKey, index) => {
         const { set } = manageParameters(target, propertyKey);
-        set(index, (request, response) => callback(data, request, response));
+        // @ts-ignore
+        set(index, (context) => callback(data, context));
     };
 }
 exports.createParamDecorator = createParamDecorator;
-function resolveParameters(request, response, target, propertyKey) {
-    const { get } = manageParameters(target, propertyKey);
-    const values = get()
+function resolveParameters(context) {
+    var _a;
+    const gottenValues = (_a = context.retrieveMethodData(parametersKey)) !== null && _a !== void 0 ? _a : [];
+    const values = gottenValues
         .map(({ callback, index }) => ({
-        value: callback(request, response),
+        value: callback(context),
         index,
     }));
     return values
@@ -204,197 +271,184 @@ function resolveParameters(request, response, target, propertyKey) {
         .map(({ value }) => value);
 }
 function GetUserData() {
-    return createParamDecorator((_, request) => {
-        const { joinRequest, eventRequest } = request;
-        if (joinRequest) {
-            return joinRequest.user;
-        }
-        else if (eventRequest) {
-            return eventRequest.user;
+    return createParamDecorator((_, context) => {
+        const userData = context.user;
+        if (!userData) {
+            throw new Error('Invalid decorator usage: GetUserData');
         }
-        throw new Error('Invalid decorator usage: GetUserData');
+        return userData;
     })(null);
 }
 exports.GetUserData = GetUserData;
 function GetInternalChannel() {
-    return createParamDecorator((_, request) => {
-        const { joinRequest, eventRequest } = request;
-        if (joinRequest) {
-            return joinRequest.channel;
+    return createParamDecorator((_, context) => {
+        const channel = context.channel;
+        if (!channel) {
+            throw new Error('Invalid decorator usage: GetInternalChannel');
         }
-        else if (eventRequest) {
-            return eventRequest.channel;
-        }
-        throw new Error('Invalid decorator usage: GetInternalChannel');
+        return channel;
     })(null);
 }
 exports.GetInternalChannel = GetInternalChannel;
 function GetUserPresences() {
-    return createParamDecorator((_, request) => {
-        const { joinRequest, eventRequest } = request;
-        if (joinRequest) {
-            return joinRequest.presence;
-        }
-        else if (eventRequest) {
-            return eventRequest.presence;
+    return createParamDecorator((_, context) => {
+        const presences = context.presence;
+        if (!presences) {
+            throw new Error('Invalid decorator usage: GetUserPresences');
         }
-        throw new Error('Invalid decorator usage: GetUserPresences');
+        return presences;
     })(null);
 }
 exports.GetUserPresences = GetUserPresences;
 function GetConnectionRequest() {
-    return createParamDecorator((_, request) => {
-        const { connection } = request;
-        if (connection) {
-            return connection;
+    return createParamDecorator((_, context) => {
+        const connection = context.connection;
+        if (!connection) {
+            throw new Error('Invalid decorator usage: GetConnectionRequest');
         }
-        throw new Error('Invalid decorator usage: GetConnectionRequest');
+        return connection;
     })(null);
 }
 exports.GetConnectionRequest = GetConnectionRequest;
 function GetConnectionResponse() {
-    return createParamDecorator((_, __, response) => {
-        const { connection } = response;
-        if (connection) {
-            return connection;
+    return createParamDecorator((_, context) => {
+        const response = context.connectionResponse;
+        if (!response) {
+            throw new Error('Invalid decorator usage: GetConnectionResponse');
         }
-        throw new Error('Invalid decorator usage: GetConnectionResponse');
+        return response;
     })(null);
 }
 exports.GetConnectionResponse = GetConnectionResponse;
 function GetConnectionRequestId() {
-    return createParamDecorator((_, request) => {
-        const { connection } = request;
-        if (connection) {
-            return connection.id;
+    return createParamDecorator((_, context) => {
+        const connection = context.connection;
+        if (!connection) {
+            throw new Error('Invalid decorator usage: GetConnectionRequestId');
         }
-        throw new Error('Invalid decorator usage: GetConnectionRequestId');
+        return connection.id;
     })(null);
 }
 exports.GetConnectionRequestId = GetConnectionRequestId;
 function GetConnectionParams() {
-    return createParamDecorator((_, request) => {
-        const { connection } = request;
-        if (connection) {
-            return connection.params;
+    return createParamDecorator((_, context) => {
+        const connection = context.connection;
+        if (!connection) {
+            throw new Error('Invalid decorator usage: GetConnectionParams');
         }
-        throw new Error('Invalid decorator usage: GetConnectionParams');
+        return connection.params;
     })(null);
 }
 exports.GetConnectionParams = GetConnectionParams;
 function GetConnectionHeaders() {
-    return createParamDecorator((_, request) => {
-        const { connection } = request;
-        if (connection) {
-            return connection.headers;
+    return createParamDecorator((_, context) => {
+        const connection = context.connection;
+        if (!connection) {
+            throw new Error('Invalid decorator usage: GetConnectionHeaders');
         }
-        throw new Error('Invalid decorator usage: GetConnectionHeaders');
+        return connection.headers;
     })(null);
 }
 exports.GetConnectionHeaders = GetConnectionHeaders;
 function GetConnectionQuery() {
-    return createParamDecorator((_, request) => {
-        const { connection } = request;
-        if (connection) {
-            return connection.query;
+    return createParamDecorator((_, context) => {
+        const connection = context.connection;
+        if (!connection) {
+            throw new Error('Invalid decorator usage: GetConnectionQuery');
         }
-        throw new Error('Invalid decorator usage: GetConnectionQuery');
+        return connection.query;
     })(null);
 }
 exports.GetConnectionQuery = GetConnectionQuery;
 function GetJoinRequest() {
-    return createParamDecorator((_, request) => {
-        const { joinRequest } = request;
-        if (joinRequest) {
-            return joinRequest;
+    return createParamDecorator((_, context) => {
+        const joinRequest = context.joinRequest;
+        if (!joinRequest) {
+            throw new Error('Invalid decorator usage: GetJoinRequest');
         }
-        throw new Error('Invalid decorator usage: GetJoinRequest');
+        return joinRequest;
     })(null);
 }
 exports.GetJoinRequest = GetJoinRequest;
 function GetJoinResponse() {
-    return createParamDecorator((_, __, response) => {
-        const { joinResponse } = response;
-        if (joinResponse) {
-            return joinResponse;
+    return createParamDecorator((_, context) => {
+        const joinResponse = context.joinResponse;
+        if (!joinResponse) {
+            throw new Error('Invalid decorator usage: GetJoinResponse');
         }
-        throw new Error('Invalid decorator usage: GetJoinResponse');
+        return joinResponse;
     })(null);
 }
 exports.GetJoinResponse = GetJoinResponse;
 function GetJoinParams() {
-    return createParamDecorator((_, request) => {
-        const { joinRequest } = request;
-        if (joinRequest) {
-            return joinRequest.joinParams;
+    return createParamDecorator((_, context) => {
+        const joinRequest = context.joinRequest;
+        if (!joinRequest) {
+            throw new Error('Invalid decorator usage: GetJoinParams');
         }
-        throw new Error('Invalid decorator usage: GetJoinParams');
+        return joinRequest.joinParams;
     })(null);
 }
 exports.GetJoinParams = GetJoinParams;
 function GetEventPayload() {
     return createParamDecorator((_, request) => {
-        const { eventRequest } = request;
-        if (eventRequest) {
-            return eventRequest.event.payload;
+        const eventRequest = request.eventRequest;
+        if (!eventRequest) {
+            throw new Error('Invalid decorator usage: GetEventPayload');
         }
-        throw new Error('Invalid decorator usage: GetEventPayload');
+        return eventRequest.event.payload;
     })(null);
 }
 exports.GetEventPayload = GetEventPayload;
 function GetEventParams() {
-    return createParamDecorator((_, request) => {
-        const { eventRequest, joinRequest } = request;
-        if (eventRequest) {
-            return eventRequest.event.params;
-        }
-        else if (joinRequest) {
-            return joinRequest.event.params;
+    return createParamDecorator((_, context) => {
+        var _a;
+        const params = (_a = context.event) === null || _a === void 0 ? void 0 : _a.params;
+        if (!params) {
+            throw new Error('Invalid decorator usage: GetEventParams');
         }
-        throw new Error('Invalid decorator usage: GetEventParams');
+        return params;
     })(null);
 }
 exports.GetEventParams = GetEventParams;
 function GetEventQuery() {
     return createParamDecorator((_, request) => {
-        const { eventRequest, joinRequest } = request;
-        if (eventRequest) {
-            return eventRequest.event.query;
-        }
-        else if (joinRequest) {
-            return joinRequest.event.query;
+        var _a;
+        const query = (_a = request.event) === null || _a === void 0 ? void 0 : _a.query;
+        if (!query) {
+            throw new Error('Invalid decorator usage: GetEventQuery');
         }
-        throw new Error('Invalid decorator usage: GetEventQuery');
+        return query;
     })(null);
 }
 exports.GetEventQuery = GetEventQuery;
 function GetEventResponse() {
-    return createParamDecorator((_, __, response) => {
-        const { eventResponse } = response;
-        if (eventResponse) {
-            return eventResponse;
+    return createParamDecorator((_, context) => {
+        const response = context.eventResponse;
+        if (!response) {
+            throw new Error('Invalid decorator usage: GetEventResponse');
         }
-        throw new Error('Invalid decorator usage: GetEventResponse');
+        return response;
     })(null);
 }
 exports.GetEventResponse = GetEventResponse;
 function GetEventRequest() {
-    return createParamDecorator((_, request) => {
-        const { eventRequest } = request;
-        if (eventRequest) {
-            return eventRequest;
+    return createParamDecorator((_, context) => {
+        const request = context.eventRequest;
+        if (!request) {
+            throw new Error('Invalid decorator usage: GetEventRequest');
         }
-        throw new Error('Invalid decorator usage: GetEventRequest');
+        return request;
     })(null);
 }
 exports.GetEventRequest = GetEventRequest;
 function GetLeaveEvent() {
-    return createParamDecorator((_, request) => {
-        const { leveeEvent } = request;
-        if (leveeEvent) {
-            return leveeEvent;
+    return createParamDecorator((_, context) => {
+        const event = context.leveeEvent;
+        if (!event) {
+            throw new Error('Invalid decorator usage: GetLeaveEvent');
         }
-        throw new Error('Invalid decorator usage: GetLeaveEvent');
+        return event;
     })(null);
 }
 exports.GetLeaveEvent = GetLeaveEvent;
@@ -410,9 +464,10 @@ function OnConnectionRequest() {
                 const res = {
                     connection: response,
                 };
-                const canProceed = yield resolveGuards(moduleRef, req, instance, propertyKey);
+                const context = new Context(req, res, instance, propertyKey);
+                const canProceed = yield resolveGuards(moduleRef, context);
                 if (canProceed) {
-                    const data = yield originalMethod.apply(instance, resolveParameters(req, res, target, propertyKey));
+                    const data = yield originalMethod.apply(instance, resolveParameters(context));
                     if (!response.hasResponded) {
                         if (data) {
                             const { event, assigns } = data, rest = __rest(data, ["event", "assigns"]);
@@ -448,16 +503,15 @@ function OnJoinRequest() {
         set('', (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
             try {
                 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, instance, propertyKey);
+                const context = new Context(req, res, instance, propertyKey);
+                const canProceed = yield resolveGuards(moduleRef, context);
                 if (canProceed) {
-                    const data = yield originalMethod.apply(instance, resolveParameters(req, res, target, propertyKey));
+                    const data = yield originalMethod.apply(instance, resolveParameters(context));
                     if (!response.hasResponded) {
                         if (data) {
                             const { event, presence, assigns } = data, rest = __rest(data, ["event", "presence", "assigns"]);
@@ -496,16 +550,15 @@ function OnEvent(event = '*') {
         set(event, (instance, moduleRef, request, response) => __awaiter(this, void 0, void 0, function* () {
             try {
                 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, instance, propertyKey);
+                const context = new Context(req, res, instance, propertyKey);
+                const canProceed = yield resolveGuards(moduleRef, context);
                 if (canProceed) {
-                    const data = yield originalMethod.apply(instance, resolveParameters(req, res, target, propertyKey));
+                    const data = yield originalMethod.apply(instance, resolveParameters(context));
                     if (!response.hasResponded) {
                         if (data) {
                             const { event, presence, updatePresence, assigns } = data, rest = __rest(data, ["event", "presence", "updatePresence", "assigns"]);
@@ -546,9 +599,10 @@ function OnLeaveEvent() {
         const { set } = manageOnLeaveHandlers(target);
         set('', (instance, _, event) => __awaiter(this, void 0, void 0, function* () {
             try {
-                yield originalMethod.apply(instance, resolveParameters({
+                const context = new Context({
                     leveeEvent: event,
-                }, {}, target, propertyKey));
+                }, {}, instance, propertyKey);
+                yield originalMethod.apply(instance, resolveParameters(context));
             }
             catch (error) {
                 if (error instanceof Error) {

package/package.json

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

package/types.d.ts

@@ -87,20 +87,7 @@ 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;
+type ParamDecoratorCallback<Input> = (data: Input, context: Context) => unknown | Promise<unknown>;
 
 interface UserData {
     assigns: PondAssigns;
@@ -112,9 +99,9 @@ export interface CanActivate {
 
     /**
      * @desc Whether the client can continue with the request
-     * @param request - the request to check
+     * @param context - The context of the request
      */
-    canActivate(request: NestRequest): boolean | Promise<boolean>;
+    canActivate(context: Context): boolean | Promise<boolean>;
 }
 
 export enum ChannelState {
@@ -125,6 +112,88 @@ export enum ChannelState {
     CLOSED = 'CLOSED',
 }
 
+declare class Context {
+    /**
+     * @desc The request object, available in onJoin handlers
+     */
+    joinRequest: JoinRequest<string> | null;
+
+    /**
+     * @desc The request object, available in onEvent handlers
+     */
+    eventRequest: EventRequest<string> | null;
+
+    /**
+     * @desc The request object, available in onConnection handlers
+     */
+    connection: IncomingConnection<string> | null;
+
+    /**
+     * @desc The leave event, available in onLeave handlers
+     */
+    leveeEvent: LeaveEvent | null;
+
+    /**
+     * @desc The response object, available in onJoin handlers
+     */
+    joinResponse: JoinResponse | null;
+
+    /**
+     * @desc The response object, available in onEvent handlers
+     */
+    eventResponse: EventResponse | null;
+
+    /**
+     * @desc The response object, available in onConnection handlers
+     */
+    connectionResponse: ConnectionResponse | null;
+
+    /**
+     * @desc The user data, available in onJoin, onEvent handlers
+     */
+    user: UserData | null;
+
+    /**
+     * @desc The channel, available in onJoin, onEvent handlers
+     */
+    channel: Channel | null;
+
+    /**
+     * @desc The assigns, available in onJoin, onEvent handlers
+     */
+    presence: UserPresences | null;
+
+    /**
+     * @desc The assigns, available in onJoin, onEvent handlers
+     */
+    event: EventParams<string> | null;
+
+    /**
+     * @desc Retrieves metadata associated with the class
+     * @param key - the key to retrieve
+     */
+    public retrieveClassData<A = unknown>(key: symbol): A | null;
+
+    /**
+     * @desc Retrieves metadata associated with the method
+     * @param key - the key to retrieve
+     */
+    public retrieveMethodData<A = unknown>(key: symbol): A | null;
+
+    /**
+     * @desc Adds request data to the context
+     * @param key - the key to add
+     * @param value - the value to add
+     */
+    public addData(key: string, value: unknown): void;
+
+    /**
+     * @desc Retrieves request data from the context
+     * @param key - the key to retrieve
+     */
+    public getData<A = unknown>(key: string): A | null;
+}
+
 declare class AbstractRequest<Path extends string> {
     event: PondEvent<Path>;