@eleven-am/pondsocket 0.1.126 → 0.1.127

package/lobby/JoinRequest.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const joinRequest_1 = require("./joinRequest");
+const eventResponse_test_1 = require("../channel/eventResponse.test");
+const createMockSocket = (params = {}) => {
+    const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
+    const socket = {
+        clientId: 'sender',
+        assigns: { assign: 'assign' },
+        requestId: 'requestId',
+        channelName: 'channel',
+        socket: {
+            send: jest.fn(),
+        },
+    };
+    const request = new joinRequest_1.JoinRequest(socket, params, channelEngine);
+    return {
+        channelEngine,
+        socket,
+        request,
+    };
+};
+describe('JoinRequest', () => {
+    it('should create a new PondChannelResponse', () => {
+        const { request } = createMockSocket();
+        expect(request).toBeDefined();
+    });
+    it('should return the join params', () => {
+        const { request } = createMockSocket({ params: 'params' });
+        expect(request.joinParams).toEqual({ params: 'params' });
+    });
+    it('should return the user data', () => {
+        const { request } = createMockSocket();
+        expect(request.user).toEqual({
+            id: 'sender',
+            assigns: { assign: 'assign' },
+            presence: {},
+        });
+    });
+});

package/lobby/JoinResponse.test.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const joinResponse_1 = require("./joinResponse");
+const eventResponse_test_1 = require("../channel/eventResponse.test");
+const createPondResponse = () => {
+    const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
+    const socket = {
+        clientId: 'sender',
+        assigns: { assign: 'assign' },
+        channelName: 'channel',
+        requestId: 'requestId',
+        socket: {
+            send: jest.fn(),
+        },
+    };
+    const response = new joinResponse_1.JoinResponse(socket, channelEngine);
+    return {
+        channelEngine,
+        socket,
+        response,
+    };
+};
+describe('JoinResponse', () => {
+    it('should create a new PondChannelResponse', () => {
+        const { response } = createPondResponse();
+        expect(response).toBeDefined();
+    });
+    it('should accept the request', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+        jest.spyOn(channelEngine, 'addUser');
+        response.accept();
+        // check if the response was sent
+        expect(channelEngine.addUser).toHaveBeenCalledWith(socket.clientId, socket.assigns, expect.any(Function));
+        expect(channelEngine.getUserData(socket.clientId)).not.toBeNull();
+    });
+    it('should reject the request', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+        jest.spyOn(channelEngine, 'addUser');
+        response.reject();
+        // check if the response was sent
+        expect(channelEngine.addUser).not.toHaveBeenCalled();
+        expect(channelEngine.getUserData(socket.clientId)).toBeUndefined();
+        // also check if the socket was sent a message
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error - we are mocking the socket
+        const params = socket.socket.send.mock.calls[0][0];
+        expect(JSON.parse(params)).toEqual(expect.objectContaining({
+            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: 'Unauthorized connection',
+                code: 401,
+            },
+            channelName: 'test',
+            action: pondsocket_common_1.ServerActions.ERROR,
+        }));
+    });
+    it('should send a direct message', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+        jest.spyOn(channelEngine, 'addUser');
+        response.send('POND_MESSAGE', { message: 'message' });
+        // check if the response was sent
+        expect(channelEngine.addUser).toHaveBeenCalled();
+        expect(channelEngine.getUserData(socket.clientId)).toStrictEqual({
+            assigns: {
+                assign: 'assign',
+            },
+            id: 'sender',
+            presence: {},
+        });
+        // also check if the socket was sent a message
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error - we are mocking the socket
+        const first = socket.socket.send.mock.calls[0][0];
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error - we are mocking the socket
+        const params = socket.socket.send.mock.calls[1][0];
+        expect(JSON.parse(params)).toEqual(expect.objectContaining({
+            channelName: 'test',
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            payload: {
+                message: 'message',
+            },
+            event: 'POND_MESSAGE',
+        }));
+        expect(JSON.parse(first)).toEqual(expect.objectContaining({
+            channelName: 'test',
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            payload: {},
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+        }));
+    });
+    // auxiliary functions
+    it('should send messages to different users', () => {
+        const { response, channelEngine } = createPondResponse();
+        // spy on the channelEngine to see if any messages were published
+        const broadcast = jest.spyOn(channelEngine, 'sendMessage');
+        // add a second user to the channel
+        channelEngine.addUser('user2', { assign: 'assign' }, () => { });
+        // send a message to a single user
+        // this is because the sender does not exist in the channel yet
+        expect(() => response.sendToUsers('hello_everyone', { message: 'hello' }, ['user2'])).toThrow();
+        // clear the spy
+        broadcast.mockClear();
+        // add the sender to the channel by using the response.accept() method
+        response.accept().sendToUsers('hello_everyone', { message: 'hello' }, ['user2']);
+        // check if the message was sent
+        expect(broadcast).toHaveBeenCalledWith('requestId', 'sender', ['user2'], pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        // clear the spy
+        broadcast.mockClear();
+        // send a message to all users
+        response.broadcast('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        // clear the spy
+        broadcast.mockClear();
+        // send a message to all users except the sender
+        response.broadcastFromUser('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+    });
+    it('should be able to track the presence of users', () => {
+        const { response, channelEngine } = createPondResponse();
+        // spy on the channelEngine to see if the trackPresence method was called
+        const trackPresence = jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        // add a second user to the channel
+        response.accept()
+            .trackPresence({
+            status: 'online',
+        });
+        // check if the trackPresence method was called
+        expect(trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+    });
+    it('should throw an error if accept, reject / send is called more than once', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        jest.spyOn(channelEngine, 'addUser');
+        expect(channelEngine.addUser).not.toHaveBeenCalled();
+        response.accept();
+        expect(channelEngine.addUser).toHaveBeenCalledWith(socket.clientId, socket.assigns, expect.any(Function));
+        expect(() => response.accept()).toThrow('Request to join channel test rejected: Request already executed');
+        expect(() => response.reject()).toThrow('Request to join channel test rejected: Request already executed');
+        expect(() => response.send('event', { payload: 'payload' })).toThrow('Request to join channel test rejected: Request already executed');
+    });
+});

package/lobby/joinResponse.js

@@ -13,8 +13,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _JoinResponse_instances, _JoinResponse_user, _JoinResponse_engine, _JoinResponse_executed, _JoinResponse_performChecks;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinResponse = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const abstractResponse_1 = require("../abstracts/abstractResponse");
-const enums_1 = require("../enums");
 const pondError_1 = require("../errors/pondError");
 class JoinResponse extends abstractResponse_1.PondResponse {
     constructor(user, engine) {
@@ -41,9 +41,9 @@ class JoinResponse extends abstractResponse_1.PondResponse {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
         const newAssigns = Object.assign(Object.assign({}, assigns || {}), __classPrivateFieldGet(this, _JoinResponse_user, "f").assigns);
         const acknowledgement = {
-            action: enums_1.ServerActions.SYSTEM,
+            action: pondsocket_common_1.ServerActions.SYSTEM,
             channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
-            event: enums_1.Events.ACKNOWLEDGE,
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
             requestId: this.requestId,
             payload: {},
         };
@@ -61,13 +61,13 @@ class JoinResponse extends abstractResponse_1.PondResponse {
     reject(message, errorCode) {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
         const errorMessage = {
-            event: enums_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
             payload: {
                 message: message || 'Unauthorized connection',
                 code: errorCode || 401,
             },
             channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
-            action: enums_1.ServerActions.ERROR,
+            action: pondsocket_common_1.ServerActions.ERROR,
             requestId: this.requestId,
         };
         __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(errorMessage));
@@ -81,7 +81,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      */
     send(event, payload, assigns) {
         this.accept(assigns);
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId], enums_1.ServerActions.SYSTEM, event, payload);
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId], pondsocket_common_1.ServerActions.SYSTEM, event, payload);
         return this;
     }
     /**
@@ -90,7 +90,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @param payload - the payload to send
      */
     broadcast(event, payload) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
     /**
@@ -99,7 +99,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @param payload - the payload to send
      */
     broadcastFromUser(event, payload) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, enums_1.ChannelReceiver.ALL_EXCEPT_SENDER, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
     /**
@@ -109,7 +109,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @param userIds - the ids of the clients to send the message to
      */
     sendToUsers(event, payload, userIds) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, userIds, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, userIds, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
     /**

package/lobby/lobby.js

@@ -13,10 +13,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LobbyEngine_channels, _LobbyEngine_middleware, _LobbyEngine_leaveCallback, _PondChannel_lobby;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondChannel = exports.LobbyEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const middleware_1 = require("../abstracts/middleware");
 const channel_1 = require("../channel/channel");
-const enums_1 = require("../enums");
-const uuid_1 = require("../misc/uuid");
 class LobbyEngine {
     constructor() {
         _LobbyEngine_channels.set(this, void 0);
@@ -69,11 +68,11 @@ class LobbyEngine {
             if (!channel) {
                 throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
             }
-            channel.sendMessage((0, uuid_1.uuid)(), enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.SYSTEM, event, payload);
+            channel.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
         }
         else {
             __classPrivateFieldGet(this, _LobbyEngine_channels, "f").forEach((channel) => {
-                channel.sendMessage((0, uuid_1.uuid)(), enums_1.SystemSender.CHANNEL, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.SYSTEM, event, payload);
+                channel.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
             });
         }
     }

package/matcher/matcher.test.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcher_1 = require("./matcher");
+describe('parseAddress', () => {
+    it('should return null if a string does not match a regex and {} if it does', () => {
+        const regex = new RegExp(/^test/);
+        expect((0, matcher_1.parseAddress)(regex, 'test')).toStrictEqual({
+            params: {},
+            query: {},
+        });
+        const regex2 = new RegExp(/^test2/);
+        expect((0, matcher_1.parseAddress)(regex2, 'test')).toBe(null);
+    });
+    it('should return the params of a string matching the pattern', () => {
+        const pattern = '/test/:id';
+        const secondPattern = '/test/:id/:id2';
+        const string = '/test/5';
+        const secondString = '/test/5/6';
+        expect((0, matcher_1.parseAddress)(pattern, string))
+            .toStrictEqual({
+            params: {
+                id: '5',
+            },
+            query: {},
+        });
+        expect((0, matcher_1.parseAddress)(secondPattern, secondString))
+            .toStrictEqual({
+            params: {
+                id: '5',
+                id2: '6',
+            },
+            query: {},
+        });
+        expect((0, matcher_1.parseAddress)(pattern, secondString))
+            .toBe(null);
+        expect((0, matcher_1.parseAddress)(secondPattern, string))
+            .toBe(null);
+    });
+    it('should not match colons without slashes', () => {
+        const pattern = '/test:id';
+        const string = '/test5';
+        expect((0, matcher_1.parseAddress)(pattern, string))
+            .toBe(null);
+    });
+    it('should match when there is a *', () => {
+        const pattern = '/test/:id/*';
+        const string = '/test/5/6';
+        expect((0, matcher_1.parseAddress)(pattern, string))
+            .toStrictEqual({
+            params: {
+                id: '5',
+                '*': '/6',
+            },
+            query: {},
+        });
+        const secondPattern = '*';
+        const secondString = '/test/5/6';
+        expect((0, matcher_1.parseAddress)(secondPattern, secondString))
+            .toStrictEqual({
+            params: {
+                '*': '/test/5/6',
+            },
+            query: {},
+        });
+    });
+    it('should return the query of string', () => {
+        const pattern = '/test/:id';
+        const string = '/test/5?test=5';
+        const secondString = '/test/5?test=5&test2=6';
+        expect((0, matcher_1.parseAddress)(pattern, string))
+            .toStrictEqual({
+            params: {
+                id: '5',
+            },
+            query: {
+                test: '5',
+            },
+        });
+        expect((0, matcher_1.parseAddress)(pattern, secondString))
+            .toStrictEqual({
+            params: {
+                id: '5',
+            },
+            query: {
+                test: '5',
+                test2: '6',
+            },
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.126",
+  "version": "0.1.127",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -16,28 +16,31 @@
     "access": "public"
   },
   "scripts": {
-    "test": "jest --coverage --verbose --watchAll",
-    "build": "tsc --project tsconfig.build.json",
-    "publishToNpm": "npm version patch && npm publish"
+    "test": "jest --coverage --verbose",
+    "build": "rimraf dist && tsc && npm run remove",
+    "lint": "eslint --ext .ts src",
+    "lint:fix": "eslint --fix --ext .ts src",
+    "remove": "rm dist/dist.js dist/distIndex.js",
+    "copy": "cp src/dist.ts dist/types.d.ts && cp src/distIndex.ts dist/index.d.ts && cp package.json dist && cp README.md dist && cp LICENSE dist",
+    "push": "npm version patch && npm run copy && cd dist && npm publish && cd ..",
+    "pipeline": "npm run lint && npm run test && npm run build && npm run push"
   },
   "author": "Roy OSSAI",
   "license": "GPL-3.0",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "./index.js",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "websocket": "^1.0.34",
-    "ws": "^8.16.0"
+    "@eleven-am/pondsocket-common": "^0.0.5",
+    "ws": "^8.16.0",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@nestjs/common": "^10.3.0",
-    "@nestjs/core": "^10.3.0",
-    "@types/express": "^4.17.21",
     "@types/jest": "^29.5.11",
-    "@types/node": "^20.10.5",
+    "@types/node": "^20.10.6",
     "@types/websocket": "^1.0.10",
     "@types/ws": "^8.5.10",
     "@typescript-eslint/eslint-plugin": "^6.16.0",
@@ -45,10 +48,26 @@
     "eslint-plugin-file-progress": "^1.3.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
-    "reflect-metadata": "^0.1.14",
     "superwstest": "^2.0.3",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.test\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
   }
 }

package/presence/presence.js

@@ -13,9 +13,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _PresenceEngine_instances, _PresenceEngine_presenceMap, _PresenceEngine_channel, _PresenceEngine_publish;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresenceEngine = void 0;
-const enums_1 = require("../enums");
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const pondError_1 = require("../errors/pondError");
-const uuid_1 = require("../misc/uuid");
 class PresenceEngine {
     constructor(channel) {
         _PresenceEngine_instances.add(this);
@@ -49,7 +48,7 @@ class PresenceEngine {
     trackPresence(presenceKey, presence) {
         if (!__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").has(presenceKey)) {
             __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, presence);
-            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, enums_1.PresenceEventTypes.JOIN, {
+            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.JOIN, {
                 changed: presence,
                 presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
             });
@@ -57,7 +56,7 @@ class PresenceEngine {
         else {
             const code = 400;
             const message = `PresenceEngine: Presence with key ${presenceKey} already exists`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, enums_1.PresenceEventTypes.JOIN);
+            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.JOIN);
         }
     }
     /**
@@ -69,7 +68,7 @@ class PresenceEngine {
         const presence = __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").get(presenceKey);
         if (presence) {
             __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").delete(presenceKey);
-            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, enums_1.PresenceEventTypes.LEAVE, {
+            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.LEAVE, {
                 changed: presence,
                 presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
             });
@@ -77,7 +76,7 @@ class PresenceEngine {
         else if (!graceful) {
             const code = 404;
             const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, enums_1.PresenceEventTypes.LEAVE);
+            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.LEAVE);
         }
     }
     /**
@@ -90,7 +89,7 @@ class PresenceEngine {
         if (oldPresence) {
             const newPresence = Object.assign(Object.assign({}, oldPresence), presence);
             __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, newPresence);
-            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, enums_1.PresenceEventTypes.UPDATE, {
+            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.UPDATE, {
                 changed: newPresence,
                 presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
             });
@@ -98,7 +97,7 @@ class PresenceEngine {
         else {
             const code = 404;
             const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, enums_1.PresenceEventTypes.UPDATE);
+            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.UPDATE);
         }
     }
 }
@@ -108,5 +107,5 @@ _PresenceEngine_presenceMap = new WeakMap(), _PresenceEngine_channel = new WeakM
     if (recipients.length === 0) {
         return;
     }
-    __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage((0, uuid_1.uuid)(), enums_1.SystemSender.CHANNEL, recipients, enums_1.ServerActions.PRESENCE, event, payload);
+    __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, recipients, pondsocket_common_1.ServerActions.PRESENCE, event, payload);
 };

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);
+        });
+    });
+});