@eleven-am/pondsocket 0.1.11 → 0.1.12

package/dist/server/channel/channelResponse.test.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelEvent = exports.createChannelEngine = void 0;
+const channelEngine_1 = require("./channelEngine");
+const channelEngine_test_1 = require("./channelEngine.test");
+const eventResponse_1 = require("./eventResponse");
+const createChannelEngine = () => {
+    const parentEngine = (0, channelEngine_test_1.createParentEngine)();
+    return new channelEngine_1.ChannelEngine('test', parentEngine);
+};
+exports.createChannelEngine = createChannelEngine;
+const createChannelEvent = () => {
+    const responseEvent = {
+        event: 'event',
+        payload: {
+            payload: 'payload',
+        },
+        sender: 'sender',
+        action: channelEngine_1.ServerActions.BROADCAST,
+        recipients: ['recipient'],
+    };
+    return responseEvent;
+};
+exports.createChannelEvent = createChannelEvent;
+const createChannelResponse = () => {
+    const channelEngine = (0, exports.createChannelEngine)();
+    const event = (0, exports.createChannelEvent)();
+    channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
+    const response = new eventResponse_1.EventResponse(event, channelEngine);
+    return { channelEngine,
+        event,
+        response };
+};
+describe('ChannelResponse', () => {
+    it('should create a new ChannelResponse', () => {
+        const { response } = createChannelResponse();
+        expect(response).toBeDefined();
+    });
+    it('should return the responseSent', () => {
+        const { response } = createChannelResponse();
+        expect(response.responseSent).toEqual(false);
+    });
+    it('should accept the request', () => {
+        const { response } = createChannelResponse();
+        response.accept();
+        expect(response.responseSent).toEqual(true);
+    });
+    it('should reject the request', () => {
+        const { response, channelEngine, event } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.reject();
+        expect(response.responseSent).toEqual(true);
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('channel', [event.sender], channelEngine_1.ServerActions.ERROR, 'error_channel', { message: 'Unauthorized request',
+            code: 403 });
+    });
+    it('should send a direct message', () => {
+        const { response, channelEngine, event } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.send('event', { payload: 'payload' });
+        expect(response.responseSent).toEqual(true);
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('channel', [event.sender], channelEngine_1.ServerActions.SYSTEM, 'event', { payload: 'payload' });
+    });
+    it('should broadcast a message', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.broadcast('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', 'all_users', channelEngine_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should broadcastFromUser a message', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.broadcastFromUser('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should sendToUsers a message', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        channelEngine.addUser('recipient', { assign: 'assign' }, () => { });
+        response.sendToUsers('event', { payload: 'payload' }, ['recipient']);
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['recipient'], channelEngine_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should track a trackPresence', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'trackPresence');
+        response.trackPresence({ status: 'online' });
+        expect(channelEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+    });
+    it('should untrack a trackPresence', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'unTrackPresence');
+        response.unTrackPresence();
+        expect(channelEngine.unTrackPresence).toHaveBeenCalledWith('sender');
+    });
+    it('should broadcast an error if untrackPresence is called twice', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        // because by default the user is not tracked and the presence engine only exists after a first trackPresence
+        // we need to call trackPresence first
+        response.trackPresence({ status: 'online' });
+        response.unTrackPresence();
+        response.unTrackPresence();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('channel', ['sender'], channelEngine_1.ServerActions.ERROR, 'error_channel', {
+            message: 'PresenceEngine: Presence with key sender does not exist',
+            code: 500,
+        });
+    });
+    it('should updatePresence', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'updatePresence');
+        response.trackPresence({ status: 'online' });
+        response.updatePresence({ status: 'updated' });
+        expect(channelEngine.updatePresence).toHaveBeenCalledWith('sender', { status: 'updated' });
+    });
+    it('should update a users assign data', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'updateAssigns');
+        response.accept({ assign: 'updated' });
+        expect(channelEngine.updateAssigns).toHaveBeenCalledWith('sender', { assign: 'updated' });
+    });
+    it('should evict a user', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'kickUser');
+        response.evictUser('recipient');
+        expect(channelEngine.kickUser).toHaveBeenCalledWith('sender', 'recipient');
+        expect(response.responseSent).toEqual(true);
+    });
+    it('should destroy the channel', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'destroy');
+        response.closeChannel('recipient');
+        expect(channelEngine.destroy).toHaveBeenCalledWith('recipient');
+        expect(response.responseSent).toEqual(true);
+    });
+});

package/dist/server/channel/eventRequest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRequest = void 0;
+const abstractRequest_1 = require("../abstracts/abstractRequest");
+class EventRequest extends abstractRequest_1.AbstractRequest {
+    constructor(event, engine) {
+        super(event.event, engine, event.payload);
+        this._internalEvent = event;
+    }
+    get user() {
+        const assigns = this._engine.getUserData(this._internalEvent.sender);
+        if (!assigns) {
+            throw new Error(`ChannelRequest: User with id ${this._internalEvent.sender} does not exist in channel ${this._engine.name}`);
+        }
+        return assigns;
+    }
+}
+exports.EventRequest = EventRequest;

package/dist/server/channel/eventResponse.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventResponse = void 0;
+const channelEngine_1 = require("./channelEngine");
+const abstractResponse_1 = require("../abstracts/abstractResponse");
+class EventResponse extends abstractResponse_1.PondResponse {
+    constructor(event, engine) {
+        super();
+        this._hasExecuted = false;
+        this._event = event;
+        this._engine = engine;
+    }
+    /**
+     * @desc Checks if the response has been sent
+     */
+    get responseSent() {
+        return this._hasExecuted;
+    }
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    accept(assigns) {
+        this._manageAssigns(assigns);
+        this._hasExecuted = true;
+        return this;
+    }
+    /**
+     * @desc Rejects the request and optionally assigns data to the client
+     * @param message - the error message
+     * @param errorCode - the error code
+     * @param assigns - the data to assign to the client
+     */
+    reject(message, errorCode, assigns) {
+        this._manageAssigns(assigns);
+        const text = message || 'Unauthorized request';
+        this._engine.sendMessage('channel', [this._event.sender], channelEngine_1.ServerActions.ERROR, 'error_channel', { message: text,
+            code: errorCode || 403 });
+        this._hasExecuted = true;
+        return this;
+    }
+    /**
+     * @desc Emits a direct message to the client
+     * @param event - the event name
+     * @param payload - the payload to send
+     * @param assigns - the data to assign to the client
+     */
+    send(event, payload, assigns) {
+        this._engine.sendMessage('channel', [this._event.sender], channelEngine_1.ServerActions.SYSTEM, event, payload);
+        return this.accept(assigns);
+    }
+    /**
+     * @desc Sends a message to all clients in the channel
+     * @param event - the event to send
+     * @param payload - the payload to send
+     */
+    broadcast(event, payload) {
+        this._engine.sendMessage(this._event.sender, 'all_users', channelEngine_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Sends a message to all clients in the channel except the client making the request
+     * @param event - the event to send
+     * @param payload - the payload to send
+     */
+    broadcastFromUser(event, payload) {
+        this._engine.sendMessage(this._event.sender, 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Sends a message to a set of clients in the channel
+     * @param event - the event to send
+     * @param payload - the payload to send
+     * @param userIds - the ids of the clients to send the message to
+     */
+    sendToUsers(event, payload, userIds) {
+        this._engine.sendMessage(this._event.sender, userIds, channelEngine_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Tracks a user's presence in the channel
+     * @param presence - the initial presence data
+     * @param userId - the id of the user to track
+     */
+    trackPresence(presence, userId) {
+        this._engine.trackPresence(userId || this._event.sender, presence);
+        return this;
+    }
+    /**
+     * @desc Updates a user's presence in the channel
+     * @param presence - the updated presence data
+     * @param userId - the id of the user to update
+     */
+    updatePresence(presence, userId) {
+        this._engine.updatePresence(userId || this._event.sender, presence);
+        return this;
+    }
+    /**
+     * @desc Removes a user's presence from the channel
+     * @param userId - the id of the user to remove
+     */
+    unTrackPresence(userId) {
+        userId = userId || this._event.sender;
+        try {
+            this._engine.unTrackPresence(userId);
+        }
+        catch (e) {
+            this._engine.sendMessage('channel', [userId], channelEngine_1.ServerActions.ERROR, 'error_channel', { message: e.message,
+                code: 500 });
+        }
+        return this;
+    }
+    /**
+     * @desc Evicts a user from the channel
+     * @param reason - the reason for the eviction
+     * @param userId - the id of the user to evict,
+     */
+    evictUser(reason, userId) {
+        this._engine.kickUser(userId || this._event.sender, reason);
+        this._hasExecuted = true;
+    }
+    /**
+     * @desc Closes the channel from the server side for all clients
+     * @param reason - the reason for closing the channel
+     */
+    closeChannel(reason) {
+        this._engine.destroy(reason);
+        this._hasExecuted = true;
+    }
+    /**
+     * @desc Gets the event that triggered the response
+     * @param assigns - the data to assign to the client
+     * @private
+     */
+    _manageAssigns(assigns) {
+        if (assigns) {
+            this._engine.updateAssigns(this._event.sender, assigns);
+        }
+    }
+}
+exports.EventResponse = EventResponse;

package/dist/server/endpoint/connectionResponse.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionResponse = void 0;
+const abstractResponse_1 = require("../abstracts/abstractResponse");
+class ConnectionResponse extends abstractResponse_1.PondResponse {
+    constructor(handler) {
+        super();
+        this._hasExecuted = false;
+        this._handler = handler;
+    }
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    accept(assigns) {
+        if (this._hasExecuted) {
+            throw new Error('EndpointResponse: Message has already been processed');
+        }
+        this._hasExecuted = true;
+        this._handler(assigns || {}, {});
+    }
+    /**
+     * @desc Rejects the request with the given error message
+     * @param message - the error message
+     * @param errorCode - the error code
+     */
+    reject(message, errorCode) {
+        if (this._hasExecuted) {
+            throw new Error('EndpointResponse: Message has already been processed');
+        }
+        this._hasExecuted = true;
+        this._handler({}, { error: { message: message || 'Message rejected',
+                code: errorCode || 403 } });
+    }
+    /**
+     * @desc Emits a direct message to the client
+     * @param event - the event name
+     * @param payload - the payload to send
+     * @param assigns - the data to assign to the client
+     */
+    send(event, payload, assigns) {
+        if (this._hasExecuted) {
+            throw new Error('EndpointResponse: Message has already been processed');
+        }
+        this._hasExecuted = true;
+        this._handler(assigns || {}, { message: { event,
+                payload } });
+    }
+}
+exports.ConnectionResponse = ConnectionResponse;

package/dist/server/endpoint/endpoint.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoint = exports.ClientActions = void 0;
+const connectionResponse_1 = require("./connectionResponse");
+const channelEngine_1 = require("../channel/channelEngine");
+const matchPattern_1 = require("../utils/matchPattern");
+var ClientActions;
+(function (ClientActions) {
+    ClientActions["JOIN_CHANNEL"] = "JOIN_CHANNEL";
+    ClientActions["LEAVE_CHANNEL"] = "LEAVE_CHANNEL";
+    ClientActions["BROADCAST"] = "BROADCAST";
+})(ClientActions = exports.ClientActions || (exports.ClientActions = {}));
+class Endpoint {
+    constructor(server) {
+        this._server = server;
+        this._channels = [];
+        this._sockets = new Set();
+        this._matcher = new matchPattern_1.MatchPattern();
+    }
+    /**
+     * @desc Adds a new PondChannel to this path on this endpoint
+     * @param path - The path to add the channel to
+     * @param channel - The channel to add
+     *
+     * @example
+     * endpoint.useChannel('/chat', pondChannelInstance);
+     */
+    useChannel(path, channel) {
+        const manager = channel._buildManager();
+        this._channels.push({ path,
+            manager });
+    }
+    /**
+     * @desc List all clients connected to this endpoint
+     */
+    listConnections() {
+        return [...this._sockets].map(({ clientId }) => clientId);
+    }
+    /**
+     * @desc Gets all clients connected to this endpoint
+     */
+    getClients() {
+        return [...this._sockets];
+    }
+    /**
+     * @desc Broadcasts a message to all clients connected to this endpoint
+     * @param event - The event to broadcast
+     * @param payload - The payload to broadcast
+     */
+    broadcast(event, payload) {
+        this._sockets.forEach(({ socket }) => {
+            const message = {
+                event,
+                payload,
+                action: channelEngine_1.ServerActions.BROADCAST,
+                channelName: 'SERVER',
+            };
+            this._sendMessage(socket, message);
+        });
+    }
+    /**
+     * @desc Closes specific clients connected to this endpoint
+     * @param clientIds - The id for the client / clients to close
+     */
+    closeConnection(clientIds) {
+        const clients = typeof clientIds === 'string' ? [clientIds] : clientIds;
+        this.getClients()
+            .forEach(({ clientId, socket }) => {
+            if (clients.includes(clientId)) {
+                socket.close();
+            }
+        });
+    }
+    /**
+     * @desc Authenticates the client to the endpoint
+     * @param request - Incoming request
+     * @param socket - Incoming socket
+     * @param head - Incoming head
+     * @param data - Incoming the data resolved from the handler
+     * @param handler - The handler to use to authenticate the client
+     */
+    _authoriseConnection(request, socket, head, data, handler) {
+        const clientId = this._generateClientId();
+        const req = Object.assign(Object.assign({ headers: request.headers }, data), { id: clientId });
+        const resolver = (assigns, data) => {
+            if (data.error) {
+                socket.write(`HTTP/1.1 ${data.error.code} ${data.error.message}\r\n\r\n`);
+                return socket.destroy();
+            }
+            this._server.handleUpgrade(request, socket, head, (ws) => {
+                this._server.emit('connection', ws);
+                const socketCache = {
+                    socket: ws,
+                    assigns,
+                    clientId,
+                };
+                this._sockets.add(socketCache);
+                this._manageSocket(socketCache);
+                if (data.message) {
+                    const newMessage = {
+                        event: data.message.event,
+                        channelName: 'SERVER',
+                        payload: data.message.payload,
+                        action: channelEngine_1.ServerActions.SYSTEM,
+                    };
+                    this._sendMessage(ws, newMessage);
+                }
+            });
+        };
+        const res = new connectionResponse_1.ConnectionResponse(resolver);
+        handler(req, res);
+    }
+    /**
+     * @desc Manages a new socket connection
+     * @param cache - The socket cache
+     * @private
+     */
+    _manageSocket(cache) {
+        const socket = cache.socket;
+        socket.addEventListener('message', (message) => {
+            this._readMessage(cache, message.data);
+        });
+        socket.addEventListener('close', () => {
+            this._channels
+                .forEach(({ manager }) => manager.removeUser(cache.clientId));
+        });
+        socket.addEventListener('error', () => {
+            this._channels
+                .forEach(({ manager }) => manager.removeUser(cache.clientId));
+        });
+    }
+    /**
+     * @desc Sends a message to a client
+     * @param socket - The socket to send the message to
+     * @param message - The message to send
+     */
+    _sendMessage(socket, message) {
+        socket.send(JSON.stringify(message));
+    }
+    /**
+     * @desc Adds a new client to a channel on this endpoint
+     * @param channel - The channel to add the client to
+     * @param socket - The client to add to the channel
+     * @param joinParams - The parameters to pass to the channel
+     * @private
+     */
+    _joinChannel(channel, socket, joinParams) {
+        for (const { path, manager } of this._channels) {
+            const match = this._matcher.parseEvent(path, channel);
+            if (match) {
+                const request = Object.assign(Object.assign(Object.assign({}, match), socket), { joinParams, channelName: channel });
+                return manager.addUser(request);
+            }
+        }
+        throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
+    }
+    /**
+     * @desc Executes a function on a channel
+     * @param channel - The channel to execute the function on
+     * @param handler - The function to execute
+     * @private
+     */
+    _execute(channel, handler) {
+        for (const { manager } of this._channels) {
+            const isPresent = manager.listChannels().includes(channel);
+            if (isPresent) {
+                return manager.execute(channel, handler);
+            }
+        }
+        throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
+    }
+    /**
+     * @desc Deals with a message sent from a client
+     * @param cache - The socket cache of the client
+     * @param message - The message to handle
+     */
+    _handleMessage(cache, message) {
+        switch (message.action) {
+            case ClientActions.JOIN_CHANNEL:
+                this._joinChannel(message.channelName, cache, message.payload);
+                break;
+            case ClientActions.LEAVE_CHANNEL:
+                this._execute(message.channelName, (channel) => {
+                    channel.removeUser(cache.clientId);
+                });
+                break;
+            case ClientActions.BROADCAST:
+                this._execute(message.channelName, (channel) => {
+                    channel.broadcastMessage(cache.clientId, message);
+                });
+                break;
+            default:
+                throw new Error(`GatewayEngine: Action ${message.action} does not exist`);
+        }
+    }
+    /**
+     * @desc Handles a message sent from a client
+     * @param cache - The socket cache of the client
+     * @param message - The message to handle
+     * @private
+     */
+    _readMessage(cache, message) {
+        const errorMessage = {
+            event: 'error',
+            action: channelEngine_1.ServerActions.ERROR,
+            channelName: 'ENDPOINT',
+            payload: {},
+        };
+        try {
+            const data = JSON.parse(message);
+            if (!data.action) {
+                errorMessage.payload = {
+                    message: 'No action provided',
+                };
+            }
+            else if (!data.channelName) {
+                errorMessage.payload = {
+                    message: 'No channel name provided',
+                };
+            }
+            else if (!data.payload) {
+                errorMessage.payload = {
+                    message: 'No payload provided',
+                };
+            }
+            if (!this._isObjectEmpty(errorMessage.payload)) {
+                this._sendMessage(cache.socket, errorMessage);
+            }
+            else {
+                this._handleMessage(cache, data);
+            }
+        }
+        catch (e) {
+            if (e instanceof SyntaxError) {
+                errorMessage.payload = {
+                    message: 'Invalid JSON',
+                };
+                this._sendMessage(cache.socket, errorMessage);
+            }
+            else if (e instanceof Error) {
+                errorMessage.payload = {
+                    message: e.message,
+                };
+                this._sendMessage(cache.socket, errorMessage);
+            }
+        }
+    }
+    /**
+     * @desc Checks if an object is empty
+     * @param obj - The object to check
+     * @private
+     */
+    _isObjectEmpty(obj) {
+        return Object.keys(obj).length === 0;
+    }
+    /**
+     * @desc Generates a new client ID
+     * @private
+     */
+    _generateClientId() {
+        let id = '';
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < 21; i++) {
+            id += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return id;
+    }
+}
+exports.Endpoint = Endpoint;