@eleven-am/pondsocket 0.1.50 → 0.1.52

package/server/server/server.test.js

@@ -1,121 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const http_1 = require("http");
-const superwstest_1 = __importDefault(require("superwstest"));
-const ws_1 = require("ws");
-const pondSocket_1 = require("./pondSocket");
-const enums_1 = require("../../enums");
-const channelEngine_1 = require("../channel/channelEngine");
-const endpoint_1 = require("../endpoint/endpoint");
-describe('server', () => {
-    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', () => {
-        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', () => {
-        const socket = new pondSocket_1.PondSocket();
-        const endpoint = socket.createEndpoint('/api/socket', () => {
-            console.log('socket');
-        });
-        expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
-    });
-    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');
-        });
-        const endpoint2 = socket.createEndpoint('/api/socket2', () => {
-            console.log('socket2');
-        });
-        expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
-        expect(endpoint2).toBeInstanceOf(endpoint_1.Endpoint);
-    });
-    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);
-        server.emit('upgrade', {}, socketClient);
-        server.close();
-        // these functions are called because there is no endpoint to accept the socket
-        expect(socketClient.write).toHaveBeenCalled();
-        expect(socketClient.destroy).toHaveBeenCalled();
-    });
-    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);
-        expect(server).toBeDefined();
-        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);
-        expect(server).toBeDefined();
-        socket.createEndpoint('/api/:path', (req, res) => {
-            expect(req.params.path).toBe('socket');
-            res.reject();
-        });
-        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);
-        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({
-            event: 'testEvent',
-            channelName: enums_1.SystemSender.ENDPOINT,
-            payload: { test: 'test' },
-            action: channelEngine_1.ServerActions.SYSTEM,
-        })
-            .close()
-            .expectClosed();
-        server.close();
-    }));
-});

package/server/utils/matchPattern.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchPattern = void 0;
-class MatchPattern {
-    /**
-     * @desc Generates a pond request resolver object
-     * @param path - the path to resolve
-     * @param address - the address to resolve
-     */
-    parseEvent(path, address) {
-        if (path === '*') {
-            return {
-                params: {},
-                address,
-                query: this._parseQueries(address),
-            };
-        }
-        const match = this._matchStringToPattern(address, path);
-        if (match) {
-            return {
-                params: match,
-                address,
-                query: this._parseQueries(address),
-            };
-        }
-        return null;
-    }
-    /**
-     * @desc Creates an object from the params of a path
-     * @param path - the path to create the object from
-     *
-     * @example
-     * /api/id?name=abc should return { name: 'abc' }
-     * /api/id?name=abc&age=123 should return { name: 'abc', age: '123' }
-     */
-    _parseQueries(path) {
-        const obj = {};
-        const params = path.split('?')[1];
-        if (params) {
-            params.split('&').forEach((param) => {
-                const [key, value] = param.split('=');
-                obj[key] = value;
-            });
-        }
-        return obj;
-    }
-    /**
-     * @desc checks if the pattern is matchable
-     * @param pattern - the pattern to check
-     */
-    _isPatternMatchable(pattern) {
-        return typeof pattern === 'string' && pattern.includes(':');
-    }
-    /**
-     * @desc compares string to string | regex
-     * @param string - the string to compare to the pattern
-     * @param pattern - the pattern to compare to the string
-     */
-    _compareStringToPattern(string, pattern) {
-        if (typeof pattern === 'string') {
-            return string.split('?')[0] === pattern;
-        }
-        return pattern.test(string);
-    }
-    /**
-     * @desc Returns the {key: value} matches of a string
-     * @param string - the string to create the regex from
-     * @param pattern - the pattern to match
-     *
-     * @example
-     * /api/:id should match /api/123 and return { id: 123 }
-     * /api/:id/:name should match /api/123/abc and return { id: 123, name: abc }
-     * hello:id should match hello:123 and return { id: 123 }
-     * @private
-     */
-    _matchString(string, pattern) {
-        const replace = pattern.replace(/:[^/]+/g, '([^/]+)');
-        const regExp = new RegExp(`^${replace}$`);
-        const matches = string.split('?')[0].match(regExp);
-        if (matches) {
-            const keys = pattern.match(/:[^/]+/g);
-            if (keys) {
-                const obj = {};
-                keys.forEach((key, index) => {
-                    obj[key.replace(':', '')] = matches[index + 1].replace(/\?.*$/, '');
-                });
-                return obj;
-            }
-        }
-        return null;
-    }
-    /**
-     * @desc matches a string to a pattern and returns its params if any
-     * @param string - the string to match
-     * @param pattern - the pattern to match to
-     */
-    _matchStringToPattern(string, pattern) {
-        if (this._isPatternMatchable(pattern)) {
-            return this._matchString(string, pattern);
-        }
-        const valid = this._compareStringToPattern(string, pattern);
-        if (valid) {
-            return {};
-        }
-        return null;
-    }
-}
-exports.MatchPattern = MatchPattern;

package/server/utils/matchPattern.test.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const matchPattern_1 = require("./matchPattern");
-describe('BaseClass', () => {
-    const baseClass = new matchPattern_1.MatchPattern();
-    it('should return true if a string matches a regex | string', () => {
-        const regex = new RegExp(/^test/);
-        expect(baseClass['_compareStringToPattern']('test', regex)).toBe(true);
-        const string = 'test';
-        expect(baseClass['_compareStringToPattern']('test', string)).toBe(true);
-    });
-    it('should return false if a string does not match a regex | string', () => {
-        const regex = new RegExp(/^test$/);
-        expect(baseClass['_compareStringToPattern']('test2', regex)).toBe(false);
-        const string = 'test';
-        expect(baseClass['_compareStringToPattern']('test2', string)).toBe(false);
-    });
-    it('should return the params of a string matching the pattern', () => {
-        const pattern = '/test/:id';
-        const secondPattern = '/test/:id/:id2';
-        const string = '/test/5';
-        const secondString = '/test/5/6';
-        expect(baseClass['_matchString'](string, pattern)).toEqual({ id: '5' });
-        expect(baseClass['_matchString'](secondString, secondPattern)).toEqual({ id: '5',
-            id2: '6' });
-        // this function fails if the pattern is not a string or regex
-        expect(baseClass['_matchString'](secondString, pattern)).toEqual(null);
-        // But will return null if the string is smaller than the pattern
-        expect(baseClass['_matchString'](string, secondPattern)).toEqual(null);
-        // it should also match patterns without the slash
-        const thirdPattern = 'test:id';
-        const thirdString = 'test5';
-        expect(baseClass['_matchString'](thirdString, thirdPattern)).toEqual({ id: '5' });
-    });
-    it('should return the query of string', () => {
-        const string = '/test/5?test=5';
-        const secondString = '/test/5?test=5&test2=6';
-        expect(baseClass['_parseQueries'](string)).toEqual({ test: '5' });
-        expect(baseClass['_parseQueries'](secondString)).toEqual({ test: '5',
-            test2: '6' });
-    });
-    it('should return null if the string does not match the pattern', () => {
-        const pattern = 'pondSocket';
-        const string = '/test2/5';
-        expect(baseClass['_matchStringToPattern'](string, pattern)).toBe(null);
-    });
-    it('should return the params of a string matching the pattern', () => {
-        const pattern = 'pondSocket';
-        const string = 'pondSocket';
-        expect(baseClass['_matchStringToPattern'](string, pattern)).toEqual({});
-    });
-    it('should generateEventRequest', () => {
-        const pattern = 'pondSocket:test';
-        const string = 'pondSockethello?test=5&test2=6';
-        expect(baseClass.parseEvent(pattern, string)).toEqual({
-            address: string,
-            params: { test: 'hello' },
-            query: { test: '5',
-                test2: '6' },
-        });
-        const unMatchingString = 'pondocket2hello?test=5&test2=6';
-        expect(baseClass.parseEvent(pattern, unMatchingString)).toEqual(null);
-    });
-    it('should match any string if the path is *', () => {
-        const pattern = '*';
-        const string = 'pondSockethello?test=5&test2=6';
-        expect(baseClass.parseEvent(pattern, string)).toEqual({
-            address: string,
-            params: {},
-            query: {
-                test: '5',
-                test2: '6',
-            },
-        });
-    });
-});

package/server/utils/subjectUtils.js

@@ -1,68 +0,0 @@
-"use strict";
-// A Subject CLASS that sends a message to all subscribers
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleBehaviorSubject = exports.SimpleSubject = exports.BehaviorSubject = exports.Subject = void 0;
-class Subject {
-    constructor() {
-        this._observers = new Map();
-    }
-    subscribe(identifier, observer) {
-        this._observers.set(identifier, observer);
-    }
-    next(message) {
-        this._observers.forEach((observer) => observer(message));
-    }
-    unsubscribe(identifier) {
-        this._observers.delete(identifier);
-    }
-}
-exports.Subject = Subject;
-// A behavior subject CLASS that sends the last message to new subscribers
-class BehaviorSubject extends Subject {
-    next(message) {
-        this._lastMessage = message;
-        super.next(message);
-    }
-    subscribe(identifier, observer) {
-        if (this._lastMessage) {
-            observer(this._lastMessage);
-        }
-        return super.subscribe(identifier, observer);
-    }
-}
-exports.BehaviorSubject = BehaviorSubject;
-// Simple Subject CLASS
-class SimpleSubject {
-    constructor() {
-        this._observers = new Set();
-    }
-    subscribe(observer) {
-        this._observers.add(observer);
-        return () => this._observers.delete(observer);
-    }
-    next(message) {
-        this._observers.forEach((observer) => observer(message));
-    }
-}
-exports.SimpleSubject = SimpleSubject;
-// Simple BehaviorSubject CLASS
-class SimpleBehaviorSubject extends SimpleSubject {
-    constructor(initialValue) {
-        super();
-        this._lastMessage = initialValue;
-    }
-    get value() {
-        return this._lastMessage;
-    }
-    next(message) {
-        this._lastMessage = message;
-        super.next(message);
-    }
-    subscribe(observer) {
-        if (this._lastMessage) {
-            observer(this._lastMessage);
-        }
-        return super.subscribe(observer);
-    }
-}
-exports.SimpleBehaviorSubject = SimpleBehaviorSubject;

package/server/utils/subjectUtils.test.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const subjectUtils_1 = require("./subjectUtils");
-describe('Subject', () => {
-    let testSubject;
-    let observer1;
-    let observer2;
-    beforeEach(() => {
-        testSubject = new subjectUtils_1.Subject();
-        observer1 = jest.fn();
-        observer2 = jest.fn();
-        testSubject.subscribe('observer1', observer1);
-        testSubject.subscribe('observer2', observer2);
-    });
-    afterEach(() => {
-        testSubject.unsubscribe('observer1');
-        testSubject.unsubscribe('observer2');
-    });
-    it('should notify all subscribers when next is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        expect(observer1).toHaveBeenCalledWith(message);
-        expect(observer2).toHaveBeenCalledWith(message);
-    });
-    it('should unsubscribe an observer when unsubscribe is called', () => {
-        const identifier = 'observer1';
-        testSubject.unsubscribe(identifier);
-        expect(testSubject['_observers'].has(identifier)).toBe(false);
-    });
-});
-describe('BehaviorSubject', () => {
-    let testSubject;
-    let observer1;
-    let observer2;
-    beforeEach(() => {
-        testSubject = new subjectUtils_1.BehaviorSubject();
-        observer1 = jest.fn();
-        observer2 = jest.fn();
-        testSubject.subscribe('observer1', observer1);
-        testSubject.subscribe('observer2', observer2);
-    });
-    afterEach(() => {
-        testSubject.unsubscribe('observer1');
-        testSubject.unsubscribe('observer2');
-    });
-    it('should notify all subscribers when next is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        expect(observer1).toHaveBeenCalledWith(message);
-        expect(observer2).toHaveBeenCalledWith(message);
-    });
-    it('should unsubscribe an observer when unsubscribe is called', () => {
-        const identifier = 'observer1';
-        testSubject.unsubscribe(identifier);
-        expect(testSubject['_observers'].has(identifier)).toBe(false);
-    });
-    it('should notify new subscribers with the last message when subscribe is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        const newObserver = jest.fn();
-        testSubject.subscribe('newObserver', newObserver);
-        expect(newObserver).toHaveBeenCalledWith(message);
-    });
-});
-describe('SimpleSubject', () => {
-    let testSubject;
-    let observer1;
-    let observer2;
-    beforeEach(() => {
-        testSubject = new subjectUtils_1.SimpleSubject();
-        observer1 = jest.fn();
-        observer2 = jest.fn();
-        testSubject.subscribe(observer1);
-        testSubject.subscribe(observer2);
-    });
-    afterEach(() => {
-        testSubject.next(0);
-    });
-    it('should notify all subscribers when publish is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        expect(observer1).toHaveBeenCalledWith(message);
-        expect(observer2).toHaveBeenCalledWith(message);
-    });
-    it('should unsubscribe an observer when unsubscribe is called', () => {
-        const unsubscribe = testSubject.subscribe(observer1);
-        unsubscribe();
-        expect(testSubject['_observers'].size).toBe(1);
-    });
-});
-describe('SimpleBehaviorSubject', () => {
-    let testSubject;
-    let observer1;
-    let observer2;
-    beforeEach(() => {
-        testSubject = new subjectUtils_1.SimpleBehaviorSubject(0);
-        observer1 = jest.fn();
-        observer2 = jest.fn();
-        testSubject.subscribe(observer1);
-        testSubject.subscribe(observer2);
-    });
-    afterEach(() => {
-        testSubject.next(0);
-    });
-    it('should notify all subscribers when publish is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        expect(observer1).toHaveBeenCalledWith(message);
-        expect(observer2).toHaveBeenCalledWith(message);
-    });
-    it('should unsubscribe an observer when unsubscribe is called', () => {
-        const unsubscribe = testSubject.subscribe(observer1);
-        unsubscribe();
-        expect(testSubject['_observers'].size).toBe(1);
-    });
-    it('should notify new subscribers with the last message when subscribe is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        const newObserver = jest.fn();
-        testSubject.subscribe(newObserver);
-        expect(newObserver).toHaveBeenCalledWith(message);
-    });
-    it('should return the last message when value is called', () => {
-        const message = 10;
-        testSubject.next(message);
-        expect(testSubject.value).toBe(message);
-    });
-});