@eleven-am/pondsocket 0.1.49 → 0.1.51

package/server/abstracts/middleware.test.js

@@ -1,70 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const middleware_1 = require("./middleware");
-describe('Middleware', () => {
-    it('should be able to add middleware to the stack', () => {
-        const middleware = new middleware_1.Middleware();
-        middleware.use(() => { });
-        expect(middleware['_stack'].length).toBe(1);
-    });
-    it('should be able to run middleware', () => __awaiter(void 0, void 0, void 0, function* () {
-        const middleware = new middleware_1.Middleware();
-        const mock = jest.fn();
-        middleware.use(mock);
-        yield middleware.run({}, {}, () => { });
-        expect(mock).toHaveBeenCalled();
-    }));
-    it('should be able to run multiple middleware', () => __awaiter(void 0, void 0, void 0, function* () {
-        const middleware = new middleware_1.Middleware();
-        const mock = jest.fn();
-        middleware.use((_, __, next) => {
-            mock('first');
-            next();
-        });
-        middleware.use((_, __, next) => {
-            mock('second');
-            next();
-        });
-        yield middleware.run({}, {}, () => { });
-        expect(mock).toHaveBeenCalledTimes(2);
-        expect(mock.mock.calls[0][2]).toBe(mock.mock.calls[1][2]);
-    }));
-    it('should be merge middleware in the correct order', () => __awaiter(void 0, void 0, void 0, function* () {
-        const middleware = new middleware_1.Middleware();
-        const mock = jest.fn();
-        middleware.use(mock);
-        middleware.use(mock);
-        const middleware2 = new middleware_1.Middleware(middleware);
-        expect(middleware2['_stack'].length).toBe(2);
-    }));
-    it('should call the final function when the middleware stack is empty', () => __awaiter(void 0, void 0, void 0, function* () {
-        const middleware = new middleware_1.Middleware();
-        const mock = jest.fn();
-        yield middleware.run({}, {}, mock);
-        expect(mock).toHaveBeenCalled();
-    }));
-    it('should be able to run middleware in the correct order when using a second middleware', () => __awaiter(void 0, void 0, void 0, function* () {
-        const middleware = new middleware_1.Middleware();
-        const mock = jest.fn();
-        middleware.use((_, __, next) => {
-            mock('first');
-            next();
-        });
-        middleware.use((_, __, next) => {
-            mock('second');
-            next();
-        });
-        const middleware2 = new middleware_1.Middleware(middleware);
-        yield middleware2.run({}, {}, () => { });
-        expect(mock.mock.calls[0][2]).toBe(mock.mock.calls[1][2]);
-    }));
-});

package/server/channel/channelEngine.js

@@ -1,280 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelEngine = exports.ServerActions = void 0;
-const eventRequest_1 = require("./eventRequest");
-const eventResponse_1 = require("./eventResponse");
-const enums_1 = require("../../enums");
-const presenceEngine_1 = require("../presence/presenceEngine");
-const subjectUtils_1 = require("../utils/subjectUtils");
-var ServerActions;
-(function (ServerActions) {
-    ServerActions["PRESENCE"] = "PRESENCE";
-    ServerActions["SYSTEM"] = "SYSTEM";
-    ServerActions["BROADCAST"] = "BROADCAST";
-    ServerActions["ERROR"] = "ERROR";
-})(ServerActions = exports.ServerActions || (exports.ServerActions = {}));
-class ChannelEngine {
-    constructor(name, parent) {
-        this.name = name;
-        this._receiver = new subjectUtils_1.Subject();
-        this._users = new Map();
-        this._parentEngine = parent;
-    }
-    /**
-     * @desc Adds a user to the channel
-     * @param userId - The id of the user to add
-     * @param assigns - The assigns to add to the user
-     * @param onMessage - The callback to call when a message is received
-     */
-    addUser(userId, assigns, onMessage) {
-        const oldUser = this._users.get(userId);
-        if (oldUser) {
-            throw new Error(`ChannelEngine: User with id ${userId} already exists in channel ${this.name}`);
-        }
-        this._users.set(userId, assigns);
-        return this._subscribe(userId, onMessage);
-    }
-    /**
-     * @desc Removes a user from the channel
-     * @param userId - The id of the user to remove
-     * @param isPond - Whether the user is a pond or not
-     */
-    removeUser(userId, isPond = false) {
-        const user = this._users.get(userId);
-        if (user) {
-            this._users.delete(userId);
-            this.unTrackPresence(userId, true);
-            this._receiver.unsubscribe(userId);
-            if (this._users.size === 0) {
-                this._parentEngine.destroyChannel();
-            }
-        }
-        else if (!isPond) {
-            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
-        }
-    }
-    /**
-     * @desc Kicks a user from the channel
-     * @param userId - The id of the user to kick
-     * @param reason - The reason for kicking the user
-     */
-    kickUser(userId, reason) {
-        this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], ServerActions.SYSTEM, 'kicked_out', {
-            message: 'You have been kicked out of the channel',
-            reason,
-        });
-        this.removeUser(userId);
-        this.sendMessage(enums_1.SystemSender.CHANNEL, 'all_users', ServerActions.SYSTEM, 'kicked', {
-            userId,
-            reason,
-        });
-    }
-    /**
-     * @desc Self destructs the channel
-     * @param reason - The reason for self-destructing the channel
-     */
-    destroy(reason) {
-        this.sendMessage(enums_1.SystemSender.CHANNEL, 'all_users', ServerActions.ERROR, 'destroyed', {
-            message: 'Channel has been destroyed',
-            reason,
-        });
-        this._parentEngine.destroyChannel();
-        this._users.forEach((_, userId) => this._receiver.unsubscribe(userId));
-    }
-    /**
-     * @desc Begins tracking a user's presence
-     * @param userId - The id of the user to track
-     * @param presence - The initial presence of the user
-     */
-    trackPresence(userId, presence) {
-        this._presenceEngine = this._presenceEngine || new presenceEngine_1.PresenceEngine();
-        if (!this._users.has(userId)) {
-            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
-        }
-        if (this._presenceEngine.getUserPresence(userId)) {
-            throw new Error(`ChannelEngine: User with id ${userId} already has a presence subscription in channel ${this.name}`);
-        }
-        this._presenceEngine.trackPresence(userId, presence, (change) => {
-            const { type } = change, rest = __rest(change, ["type"]);
-            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], ServerActions.PRESENCE, type, rest);
-        });
-    }
-    /**
-     * @desc Updates a user's presence
-     * @param userId - The id of the user to update
-     * @param presence - The new presence of the user
-     */
-    updatePresence(userId, presence) {
-        if (!this._users.has(userId)) {
-            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
-        }
-        if (this._presenceEngine) {
-            this._presenceEngine.updatePresence(userId, presence);
-        }
-        else {
-            throw new Error('ChannelEngine: Presence engine is not initialized');
-        }
-    }
-    /**
-     * @desc Updates a user's assigns
-     * @param userId - The id of the user to update
-     * @param assigns - The new assigns of the user
-     */
-    updateAssigns(userId, assigns) {
-        const user = this._users.get(userId);
-        if (user) {
-            this._users.set(userId, Object.assign(Object.assign({}, user), assigns));
-        }
-        else {
-            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
-        }
-    }
-    /**
-     * @desc Gets the data of a user
-     * @param userId - The id of the user to get
-     */
-    getUserData(userId) {
-        const presence = this._presenceEngine ? this._presenceEngine.getUserPresence(userId) : {};
-        if (this._users.has(userId)) {
-            return {
-                id: userId,
-                assigns: this._users.get(userId),
-                presence: presence || {},
-            };
-        }
-        return undefined;
-    }
-    /**
-     * @desc Gets the assign data of all users
-     */
-    getAssigns() {
-        const assigns = {};
-        this._users.forEach((value, key) => {
-            assigns[key] = value;
-        });
-        return assigns;
-    }
-    /**
-     * @desc Gets the presence data of all users
-     */
-    getPresence() {
-        if (this._presenceEngine) {
-            return this._presenceEngine.getPresence();
-        }
-        return {};
-    }
-    /**
-     * @desc Stops tracking a user's presence
-     * @param userId - The id of the user to be untracked
-     * @param isPond - Whether the user is a pond
-     */
-    unTrackPresence(userId, isPond = false) {
-        if (this._presenceEngine) {
-            if (isPond && this._presenceEngine.getUserPresence(userId)) {
-                this._presenceEngine.removePresence(userId);
-            }
-            else if (!isPond) {
-                this._presenceEngine.removePresence(userId);
-            }
-        }
-    }
-    /**
-     * @desc Sends a message to a specified set of users, from a specified sender
-     * @param sender - The sender of the message
-     * @param recipient - The users to send the message to
-     * @param action - The action of the message
-     * @param event - The event name
-     * @param payload - The payload of the message
-     * @private
-     */
-    sendMessage(sender, recipient, action, event, payload) {
-        if (!this._users.has(sender) && sender !== enums_1.SystemSender.CHANNEL) {
-            throw new Error(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`);
-        }
-        this._receiver.next({
-            sender,
-            recipients: this._getUsersFromRecipients(recipient, sender),
-            action,
-            payload,
-            event,
-        });
-    }
-    /**
-     * @desc Handles a message from a user
-     * @param userId - The id of the user who sent the message
-     * @param message - The message received
-     */
-    broadcastMessage(userId, message) {
-        if (!this._users.has(userId)) {
-            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
-        }
-        const responseEvent = {
-            event: message.event,
-            payload: message.payload,
-            action: ServerActions.BROADCAST,
-            sender: userId,
-            recipients: this._getUsersFromRecipients(message.addresses || 'all_users', userId),
-        };
-        const request = new eventRequest_1.EventRequest(responseEvent, this);
-        const response = new eventResponse_1.EventResponse(responseEvent, this);
-        this._parentEngine.execute(request, response, () => {
-            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], ServerActions.ERROR, enums_1.ErrorTypes.HANDLER_NOT_FOUND, {
-                message: 'A handler did not respond to the event',
-                code: 404,
-            });
-        });
-    }
-    /**
-     * @desc Subscribes to a user's messages
-     * @param userId - The id of the user to subscribe to
-     * @param onMessage - The callback to call when a message is received
-     * @private
-     */
-    _subscribe(userId, onMessage) {
-        this._receiver.subscribe(userId, (event) => {
-            if (event.recipients.includes(userId)) {
-                onMessage({
-                    action: event.action,
-                    event: event.event,
-                    payload: event.payload,
-                    channelName: this.name,
-                });
-            }
-        });
-    }
-    _getUsersFromRecipients(recipients, sender) {
-        const allUsers = Array.from(this._users.keys());
-        let users;
-        switch (recipients) {
-            case 'all_users':
-                users = allUsers;
-                break;
-            case 'all_except_sender':
-                if (sender === enums_1.SystemSender.CHANNEL) {
-                    throw new Error('ChannelEngine: Cannot send to all users except sender when sender is channel');
-                }
-                users = allUsers.filter((user) => user !== sender);
-                break;
-            default:
-                const absentUsers = recipients.filter((user) => !allUsers.includes(user));
-                if (absentUsers.length > 0) {
-                    throw new Error(`ChannelEngine: Users ${absentUsers.join(', ')} are not in channel ${this.name}`);
-                }
-                users = recipients;
-                break;
-        }
-        return users;
-    }
-}
-exports.ChannelEngine = ChannelEngine;