@eleven-am/pondsocket 0.1.43 → 0.1.45

package/client/channel.js

@@ -8,19 +8,18 @@ class Channel {
         this._name = name;
         this._queue = [];
         this._presence = [];
-        this._finished = false;
         this._joinParams = params;
         this._publisher = publisher;
         this._clientState = clientState;
         this._receiver = new subjectUtils_1.SimpleSubject();
-        this._joinState = new subjectUtils_1.SimpleBehaviorSubject(false);
+        this._joinState = new subjectUtils_1.SimpleBehaviorSubject(enums_1.ChannelState.IDLE);
         this._presenceSub = this._init(receiver);
     }
     /**
      * @desc Connects to the channel.
      */
     join() {
-        if (this._finished) {
+        if (this._joinState.value === enums_1.ChannelState.CLOSED) {
             throw new Error('This channel has been closed');
         }
         const joinMessage = {
@@ -29,6 +28,7 @@ class Channel {
             event: enums_1.ClientActions.JOIN_CHANNEL,
             payload: this._joinParams,
         };
+        this._joinState.next(enums_1.ChannelState.JOINING);
         if (this._clientState.value === enums_1.PondState.OPEN) {
             this._publisher(joinMessage);
         }
@@ -47,7 +47,7 @@ class Channel {
             payload: {},
         };
         this._publish(leaveMessage);
-        this._finished = true;
+        this._joinState.next(enums_1.ChannelState.CLOSED);
         this._presenceSub();
     }
     /**
@@ -143,15 +143,9 @@ class Channel {
     /**
      * @desc Gets the current connection state of the channel.
      */
-    isConnected() {
+    get channelState() {
         return this._joinState.value;
     }
-    /**
-     * @desc check is the channel has been closed.
-     */
-    hasClosed() {
-        return this._finished;
-    }
     /**
      * @desc Gets the current presence of the channel.
      */
@@ -163,7 +157,7 @@ class Channel {
      * @param callback - The callback to call when the presence changes.
      */
     onUsersChange(callback) {
-        return this._subscribeToPresence((event, payload) => callback(payload.presence));
+        return this._subscribeToPresence((_event, payload) => callback(payload.presence));
     }
     _send(event, payload, receivers = 'all_users') {
         const message = {
@@ -176,8 +170,10 @@ class Channel {
         this._publish(message);
     }
     _publish(data) {
-        if (this._joinState.value && this._clientState.value !== enums_1.PondState.OPEN) {
-            this._publisher(data);
+        if (this._clientState.value === enums_1.PondState.OPEN) {
+            if (this._joinState.value === enums_1.ChannelState.JOINED || this._joinState.value === enums_1.ChannelState.JOINING) {
+                this._publisher(data);
+            }
             return;
         }
         this._queue.push(data);
@@ -192,10 +188,10 @@ class Channel {
     _init(receiver) {
         const unsubMessages = receiver.subscribe((data) => {
             if (data.channelName === this._name) {
-                if (!this._joinState.value) {
-                    this._joinState.publish(true);
+                if (this._joinState.value !== enums_1.ChannelState.JOINED) {
+                    this._joinState.next(enums_1.ChannelState.JOINED);
                 }
-                this._receiver.publish(data);
+                this._receiver.next(data);
             }
         });
         const unsubStateChange = this._clientState.subscribe((state) => {
@@ -212,11 +208,11 @@ class Channel {
                     .forEach((message) => {
                     this._publisher(message);
                 });
-                this._joinState.publish(true);
+                this._joinState.next(enums_1.ChannelState.JOINED);
                 this._queue = [];
             }
             else if (state !== enums_1.PondState.OPEN) {
-                this._joinState.publish(false);
+                this._joinState.next(enums_1.ChannelState.STALLED);
             }
         });
         const unsubPresence = this._subscribeToPresence((_, payload) => {

package/client/channel.test.js

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const channel_1 = require("./channel");
+const enums_1 = require("../enums");
+const channelEngine_1 = require("../server/channel/channelEngine");
+const subjectUtils_1 = require("../server/utils/subjectUtils");
+const createChannel = (params) => {
+    const publisher = jest.fn();
+    const state = new subjectUtils_1.SimpleBehaviorSubject(enums_1.PondState.OPEN);
+    const receiver = new subjectUtils_1.SimpleSubject();
+    const channel = new channel_1.Channel(publisher, state, 'test', receiver, params);
+    return {
+        channel,
+        publisher,
+        state,
+        receiver,
+    };
+};
+describe('Channel', () => {
+    it('should correctly send a join message', () => {
+        const { channel, publisher, state } = createChannel();
+        expect(publisher).not.toHaveBeenCalled();
+        expect(state.value).toBe(enums_1.PondState.OPEN);
+        channel.join();
+        expect(publisher).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.JOIN_CHANNEL,
+            channelName: 'test',
+            event: enums_1.ClientActions.JOIN_CHANNEL,
+            payload: {},
+        });
+        const { channel: channel2, publisher: publisher2, state: state2 } = createChannel();
+        state2.next(enums_1.PondState.CLOSED);
+        expect(state2.value).toBe(enums_1.PondState.CLOSED);
+        expect(publisher2).not.toHaveBeenCalled();
+        expect(channel2['_queue']).toEqual([]);
+        channel2.join();
+        expect(publisher2).not.toHaveBeenCalled();
+        expect(channel2['_queue']).toEqual([
+            {
+                action: enums_1.ClientActions.JOIN_CHANNEL,
+                channelName: 'test',
+                event: enums_1.ClientActions.JOIN_CHANNEL,
+                payload: {},
+            },
+        ]);
+        state2.next(enums_1.PondState.OPEN);
+        expect(publisher2).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.JOIN_CHANNEL,
+            channelName: 'test',
+            event: enums_1.ClientActions.JOIN_CHANNEL,
+            payload: {},
+        });
+        expect(channel2['_queue']).toEqual([]);
+        const { channel: channel3 } = createChannel();
+        channel3.leave();
+        expect(() => channel3.join())
+            .toThrowError('This channel has been closed');
+    });
+    it('should correctly send a leave message', () => {
+        const { channel, publisher, receiver } = createChannel();
+        expect(channel.channelState).toBe(enums_1.ChannelState.IDLE);
+        channel.join();
+        expect(channel.channelState).toBe(enums_1.ChannelState.JOINING);
+        // once the server responds with a join message, the channel should be connected
+        receiver.next({
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: 'SYSTEM',
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(channel.channelState).toBe(enums_1.ChannelState.JOINED);
+        channel.leave();
+        expect(channel.channelState).toBe(enums_1.ChannelState.CLOSED);
+        expect(publisher).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.LEAVE_CHANNEL,
+            channelName: 'test',
+            event: enums_1.ClientActions.LEAVE_CHANNEL,
+            payload: {},
+        });
+    });
+    it('should notify subscribers when the channel state changes', () => {
+        const { channel, receiver } = createChannel();
+        const stateListener = jest.fn();
+        channel.onConnectionChange(stateListener);
+        expect(stateListener).toHaveBeenCalledWith(enums_1.ChannelState.IDLE);
+        channel.join();
+        receiver.next({
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: 'SYSTEM',
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(stateListener).toHaveBeenCalledWith(enums_1.ChannelState.JOINED);
+        channel.leave();
+        expect(stateListener).toHaveBeenCalledWith(enums_1.ChannelState.CLOSED);
+    });
+    it('should correctly send a message', () => {
+        const { channel, publisher, state } = createChannel();
+        expect(channel.channelState).toBe(enums_1.ChannelState.IDLE);
+        expect(publisher).not.toHaveBeenCalled();
+        expect(channel['_queue']).toEqual([]);
+        // when the socket is connected but the channel is not joined, the message would not be queued
+        channel.broadcast('test', { test: true });
+        expect(publisher).not.toHaveBeenCalled();
+        expect(channel['_queue']).toEqual([]);
+        channel.join();
+        publisher.mockClear();
+        // however once the channel is joined, the message should be sent
+        channel.broadcast('test', { test: true });
+        expect(publisher).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.BROADCAST,
+            addresses: 'all_users',
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: true,
+            },
+        });
+        // if for some reason the socket is disconnected, the message should be queued
+        publisher.mockClear();
+        state.next(enums_1.PondState.CLOSED);
+        expect(state.value).toBe(enums_1.PondState.CLOSED);
+        channel.broadcast('test', { test: true });
+        expect(publisher).not.toHaveBeenCalled();
+        expect(channel['_queue']).toEqual([
+            {
+                action: enums_1.ClientActions.BROADCAST,
+                addresses: 'all_users',
+                channelName: 'test',
+                event: 'test',
+                payload: {
+                    test: true,
+                },
+            },
+        ]);
+        // once the socket is reconnected, a join message should be sent and the queued messages should be sent
+        publisher.mockClear();
+        state.next(enums_1.PondState.OPEN);
+        expect(publisher).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.JOIN_CHANNEL,
+            channelName: 'test',
+            event: enums_1.ClientActions.JOIN_CHANNEL,
+            payload: {},
+        });
+        expect(publisher).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.BROADCAST,
+            addresses: 'all_users',
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: true,
+            },
+        });
+        expect(channel['_queue']).toEqual([]);
+        // if the channel is closed, the message should not be sent, and should not be queued
+        publisher.mockClear();
+        channel.leave();
+        // the leave message should be sent
+        expect(publisher).toHaveBeenCalledWith({
+            action: enums_1.ClientActions.LEAVE_CHANNEL,
+            channelName: 'test',
+            event: enums_1.ClientActions.LEAVE_CHANNEL,
+            payload: {},
+        });
+        expect(channel.channelState).toBe(enums_1.ChannelState.CLOSED);
+        channel.broadcast('test', { test: true });
+        expect(channel['_queue']).toEqual([]);
+        expect(publisher).toBeCalledTimes(1);
+    });
+    // The presence system tests
+    it('should notify subscribers when a user joins the channel', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onJoin(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.JOIN,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith({
+            id: 'test',
+            status: 'online',
+        });
+        presenceListener.mockClear();
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // also, if a presence event is received for a different channel, it should not be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.JOIN,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+    });
+    it('should notify subscribers when a user leaves the channel', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onLeave(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.LEAVE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith({
+            id: 'test',
+            status: 'online',
+        });
+        presenceListener.mockClear();
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // also, if a presence event is received for a different channel, it should not be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.LEAVE,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+    });
+    it('should notify subscribers when a user updates their presence', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onUsersChange(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith([
+            {
+                id: 'test',
+                status: 'online',
+            },
+            {
+                id: 'test2',
+                status: 'online',
+            },
+        ]);
+        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        presenceListener.mockClear();
+        // if we receive a leave or join event, it should be sent to the listener
+        // this is because we are listening for all presence events
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.JOIN,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith([
+            {
+                id: 'test',
+                status: 'online',
+            },
+        ]);
+        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        presenceListener.mockClear();
+        // also, if a presence event is received for a different channel, it should not be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.UPDATE,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // we once again send a presence event for the same channel, but this time it should be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: enums_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'away',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'away',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith([
+            {
+                id: 'test',
+                status: 'away',
+            },
+            {
+                id: 'test2',
+                status: 'online',
+            },
+        ]);
+        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+    });
+    // message events
+    it('should notify subscribers when a message is received', () => {
+        const { channel, receiver } = createChannel();
+        const messageListener = jest.fn();
+        channel.onMessage(messageListener);
+        expect(messageListener).not.toHaveBeenCalled();
+        receiver.next({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            event: 'message',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(messageListener).toHaveBeenCalledWith('message', {
+            id: 'test',
+            message: 'test',
+        });
+        // if a message event is received for a different channel, it should not be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            event: 'message',
+            channelName: 'test2',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(messageListener).toHaveBeenCalledTimes(1);
+        // we can also subscribe to a specific message event
+        const specificMessageListener = jest.fn();
+        channel.onMessageEvent('test', specificMessageListener);
+        expect(specificMessageListener).not.toHaveBeenCalled();
+        receiver.next({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            event: 'test',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(specificMessageListener).toHaveBeenCalledWith({
+            id: 'test',
+            message: 'test',
+        });
+        specificMessageListener.mockClear();
+        // if a message event is received for the same channel, but a different event, it should not be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            event: 'test2',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(specificMessageListener).not.toHaveBeenCalled();
+        // if a message event is received for a different channel, it should not be sent to the listener
+        receiver.next({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            event: 'test',
+            channelName: 'test2',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(specificMessageListener).not.toHaveBeenCalled();
+    });
+});

package/client.js

@@ -30,14 +30,14 @@ class PondClient {
     connect(backoff = 1) {
         const socket = new WebSocket(this._address.toString());
         socket.onopen = () => {
-            this._connectionState.publish(enums_1.PondState.OPEN);
+            this._connectionState.next(enums_1.PondState.OPEN);
         };
         socket.onmessage = (message) => {
             const data = JSON.parse(message.data);
-            this._broadcaster.publish(data);
+            this._broadcaster.next(data);
         };
         socket.onerror = () => {
-            this._connectionState.publish(enums_1.PondState.CLOSED);
+            this._connectionState.next(enums_1.PondState.CLOSED);
             setTimeout(() => {
                 this.connect(backoff * 2);
             }, backoff * 1000);
@@ -65,7 +65,8 @@ class PondClient {
      * @param params - The params to send to the server.
      */
     createChannel(name, params) {
-        if (this._channels[name] && !this._channels[name].hasClosed()) {
+        var _a;
+        if (((_a = this._channels[name]) === null || _a === void 0 ? void 0 : _a.channelState) !== enums_1.ChannelState.CLOSED) {
             return this._channels[name];
         }
         const publisher = this._createPublisher();