@eleven-am/pondsocket 0.1.8 → 0.1.9

package/pondSocket/pondChannel.js

@@ -1,58 +1,102 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondChannel = void 0;
-const pondBase_1 = require("../pondBase");
-const channel_1 = require("./channel");
-const enums_1 = require("./enums");
-const pondResponse_1 = require("./pondResponse");
-const channelMiddleWare_1 = require("./channelMiddleWare");
-class PondChannel extends pondBase_1.BaseClass {
-    constructor(path, handler) {
-        super();
-        this._channels = new pondBase_1.PondBase();
-        this._handler = handler;
-        this.path = path;
-        this._subscriptions = {};
-        this._middleware = new channelMiddleWare_1.ChannelMiddleware();
-    }
-    /**
-     * @desc Gets a list of all the channels in the endpoint.
-     */
-    get info() {
-        return this._channels.map(channel => channel.info);
+var pondBase_1 = require("../pondBase");
+var channel_1 = require("./channel");
+var enums_1 = require("./enums");
+var pondResponse_1 = require("./pondResponse");
+var channelMiddleWare_1 = require("./channelMiddleWare");
+var PondChannel = /** @class */ (function (_super) {
+    __extends(PondChannel, _super);
+    function PondChannel(path, handler) {
+        var _this = _super.call(this) || this;
+        _this._channels = new pondBase_1.PondBase();
+        _this._handler = handler;
+        _this.path = path;
+        _this._subscriptions = {};
+        _this._middleware = new channelMiddleWare_1.ChannelMiddleware();
+        return _this;
     }
+    Object.defineProperty(PondChannel.prototype, "info", {
+        /**
+         * @desc Gets a list of all the channels in the endpoint.
+         */
+        get: function () {
+            return this._channels.map(function (channel) { return channel.info; });
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * @desc Sends a message to a client
      * @param socket - The socket to send the message to
      * @param message - The message to send
      */
-    static _sendMessage(socket, message) {
+    PondChannel._sendMessage = function (socket, message) {
         socket.send(JSON.stringify(message));
-    }
+    };
     /**
      * @desc A listener for a channel event
      * @param event - The event to listen for, can be a regex
      * @param callback - The callback to call when the event is received
      */
-    on(event, callback) {
+    PondChannel.prototype.on = function (event, callback) {
         this._buildHandler(event, callback);
-    }
+    };
     /**
      * @desc Add new user to channel
      * @param user - The user to add to the channel
      * @param channelName - The name of the channel
      * @param joinParams - The params to join the channel with
      */
-    addUser(user, channelName, joinParams) {
-        const document = this._getChannel(channelName);
-        const channel = document.doc;
-        const resolver = (newAssigns, message) => {
-            const { assigns, presence, channelData } = newAssigns;
-            this._subscriptions[user.clientId] = this._subscriptions[user.clientId] || [];
-            const sub = channel.subscribeToMessages(user.clientId, (event) => {
+    PondChannel.prototype.addUser = function (user, channelName, joinParams) {
+        var _this = this;
+        var document = this._getChannel(channelName);
+        var channel = document.doc;
+        var resolver = function (newAssigns, message) {
+            var assigns = newAssigns.assigns, presence = newAssigns.presence, channelData = newAssigns.channelData;
+            _this._subscriptions[user.clientId] = _this._subscriptions[user.clientId] || [];
+            var sub = channel.subscribeToMessages(user.clientId, function (event) {
                 PondChannel._sendMessage(user.socket, event);
             });
-            this._subscriptions[user.clientId].push({ name: channelName, sub });
+            _this._subscriptions[user.clientId].push({ name: channelName, sub: sub });
             channel.addUser({
                 presence: presence,
                 assigns: assigns,
@@ -62,65 +106,62 @@ class PondChannel extends pondBase_1.BaseClass {
             if (message)
                 channel.sendTo(message.event, message.payload, enums_1.PondSenders.POND_CHANNEL, [user.clientId]);
         };
-        const response = new pondResponse_1.PondChannelResponse(user, resolver);
-        const resolved = this.generateEventRequest(this.path, channelName);
+        var response = new pondResponse_1.PondChannelResponse(user, resolver);
+        var resolved = this.generateEventRequest(this.path, channelName);
         if (resolved === null) {
             document.removeDoc();
-            return response.reject(`Invalid channel name: ${channelName}`);
+            return response.reject("Invalid channel name: ".concat(channelName));
         }
-        const request = {
-            joinParams, ...resolved,
-            clientId: user.clientId, channelName,
-            clientAssigns: user.assigns
-        };
+        var request = __assign(__assign({ joinParams: joinParams }, resolved), { clientId: user.clientId, channelName: channelName, clientAssigns: user.assigns });
         this._handler(request, response, channel);
         if (channel.presence.length === 0)
             document.removeDoc();
         if (!response.isResolved)
             throw new Error("PondChannel: Response was not resolved");
-    }
+    };
     /**
      * @desc Sends a message to a channel in the endpoint.
      * @param channelName - The name of the channel to send the message to.
      * @param event - The event to send the message with.
      * @param message - The message to send.
      */
-    broadcastToChannel(channelName, event, message) {
-        this._execute(channelName, channel => {
+    PondChannel.prototype.broadcastToChannel = function (channelName, event, message) {
+        this._execute(channelName, function (channel) {
             channel.broadcast(event, message, enums_1.PondSenders.POND_CHANNEL);
         });
-    }
+    };
     /**
      * @desc Closes a client connection to a channel in the endpoint.
      * @param channelName - The name of the channel to close the connection to.
      * @param clientId - The id of the client to close the connection to.
      */
-    closeFromChannel(channelName, clientId) {
-        this._execute(channelName, channel => {
-            this._removeSubscriptions(clientId, channelName);
+    PondChannel.prototype.closeFromChannel = function (channelName, clientId) {
+        var _this = this;
+        this._execute(channelName, function (channel) {
+            _this._removeSubscriptions(clientId, channelName);
             channel.removeUser(clientId);
         });
-    }
+    };
     /**
      * @desc Modify the presence of a client in a channel on the endpoint.
      * @param channelName - The name of the channel to modify the presence of.
      * @param clientId - The id of the client to modify the presence of.
      * @param assigns - The assigns to modify the presence with.
      */
-    modifyPresence(channelName, clientId, assigns) {
-        this._execute(channelName, channel => {
+    PondChannel.prototype.modifyPresence = function (channelName, clientId, assigns) {
+        this._execute(channelName, function (channel) {
             channel.updateUser(clientId, assigns.presence || {}, assigns.assigns || {});
         });
-    }
+    };
     /**
      * @desc Gets the information of the channel
      * @param channelName - The name of the channel to get the information of.
      */
-    getChannelInfo(channelName) {
-        return this._execute(channelName, channel => {
+    PondChannel.prototype.getChannelInfo = function (channelName) {
+        return this._execute(channelName, function (channel) {
             return channel.info;
         });
-    }
+    };
     /**
      * @desc Sends a message to the channel
      * @param channelName - The name of the channel to send the message to.
@@ -128,92 +169,104 @@ class PondChannel extends pondBase_1.BaseClass {
      * @param event - The event to send the message to
      * @param message - The message to send
      */
-    send(channelName, clientId, event, message) {
-        const clients = Array.isArray(clientId) ? clientId : [clientId];
-        this._execute(channelName, channel => {
+    PondChannel.prototype.send = function (channelName, clientId, event, message) {
+        var clients = Array.isArray(clientId) ? clientId : [clientId];
+        this._execute(channelName, function (channel) {
             channel.sendTo(event, message, enums_1.PondSenders.POND_CHANNEL, clients);
         });
-    }
+    };
     /**
      * @desc Searches for a channel in the endpoint.
      * @param channelName - The name of the channel to search for.
      */
-    getChannel(channelName) {
+    PondChannel.prototype.getChannel = function (channelName) {
         var _a;
         return ((_a = this._channels.get(channelName)) === null || _a === void 0 ? void 0 : _a.doc) || null;
-    }
+    };
     /**
      * @desc removes a user from all channels
      * @param clientId - The id of the client to remove
      */
-    removeUser(clientId) {
+    PondChannel.prototype.removeUser = function (clientId) {
+        var e_1, _a;
         if (this._subscriptions[clientId]) {
-            this._subscriptions[clientId].forEach(doc => doc.sub.unsubscribe());
+            this._subscriptions[clientId].forEach(function (doc) { return doc.sub.unsubscribe(); });
             delete this._subscriptions[clientId];
-            for (const channel of this._channels)
-                if (channel.doc.hasUser(clientId))
-                    channel.doc.removeUser(clientId);
+            try {
+                for (var _b = __values(this._channels), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var channel = _c.value;
+                    if (channel.doc.hasUser(clientId))
+                        channel.doc.removeUser(clientId);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
         }
-    }
+    };
     /**
      * @desc Executes a function on a channel in the endpoint.
      * @param channelName - The name of the channel to execute the function on.
      * @param handler - The function to execute on the channel.
      * @private
      */
-    _execute(channelName, handler) {
-        const newChannel = this.getChannel(channelName);
+    PondChannel.prototype._execute = function (channelName, handler) {
+        var newChannel = this.getChannel(channelName);
         if (newChannel)
             return handler(newChannel);
-        throw new Error(`Channel ${channelName} does not exist`);
-    }
+        throw new Error("Channel ".concat(channelName, " does not exist"));
+    };
     /**
      * @desc Creates a new channel in the endpoint.
      * @param channelName - The name of the channel to create.
      * @private
      */
-    _getChannel(channelName) {
-        return this._channels.getOrCreate(channelName, doc => {
-            return new channel_1.Channel(channelName, this._middleware, doc.removeDoc.bind(doc));
+    PondChannel.prototype._getChannel = function (channelName) {
+        var _this = this;
+        return this._channels.getOrCreate(channelName, function (doc) {
+            return new channel_1.Channel(channelName, _this._middleware, doc.removeDoc.bind(doc));
         });
-    }
+    };
     /**
      * @desc Removes a subscription from a user
      * @param clientId - The id of the client to remove the subscription from
      * @param channelName - The name of the channel to remove the subscription from
      * @private
      */
-    _removeSubscriptions(clientId, channelName) {
-        const clients = Array.isArray(clientId) ? clientId : [clientId];
-        clients.forEach(client => {
-            const subs = this._subscriptions[client];
+    PondChannel.prototype._removeSubscriptions = function (clientId, channelName) {
+        var _this = this;
+        var clients = Array.isArray(clientId) ? clientId : [clientId];
+        clients.forEach(function (client) {
+            var subs = _this._subscriptions[client];
             if (subs) {
-                const sub = subs.find(s => s.name === channelName);
+                var sub = subs.find(function (s) { return s.name === channelName; });
                 if (sub) {
                     sub.sub.unsubscribe();
                     subs.splice(subs.indexOf(sub), 1);
                 }
             }
         });
-    }
+    };
     /**
      * @desc Builds an event handler for a channel
      * @param event - The event to build the handler for
      * @param callback - The callback to build the handler for
      * @private
      */
-    _buildHandler(event, callback) {
-        this._middleware.use((data, res, channel) => {
-            const info = this.generateEventRequest(event, data.event);
+    PondChannel.prototype._buildHandler = function (event, callback) {
+        var _this = this;
+        this._middleware.use(function (data, res, channel) {
+            var info = _this.generateEventRequest(event, data.event);
             if (!info)
                 return;
-            const req = {
-                ...data,
-                params: info.params,
-                query: info.query,
-            };
+            var req = __assign(__assign({}, data), { params: info.params, query: info.query });
             callback(req, res, channel);
         });
-    }
-}
+    };
+    return PondChannel;
+}(pondBase_1.BaseClass));
 exports.PondChannel = PondChannel;

package/pondSocket/pondChannel.test.js

@@ -1,34 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const pondChannel_1 = require("./pondChannel");
-const channel_test_1 = require("./channel.test");
-const enums_1 = require("./enums");
-const channel_1 = require("./channel");
-const pondBase_1 = require("../pondBase");
-const createPondChannel = (path, handler) => {
+var pondChannel_1 = require("./pondChannel");
+var channel_test_1 = require("./channel.test");
+var enums_1 = require("./enums");
+var channel_1 = require("./channel");
+var pondBase_1 = require("../pondBase");
+var createPondChannel = function (path, handler) {
     path = path || "/pond";
     handler = handler || jest.fn();
     return new pondChannel_1.PondChannel(path, handler);
 };
-describe('PondChannel', () => {
-    it('should exists', () => {
+describe('PondChannel', function () {
+    it('should exists', function () {
         expect(pondChannel_1.PondChannel).toBeDefined();
     });
-    it('should be a class', () => {
+    it('should be a class', function () {
         expect(pondChannel_1.PondChannel).toBeInstanceOf(Function);
     });
-    it('should be able to get the info of a channel', () => {
-        const pondChannel = createPondChannel();
-        const { channel } = (0, channel_test_1.createChannel)('/channel');
+    it('should be able to get the info of a channel', function () {
+        var pondChannel = createPondChannel();
+        var channel = (0, channel_test_1.createChannel)('/channel').channel;
         // Because we want to get the info of the channel, we need to add it to the pondChannel
         // for testing purposes
         pondChannel['_channels'].set(channel.name, channel);
         expect(pondChannel.info).toEqual([channel.info]);
     });
-    it('should be able ot add a user', () => {
-        const pondChannel = createPondChannel('/test');
-        expect(() => pondChannel.getChannelInfo('/test')).toThrow(); // This throws an error because the channel does not exist anymore
-        const testUser = {
+    it('should be able ot add a user', function () {
+        var pondChannel = createPondChannel('/test');
+        expect(function () { return pondChannel.getChannelInfo('/test'); }).toThrow(); // This throws an error because the channel does not exist anymore
+        var testUser = {
             clientId: 'test', assigns: {}, socket: {
                 send: jest.fn(), on: jest.fn(),
             }
@@ -37,25 +37,25 @@ describe('PondChannel', () => {
         // /balls !== /test so we expect an error message to be sent to the client from the pond channel
         expect(testUser.socket.send).toBeCalledWith(JSON.stringify({
             action: enums_1.ServerActions.ERROR, event: "JOIN_REQUEST_ERROR", channelName: enums_1.PondSenders.POND_CHANNEL, payload: {
-                message: `Invalid channel name: /balls`, code: 403,
+                message: "Invalid channel name: /balls", code: 403,
             }
         }));
         expect(pondChannel.getChannel('/test')).toBeNull(); // The channel does not exist yet
-        expect(() => pondChannel.addUser(testUser, '/test', {}))
+        expect(function () { return pondChannel.addUser(testUser, '/test', {}); })
             .toThrow(); // handler function does not act on the incoming connection, it is just a jest mock function
         // /test === /test so we expect the user to be added to the channel
         // if the channel does not exist, it will be created
         expect(pondChannel.getChannel('/test')).toBeNull(); // The channel does not exist yet
-        const newPondChannel = new pondChannel_1.PondChannel('/test', (_, res) => {
+        var newPondChannel = new pondChannel_1.PondChannel('/test', function (_, res) {
             res.accept(); // here we accept the connection
         });
         newPondChannel.addUser(testUser, '/test', {});
         expect(newPondChannel.getChannel('/test')).not.toBeNull(); // The channel does exist now
-        const newChannel = newPondChannel.getChannel('/test');
+        var newChannel = newPondChannel.getChannel('/test');
         expect(newChannel).toBeDefined();
         expect(newChannel).toBeInstanceOf(channel_1.Channel);
         expect(newChannel === null || newChannel === void 0 ? void 0 : newChannel.name).toBe('/test');
-        const rejectPondChannel = new pondChannel_1.PondChannel('/:test', (req, res) => {
+        var rejectPondChannel = new pondChannel_1.PondChannel('/:test', function (req, res) {
             if (req.params.test === 'balls')
                 res.reject(); // here we reject the connection
             else if (req.params.test === 'rejectWithMessage')
@@ -66,24 +66,24 @@ describe('PondChannel', () => {
         expect(rejectPondChannel.getChannel('/rejectWithMessage')).toBeNull(); // The channel does not exist as it rejects the connection and deletes itself
         expect(testUser.socket.send).toBeCalledWith(JSON.stringify({
             action: enums_1.ServerActions.ERROR, event: "JOIN_REQUEST_ERROR", channelName: enums_1.PondSenders.POND_CHANNEL, payload: {
-                message: `test`, code: 69420,
+                message: "test", code: 69420,
             }
         }));
         rejectPondChannel.addUser(testUser, '/balls', {});
         expect(rejectPondChannel.getChannel('/balls')).toBeNull(); // The channel does not exist as it rejects the connection and deletes itself
         expect(testUser.socket.send).toBeCalledWith(JSON.stringify({
             action: enums_1.ServerActions.ERROR, event: "JOIN_REQUEST_ERROR", channelName: enums_1.PondSenders.POND_CHANNEL, payload: {
-                message: `Unauthorized join request`, code: 403,
+                message: "Unauthorized join request", code: 403,
             }
         }));
-        const acceptPondChannel = new pondChannel_1.PondChannel('/:test', (_, res) => {
+        var acceptPondChannel = new pondChannel_1.PondChannel('/:test', function (_, res) {
             res.send('test', {
                 test: 'test'
             }); // here we send a message after accepting the connection
         });
         testUser.socket.send.mockClear(); // Clear the mock function
-        const messages = [];
-        testUser.socket.send = (message) => {
+        var messages = [];
+        testUser.socket.send = function (message) {
             messages.push(JSON.parse(message));
         };
         acceptPondChannel.addUser(testUser, '/test', {});
@@ -97,18 +97,18 @@ describe('PondChannel', () => {
                 }
             }]);
     });
-    it('should be able to receive subscriptions', () => {
-        const pond = new pondChannel_1.PondChannel('/:test', (_, res) => {
+    it('should be able to receive subscriptions', function () {
+        var pond = new pondChannel_1.PondChannel('/:test', function (_, res) {
             res.accept();
         });
         //when events are added, they are added sequentially
         // this means the first handler is called first, and the second handler is called second...
         // so if a regex handler should be added last so everything else can be tried first
-        let narrowedMessageCount = 0;
-        pond.on('event:test', (req, res) => {
+        var narrowedMessageCount = 0;
+        pond.on('event:test', function (req, res) {
             narrowedMessageCount++;
             if (req.params.test === 'balls')
-                expect(() => res.reject()).toThrow(); // this would throw an error because the sender is the pond channel itself
+                expect(function () { return res.reject(); }).toThrow(); // this would throw an error because the sender is the pond channel itself
             // we know this because we wrote the test that way, to confirm who the sender is you can check the req.client property
             else if (req.params.test === 'rejectWithMessage')
                 res.reject('test', 69420); // here we reject the connection with a message and a status code
@@ -149,8 +149,8 @@ describe('PondChannel', () => {
                     }
                 });
         });
-        let encompassingMessageCount = 0;
-        pond.on(/(.*?)/, (req, res) => {
+        var encompassingMessageCount = 0;
+        pond.on(/(.*?)/, function (req, res) {
             console.log(req.event);
             expect(req.params).toEqual({});
             // with all encompassing regex, the params should be empty
@@ -161,8 +161,8 @@ describe('PondChannel', () => {
                 message: 'This is a fallback route'
             });
         });
-        let userMessageCount = 0;
-        const sender = () => {
+        var userMessageCount = 0;
+        var sender = function () {
             userMessageCount++;
         };
         // we add two users to the pond on ethe channel /pond
@@ -207,7 +207,7 @@ describe('PondChannel', () => {
         encompassingMessageCount = 0;
         userMessageCount = 0;
         narrowedMessageCount = 0;
-        const channel = pond.getChannel('/pond');
+        var channel = pond.getChannel('/pond');
         expect(channel).toBeInstanceOf(channel_1.Channel);
         expect(channel).not.toBeNull();
         // since the PondChannel has no way to send messages on behalf of a client we get the channel from the pond and send the message directly to the channel
@@ -339,12 +339,12 @@ describe('PondChannel', () => {
             assigns: [{}],
         });
     });
-    it('should be capable of removing a user from a channel', () => {
-        const pond = new pondChannel_1.PondChannel('/test', (_, res) => {
+    it('should be capable of removing a user from a channel', function () {
+        var pond = new pondChannel_1.PondChannel('/test', function (_, res) {
             res.accept(); // here we accept the connection
         });
-        let userMessageCount = 0;
-        const sender = () => {
+        var userMessageCount = 0;
+        var sender = function () {
             userMessageCount++;
         };
         pond.addUser({