@eleven-am/pondsocket 0.1.125 → 0.1.127

package/README.md

@@ -30,18 +30,6 @@ const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
 
 // Start the server
 pond.listen(3000);
-
-// Or alternatively, working with express
-import pondSocket from "@eleven-am/pondsocket/express";
-import express from "express";
-
-const app = pondSocket(express());
-
-const endpoint = app.upgrade('/api/socket', (req, res) => {
-    // Handle socket connection and authentication
-});
-
-app.listen(3000);
 ```
 
 Within each endpoint, sockets interact through channels. Channels provide an organized way to group users and manage efficient communication among them. When users join a channel, they can participate in real-time events and exchange information with other users in the same channel.
@@ -57,7 +45,7 @@ const channel = endpoint.createChannel('/channel/:id', (req, res) => {
 On the client-side, PondSocket provides the PondClient class to establish connections with the server. Clients can easily initiate connections, join channels, and participate in real-time interactions.
 
 ```javascript
-import PondClient from "@eleven-am/pondsocket/client";
+import PondClient from "@eleven-am/pondsocket-client";
 
 const socket = new PondClient('/api/socket', {});
 socket.connect();
@@ -75,7 +63,7 @@ channel.join();
 PondSocket also offers a Node.js client, which can be imported using:
 
 ```javascript
-import PondClient from "@eleven-am/pondsocket/node";
+import PondClient from "@eleven-am/pondsocket-client";
 ```
 
 This node client allows you to turn another server into a client, enabling easy communication between different server instances.
@@ -96,7 +84,7 @@ This node client allows you to turn another server into a client, enabling easy
 To connect to the PondSocket server and send messages while associating a username with the client connection, follow the steps below:
 
 ```javascript
-import PondClient from "@eleven-am/pondsocket/client";
+import PondClient from "@eleven-am/pondsocket-client";
 
 // Your server URL
 const serverUrl = 'ws://your-server-url/api/socket';
@@ -500,6 +488,8 @@ The `ClientChannel` class represents a channel in the PondClient.
 
 - `sendMessage(event: string, payload: PondMessage, recipient: string[]): void`: Sends a message to specific clients in the channel with the specified event, payload, and recipient.
 
+- `sendForResponse(event: string, payload: PondMessage): Promise<PondMessage>`: Sends a message to the server with the specified event, payload, and returns a promise that resolves with the response.
+
 - `broadcastFrom(event: string, payload: PondMessage): void`: Broadcasts a message to every other client in the channel except yourself with the specified event and payload.
 
 - `broadcast(event: string, payload: PondMessage): void`: Broadcasts a message to the channel, including yourself, with the specified event and payload.

package/abstracts/abstractRequest.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractRequest_1 = require("./abstractRequest");
+const createMockChannelEngine = () => ({
+    name: 'test',
+    getAssigns: () => ({}),
+    getPresence: () => ({}),
+});
+describe('AbstractRequest', () => {
+    it('should be able to be instantiated', () => {
+        const request = new abstractRequest_1.AbstractRequest('/test', createMockChannelEngine(), {});
+        expect(request).toBeTruthy();
+        expect(request.channelName).toBe('test');
+        expect(request.assigns).toEqual({});
+        expect(request.presence).toEqual({});
+    });
+    it('should be able to parse queries', () => {
+        const request = new abstractRequest_1.AbstractRequest('/1234?choke=balls', createMockChannelEngine(), {});
+        expect(() => request.event).toThrowError('Event was not parsed');
+        expect(request['_parseQueries']('/:id')).toBe(true);
+        expect(request.event).toEqual({
+            event: '/1234?choke=balls',
+            params: { id: '1234' },
+            query: { choke: 'balls' },
+            payload: {},
+        });
+    });
+    it('should be return the value of the payload', () => {
+        const request = new abstractRequest_1.AbstractRequest('/test', createMockChannelEngine(), { test: 'test' });
+        expect(request['_parseQueries']('/:id')).toBe(true);
+        expect(request.event.payload).toEqual({ test: 'test' });
+        const request2 = new abstractRequest_1.AbstractRequest('/test', createMockChannelEngine(), {
+            test: 'test',
+            test2: 'test2',
+        });
+        expect(request2['_parseQueries']('/:id')).toBe(true);
+        expect(request2.event.payload).toEqual({
+            test: 'test',
+            test2: 'test2',
+        });
+    });
+});

package/abstracts/abstractResponse.js

@@ -2,5 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondResponse = void 0;
 class PondResponse {
+    constructor(requestId) {
+        this.requestId = requestId;
+    }
 }
 exports.PondResponse = PondResponse;

package/abstracts/middleware.test.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = require("./middleware");
+describe('Middleware', () => {
+    it('should be able to add middleware to the stack', () => {
+        const middleware = new middleware_1.Middleware();
+        middleware.use(() => { });
+        expect(middleware.length).toBe(1);
+    });
+    it('should be able to run middleware', () => __awaiter(void 0, void 0, void 0, function* () {
+        const middleware = new middleware_1.Middleware();
+        const mock = jest.fn();
+        middleware.use(mock);
+        yield middleware.run({}, {}, () => { });
+        expect(mock).toHaveBeenCalled();
+    }));
+    it('should be able to run multiple middleware', () => __awaiter(void 0, void 0, void 0, function* () {
+        const middleware = new middleware_1.Middleware();
+        const mock = jest.fn();
+        middleware.use((_, __, next) => {
+            mock('first');
+            next();
+        });
+        middleware.use((_, __, next) => {
+            mock('second');
+            next();
+        });
+        yield middleware.run({}, {}, () => { });
+        expect(mock).toHaveBeenCalledTimes(2);
+        expect(mock.mock.calls[0][2]).toBe(mock.mock.calls[1][2]);
+    }));
+    it('should be merge middleware in the correct order', () => {
+        const middleware = new middleware_1.Middleware();
+        const mock = jest.fn();
+        middleware.use(mock);
+        middleware.use(mock);
+        const middleware2 = new middleware_1.Middleware(middleware);
+        expect(middleware2.length).toBe(2);
+    });
+    it('should call the final function when the middleware stack is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+        const middleware = new middleware_1.Middleware();
+        const mock = jest.fn();
+        yield middleware.run({}, {}, mock);
+        expect(mock).toHaveBeenCalled();
+    }));
+    it('should be able to run middleware in the correct order when using a second middleware', () => __awaiter(void 0, void 0, void 0, function* () {
+        const middleware = new middleware_1.Middleware();
+        const mock = jest.fn();
+        middleware.use((_, __, next) => {
+            mock('first');
+            next();
+        });
+        middleware.use((_, __, next) => {
+            mock('second');
+            next();
+        });
+        const middleware2 = new middleware_1.Middleware(middleware);
+        yield middleware2.run({}, {}, () => { });
+        expect(mock.mock.calls[0][2]).toBe(mock.mock.calls[1][2]);
+    }));
+});

package/channel/channel.js

@@ -24,12 +24,11 @@ var __rest = (this && this.__rest) || function (s, e) {
 var _Channel_engine, _ChannelEngine_instances, _ChannelEngine_receiver, _ChannelEngine_presenceEngine, _ChannelEngine_users, _ChannelEngine_parentEngine, _ChannelEngine_subscribe, _ChannelEngine_getUsersFromRecipients;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelEngine = exports.Channel = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const eventRequest_1 = require("./eventRequest");
 const eventResponse_1 = require("./eventResponse");
-const enums_1 = require("../enums");
 const pondError_1 = require("../errors/pondError");
 const presence_1 = require("../presence/presence");
-const subject_1 = require("../subjects/subject");
 class Channel {
     constructor(engine) {
         _Channel_engine.set(this, void 0);
@@ -45,16 +44,16 @@ class Channel {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getUserData(userId);
     }
     broadcastMessage(event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
     }
     broadcastMessageFromUser(userId, event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, enums_1.ChannelReceiver.ALL_EXCEPT_SENDER, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage((0, pondsocket_common_1.uuid)(), userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
     }
     sendToUser(userId, event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.BROADCAST, event, payload);
     }
     sendToUsers(userIds, event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(enums_1.SystemSender.CHANNEL, userIds, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, userIds, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
     }
     evictUser(userId, reason) {
         __classPrivateFieldGet(this, _Channel_engine, "f").kickUser(userId, reason !== null && reason !== void 0 ? reason : 'You have been banned from the channel');
@@ -79,7 +78,7 @@ class ChannelEngine {
         _ChannelEngine_users.set(this, void 0);
         _ChannelEngine_parentEngine.set(this, void 0);
         this.name = name;
-        __classPrivateFieldSet(this, _ChannelEngine_receiver, new subject_1.Subject(), "f");
+        __classPrivateFieldSet(this, _ChannelEngine_receiver, new pondsocket_common_1.Subject(), "f");
         __classPrivateFieldSet(this, _ChannelEngine_users, new Map(), "f");
         __classPrivateFieldSet(this, _ChannelEngine_parentEngine, parent, "f");
     }
@@ -132,12 +131,12 @@ class ChannelEngine {
      * @param reason - The reason for kicking the user
      */
     kickUser(userId, reason) {
-        this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.SYSTEM, 'kicked_out', {
+        this.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, 'kicked_out', {
             message: reason,
             code: 403,
         });
         this.removeUser(userId);
-        this.sendMessage(enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.SYSTEM, 'kicked', {
+        this.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, 'kicked', {
             userId,
             reason,
         });
@@ -147,7 +146,7 @@ class ChannelEngine {
      * @param reason - The reason for self-destructing the channel
      */
     destroy(reason) {
-        this.sendMessage(enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.ERROR, 'destroyed', {
+        this.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.ERROR, 'destroyed', {
             message: reason !== null && reason !== void 0 ? reason : 'Channel has been destroyed',
         });
         __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").destroyChannel();
@@ -195,19 +194,21 @@ class ChannelEngine {
     }
     /**
      * @desc Sends a message to a specified set of users, from a specified sender
+     * @param requestId - The id of the request
      * @param sender - The sender of the message
      * @param recipient - The users to send the message to
      * @param action - The action of the message
      * @param event - The event name
      * @param payload - The payload of the message
      */
-    sendMessage(sender, recipient, action, event, payload) {
-        if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(sender) && sender !== enums_1.SystemSender.CHANNEL) {
+    sendMessage(requestId, sender, recipient, action, event, payload) {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(sender) && sender !== pondsocket_common_1.SystemSender.CHANNEL) {
             throw new pondError_1.ChannelError(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`, 404, this.name);
         }
         const eventMessage = {
             recipients: __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender),
             channelName: this.name,
+            requestId,
             action,
             payload,
             event,
@@ -227,14 +228,15 @@ class ChannelEngine {
             sender: userId,
             event: message.event,
             payload: message.payload,
-            action: enums_1.ServerActions.BROADCAST,
+            action: pondsocket_common_1.ServerActions.BROADCAST,
             channelName: this.name,
-            recipients: __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, message.addresses || enums_1.ChannelReceiver.ALL_USERS, userId),
+            requestId: message.requestId,
+            recipients: __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, message.addresses || pondsocket_common_1.ChannelReceiver.ALL_USERS, userId),
         };
         const request = new eventRequest_1.EventRequest(responseEvent, this);
         const response = new eventResponse_1.EventResponse(responseEvent, this);
         __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").execute(request, response, () => {
-            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], enums_1.ServerActions.ERROR, enums_1.ErrorTypes.HANDLER_NOT_FOUND, {
+            this.sendMessage(responseEvent.requestId, pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.HANDLER_NOT_FOUND, {
                 message: 'A handler did not respond to the event',
                 code: 404,
             });
@@ -268,17 +270,17 @@ _ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new Wea
     const allUsers = Array.from(__classPrivateFieldGet(this, _ChannelEngine_users, "f").keys());
     let users;
     switch (recipients) {
-        case enums_1.ChannelReceiver.ALL_USERS:
+        case pondsocket_common_1.ChannelReceiver.ALL_USERS:
             users = allUsers;
             break;
-        case enums_1.ChannelReceiver.ALL_EXCEPT_SENDER:
-            if (sender === enums_1.SystemSender.CHANNEL) {
-                throw new pondError_1.ChannelError(`ChannelEngine: Cannot use ${enums_1.ChannelReceiver.ALL_EXCEPT_SENDER} with ${enums_1.SystemSender.CHANNEL}`, 500, this.name);
+        case pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER:
+            if (sender === pondsocket_common_1.SystemSender.CHANNEL) {
+                throw new pondError_1.ChannelError(`ChannelEngine: Cannot use ${pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER} with ${pondsocket_common_1.SystemSender.CHANNEL}`, 500, this.name);
             }
             users = allUsers.filter((user) => user !== sender);
             break;
         default:
-            if (!Array.isArray(recipients) || !recipients.every((recipient) => typeof recipient === 'string')) {
+            if (!Array.isArray(recipients)) {
                 throw new pondError_1.ChannelError(`ChannelEngine: Invalid recipients ${recipients}`, 500, this.name);
             }
             if (recipients.some((user) => !allUsers.includes(user))) {