@eleven-am/pondsocket-nest 0.0.21 → 0.0.23

package/README.md

@@ -187,7 +187,7 @@ const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
         const role = getRoleFromToken(token);
 
         // Handle socket connection and authentication for valid users
-        res.accept({ role }); // Assign the user's role to the socket
+        res.accept({role}); // Assign the user's role to the socket
     } else {
         // Reject the connection for invalid users or without a token
         res.reject('Invalid token', 401);
@@ -198,9 +198,9 @@ const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
 const profanityChannel = endpoint.createChannel('/channel/:id', async (req, res) => {
     // When joining the channel, any joinParams passed from the client will be available in the request payload
     // Also any previous assigns on the socket will be available in the request payload as well
-    const { role } = req.user.assigns;
-    const { username } = req.joinParams;
-    const { id } = req.event.params;
+    const {role} = req.user.assigns;
+    const {username} = req.joinParams;
+    const {id} = req.event.params;
 
     // maybe retrieve the previous messages from the database
     const messages = await getMessagesFromDatabase(id);
@@ -208,7 +208,7 @@ const profanityChannel = endpoint.createChannel('/channel/:id', async (req, res)
     // Check if the user has the required role to join the channel
     if (role === 'admin') {
         // Accept the join request
-        res.accept({ username, profanityCount: 0 })
+        res.accept({username, profanityCount: 0})
             // optionally you can track the presence of the user in the channel
             .trackPresence({
                 username,
@@ -217,7 +217,7 @@ const profanityChannel = endpoint.createChannel('/channel/:id', async (req, res)
                 onlineSince: Date.now(),
             })
             // and send the user the channel history
-            .sendToUsers('history', { messages }, [req.user.id]);
+            .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 })
@@ -229,19 +229,19 @@ const profanityChannel = endpoint.createChannel('/channel/:id', async (req, res)
         //   });
     } else {
         // Reject the join request
-        res.reject('You do not have the required role to join this channel', 403);
+        res.decline('You do not have the required role to join this channel', 403);
     }
 });
 
 // Attach message event listener to the profanityChannel
 profanityChannel.onEvent('message', (req, res) => {
-    const { text } = req.event.payload;
+    const {text} = req.event.payload;
 
     // Check for profanity
     if (isTextProfane(text)) {
         // Reject the message if it contains profanity
-        res.reject('Profanity is not allowed', 400, {
-            profanityCount:  req.user.assigns.profanityCount + 1
+        res.decline('Profanity is not allowed', 400, {
+            profanityCount: req.user.assigns.profanityCount + 1
         });
 
         // note that profanityCount is updated so req.user.assigns.profanityCount will be updated
@@ -250,9 +250,9 @@ profanityChannel.onEvent('message', (req, res) => {
             res.evictUser('You have been kicked from the channel for using profanity');
         } else {
             // you can broadcast a message to all users or In the channel that profanity is not allowed
-            res.broadcast('profanity-warning', { message: 'Profanity is not allowed' })
+            res.broadcast('profanity-warning', {message: 'Profanity is not allowed'})
                 // or you can send a message to the user that profanity is not allowed
-                .sendToUsers('profanity-warning', { message: `You have used profanity ${profanityCount} times. You will be kicked from the channel if you use profanity more than 3 times.` }, [req.user.id]);
+                .sendToUsers('profanity-warning', {message: `You have used profanity ${profanityCount} times. You will be kicked from the channel if you use profanity more than 3 times.`}, [req.user.id]);
         }
     } else {
         // Accept the message to allow broadcasting to other clients in the channel
@@ -264,8 +264,8 @@ profanityChannel.onEvent('message', (req, res) => {
 });
 
 profanityChannel.onEvent('presence/:presence', (req, res) => {
-    const { presence } = req.event.params;
-    const { username } = req.user.assigns;
+    const {presence} = req.event.params;
+    const {username} = req.user.assigns;
 
     // Handle presence events
     res.updatePresence({
@@ -277,7 +277,7 @@ profanityChannel.onEvent('presence/:presence', (req, res) => {
 });
 
 profanityChannel.onLeave((event) => {
-    const { username } = event.assigns;
+    const {username} = event.assigns;
 
     // When a user leaves the channel, PondSocket will automatically remove the user from the presence list and inform other users in the channel
 

package/index.d.ts

@@ -1,13 +1,18 @@
 import type {
-    UserData,
-    JoinRequest,
+    Channel as PondChannel,
+    ConnectionResponse,
     EventRequest,
+    EventResponse,
     IncomingConnection,
-    Channel as PondChannel,
+    JoinRequest,
+    JoinResponse,
     LeaveEvent,
-    JoinResponse, EventResponse,
-    ConnectionResponse,
-    PondEvenType, PondEvent, PondMessage, PondPresence, PondAssigns,
+    PondAssigns,
+    PondEvent,
+    PondEvenType,
+    PondMessage,
+    PondPresence,
+    UserData,
 } from '@eleven-am/pondsocket/types';
 import type { DynamicModule, ModuleMetadata } from '@nestjs/common';
 
@@ -35,9 +40,11 @@ type NestFuncType<Event extends string, Payload extends PondMessage, Presence ex
     broadcast?: Event;
     assigns?: Assigns;
     presence?: Presence;
+    subscribeTo?: string[];
+    unsubscribeFrom?: string[];
 } & Payload;
 
-type NestReturnType<EventType extends PondEvenType, Event extends keyof EventType, Presence extends PondPresence = PondPresence, Assigns extends PondAssigns = PondAssigns> =
+type PondResponse<EventType extends PondEvenType, Event extends keyof EventType, Presence extends PondPresence = PondPresence, Assigns extends PondAssigns = PondAssigns> =
     Event extends string ?
         EventType[Event] extends [PondMessage, PondMessage] ? NestFuncType<Event, EventType[Event][1], Presence, Assigns> :
             EventType[Event] extends PondMessage ? NestFuncType<Event, EventType[Event], Presence, Assigns> :

package/modules/pondSocket.js

@@ -1,23 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocketModule = void 0;
+const nestjs_discovery_1 = require("@golevelup/nestjs-discovery");
 // eslint-disable-next-line import/no-unresolved
 const core_1 = require("@nestjs/core");
-// eslint-disable-next-line import/no-unresolved
-const modules_container_1 = require("@nestjs/core/injector/modules-container");
-const discovery_1 = require("../services/discovery");
 const pondSocket_1 = require("../services/pondSocket");
 class PondSocketModule {
-    static forRoot({ guards = [], providers = [], imports = [], exports = [], isGlobal = false, appModuleName = 'AppModule', }) {
-        const discoveryServiceProvider = {
-            provide: discovery_1.DiscoveryService,
-            useFactory: (moduleRef) => new discovery_1.DiscoveryService(moduleRef, appModuleName),
-            inject: [modules_container_1.ModulesContainer, core_1.HttpAdapterHost],
-        };
+    static forRoot({ guards = [], providers = [], imports = [], exports = [], isGlobal = false, }) {
         const pondSocketProvider = {
             provide: pondSocket_1.PondSocketService,
             useFactory: (moduleRef, adapterHost, discovery) => new pondSocket_1.PondSocketService(moduleRef, discovery, adapterHost, guards),
-            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, discovery_1.DiscoveryService],
+            inject: [core_1.ModuleRef, core_1.HttpAdapterHost, nestjs_discovery_1.DiscoveryModule],
         };
         return {
             imports,
@@ -25,7 +18,6 @@ class PondSocketModule {
             global: isGlobal,
             module: PondSocketModule,
             providers: [
-                discoveryServiceProvider,
                 pondSocketProvider,
                 ...providers,
                 ...guards,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket-nest",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -28,18 +28,19 @@
     "pipeline": "npm run lint && npm run build && npm run push"
   },
   "dependencies": {
-    "@eleven-am/pondsocket": "^0.1.141"
+    "@eleven-am/pondsocket": "^0.1.145",
+    "@golevelup/nestjs-discovery": "^4.0.0"
   },
   "devDependencies": {
-    "@nestjs/common": "^10.3.0",
-    "@nestjs/core": "^10.3.0",
-    "@types/jest": "^29.5.11",
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@nestjs/common": "^10.3.3",
+    "@nestjs/core": "^10.3.3",
+    "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
     "eslint-plugin-file-progress": "^1.3.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
-    "prettier": "^3.2.4",
-    "ts-jest": "^29.1.1",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3"

package/performers/action.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.performAction = void 0;
 const guards_1 = require("./guards");
+const narrow_1 = require("./narrow");
 const response_1 = require("./response");
 const context_1 = require("../context/context");
 const parametres_1 = require("../managers/parametres");
@@ -31,15 +32,15 @@ function performAction(instance, moduleRef, originalMethod, propertyKey, leaveEv
         const req = {};
         const res = {};
         if (request && response) {
-            if ('joinParams' in request && 'broadcast' in response && !('sendOnly' in response)) {
+            if ((0, narrow_1.isJoinRequest)(request) && (0, narrow_1.isJoinResponse)(response)) {
                 req.joinRequest = request;
                 res.joinResponse = response;
             }
-            else if ('channel' in request && 'sendOnly' in response) {
+            else if ((0, narrow_1.isEventRequest)(request) && (0, narrow_1.isEventResponse)(response)) {
                 req.eventRequest = request;
                 res.eventResponse = response;
             }
-            else if ('headers' in request) {
+            else if ((0, narrow_1.isConnectionRequest)(request) && (0, narrow_1.isConnectionResponse)(response)) {
                 req.connection = request;
                 res.connection = response;
             }
@@ -53,10 +54,10 @@ function performAction(instance, moduleRef, originalMethod, propertyKey, leaveEv
         const canProceed = yield (0, guards_1.performGuards)(moduleRef, context);
         if (canProceed) {
             const data = yield originalMethod.apply(instance, retrieveParameters(context));
-            (0, response_1.performResponse)(data, socketId, channel, response);
+            (0, response_1.performResponse)(socketId, channel, data, response);
         }
-        else if (response) {
-            response.reject('Unauthorized', 401);
+        else if (response && ((0, narrow_1.isJoinResponse)(response) || (0, narrow_1.isConnectionResponse)(response))) {
+            response.decline('Unauthorized', 403);
         }
     });
 }

package/performers/errors.js

@@ -3,15 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.performErrors = void 0;
 // eslint-disable-next-line import/no-unresolved
 const common_1 = require("@nestjs/common");
+const narrow_1 = require("./narrow");
 function performErrors(error, response) {
+    let message;
+    let status;
+    if (error instanceof common_1.HttpException) {
+        message = error.message;
+        status = error.getStatus();
+    }
+    else if (error instanceof Error) {
+        message = error.message;
+        status = 500;
+    }
+    else {
+        message = 'An unknown error occurred';
+        status = 500;
+    }
     if (response.hasResponded) {
         return response;
     }
-    if (error instanceof common_1.HttpException) {
-        return response.reject(error.message, error.getStatus());
-    }
-    if (error instanceof Error) {
-        return response.reject(error.message, 500);
+    if ((0, narrow_1.isEventResponse)(response)) {
+        return response.reply('UNKNOWN_ERROR', {
+            message,
+            status,
+        });
     }
+    return response.decline(message, status);
 }
 exports.performErrors = performErrors;

package/performers/narrow.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConnectionResponse = exports.isJoinResponse = exports.isEventResponse = exports.isConnectionRequest = exports.isJoinRequest = exports.isEventRequest = void 0;
+function isEventRequest(request) {
+    return 'channel' in request && !('joinParams' in request);
+}
+exports.isEventRequest = isEventRequest;
+function isJoinRequest(request) {
+    return 'joinParams' in request;
+}
+exports.isJoinRequest = isJoinRequest;
+function isConnectionRequest(request) {
+    return 'headers' in request;
+}
+exports.isConnectionRequest = isConnectionRequest;
+function isEventResponse(response) {
+    return !('accept' in response);
+}
+exports.isEventResponse = isEventResponse;
+function isJoinResponse(response) {
+    return 'accept' in response && 'broadcast' in response;
+}
+exports.isJoinResponse = isJoinResponse;
+function isConnectionResponse(response) {
+    return 'accept' in response && !('broadcast' in response);
+}
+exports.isConnectionResponse = isConnectionResponse;

package/performers/response.js

@@ -12,43 +12,59 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.performResponse = void 0;
+const narrow_1 = require("./narrow");
 function isNotEmpty(value) {
     return value !== null &&
         value !== undefined &&
         value !== '' &&
         Object.keys(value).length !== 0;
 }
-function performResponse(data, socketId, channel, response) {
+function performResponse(socketId, channel, data, response) {
     if (response && response.hasResponded || !isNotEmpty(data)) {
         return;
     }
-    const { event, presence, assigns, broadcast } = data, rest = __rest(data, ["event", "presence", "assigns", "broadcast"]);
+    const { event, presence, assigns, broadcast, subscribeTo, unsubscribeFrom } = data, rest = __rest(data, ["event", "presence", "assigns", "broadcast", "subscribeTo", "unsubscribeFrom"]);
     if (response) {
-        if (event && typeof event === 'string' && isNotEmpty(rest)) {
-            if ('sendOnly' in response) {
-                response.sendOnly(event, rest, assigns);
+        if ((0, narrow_1.isConnectionResponse)(response) || (0, narrow_1.isJoinResponse)(response)) {
+            response
+                .assign(typeof assigns === 'object' ? assigns : {})
+                .accept();
+        }
+        else {
+            response
+                .assign(typeof assigns === 'object' ? assigns : {});
+        }
+        if (isNotEmpty(rest)) {
+            if (event) {
+                response.reply(event, rest);
             }
-            else {
-                response.send(event, rest, assigns);
+            if (broadcast && ((0, narrow_1.isJoinResponse)(response) || (0, narrow_1.isEventResponse)(response))) {
+                response.broadcast(broadcast, rest);
             }
         }
-        else if (isNotEmpty(assigns)) {
-            response.accept(assigns);
+        if (subscribeTo) {
+            subscribeTo.forEach((channelName) => {
+                response.subscribeTo(channelName);
+            });
         }
-        if (broadcast && typeof broadcast === 'string' && isNotEmpty(rest) && 'broadcast' in response) {
-            response.broadcast(broadcast, rest);
+        if (unsubscribeFrom) {
+            unsubscribeFrom.forEach((channelName) => {
+                response.unsubscribeFrom(channelName);
+            });
         }
     }
-    else if (channel && broadcast && typeof broadcast === 'string' && isNotEmpty(rest)) {
-        channel.broadcastMessage(broadcast, rest);
-    }
-    if (presence && isNotEmpty(presence) && channel) {
-        const existingPresence = channel.getPresences()[socketId];
-        if (existingPresence) {
-            channel.updatePresence(socketId, presence);
+    else if (channel) {
+        if (isNotEmpty(rest) && broadcast) {
+            channel.broadcast(broadcast, rest);
         }
-        else if (response) {
-            channel.trackPresence(socketId, presence);
+        if (isNotEmpty(presence)) {
+            const existingPresence = channel.getPresences()[socketId];
+            if (existingPresence) {
+                channel.updatePresence(socketId, presence);
+            }
+            else {
+                channel.trackPresence(socketId, presence);
+            }
         }
     }
 }

package/services/pondSocket.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocketService = void 0;
 const http_1 = require("http");
 const pondsocket_1 = __importDefault(require("@eleven-am/pondsocket"));
+const constants_1 = require("../constants");
 const channel_1 = require("../managers/channel");
 const channelInstance_1 = require("../managers/channelInstance");
 const connection_1 = require("../managers/connection");
@@ -38,7 +39,7 @@ class PondSocketService {
     }
     init(httpAdapter) {
         return __awaiter(this, void 0, void 0, function* () {
-            const groupedInstances = yield this.buildInstances();
+            const groupedInstances = yield this.getGroupedInstances();
             const app = httpAdapter.getInstance();
             const server = (0, http_1.createServer)(app);
             const socket = new pondsocket_1.default(server);
@@ -48,31 +49,6 @@ class PondSocketService {
             return socket;
         });
     }
-    buildInstances() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const modules = yield this.discovery.groupToModules();
-            const values = [...modules.values()];
-            const channelsWithNoEndpoint = values.filter((value) => value.endpoints.length === 0 && value.channels.length > 0);
-            const channelsWithEndpoint = values.filter((value) => value.endpoints.length > 0 && value.channels.length > 0);
-            const groupedInstances = channelsWithEndpoint.map((group) => group.endpoints.map((endpoint) => ({
-                endpoint,
-                channels: group.channels,
-            }))).flat();
-            if (channelsWithNoEndpoint.length > 0) {
-                const appModule = yield this.discovery.getAppModule();
-                const value = modules.get(appModule.dependencyType);
-                if (value && value.endpoints.length > 0) {
-                    value.endpoints.forEach((endpoint) => {
-                        groupedInstances.push({
-                            endpoint,
-                            channels: channelsWithNoEndpoint.map((group) => group.channels).flat(),
-                        });
-                    });
-                }
-            }
-            return groupedInstances;
-        });
-    }
     manageEndpoint(socket, groupedInstance) {
         const instance = groupedInstance.endpoint.instance;
         const constructor = instance.constructor;
@@ -134,5 +110,49 @@ class PondSocketService {
             }));
         }
     }
+    getGroupedInstances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoints = yield this.discovery.providersWithMetaAtKey(constants_1.endpointKey);
+            const channels = yield this.discovery.providersWithMetaAtKey(constants_1.channelKey);
+            const modules = new Map();
+            endpoints.forEach((endpoint) => {
+                const module = endpoint.discoveredClass.parentModule.injectType;
+                if (!modules.has(module)) {
+                    modules.set(module, {
+                        endpoints: [],
+                        channels: [],
+                    });
+                }
+                modules.get(module).endpoints.push(endpoint.discoveredClass.instance);
+            });
+            channels.forEach((channel) => {
+                const module = channel.discoveredClass.parentModule.injectType;
+                if (!modules.has(module)) {
+                    modules.set(module, {
+                        endpoints: [],
+                        channels: [],
+                    });
+                }
+                modules.get(module).channels.push(channel.discoveredClass.instance);
+            });
+            const instances = [...modules.values()];
+            const channelsWithNoEndpoints = instances.filter((instance) => instance.channels.length > 0 && instance.endpoints.length === 0);
+            const channelsWithEndpoints = instances.filter((instance) => instance.channels.length > 0 && instance.endpoints.length > 0);
+            const groupedInstances = channelsWithEndpoints.map((instance) => instance.endpoints.map((endpoint) => ({
+                endpoint,
+                channels: instance.channels,
+            }))).flat();
+            const baseEndpoint = endpoints.find((endpoint) => endpoint.discoveredClass.parentModule.name === 'AppModule');
+            const baseEndpointInstance = groupedInstances.find((groupedInstance) => groupedInstance.endpoint.instance === (baseEndpoint === null || baseEndpoint === void 0 ? void 0 : baseEndpoint.discoveredClass.instance));
+            if (channelsWithNoEndpoints.length > 0 && baseEndpointInstance) {
+                const channels = channelsWithNoEndpoints.map((instance) => instance.channels).flat();
+                baseEndpointInstance.channels.push(...channels);
+            }
+            else if (channelsWithNoEndpoints.length > 0) {
+                throw new Error('No base endpoint found');
+            }
+            return groupedInstances;
+        });
+    }
 }
 exports.PondSocketService = PondSocketService;