@eleven-am/pondsocket 0.1.125 → 0.1.127

package/endpoint/response.js

@@ -13,12 +13,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ConnectionResponse_instances, _ConnectionResponse_webSocket, _ConnectionResponse_engine, _ConnectionResponse_clientId, _ConnectionResponse_executed, _ConnectionResponse_sendMessage, _ConnectionResponse_performChecks;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionResponse = 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 ConnectionResponse extends abstractResponse_1.PondResponse {
     constructor(webSocket, engine, clientId) {
-        super();
+        super((0, pondsocket_common_1.uuid)());
         _ConnectionResponse_instances.add(this);
         _ConnectionResponse_webSocket.set(this, void 0);
         _ConnectionResponse_engine.set(this, void 0);
@@ -59,7 +59,7 @@ class ConnectionResponse extends abstractResponse_1.PondResponse {
             message: message || 'Unauthorized connection',
             code: errorCode || 401,
         };
-        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, enums_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_CONNECTION, payload);
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.UNAUTHORIZED_CONNECTION, payload);
         __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").close();
     }
     /**
@@ -70,16 +70,17 @@ class ConnectionResponse extends abstractResponse_1.PondResponse {
      */
     send(event, payload, assigns) {
         this.accept(assigns);
-        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
     }
 }
 exports.ConnectionResponse = ConnectionResponse;
 _ConnectionResponse_webSocket = new WeakMap(), _ConnectionResponse_engine = new WeakMap(), _ConnectionResponse_clientId = new WeakMap(), _ConnectionResponse_executed = new WeakMap(), _ConnectionResponse_instances = new WeakSet(), _ConnectionResponse_sendMessage = function _ConnectionResponse_sendMessage(action, event, payload) {
     const message = {
-        action,
         event,
+        action,
         payload,
-        channelName: enums_1.SystemSender.ENDPOINT,
+        requestId: this.requestId,
+        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
     };
     __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").send(JSON.stringify(message));
 }, _ConnectionResponse_performChecks = function _ConnectionResponse_performChecks() {

package/index.d.ts

@@ -1,3 +1,5 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
 import { PondSocket } from './types';
 
 export default PondSocket;

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,12 +13,12 @@ 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) {
-        super();
+        super(user.requestId);
         _JoinResponse_instances.add(this);
         _JoinResponse_user.set(this, void 0);
         _JoinResponse_engine.set(this, void 0);
@@ -41,9 +41,10 @@ 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: {},
         };
         __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(acknowledgement));
@@ -60,13 +61,14 @@ 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));
         return this;
@@ -79,7 +81,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      */
     send(event, payload, assigns) {
         this.accept(assigns);
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(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;
     }
     /**
@@ -88,7 +90,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @param payload - the payload to send
      */
     broadcast(event, payload) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(__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;
     }
     /**
@@ -97,7 +99,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @param payload - the payload to send
      */
     broadcastFromUser(event, payload) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(__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;
     }
     /**
@@ -107,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(__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,9 +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");
 class LobbyEngine {
     constructor() {
         _LobbyEngine_channels.set(this, void 0);
@@ -68,11 +68,11 @@ class LobbyEngine {
             if (!channel) {
                 throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
             }
-            channel.sendMessage(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(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.125",
+  "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,7 +13,7 @@ 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");
 class PresenceEngine {
     constructor(channel) {
@@ -48,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()),
             });
@@ -56,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);
         }
     }
     /**
@@ -68,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()),
             });
@@ -76,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);
         }
     }
     /**
@@ -89,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()),
             });
@@ -97,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);
         }
     }
 }
@@ -107,5 +107,5 @@ _PresenceEngine_presenceMap = new WeakMap(), _PresenceEngine_channel = new WeakM
     if (recipients.length === 0) {
         return;
     }
-    __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage(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);
 };