@eleven-am/pondsocket 0.1.56 → 0.1.57

package/src/matcher/matcher.ts

@@ -0,0 +1,105 @@
+// eslint-disable-next-line import/no-unresolved
+import { Params, PondPath, EventParams } from '../types';
+
+/**
+ * @desc Returns the {key: value} matches of a string
+ * @param path - the string to create the regex from
+ * @param address - 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
+ */
+function matchPath (path: string, address: string) {
+    const pathParts = path.split('/');
+    const addressParts = address.split('/');
+
+    const params: Record<string, string> = {};
+    const length = Math.max(pathParts.length, addressParts.length);
+
+    for (let i = 0; i < length; i++) {
+        const pathPart = pathParts[i];
+        const addressPart = addressParts[i];
+
+        if (pathPart === undefined || addressPart === undefined) {
+            return null;
+        } else if (pathPart === '*') {
+            return params as Params<typeof path>;
+        } else if (pathPart.startsWith(':')) {
+            params[pathPart.slice(1)] = addressPart;
+        } else if (pathPart !== addressPart) {
+            return null;
+        }
+    }
+
+    return params as Params<typeof path>;
+}
+
+/**
+ * @desc Given a Regex expression it returns an empty object if the address matches
+ * @param regex - The regex to match the address against
+ * @param address - The address ot match
+ */
+function matchRegex (regex: RegExp, address: string) {
+    if (address.match(regex)) {
+        return {};
+    }
+
+    return null;
+}
+
+/**
+ * @desc Creates an object from the params of a path
+ * @param address - 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' }
+ */
+function getQuery (address: string) {
+    const obj: { [p: string]: string } = {};
+    const params = address.split('?')[1];
+
+    if (params) {
+        params.split('&').forEach((param) => {
+            const [key, value] = param.split('=');
+
+            obj[key] = value;
+        });
+    }
+
+    return obj;
+}
+
+/**
+ * @desc Generates a pond request resolver object
+ * @param path - the path to resolve
+ * @param address - the address to resolve
+ */
+export function parseAddress <Path extends string> (path: PondPath<Path>, address: string) {
+    let params: Record<string, string> | null;
+    const [paramsPath] = address.split('?');
+
+    if (typeof path === 'string') {
+        params = matchPath(path, paramsPath);
+
+        if (params === null) {
+            return null;
+        }
+    } else {
+        params = matchRegex(path, paramsPath);
+
+        if (params === null) {
+            return null;
+        }
+    }
+
+    const query = getQuery(address);
+
+    return {
+        params,
+        query,
+    } as EventParams<Path>;
+}

package/src/node.ts

@@ -0,0 +1,33 @@
+import PondSocketClient from './client';
+// eslint-disable-next-line import/no-unresolved
+import { ChannelEvent } from './types';
+
+const WebSocket = require('websocket').w3cwebsocket as typeof import('websocket').w3cwebsocket;
+
+export default class PondClient extends PondSocketClient {
+    /**
+     * @desc Connects to the server and returns the socket.
+     */
+    public connect (backoff = 1) {
+        const socket = new WebSocket(this._address.toString());
+
+        socket.onopen = () => {
+            this._connectionState.publish(true);
+        };
+
+        socket.onmessage = (message) => {
+            const data = JSON.parse(message.data as string) as ChannelEvent;
+
+            this._broadcaster.publish(data);
+        };
+
+        socket.onerror = () => {
+            this._connectionState.publish(false);
+            setTimeout(() => {
+                this.connect(backoff * 2);
+            }, backoff * 1000);
+        };
+
+        this._socket = socket;
+    }
+}

package/src/presence/presence.ts

@@ -0,0 +1,127 @@
+import { ChannelEngine } from '../channel/channel';
+import { PresenceEventTypes, SystemSender, ServerActions } from '../enums';
+import { PresenceError } from '../errors/pondError';
+// eslint-disable-next-line import/no-unresolved
+import { PondPresence, UserPresences, PresencePayload } from '../types';
+
+export class PresenceEngine {
+    readonly #presenceMap: Map<string, PondPresence>;
+
+    readonly #channel: ChannelEngine;
+
+    constructor (channel: ChannelEngine) {
+        this.#channel = channel;
+        this.#presenceMap = new Map<string, PondPresence>();
+    }
+
+    /**
+     * @desc Lists all the presence of the users
+     */
+    public getPresence (): UserPresences {
+        return Array.from(this.#presenceMap.entries())
+            .reduce((acc, [key, value]) => {
+                acc[key] = value;
+
+                return acc;
+            }, {} as UserPresences);
+    }
+
+    /**
+     * @desc Returns the presence of a user
+     * @param userId - The id of the user
+     */
+    public getUserPresence (userId: string): PondPresence | undefined {
+        return this.#presenceMap.get(userId);
+    }
+
+    /**
+     * @desc Tracks a presence
+     * @param presenceKey - The key of the presence
+     * @param presence - The presence
+     */
+    public trackPresence (presenceKey: string, presence: PondPresence) {
+        if (!this.#presenceMap.has(presenceKey)) {
+            this.#presenceMap.set(presenceKey, presence);
+            this.#publish(PresenceEventTypes.JOIN, {
+                changed: presence,
+                presence: Array.from(this.#presenceMap.values()),
+            });
+        } else {
+            const code = 400;
+            const message = `PresenceEngine: Presence with key ${presenceKey} already exists`;
+
+            throw new PresenceError(message, code, this.#channel.name, PresenceEventTypes.JOIN);
+        }
+    }
+
+    /**
+     * @desc Removes a presence from the presence engine
+     * @param presenceKey - The key of the presence
+     * @param graceful - Whether to gracefully remove the presence
+     */
+    public removePresence (presenceKey: string, graceful = false) {
+        const presence = this.#presenceMap.get(presenceKey);
+
+        if (presence) {
+            this.#presenceMap.delete(presenceKey);
+            this.#publish(PresenceEventTypes.LEAVE, {
+                changed: presence,
+                presence: Array.from(this.#presenceMap.values()),
+            });
+        } else if (!graceful) {
+            const code = 404;
+            const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
+
+            throw new PresenceError(message, code, this.#channel.name, PresenceEventTypes.LEAVE);
+        }
+    }
+
+    /**
+     * @desc Updates a presence
+     * @param presenceKey - The key of the presence
+     * @param presence - The new presence
+     */
+    public updatePresence (presenceKey: string, presence: PondPresence) {
+        const oldPresence = this.#presenceMap.get(presenceKey);
+
+        if (oldPresence) {
+            const newPresence = {
+                ...oldPresence,
+                ...presence,
+            };
+
+            this.#presenceMap.set(presenceKey, newPresence);
+            this.#publish(PresenceEventTypes.UPDATE, {
+                changed: newPresence,
+                presence: Array.from(this.#presenceMap.values()),
+            });
+        } else {
+            const code = 404;
+            const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
+
+            throw new PresenceError(message, code, this.#channel.name, PresenceEventTypes.UPDATE);
+        }
+    }
+
+    /**
+     * @desc Publishes a presence event to all users in the channel
+     * @param event - The event type
+     * @param payload - The payload of the event
+     * @private
+     */
+    #publish (event: PresenceEventTypes, payload: PresencePayload) {
+        const recipients = Array.from(this.#presenceMap.keys());
+
+        if (recipients.length === 0) {
+            return;
+        }
+
+        this.#channel.sendMessage(
+            SystemSender.CHANNEL,
+            recipients,
+            ServerActions.PRESENCE,
+            event,
+            payload,
+        );
+    }
+}

package/src/presence/presenceEngine.test.ts

@@ -0,0 +1,143 @@
+import { PresenceEngine } from './presence';
+import { ChannelEngine } from '../channel/channel';
+import { createChannelEngine } from '../channel/eventResponse.test';
+import { PresenceEventTypes, SystemSender, ServerActions } from '../enums';
+// eslint-disable-next-line import/no-unresolved
+import { PondPresence } from '../types';
+
+describe('PresenceEngine', () => {
+    let presenceEngine: PresenceEngine;
+    let presence: PondPresence;
+    let presenceKey: string;
+    let channel: ChannelEngine;
+
+    beforeEach(() => {
+        channel = createChannelEngine();
+        channel.addUser('presenceKey', { assign: 'assign' }, () => {
+            // do nothing
+        });
+        presenceEngine = new PresenceEngine(channel);
+        presence = {
+            id: 'id',
+            name: 'name',
+            color: 'color',
+            type: 'type',
+            location: 'location',
+        };
+        presenceKey = 'presenceKey';
+    });
+
+    describe('trackPresence', () => {
+        it('should insert a presence into the presence engine', () => {
+            // spy on the channel sendMessage method
+            jest.spyOn(channel, 'sendMessage');
+            presenceEngine.trackPresence(presenceKey, presence);
+            expect(channel.sendMessage).toHaveBeenCalledWith(
+                SystemSender.CHANNEL,
+                ['presenceKey'],
+                ServerActions.PRESENCE,
+                PresenceEventTypes.JOIN,
+                {
+                    changed: presence,
+                    presence: [presence],
+                },
+            );
+        });
+
+        it('should throw an error if the presence already exists', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
+            expect(() => presenceEngine.trackPresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} already exists`);
+        });
+    });
+
+    describe('updatePresence', () => {
+        it('should update a presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
+            const newPresence = {
+                id: 'id',
+                name: 'name',
+                color: 'color',
+                type: 'type',
+                location: 'location',
+            };
+
+            jest.spyOn(channel, 'sendMessage');
+            presenceEngine.updatePresence(presenceKey, newPresence);
+            expect(channel.sendMessage).toHaveBeenCalledWith(
+                SystemSender.CHANNEL,
+                ['presenceKey'],
+                ServerActions.PRESENCE,
+                PresenceEventTypes.UPDATE,
+                {
+                    changed: {
+                        ...presence,
+                        ...newPresence,
+                    },
+                    presence: [newPresence],
+                },
+            );
+        });
+
+        it('should throw an error if the presence does not exist', () => {
+            expect(() => presenceEngine.updatePresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        });
+    });
+
+    describe('removePresence', () => {
+        it('should remove a presence from the presence engine', () => {
+            const listener = jest.spyOn(channel, 'sendMessage');
+
+            // before we can track a presence, we need make sure the user is in the channel
+            channel.addUser('presenceKey2', { assign: 'assign' }, () => {
+                // do nothing
+            });
+            presenceEngine.trackPresence(presenceKey, presence);
+            presenceEngine.trackPresence('presenceKey2', {
+                ...presence,
+                key: 'presence2',
+            });
+
+            expect(listener).toHaveBeenCalledTimes(2);
+
+            // clear the mock
+            listener.mockClear();
+
+            presenceEngine.removePresence(presenceKey);
+
+            expect(listener).toHaveBeenCalledTimes(1);
+            expect(listener).toHaveBeenCalledWith(
+                SystemSender.CHANNEL,
+                ['presenceKey2'],
+                ServerActions.PRESENCE,
+                PresenceEventTypes.LEAVE,
+                {
+                    changed: presence,
+                    presence: [
+                        {
+                            ...presence,
+                            key: 'presence2',
+                        },
+                    ],
+                },
+            );
+
+            listener.mockClear();
+            presenceEngine.removePresence('presenceKey2');
+            expect(listener).toHaveBeenCalledTimes(0);
+        });
+
+        it('should throw an error if the presence does not exist', () => {
+            expect(() => presenceEngine.removePresence(presenceKey)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        });
+    });
+
+    describe('getPresence', () => {
+        it('should return the presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
+            const data: any = {};
+
+            data[presenceKey] = presence;
+            expect(presenceEngine.getPresence()).toEqual(data);
+        });
+    });
+});

package/src/server/pondSocket.ts

@@ -0,0 +1,153 @@
+import { Server as HTTPServer, IncomingHttpHeaders } from 'http';
+
+import { WebSocketServer, WebSocket } from 'ws';
+
+import { Middleware } from '../abstracts/middleware';
+import { Endpoint } from '../endpoint/endpoint';
+import { ConnectionResponse } from '../endpoint/response';
+import { ServerActions, SystemSender, ErrorTypes } from '../enums';
+import { parseAddress } from '../matcher/matcher';
+// eslint-disable-next-line import/no-unresolved
+import { PondPath, IncomingConnection } from '../types';
+
+interface SocketRequest {
+    id: string;
+    headers: IncomingHttpHeaders;
+    address: string;
+}
+
+export class PondSocket {
+    readonly #server: HTTPServer;
+
+    readonly #socketServer: WebSocketServer;
+
+    readonly #middleware: Middleware<SocketRequest, WebSocket>;
+
+    constructor (server?: HTTPServer, socketServer?: WebSocketServer) {
+        this.#server = server ?? new HTTPServer();
+        this.#socketServer = socketServer ?? new WebSocketServer({ noServer: true });
+        this.#middleware = new Middleware();
+        this.#init();
+    }
+
+    /**
+     * @desc Specifies the port to listen on
+     * @param args - the arguments to pass to the server
+     */
+    public listen (...args: any[]) {
+        return this.#server.listen(...args);
+    }
+
+    /**
+     * @desc Closes the server
+     * @param callback - the callback to call when the server is closed
+     */
+    public close (callback?: () => void) {
+        return this.#server.close(callback);
+    }
+
+    /**
+     * @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
+     * @param handler - the handler function to authenticate the socket
+     * @example
+     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
+     *    const token = req.query.token;
+     *    if (!token)
+     *       return res.reject('No token provided');
+     *    res.accept({
+     *       assign: {
+     *           token
+     *       }
+     *    });
+     * })
+     */
+    public createEndpoint<Path extends string> (path: PondPath<Path>, handler: (request: IncomingConnection<Path>, response: ConnectionResponse) => void | Promise<void>) {
+        const endpoint = new Endpoint(this.#socketServer);
+
+        this.#middleware.use((req, socket, next) => {
+            const event = parseAddress(path, req.address);
+
+            if (event) {
+                const request: IncomingConnection<Path> = {
+                    ...event,
+                    headers: req.headers,
+                    address: req.address,
+                    id: req.id,
+                };
+
+                const response = new ConnectionResponse(socket, endpoint, request.id);
+
+                return handler(request, response);
+            }
+
+            return next();
+        });
+
+        return endpoint;
+    }
+
+    /**
+     * @desc managed the heartbeat of the socket server
+     * @private
+     */
+    #manageHeartbeat () {
+        this.#socketServer.on('connection', (socket: WebSocket & { isAlive?: boolean }) => {
+            socket.on('pong', () => {
+                socket.isAlive = true;
+            });
+        });
+
+        const interval = setInterval(() => {
+            this.#socketServer.clients.forEach((socket: WebSocket & { isAlive?: boolean }) => {
+                if (socket.isAlive === false) {
+                    return socket.terminate();
+                }
+
+                socket.isAlive = false;
+                socket.ping();
+            });
+        }, 30000);
+
+        this.#socketServer.on('close', () => clearInterval(interval));
+    }
+
+    /**
+     * @desc initialises the socket server
+     * @private
+     */
+    #init () {
+        this.#manageHeartbeat();
+
+        this.#server.on('error', (error) => {
+            throw new Error(error.message);
+        });
+
+        this.#server.on('upgrade', (req, socket, head) => {
+            const clientId = req.headers['sec-websocket-key'] as string;
+            const request: SocketRequest = {
+                id: clientId,
+                headers: req.headers,
+                address: req.url || '',
+            };
+
+            this.#socketServer.handleUpgrade(req, socket, head, (socket) => {
+                this.#socketServer.emit('connection', socket);
+                this.#middleware.run(request, socket, () => {
+                    const message = {
+                        action: ServerActions.ERROR,
+                        event: ErrorTypes.HANDLER_NOT_FOUND,
+                        channelName: SystemSender.ENDPOINT,
+                        payload: {
+                            message: 'No endpoint found',
+                            code: 404,
+                        },
+                    };
+
+                    socket.send(JSON.stringify(message));
+                    socket.close();
+                });
+            });
+        });
+    }
+}