@eleven-am/pondsocket-nest 0.0.60 → 0.0.62

package/README.md

@@ -190,7 +190,7 @@ const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
         res.accept({role}); // Assign the user's role to the socket
     } else {
         // Reject the connection for invalid users or without a token
-        res.decline('Invalid token', 401);
+        res.reject('Invalid token', 401);
     }
 });
 
@@ -217,7 +217,16 @@ const profanityChannel = endpoint.createChannel('/channel/:id', async (req, res)
                 onlineSince: Date.now(),
             })
             // and send the user the channel history
-            .reply('history', {messages});
+            .sendToUsers('history', {messages}, [req.user.id]);
+
+        // Alternatively, you can also send messages to the user, NOTE that the user would be automatically subscribed to the channel.
+        // res.send('history', { messages }, { username, profanityCount: 0 })
+        //   .trackPresence({
+        //       username,
+        //       role,
+        //       status: 'online',
+        //       onlineSince: Date.now(),
+        //   });
     } else {
         // Reject the join request
         res.decline('You do not have the required role to join this channel', 403);

package/helpers/createParamDecorator.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createParamDecorator = void 0;
-require("reflect-metadata");
 const parametres_1 = require("../managers/parametres");
 function createParamDecorator(callback) {
     return (data) => (target, propertyKey, index) => {
         const { set } = (0, parametres_1.manageParameters)(target, propertyKey);
-        const type = Reflect.getMetadata('design:paramtypes', target, propertyKey)[index];
-        set(index, (context) => callback(data, context, type));
+        set(index, (context) => callback(data, context));
     };
 }
 exports.createParamDecorator = createParamDecorator;

package/index.d.ts

@@ -18,7 +18,7 @@ import type { DynamicModule, ModuleMetadata } from '@nestjs/common';
 
 type Constructor<T> = new (...args: any[]) => T;
 
-type ParamDecoratorCallback<Input, ParamType> = (data: Input, context: Context, type: ParamType) => unknown | Promise<unknown>;
+type ParamDecoratorCallback<Input> = (data: Input, context: Context) => unknown | Promise<unknown>;
 
 interface CanActivate {
 
@@ -38,8 +38,7 @@ interface Metadata extends Omit<ModuleMetadata, 'controllers'> {
 type NestFuncType<Event extends string, Payload extends PondMessage, Presence extends PondPresence, Assigns extends PondAssigns = PondAssigns> = {
     event?: Event;
     broadcast?: Event;
-    broadcastFrom?: Event;
-    assigns?: Partial<Assigns>;
+    assigns?: Assigns;
     presence?: Presence;
     subscribeTo?: string[];
     unsubscribeFrom?: string[];
@@ -276,7 +275,7 @@ declare function OnConnectionRequest(): MethodDecorator;
 /**
  * @desc Method decorator that marks a method as an onEvent handler
  */
-declare function OnEvent<EventType extends PondEvenType = PondEvenType>(path?: keyof EventType): MethodDecorator;
+declare function OnEvent(path?: string): MethodDecorator;
 
 /**
  * @desc Method decorator that marks a method as an onJoin handler
@@ -292,13 +291,13 @@ 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)
  */
-declare function PondGuards (...guards: Constructor<CanActivate>[]): ClassDecorator | MethodDecorator;
+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
  */
-declare function createParamDecorator<Input, ParamType> (callback: ParamDecoratorCallback<Input, ParamType>): (data: Input) => ParameterDecorator;
+declare function createParamDecorator<Input>(callback: ParamDecoratorCallback<Input>): (data: Input) => ParameterDecorator;
 
 declare class PondSocketModule {
     static forRoot({ guards, providers, imports, exports, isGlobal, appModuleName }: Metadata): DynamicModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket-nest",
-  "version": "0.0.60",
+  "version": "0.0.62",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -28,14 +28,14 @@
     "pipeline": "npm run lint && npm run build && npm run push"
   },
   "dependencies": {
-    "@eleven-am/pondsocket": "^0.1.155",
-    "@golevelup/nestjs-discovery": "^4.0.1"
+    "@eleven-am/pondsocket": "^0.1.158",
+    "@golevelup/nestjs-discovery": "^4.0.0"
   },
   "devDependencies": {
-    "@nestjs/common": "^10.3.8",
-    "@nestjs/core": "^10.3.8",
+    "@nestjs/common": "^10.3.3",
+    "@nestjs/core": "^10.3.3",
     "@types/jest": "^29.5.12",
-    "@typescript-eslint/eslint-plugin": "^7.7.1",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
     "eslint-plugin-file-progress": "^1.3.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
@@ -43,7 +43,7 @@
     "ts-jest": "^29.1.2",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.4.5"
+    "typescript": "^5.3.3"
   },
   "jest": {
     "moduleFileExtensions": [

package/performers/action.js

@@ -16,21 +16,16 @@ const response_1 = require("./response");
 const context_1 = require("../context/context");
 const parametres_1 = require("../managers/parametres");
 function retrieveParameters(context) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const gottenValues = (_a = (0, parametres_1.manageParameters)(context.getInstance(), context.getMethod()).get()) !== null && _a !== void 0 ? _a : [];
-        const promises = gottenValues
-            .map((_b) => __awaiter(this, [_b], void 0, function* ({ callback, index }) {
-            return ({
-                value: yield callback(context),
-                index,
-            });
-        }));
-        const values = yield Promise.all(promises);
-        return values
-            .sort((a, b) => a.index - b.index)
-            .map(({ value }) => value);
-    });
+    var _a;
+    const gottenValues = (_a = (0, parametres_1.manageParameters)(context.getInstance(), context.getMethod()).get()) !== null && _a !== void 0 ? _a : [];
+    const values = gottenValues
+        .map(({ callback, index }) => ({
+        value: callback(context),
+        index,
+    }));
+    return values
+        .sort((a, b) => a.index - b.index)
+        .map(({ value }) => value);
 }
 function performAction(instance, moduleRef, originalMethod, propertyKey, leaveEvent, request, response) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -58,7 +53,7 @@ function performAction(instance, moduleRef, originalMethod, propertyKey, leaveEv
         const socketId = context.user.id;
         const canProceed = yield (0, guards_1.performGuards)(moduleRef, context);
         if (canProceed) {
-            const data = yield originalMethod.apply(instance, yield retrieveParameters(context));
+            const data = yield originalMethod.apply(instance, retrieveParameters(context));
             (0, response_1.performResponse)(socketId, channel, data, response);
         }
         else if (response && ((0, narrow_1.isJoinResponse)(response) || (0, narrow_1.isConnectionResponse)(response))) {

package/performers/errors.js

@@ -28,8 +28,6 @@ function performErrors(error, response) {
     if (!response.hasResponded) {
         return response.decline(message, status);
     }
-    if (process.env.NODE_ENV === 'development') {
-        console.error(error);
-    }
+    throw error;
 }
 exports.performErrors = performErrors;

package/performers/response.js

@@ -23,7 +23,7 @@ function performResponse(socketId, channel, data, response) {
     if (response && response.hasResponded || !isNotEmpty(data)) {
         return;
     }
-    const { event, presence, assigns, broadcast, broadcastFrom, subscribeTo, unsubscribeFrom } = data, rest = __rest(data, ["event", "presence", "assigns", "broadcast", "broadcastFrom", "subscribeTo", "unsubscribeFrom"]);
+    const { event, presence, assigns, broadcast, subscribeTo, unsubscribeFrom } = data, rest = __rest(data, ["event", "presence", "assigns", "broadcast", "subscribeTo", "unsubscribeFrom"]);
     if (response) {
         if ((0, narrow_1.isConnectionResponse)(response) || (0, narrow_1.isJoinResponse)(response)) {
             response
@@ -41,9 +41,6 @@ function performResponse(socketId, channel, data, response) {
             if (broadcast && ((0, narrow_1.isJoinResponse)(response) || (0, narrow_1.isEventResponse)(response))) {
                 response.broadcast(broadcast, rest);
             }
-            if (broadcastFrom && (0, narrow_1.isEventResponse)(response)) {
-                response.broadcastFrom(broadcastFrom, rest);
-            }
         }
         if (subscribeTo) {
             subscribeTo.forEach((channelName) => {
@@ -61,7 +58,13 @@ function performResponse(socketId, channel, data, response) {
             channel.broadcast(broadcast, rest);
         }
         if (isNotEmpty(presence)) {
-            channel.upsertPresence(socketId, presence);
+            const existingPresence = channel.getPresences()[socketId];
+            if (existingPresence) {
+                channel.updatePresence(socketId, presence);
+            }
+            else {
+                channel.trackPresence(socketId, presence);
+            }
         }
     }
 }

package/services/pondSocket.js

@@ -15,8 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocketService = void 0;
 const http_1 = require("http");
 const pondsocket_1 = __importDefault(require("@eleven-am/pondsocket"));
-// eslint-disable-next-line import/no-unresolved
-const common_1 = require("@nestjs/common");
 const constants_1 = require("../constants");
 const channel_1 = require("../managers/channel");
 const channelInstance_1 = require("../managers/channelInstance");
@@ -33,9 +31,11 @@ class PondSocketService {
         this.discovery = discovery;
         this.adapterHost = adapterHost;
         this.externalGuards = externalGuards;
-        this.logger = new common_1.Logger(PondSocketService.name);
         const httpAdapter = this.adapterHost.httpAdapter;
-        void this.init(httpAdapter);
+        httpAdapter.listen = (...args) => __awaiter(this, void 0, void 0, function* () {
+            const socket = yield this.init(httpAdapter);
+            return socket.listen(...args);
+        });
     }
     init(httpAdapter) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -46,7 +46,7 @@ class PondSocketService {
             groupedInstances.forEach((groupedInstance) => {
                 this.manageEndpoint(socket, groupedInstance);
             });
-            httpAdapter.listen = (...args) => socket.listen(...args);
+            return socket;
         });
     }
     manageEndpoint(socket, groupedInstance) {
@@ -59,10 +59,9 @@ class PondSocketService {
             return;
         }
         setGuards(this.externalGuards);
-        const { get } = (0, connection_1.manageConnection)(instance);
-        const channels = [...new Set([...groupedInstance.channels.map((channel) => channel)])];
-        const [handler] = get();
         const endpoint = socket.createEndpoint(metadata, (request, response) => __awaiter(this, void 0, void 0, function* () {
+            const { get } = (0, connection_1.manageConnection)(instance);
+            const [handler] = get();
             if (handler) {
                 yield handler.value(instance, this.moduleRef, request, response);
             }
@@ -70,14 +69,13 @@ class PondSocketService {
                 response.accept();
             }
         }));
-        this.logger.log(`Mapped {${metadata}} endpoint`);
-        if (handler) {
-            this.logger.log(`Mapped {${metadata}} connection handler`);
-        }
         setEndpoint(endpoint);
-        channels.forEach((channel) => this.manageChannel(channel, endpoint, metadata));
+        const channels = [...new Set([...groupedInstance.channels.map((channel) => channel)])];
+        channels.forEach((channel) => {
+            this.manageChannel(channel, endpoint);
+        });
     }
-    manageChannel(channel, endpoint, endpointPath) {
+    manageChannel(channel, endpoint) {
         const instance = channel.instance;
         const constructor = instance.constructor;
         const path = (0, channel_1.manageChannel)(constructor).get();
@@ -86,10 +84,10 @@ class PondSocketService {
         }
         const { set: setGuards } = (0, guards_1.manageGuards)(constructor);
         const { set: setChannel } = (0, channelInstance_1.manageChannelInstance)(instance);
-        const { get } = (0, join_1.manageJoin)(instance);
-        const [handler] = get();
         setGuards(this.externalGuards);
         const channelInstance = endpoint.createChannel(path, (request, response) => __awaiter(this, void 0, void 0, function* () {
+            const { get } = (0, join_1.manageJoin)(instance);
+            const [handler] = get();
             if (handler) {
                 yield handler.value(instance, this.moduleRef, request, response);
             }
@@ -97,10 +95,6 @@ class PondSocketService {
                 response.accept();
             }
         }));
-        this.logger.log(`Mapped {${endpointPath}:${path}} channel`);
-        if (handler) {
-            this.logger.log(`Mapped {${endpointPath}:${path}} join handler`);
-        }
         setChannel(channelInstance);
         const { get: getEventHandlers } = (0, event_1.manageEvent)(instance);
         const { get: getLeaveHandlers } = (0, leave_1.manageLeave)(instance);
@@ -108,19 +102,16 @@ class PondSocketService {
             channelInstance.onEvent(handler.path, (request, response) => __awaiter(this, void 0, void 0, function* () {
                 yield handler.value(instance, this.moduleRef, request, response);
             }));
-            this.logger.log(`Mapped {${endpointPath}:${path}} event {${handler.path}}`);
         });
         const [leaveHandler] = getLeaveHandlers();
         if (leaveHandler) {
             channelInstance.onLeave((event) => __awaiter(this, void 0, void 0, function* () {
                 yield leaveHandler.value(instance, this.moduleRef, event);
             }));
-            this.logger.log(`Mapped {${endpointPath}:${path}} leave handler`);
         }
     }
     getGroupedInstances() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const endpoints = yield this.discovery.providersWithMetaAtKey(constants_1.endpointKey);
             const channels = yield this.discovery.providersWithMetaAtKey(constants_1.channelKey);
             const modules = new Map();
@@ -151,20 +142,12 @@ class PondSocketService {
                 endpoint,
                 channels: instance.channels,
             }))).flat();
-            const baseEndpoint = endpoints.length === 1 ?
-                endpoints[0].discoveredClass :
-                (_a = endpoints
-                    .find((endpoint) => endpoint.discoveredClass.parentModule.name === 'AppModule')) === null || _a === void 0 ? void 0 : _a.discoveredClass;
-            const groupedInstanceWithBaseEndpoint = groupedInstances.find((groupedInstance) => groupedInstance.endpoint.instance === (baseEndpoint === null || baseEndpoint === void 0 ? void 0 : baseEndpoint.instance));
+            const baseEndpoint = endpoints.find((endpoint) => endpoint.discoveredClass.parentModule.name === 'AppModule');
             if (channelsWithNoEndpoints.length > 0) {
-                if (groupedInstanceWithBaseEndpoint) {
-                    const channels = channelsWithNoEndpoints.map((instance) => instance.channels).flat();
-                    groupedInstanceWithBaseEndpoint.channels = [...new Set([...groupedInstanceWithBaseEndpoint.channels, ...channels])];
-                }
-                else if (baseEndpoint) {
+                if (baseEndpoint) {
                     const channels = channelsWithNoEndpoints.map((instance) => instance.channels).flat();
                     groupedInstances.push({
-                        endpoint: baseEndpoint,
+                        endpoint: baseEndpoint.discoveredClass,
                         channels,
                     });
                 }