@eleven-am/pondsocket 0.1.9 → 0.1.11

package/pondSocket/pondResponse.js

@@ -1,46 +1,22 @@
 "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 __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndpointResponse = exports.PondChannelResponse = exports.ChannelResponse = exports.PondResponse = void 0;
-var enums_1 = require("./enums");
-var PondResponse = /** @class */ (function () {
-    function PondResponse() {
-    }
-    return PondResponse;
-}());
+const enums_1 = require("./enums");
+class PondResponse {
+}
 exports.PondResponse = PondResponse;
-var ChannelResponse = /** @class */ (function (_super) {
-    __extends(ChannelResponse, _super);
-    function ChannelResponse(clientId, channel, resolver) {
-        var _this = _super.call(this) || this;
-        _this._clientId = clientId;
-        _this._channel = channel;
-        _this._resolver = resolver;
-        _this._hasExecuted = false;
-        return _this;
+class ChannelResponse extends PondResponse {
+    constructor(clientId, channel, resolver) {
+        super();
+        this._clientId = clientId;
+        this._channel = channel;
+        this._resolver = resolver;
+        this._hasExecuted = false;
+    }
+    get hasExecuted() {
+        return this._hasExecuted;
     }
-    Object.defineProperty(ChannelResponse.prototype, "hasExecuted", {
-        get: function () {
-            return this._hasExecuted;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ChannelResponse.prototype.accept = function (assigns) {
+    accept(assigns) {
         if (this._hasExecuted)
             throw new Error('Response has already been sent');
         this._hasExecuted = true;
@@ -51,8 +27,8 @@ var ChannelResponse = /** @class */ (function (_super) {
             this._channel.data = assigns.channelData || {};
         }
         this._resolver(false);
-    };
-    ChannelResponse.prototype.reject = function (message, errorCode) {
+    }
+    reject(message, errorCode) {
         if (this._hasExecuted)
             throw new Error('Response has already been sent');
         this._hasExecuted = true;
@@ -62,8 +38,8 @@ var ChannelResponse = /** @class */ (function (_super) {
             throw new Error('Cannot reject a message sent by the server');
         this._channel.respondToClient('error', { message: message, code: errorCode }, this._clientId, enums_1.ServerActions.ERROR);
         this._resolver(true);
-    };
-    ChannelResponse.prototype.send = function (event, payload, assigns) {
+    }
+    send(event, payload, assigns) {
         if (this._hasExecuted)
             throw new Error('Response has already been sent');
         this._hasExecuted = true;
@@ -75,38 +51,31 @@ var ChannelResponse = /** @class */ (function (_super) {
         }
         this._channel.respondToClient(event, payload, this._clientId);
         this._resolver(false);
-    };
-    return ChannelResponse;
-}(PondResponse));
+    }
+}
 exports.ChannelResponse = ChannelResponse;
-var PondChannelResponse = /** @class */ (function (_super) {
-    __extends(PondChannelResponse, _super);
-    function PondChannelResponse(user, handler) {
-        var _this = _super.call(this) || this;
-        _this._handler = handler;
-        _this._user = user;
-        _this._executed = false;
-        return _this;
+class PondChannelResponse extends PondResponse {
+    constructor(user, handler) {
+        super();
+        this._handler = handler;
+        this._user = user;
+        this._executed = false;
+    }
+    get isResolved() {
+        return this._executed;
     }
-    Object.defineProperty(PondChannelResponse.prototype, "isResolved", {
-        get: function () {
-            return this._executed;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PondChannelResponse.prototype.accept = function (assigns) {
+    accept(assigns) {
         if (this._executed)
             throw new Error('Response has already been sent');
         this._executed = true;
-        var newAssigns = this._mergeAssigns(assigns);
+        const newAssigns = this._mergeAssigns(assigns);
         this._handler(newAssigns);
-    };
-    PondChannelResponse.prototype.reject = function (message, errorCode) {
+    }
+    reject(message, errorCode) {
         if (this._executed)
             throw new Error('Response has already been sent');
         this._executed = true;
-        var newMessage = {
+        const newMessage = {
             action: enums_1.ServerActions.ERROR,
             event: "JOIN_REQUEST_ERROR",
             channelName: enums_1.PondSenders.POND_CHANNEL,
@@ -116,40 +85,36 @@ var PondChannelResponse = /** @class */ (function (_super) {
             }
         };
         this._user.socket.send(JSON.stringify(newMessage));
-    };
-    PondChannelResponse.prototype.send = function (event, payload, assigns) {
+    }
+    send(event, payload, assigns) {
         if (this._executed)
             throw new Error('Response has already been sent');
         this._executed = true;
-        var newAssigns = this._mergeAssigns(assigns);
+        const newAssigns = this._mergeAssigns(assigns);
         this._handler(newAssigns, { event: event, payload: payload });
-    };
-    PondChannelResponse.prototype._mergeAssigns = function (assigns) {
+    }
+    _mergeAssigns(assigns) {
         return {
             presence: (assigns === null || assigns === void 0 ? void 0 : assigns.presence) || {},
             channelData: (assigns === null || assigns === void 0 ? void 0 : assigns.channelData) || {},
             assigns: Object.assign({}, this._user.assigns, (assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}),
         };
-    };
-    return PondChannelResponse;
-}(PondResponse));
+    }
+}
 exports.PondChannelResponse = PondChannelResponse;
-var EndpointResponse = /** @class */ (function (_super) {
-    __extends(EndpointResponse, _super);
-    function EndpointResponse(handler) {
-        var _this = _super.call(this) || this;
-        _this._handler = handler;
-        return _this;
+class EndpointResponse extends PondResponse {
+    constructor(handler) {
+        super();
+        this._handler = handler;
     }
-    EndpointResponse.prototype.accept = function (assigns) {
+    accept(assigns) {
         this._handler((assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}, {});
-    };
-    EndpointResponse.prototype.reject = function (message, errorCode) {
+    }
+    reject(message, errorCode) {
         this._handler({}, { error: { message: message || 'Message rejected', code: errorCode || 403 } });
-    };
-    EndpointResponse.prototype.send = function (event, payload, assigns) {
+    }
+    send(event, payload, assigns) {
         this._handler((assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}, { message: { event: event, payload: payload } });
-    };
-    return EndpointResponse;
-}(PondResponse));
+    }
+}
 exports.EndpointResponse = EndpointResponse;

package/pondSocket/pondSocket.js

@@ -1,51 +1,34 @@
 "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 __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
-var http_1 = require("http");
-var ws_1 = require("ws");
-var pondBase_1 = require("../pondBase");
-var endpoint_1 = require("./endpoint");
-var socketMiddleWare_1 = require("./socketMiddleWare");
-var PondSocket = /** @class */ (function (_super) {
-    __extends(PondSocket, _super);
-    function PondSocket(server, socketServer) {
-        var _this = _super.call(this) || this;
-        _this._server = server || new http_1.Server();
-        _this._socketServer = socketServer || new ws_1.WebSocketServer({ noServer: true });
-        _this._socketChain = new socketMiddleWare_1.SocketMiddleWare(_this._server);
-        _this._init();
-        return _this;
+const http_1 = require("http");
+const ws_1 = require("ws");
+const pondBase_1 = require("../pondBase");
+const endpoint_1 = require("./endpoint");
+const socketMiddleWare_1 = require("./socketMiddleWare");
+class PondSocket extends pondBase_1.BaseClass {
+    constructor(server, socketServer) {
+        super();
+        this._server = server || new http_1.Server();
+        this._socketServer = socketServer || new ws_1.WebSocketServer({ noServer: true });
+        this._socketChain = new socketMiddleWare_1.SocketMiddleWare(this._server);
+        this._init();
     }
     /**
      * @desc Specifies the port to listen on
      * @param port - the port to listen on
      * @param callback - the callback to call when the server is listening
      */
-    PondSocket.prototype.listen = function (port, callback) {
+    listen(port, callback) {
         return this._server.listen(port, callback);
-    };
+    }
     /**
      * @desc adds a middleware to the server
      * @param middleware - the middleware to add
      */
-    PondSocket.prototype.useOnUpgrade = function (middleware) {
+    useOnUpgrade(middleware) {
         this._socketChain.use(middleware);
-    };
+    }
     /**
      * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
      * @param path - the pattern to accept || can also be a regex
@@ -64,51 +47,48 @@ var PondSocket = /** @class */ (function (_super) {
      *    });
      * })
      */
-    PondSocket.prototype.createEndpoint = function (path, handler) {
-        var _this = this;
-        var endpoint = new endpoint_1.Endpoint(this._socketServer, handler);
-        this._socketChain.use(function (req, socket, head, next) {
-            var address = req.url || "";
-            var dataEndpoint = _this.generateEventRequest(path, address);
+    createEndpoint(path, handler) {
+        const endpoint = new endpoint_1.Endpoint(this._socketServer, handler);
+        this._socketChain.use((req, socket, head, next) => {
+            const address = req.url || "";
+            const dataEndpoint = this.generateEventRequest(path, address);
             if (!dataEndpoint)
                 return next();
             endpoint.authoriseConnection(req, socket, head, dataEndpoint);
         });
         return endpoint;
-    };
+    }
     /**
      * @desc Makes sure that every client is still connected to the pond
      * @param server - WebSocket server
      */
-    PondSocket.prototype._pingClients = function (server) {
-        server.on("connection", function (ws) {
+    _pingClients(server) {
+        server.on("connection", (ws) => {
             ws.isAlive = true;
-            ws.on("pong", function () {
+            ws.on("pong", () => {
                 ws.isAlive = true;
             });
         });
-        var interval = setInterval(function () {
-            server.clients.forEach(function (ws) {
+        const interval = setInterval(() => {
+            server.clients.forEach((ws) => {
                 if (ws.isAlive === false)
                     return ws.terminate();
                 ws.isAlive = false;
                 ws.ping();
             });
         }, 30 * 1000);
-        server.on("close", function () { return clearInterval(interval); });
-    };
+        server.on("close", () => clearInterval(interval));
+    }
     /**
      * @desc Initializes the server
      */
-    PondSocket.prototype._init = function () {
-        var _this = this;
-        this._server.on("error", function (error) {
+    _init() {
+        this._server.on("error", (error) => {
             throw new Error(error.message);
         });
-        this._server.on("listening", function () {
-            _this._pingClients(_this._socketServer);
+        this._server.on("listening", () => {
+            this._pingClients(this._socketServer);
         });
-    };
-    return PondSocket;
-}(pondBase_1.BaseClass));
+    }
+}
 exports.PondSocket = PondSocket;

package/pondSocket/server.test.js

@@ -8,85 +8,58 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var endpoint_1 = require("./endpoint");
-var pondSocket_1 = require("./pondSocket");
-var superwstest_1 = __importDefault(require("superwstest"));
-var enums_1 = require("./enums");
-var http_1 = require("http");
-var ws_1 = require("ws");
-describe('server', function () {
-    it('should be defined', function () {
+const endpoint_1 = require("./endpoint");
+const pondSocket_1 = require("./pondSocket");
+const superwstest_1 = __importDefault(require("superwstest"));
+const enums_1 = require("./enums");
+const http_1 = require("http");
+const ws_1 = require("ws");
+describe('server', () => {
+    it('should be defined', () => {
         expect(pondSocket_1.PondSocket).toBeDefined();
     });
-    it('should be instantiable', function () {
+    it('should be instantiable', () => {
         expect(new pondSocket_1.PondSocket()).toBeInstanceOf(pondSocket_1.PondSocket);
     });
-    it('should ba able to create its own server and websocket server if none is provided', function () {
-        var socket = new pondSocket_1.PondSocket();
+    it('should ba able to create its own server and websocket server if none is provided', () => {
+        const socket = new pondSocket_1.PondSocket();
         expect(socket['_server']).toBeDefined();
         expect(socket['_socketServer']).toBeDefined();
     });
-    it('should take a server and websocket server if provided', function () {
-        var server = (0, http_1.createServer)();
-        var socketServer = new ws_1.Server({ noServer: true });
-        var socket = new pondSocket_1.PondSocket(server, socketServer);
+    it('should take a server and websocket server if provided', () => {
+        const server = (0, http_1.createServer)();
+        const socketServer = new ws_1.Server({ noServer: true });
+        const socket = new pondSocket_1.PondSocket(server, socketServer);
         expect(socket['_server']).toBe(server);
         expect(socket['_socketServer']).toBe(socketServer);
     });
-    it('should be able to listen on a port', function () {
-        var socket = new pondSocket_1.PondSocket();
-        expect(socket.listen(3001, function () {
+    it('should be able to listen on a port', () => {
+        const socket = new pondSocket_1.PondSocket();
+        expect(socket.listen(3001, () => {
             console.log('socket');
         })).toBeDefined();
         socket['_server'].close();
     });
-    it('should be able to create an endpoint', function () {
-        var socket = new pondSocket_1.PondSocket();
-        var endpoint = socket.createEndpoint('/api/socket', function () {
+    it('should be able to create an endpoint', () => {
+        const socket = new pondSocket_1.PondSocket();
+        const endpoint = socket.createEndpoint('/api/socket', () => {
             console.log('socket');
         });
         expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
         expect(endpoint['_handler']).toEqual(expect.any(Function));
     });
-    it('should be able to create multiple endpoints', function () {
-        var server = (0, http_1.createServer)();
-        var socketServer = new ws_1.Server({ noServer: true });
-        var socket = new pondSocket_1.PondSocket(server, socketServer);
-        var endpoint = socket.createEndpoint('/api/socket', function () {
+    it('should be able to create multiple endpoints', () => {
+        const server = (0, http_1.createServer)();
+        const socketServer = new ws_1.Server({ noServer: true });
+        const socket = new pondSocket_1.PondSocket(server, socketServer);
+        const endpoint = socket.createEndpoint('/api/socket', () => {
             console.log('socket');
         });
-        var endpoint2 = socket.createEndpoint('/api/socket2', function () {
+        const endpoint2 = socket.createEndpoint('/api/socket2', () => {
             console.log('socket2');
         });
         expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
@@ -94,15 +67,15 @@ describe('server', function () {
         expect(endpoint2).toBeInstanceOf(endpoint_1.Endpoint);
         expect(endpoint2['_handler']).toEqual(expect.any(Function));
     });
-    it('should be able to reject a socket', function () {
-        var server = (0, http_1.createServer)();
-        var socketServer = new ws_1.Server({ noServer: true });
-        var socket = new pondSocket_1.PondSocket(server, socketServer);
-        var socketClient = {
+    it('should be able to reject a socket', () => {
+        const server = (0, http_1.createServer)();
+        const socketServer = new ws_1.Server({ noServer: true });
+        const socket = new pondSocket_1.PondSocket(server, socketServer);
+        const socketClient = {
             write: jest.fn(),
             destroy: jest.fn(),
         };
-        socket.listen(3001, function () {
+        socket.listen(3001, () => {
             console.log('server listening');
         });
         server.emit('upgrade', {}, socketClient);
@@ -111,89 +84,62 @@ describe('server', function () {
         expect(socketClient.write).toHaveBeenCalled();
         expect(socketClient.destroy).toHaveBeenCalled();
     });
-    it('should be able to accept a socket if a handler is provided', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var socket, server;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    socket = new pondSocket_1.PondSocket();
-                    server = socket.listen(3001, function () {
-                        console.log('server listening');
-                    });
-                    expect(server).toBeDefined();
-                    socket.createEndpoint('/api/hello', function () {
-                        console.log('server listening');
-                    });
-                    socket.createEndpoint('/api/:path', function (req, res) {
-                        expect(req.params.path).toBe('socket');
-                        res.accept();
-                    });
-                    return [4 /*yield*/, (0, superwstest_1.default)(server)
-                            .ws('/api/socket')
-                            .expectUpgrade(function (res) { return expect(res.statusCode).toBe(101); })
-                            .close()
-                            .expectClosed()];
-                case 1:
-                    _a.sent();
-                    server.close();
-                    return [2 /*return*/];
-            }
+    it('should be able to accept a socket if a handler is provided', () => __awaiter(void 0, void 0, void 0, function* () {
+        const socket = new pondSocket_1.PondSocket();
+        const server = socket.listen(3001, () => {
+            console.log('server listening');
+        });
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/hello', () => {
+            console.log('server listening');
+        });
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.accept();
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade(res => expect(res.statusCode).toBe(101))
+            .close()
+            .expectClosed();
+        server.close();
+    }));
+    it('should be able to reject a socket if the handler rejects', () => __awaiter(void 0, void 0, void 0, function* () {
+        const socket = new pondSocket_1.PondSocket();
+        const server = socket.listen(3001, () => {
+            console.log('server listening');
+        });
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.reject();
         });
-    }); });
-    it('should be able to reject a socket if the handler rejects', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var socket, server;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    socket = new pondSocket_1.PondSocket();
-                    server = socket.listen(3001, function () {
-                        console.log('server listening');
-                    });
-                    expect(server).toBeDefined();
-                    socket.createEndpoint('/api/:path', function (req, res) {
-                        expect(req.params.path).toBe('socket');
-                        res.reject();
-                    });
-                    return [4 /*yield*/, (0, superwstest_1.default)(server)
-                            .ws('/api/socket')
-                            .expectConnectionError()];
-                case 1:
-                    _a.sent();
-                    server.close();
-                    return [2 /*return*/];
-            }
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectConnectionError();
+        server.close();
+    }));
+    it('should be able to send a message after connection', () => __awaiter(void 0, void 0, void 0, function* () {
+        const socket = new pondSocket_1.PondSocket();
+        const server = socket.listen(3001, () => {
+            console.log('server listening');
         });
-    }); });
-    it('should be able to send a message after connection', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var socket, server;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    socket = new pondSocket_1.PondSocket();
-                    server = socket.listen(3001, function () {
-                        console.log('server listening');
-                    });
-                    expect(server).toBeDefined();
-                    socket.createEndpoint('/api/:path', function (req, res) {
-                        expect(req.params.path).toBe('socket');
-                        res.send('testEvent', { test: 'test' });
-                    });
-                    return [4 /*yield*/, (0, superwstest_1.default)(server)
-                            .ws('/api/socket')
-                            .expectUpgrade(function (res) { return expect(res.statusCode).toBe(101); })
-                            .expectJson({
-                            action: enums_1.ServerActions.MESSAGE,
-                            event: 'testEvent',
-                            channelName: 'SERVER',
-                            payload: { test: 'test' },
-                        })
-                            .close()
-                            .expectClosed()];
-                case 1:
-                    _a.sent();
-                    server.close();
-                    return [2 /*return*/];
-            }
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.send('testEvent', { test: 'test' });
         });
-    }); });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade(res => expect(res.statusCode).toBe(101))
+            .expectJson({
+            action: enums_1.ServerActions.MESSAGE,
+            event: 'testEvent',
+            channelName: 'SERVER',
+            payload: { test: 'test' },
+        })
+            .close()
+            .expectClosed();
+        server.close();
+    }));
 });