@eleven-am/pondsocket 0.1.5 → 0.1.7

package/README.md

@@ -0,0 +1,141 @@
+
+# PondSocket
+
+PondSocket is a fast, minimalist and bidirectional socket framework for NodeJS. Pond allows you to think of each action during a sockets lifetime as a request instead of a huge callback that exists inside the connection event.
+## Documentation
+
+This is a Node.js module available through the npm registry.
+
+```bash
+  npm install @eleven-am/pondsocket
+```
+
+PondSocket usage depends on the environment in which it is being used.
+
+#### On the server
+
+When using PondSocket, an endpoint is created. The endpoint is the gateway by which sockets actually connect to the server.
+Multiple endpoints can be created but every endpoint is independent of the other, ie sockets on one endpoint cannot communicate with sockets on another endpoint.
+
+```js
+  import { PondSocket } from "@eleven-am/pondsocket";
+  import parse from "url";
+  
+  const pond = new PondSocket();
+ 
+  const endpoint = pond.createEndpoint('/api/socket', (req, res, _endpoint) => {
+       const { query } = parse(req.url || '');     
+       const { token } = query;     
+       if (!token)         
+            return res.reject('No token provided');      
+       res.accept({
+            assign: {
+                token
+            }
+       });  
+  })
+```
+
+While sockets connect through the endpoint, communication between sockets cannot occur on the endpoint level. Sockets have to join a channel to communicate
+between themselves.
+
+```js
+  const channel = endpoint.createChannel(/^channel(.*?)/, (req, res, channel) => {
+       const isAdmin = req.clientAssigns.admin;
+       if (!isAdmin)       
+            return res.reject('You are not an admin');
+
+       res.accept({
+           assign: {
+               admin: true, 
+               joinedDate: new Date()
+            }, 
+            presence: {
+                state: 'online'
+            }, 
+            channelData: {
+                locked: true,
+                numberOfUsers: channel.presence.length
+            }
+        });  
+   });   
+```
+
+A user goes through the createChannel function to join a channel.
+When a user joins a channel, some private information can be assigned to the user. This assign could be viewed as a cookie that is only available serverside.
+The presence is the current state of the user. When you reassign a new presence information to a user, all other users connected to the same channel are informed of the change.
+This could be used as *user is typing*, *user is away*, etc. The channelData is information that is stored on the channel and accessible from anywhere the channel is available.
+It can be anything from a boolean to an instance of a class. This data cannot be accessed from another channel as it is private to the channel.
+
+```js
+    channel.on('hello', (req, res, channel) => {      
+       const users = channel.getPresence();      
+       res.assign({
+           assign: {
+               pingDate: new Date(),
+               users: users.length
+           }
+        }); 
+
+        // res.reject('curse words are not allowed on a child friendly channel') 
+        // channel.closeFromChannel(req.client.clientId);
+    })
+```
+
+When a message is sent on a channel by a user, an event is triggered. The *on* function can be used to listen for these events. If the function is specified, it is called when the message is received.
+You can choose to decline the message being sent, or you can allow the message to be sent as usual. You can also do all the normal assigns to the channel, or user.
+In case there is no *on* function, the message will be sent without any action being taken.
+
+#### On the browser
+
+```js
+    import { PondClient } from "@eleven-am/pondsocket/client";
+
+    export const socket = new PondClientSocket('/api/socket', {});
+    socket.connect();
+```
+
+The browser compatible package can be imported from @eleven-am/pondsocket/client.
+AN url string is provided to the class along with other url params, like token.
+
+Multiple classes can be created, but it is advised to use a single class throughout the application.
+You can just create multiple channels and maintain the single socket connection.
+
+```js
+    const channelTopic = 'channel:one';
+    const options = {
+        username: 'eleven-am'
+    }
+
+    export const channel = socket.createChannel(channelTopic, options);
+    channel.join();
+```
+
+When connected to the channel you can subscribe to the events from the channel.
+
+```js
+    const subscriptionPresence = channel.onPresenceUpdate(presence => {
+        // handle the presence changes of the channel
+    });
+
+    const subscriptionMessage = channel.onMessage((event, data) => {
+        // handle the message being received 
+    });
+
+    // When done with the channel remember to unsubscribe from these listeners
+    subscriptionPresence.unsubscribe();
+    subscriptionMessage.unsubscribe();
+```
+
+There are many other features available on the channel object. Since the application is completely typed,
+suggestions should be provided by your IDE.
+
+```js
+    channel.broadcast('hello', {
+        name: 'eleven-am',
+        message: 'I am the man, man'
+    })
+
+    // channel.broadcastFrom broadcasts a message to everyone but the client that emitted the message
+    // channel.sendMessage sends a message to clients specified in the function
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/pondClient/channel.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = void 0;
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const pondSocket_1 = require("../pondSocket");
-const pondBase_1 = require("../pondBase");
-class Channel {
-    constructor(channel, params, socket) {
+var rxjs_1 = require("rxjs");
+var operators_1 = require("rxjs/operators");
+var pondSocket_1 = require("../pondSocket");
+var pondBase_1 = require("../pondBase");
+var Channel = /** @class */ (function () {
+    function Channel(channel, params, socket) {
         this._subscriptions = [];
         this._presenceSubject = new rxjs_1.Subject();
         this.channel = channel;
@@ -15,138 +15,149 @@ class Channel {
         this._subject = new rxjs_1.Subject();
         this._connectedSubject = new pondBase_1.Subject(false);
     }
-    get isActive() {
-        return this._connectedSubject.value;
-    }
+    Object.defineProperty(Channel.prototype, "isActive", {
+        get: function () {
+            return this._connectedSubject.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * @desc Connects to the channel.
      */
-    join() {
+    Channel.prototype.join = function () {
+        var _this = this;
         if (this._connectedSubject.value)
             return this;
-        const observable = this._init();
-        const subscription = observable
-            .subscribe(message => {
-            this._connectedSubject.publish(true);
+        var observable = this._init();
+        var subscription = observable
+            .subscribe(function (message) {
+            _this._connectedSubject.publish(true);
             if (message.action === "PRESENCE")
-                this._presenceSubject.next(message.payload.presence);
+                _this._presenceSubject.next(message.payload.presence);
             else if (message.action === "MESSAGE")
-                this._subject.next(message);
+                _this._subject.next(message);
             else if (message.event === "KICKED_FROM_CHANNEL")
-                this.leave();
+                _this.leave();
         });
         this._subscriptions.push(subscription);
         return this;
-    }
+    };
     /**
      * @desc Disconnects from the channel.
      */
-    leave() {
+    Channel.prototype.leave = function () {
         void this._connectedSubject.publish(false);
         this._presenceSubject.complete();
-        this._subscriptions.forEach(subscription => subscription.unsubscribe());
+        this._subscriptions.forEach(function (subscription) { return subscription.unsubscribe(); });
         this._subscriptions = [];
         this._subject.complete();
-    }
+    };
     /**
      * @desc Monitors the presence state of the channel.
      * @param callback - The callback to call when the presence state changes.
      */
-    onPresenceUpdate(callback) {
-        const sub = this._presenceSubject.subscribe(callback);
+    Channel.prototype.onPresenceUpdate = function (callback) {
+        var sub = this._presenceSubject.subscribe(callback);
         this._subscriptions.push(sub);
         return sub;
-    }
+    };
     /**
      * @desc Monitors the channel for messages.
      * @param callback - The callback to call when a message is received.
      */
-    onMessage(callback) {
-        const sub = this._subject
-            .pipe((0, operators_1.filter)((message) => message.action === "MESSAGE"))
-            .subscribe(message => callback(message.event, message.payload));
+    Channel.prototype.onMessage = function (callback) {
+        var sub = this._subject
+            .pipe((0, operators_1.filter)(function (message) { return message.action === "MESSAGE"; }))
+            .subscribe(function (message) { return callback(message.event, message.payload); });
         this._subscriptions.push(sub);
         return sub;
-    }
+    };
     /**
      * @desc Broadcasts a message to the channel, including yourself.
      * @param event - The event to send.
      * @param payload - The message to send.
      */
-    broadcast(event, payload) {
-        const message = {
+    Channel.prototype.broadcast = function (event, payload) {
+        var message = {
             channelName: this.channel,
-            payload, event,
+            payload: payload,
+            event: event,
             action: pondSocket_1.ClientActions.BROADCAST
         };
         this._socket.next(message);
-    }
+    };
     /**
      * @desc Broadcasts a message to every other client in the channel except yourself.
      * @param event - The event to send.
      * @param payload - The message to send.
      */
-    broadcastFrom(event, payload) {
-        const message = {
+    Channel.prototype.broadcastFrom = function (event, payload) {
+        var message = {
             channelName: this.channel,
-            payload, event,
+            payload: payload,
+            event: event,
             action: pondSocket_1.ClientActions.BROADCAST_FROM
         };
         this._socket.next(message);
-    }
+    };
     /**
      * @desc Updates the presence state of the current client in the channel.
      * @param presence - The presence state to update.
      */
-    updatePresence(presence) {
+    Channel.prototype.updatePresence = function (presence) {
         this._socket.next({
             action: pondSocket_1.ClientActions.UPDATE_PRESENCE,
             channelName: this.channel,
             event: "PRESENCE",
             payload: presence
         });
-    }
+    };
     /**
      * @desc Sends a message to specific clients in the channel.
      * @param event - The event to send.
      * @param payload - The message to send.
      * @param recipient - The clients to send the message to.
      */
-    sendMessage(event, payload, recipient) {
-        const addresses = Array.isArray(recipient) ? recipient : [recipient];
-        const message = {
+    Channel.prototype.sendMessage = function (event, payload, recipient) {
+        var addresses = Array.isArray(recipient) ? recipient : [recipient];
+        var message = {
             channelName: this.channel,
-            payload, event, addresses,
+            payload: payload,
+            event: event,
+            addresses: addresses,
             action: pondSocket_1.ClientActions.SEND_MESSAGE_TO_USER
         };
         this._socket.next(message);
-    }
+    };
     /**
      * @desc Listens for the connections state of the channel.
      * @param callback - The callback to call when the connection state changes.
      */
-    onConnectionChange(callback) {
-        const sub = this._connectedSubject.subscribe(callback);
+    Channel.prototype.onConnectionChange = function (callback) {
+        var sub = this._connectedSubject.subscribe(callback);
         this._subscriptions.push(sub);
         return sub;
-    }
+    };
     /**
      * @desc Initializes the channel.
      * @private
      */
-    _init() {
-        const observable = this._socket.multiplex(() => ({
+    Channel.prototype._init = function () {
+        var _this = this;
+        var observable = this._socket.multiplex(function () { return ({
             action: "JOIN_CHANNEL",
-            channelName: this.channel,
+            channelName: _this.channel,
             event: "JOIN_CHANNEL",
-            payload: this._params
-        }), () => ({
+            payload: _this._params
+        }); }, function () { return ({
             action: "LEAVE_CHANNEL",
-            channelName: this.channel,
+            channelName: _this.channel,
             event: "LEAVE_CHANNEL",
-            payload: this._params
-        }), message => message.channelName === this.channel);
+            payload: _this._params
+        }); }, function (message) { return message.channelName === _this.channel; });
         return observable;
-    }
-}
+    };
+    return Channel;
+}());
 exports.Channel = Channel;

package/pondClient/socket.js

@@ -1,29 +1,48 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondClient = void 0;
-const webSocket_1 = require("rxjs/webSocket");
-const rxjs_1 = require("rxjs");
-const channel_1 = require("./channel");
-const operators_1 = require("rxjs/operators");
-const pondBase_1 = require("../pondBase");
-class PondClient {
-    constructor(endpoint, params) {
+var webSocket_1 = require("rxjs/webSocket");
+var rxjs_1 = require("rxjs");
+var channel_1 = require("./channel");
+var operators_1 = require("rxjs/operators");
+var pondBase_1 = require("../pondBase");
+var PondClient = /** @class */ (function () {
+    function PondClient(endpoint, params) {
         this.socketState = "CLOSED";
         /**
          * @desc A retry strategy for the socket.
          * @param maxTries - The maximum number of retries.
          * @param ms - The number of milliseconds to wait before retrying.
          */
-        this._retryStrategy = (maxTries, ms) => {
-            return (0, rxjs_1.pipe)((0, operators_1.retryWhen)(attempts => {
-                const observableForRetries = (0, rxjs_1.zip)((0, rxjs_1.range)(1, maxTries), attempts)
-                    .pipe((0, operators_1.map)(([elemFromRange]) => elemFromRange), (0, operators_1.map)(i => i * i), (0, rxjs_1.switchMap)(i => (0, rxjs_1.timer)(i * ms)));
-                const observableForFailure = (0, rxjs_1.throwError)(new Error("Could not connect to server"))
+        this._retryStrategy = function (maxTries, ms) {
+            return (0, rxjs_1.pipe)((0, operators_1.retryWhen)(function (attempts) {
+                var observableForRetries = (0, rxjs_1.zip)((0, rxjs_1.range)(1, maxTries), attempts)
+                    .pipe((0, operators_1.map)(function (_a) {
+                    var _b = __read(_a, 1), elemFromRange = _b[0];
+                    return elemFromRange;
+                }), (0, operators_1.map)(function (i) { return i * i; }), (0, rxjs_1.switchMap)(function (i) { return (0, rxjs_1.timer)(i * ms); }));
+                var observableForFailure = (0, rxjs_1.throwError)(new Error("Could not connect to server"))
                     .pipe((0, rxjs_1.materialize)(), (0, rxjs_1.delay)(1000), (0, rxjs_1.dematerialize)());
                 return (0, rxjs_1.concat)(observableForRetries, observableForFailure);
             }));
         };
-        let address;
+        var address;
         try {
             address = new URL(endpoint);
         }
@@ -31,9 +50,9 @@ class PondClient {
             address = new URL(window.location.toString());
             address.pathname = endpoint;
         }
-        const query = new URLSearchParams(params);
+        var query = new URLSearchParams(params);
         address.search = query.toString();
-        const protocol = address.protocol === "https:" ? "wss:" : "ws:";
+        var protocol = address.protocol === "https:" ? "wss:" : "ws:";
         if (address.protocol !== "wss:" && address.protocol !== "ws:")
             address.protocol = protocol;
         this.address = address;
@@ -42,75 +61,72 @@ class PondClient {
     /**
      * @desc Connects to the server and returns the socket.
      */
-    connect() {
+    PondClient.prototype.connect = function () {
+        var _this = this;
         if (this.socketState !== "CLOSED")
             return;
         this.socketState = "CONNECTING";
-        const socket = (0, webSocket_1.webSocket)({
+        var socket = (0, webSocket_1.webSocket)({
             url: this.address.toString(),
             openObserver: {
-                next: () => {
-                    this.socketState = "OPEN";
+                next: function () {
+                    _this.socketState = "OPEN";
                 }
             },
             closeObserver: {
-                next: () => {
-                    this.socketState = "CLOSED";
+                next: function () {
+                    _this.socketState = "CLOSED";
                 }
             },
             closingObserver: {
-                next: () => {
-                    this.socketState = "CLOSING";
+                next: function () {
+                    _this.socketState = "CLOSING";
                 }
             }
         });
         this.socket = socket;
         this.subscription = socket.pipe(this._retryStrategy(100, 1000)).subscribe();
         return this;
-    }
+    };
     /**
      * @desc Returns the current state of the socket.
      */
-    getState() {
+    PondClient.prototype.getState = function () {
         return this.socketState;
-    }
+    };
     /**
      * @desc Creates a channel with the given name and params.
      * @param channel - The name of the channel.
      * @param params - The params to send to the server.
      */
-    createChannel(channel, params) {
-        const channelDoc = this.channels.get(channel);
-        if (channelDoc)
-            return channelDoc.doc;
-        if (this.socket) {
-            const newChannel = new channel_1.Channel(channel, params || {}, this.socket);
-            this.channels.set(channel, newChannel);
-            return newChannel;
-        }
-        return null;
-    }
+    PondClient.prototype.createChannel = function (channel, params) {
+        var _this = this;
+        return this.channels.getOrCreate(channel, function () {
+            return new channel_1.Channel(channel, params || {}, _this.socket);
+        }).doc;
+    };
     /**
      * @desc An event that is triggered when the socket receives a message.
      * @param callback - The callback to be called when the event is triggered.
      */
-    onMessage(callback) {
+    PondClient.prototype.onMessage = function (callback) {
         var _a;
-        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.subscribe(data => {
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.subscribe(function (data) {
             if (data.event)
                 callback(data.event, data.payload);
         });
-    }
+    };
     /**
      * @desc Disconnects the socket from the server.
      */
-    disconnect() {
+    PondClient.prototype.disconnect = function () {
         var _a, _b, _c;
         (_a = this.socket) === null || _a === void 0 ? void 0 : _a.complete();
         (_b = this.socket) === null || _b === void 0 ? void 0 : _b.unsubscribe();
         (_c = this.subscription) === null || _c === void 0 ? void 0 : _c.unsubscribe();
         this.socket = undefined;
         this.channels = new pondBase_1.PondBase();
-    }
-}
+    };
+    return PondClient;
+}());
 exports.PondClient = PondClient;

package/.idea/jsLibraryMappings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptLibraryMappings">
-    <includedPredefinedLibrary name="Node.js Core" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/pondsocket.iml" filepath="$PROJECT_DIR$/.idea/pondsocket.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/pondsocket.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>