@eleven-am/pondsocket 0.1.125 → 0.1.127

package/presence/presenceEngine.test.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const presence_1 = require("./presence");
+const eventResponse_test_1 = require("../channel/eventResponse.test");
+describe('PresenceEngine', () => {
+    let presenceEngine;
+    let presence;
+    let presenceKey;
+    let channel;
+    beforeEach(() => {
+        channel = (0, eventResponse_test_1.createChannelEngine)();
+        channel.addUser('presenceKey', { assign: 'assign' }, () => {
+            // do nothing
+        });
+        presenceEngine = new presence_1.PresenceEngine(channel);
+        presence = {
+            id: 'id',
+            name: 'name',
+            color: 'color',
+            type: 'type',
+            location: 'location',
+        };
+        presenceKey = 'presenceKey';
+    });
+    describe('trackPresence', () => {
+        it('should insert a presence into the presence engine', () => {
+            // spy on the channel sendMessage method
+            const sendMessage = jest.spyOn(channel, 'sendMessage');
+            presenceEngine.trackPresence(presenceKey, presence);
+            // get all the params
+            const params = sendMessage.mock.calls[0];
+            // remove the first element as it contains the request id which is random
+            params.shift();
+            expect(params).toEqual([
+                pondsocket_common_1.SystemSender.CHANNEL,
+                ['presenceKey'],
+                pondsocket_common_1.ServerActions.PRESENCE,
+                pondsocket_common_1.PresenceEventTypes.JOIN,
+                {
+                    changed: presence,
+                    presence: [presence],
+                },
+            ]);
+        });
+        it('should throw an error if the presence already exists', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
+            expect(() => presenceEngine.trackPresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} already exists`);
+        });
+    });
+    describe('updatePresence', () => {
+        it('should update a presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
+            const newPresence = {
+                id: 'id',
+                name: 'name',
+                color: 'color',
+                type: 'type',
+                location: 'location',
+            };
+            const sendMessage = jest.spyOn(channel, 'sendMessage');
+            presenceEngine.updatePresence(presenceKey, newPresence);
+            // get all the params
+            const params = sendMessage.mock.calls[0];
+            // remove the first element as it contains the request id which is random
+            params.shift();
+            expect(params).toEqual([
+                pondsocket_common_1.SystemSender.CHANNEL,
+                ['presenceKey'],
+                pondsocket_common_1.ServerActions.PRESENCE,
+                pondsocket_common_1.PresenceEventTypes.UPDATE,
+                {
+                    changed: Object.assign(Object.assign({}, presence), newPresence),
+                    presence: [newPresence],
+                },
+            ]);
+        });
+        it('should throw an error if the presence does not exist', () => {
+            expect(() => presenceEngine.updatePresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        });
+    });
+    describe('removePresence', () => {
+        it('should remove a presence from the presence engine', () => {
+            const listener = jest.spyOn(channel, 'sendMessage');
+            // before we can track a presence, we need make sure the user is in the channel
+            channel.addUser('presenceKey2', { assign: 'assign' }, () => {
+                // do nothing
+            });
+            presenceEngine.trackPresence(presenceKey, presence);
+            presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }));
+            expect(listener).toHaveBeenCalledTimes(2);
+            // clear the mock
+            listener.mockClear();
+            presenceEngine.removePresence(presenceKey);
+            expect(listener).toHaveBeenCalledTimes(1);
+            // get all the params
+            const params = listener.mock.calls[0];
+            // remove the first element as it contains the request id which is random
+            params.shift();
+            expect(params).toEqual([
+                pondsocket_common_1.SystemSender.CHANNEL,
+                ['presenceKey2'],
+                pondsocket_common_1.ServerActions.PRESENCE,
+                pondsocket_common_1.PresenceEventTypes.LEAVE,
+                {
+                    changed: presence,
+                    presence: [
+                        Object.assign(Object.assign({}, presence), { key: 'presence2' }),
+                    ],
+                },
+            ]);
+            listener.mockClear();
+            presenceEngine.removePresence('presenceKey2');
+            expect(listener).toHaveBeenCalledTimes(0);
+        });
+        it('should throw an error if the presence does not exist', () => {
+            expect(() => presenceEngine.removePresence(presenceKey)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        });
+    });
+    describe('getPresence', () => {
+        it('should return the presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
+            const data = {};
+            data[presenceKey] = presence;
+            expect(presenceEngine.getPresence()).toEqual(data);
+        });
+    });
+});

package/schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientMessageSchema = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const zod_1 = require("zod");
+exports.clientMessageSchema = zod_1.z.object({
+    event: zod_1.z.string(),
+    requestId: zod_1.z.string(),
+    channelName: zod_1.z.string(),
+    payload: zod_1.z.record(zod_1.z.any()),
+    action: zod_1.z.nativeEnum(pondsocket_common_1.ClientActions),
+    addresses: zod_1.z.union([zod_1.z.nativeEnum(pondsocket_common_1.ChannelReceiver), zod_1.z.array(zod_1.z.string())]).optional(),
+});

package/server/pondSocket.js

@@ -14,11 +14,11 @@ var _PondSocket_instances, _PondSocket_server, _PondSocket_socketServer, _PondSo
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const ws_1 = require("ws");
 const middleware_1 = require("../abstracts/middleware");
 const endpoint_1 = require("../endpoint/endpoint");
 const response_1 = require("../endpoint/response");
-const enums_1 = require("../enums");
 const matcher_1 = require("../matcher/matcher");
 class PondSocket {
     constructor(server, socketServer) {
@@ -108,9 +108,10 @@ _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _P
             __classPrivateFieldGet(this, _PondSocket_socketServer, "f").emit('connection', socket);
             __classPrivateFieldGet(this, _PondSocket_middleware, "f").run(request, socket, () => {
                 const message = {
-                    action: enums_1.ServerActions.ERROR,
-                    event: enums_1.ErrorTypes.HANDLER_NOT_FOUND,
-                    channelName: enums_1.SystemSender.ENDPOINT,
+                    action: pondsocket_common_1.ServerActions.ERROR,
+                    event: pondsocket_common_1.ErrorTypes.HANDLER_NOT_FOUND,
+                    channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+                    requestId: (0, pondsocket_common_1.uuid)(),
                     payload: {
                         message: 'No endpoint found',
                         code: 404,