@eleven-am/pondsocket 0.1.168 → 0.1.170

package/abstracts/middleware.js

@@ -4,22 +4,36 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Middleware_stack;
+var _Middleware_instances, _Middleware_stack, _Middleware_handleError;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Middleware = void 0;
+const httpError_1 = require("../errors/httpError");
 class Middleware {
     constructor(second) {
+        _Middleware_instances.add(this);
         _Middleware_stack.set(this, []);
         if (second) {
             __classPrivateFieldGet(this, _Middleware_stack, "f").push(...__classPrivateFieldGet(second, _Middleware_stack, "f"));
         }
     }
+    /**
+     * @desc Returns the middleware stack length
+     */
+    get length() {
+        return __classPrivateFieldGet(this, _Middleware_stack, "f").length;
+    }
     /**
      * @desc Adds a middleware function to the middleware stack
      * @param middleware - the middleware function to add
      */
     use(middleware) {
-        __classPrivateFieldGet(this, _Middleware_stack, "f").push(middleware);
+        if (middleware instanceof Middleware) {
+            __classPrivateFieldGet(this, _Middleware_stack, "f").push(...__classPrivateFieldGet(middleware, _Middleware_stack, "f"));
+        }
+        else {
+            __classPrivateFieldGet(this, _Middleware_stack, "f").push(middleware);
+        }
+        return this;
     }
     /**
      * @desc Runs the middleware stack
@@ -28,24 +42,33 @@ class Middleware {
      * @param final - the final function to call
      */
     run(req, res, final) {
-        const temp = __classPrivateFieldGet(this, _Middleware_stack, "f").concat();
-        const nextFunction = () => {
-            const middleware = temp.shift();
-            if (middleware) {
-                middleware(req, res, nextFunction);
+        let index = 0;
+        const next = (err) => {
+            if (err) {
+                return final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, err));
+            }
+            if (index >= __classPrivateFieldGet(this, _Middleware_stack, "f").length) {
+                return final();
             }
-            else {
-                final();
+            const middleware = __classPrivateFieldGet(this, _Middleware_stack, "f")[index];
+            index++;
+            try {
+                const result = middleware(req, res, next);
+                if (result instanceof Promise) {
+                    result.catch(next);
+                }
+            }
+            catch (error) {
+                return final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, error));
             }
         };
-        nextFunction();
-    }
-    /**
-     * @desc Returns the middleware stack length
-     */
-    get length() {
-        return __classPrivateFieldGet(this, _Middleware_stack, "f").length;
+        next();
     }
 }
 exports.Middleware = Middleware;
-_Middleware_stack = new WeakMap();
+_Middleware_stack = new WeakMap(), _Middleware_instances = new WeakSet(), _Middleware_handleError = function _Middleware_handleError(error) {
+    if (error instanceof httpError_1.HttpError) {
+        return error;
+    }
+    return new httpError_1.HttpError(500, error instanceof Error ? error.message : 'An error occurred while processing the request');
+};

package/abstracts/redisClient.js

@@ -0,0 +1,278 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _RedisClient_instances, _RedisClient_redisClient, _RedisClient_pubClient, _RedisClient_subClient, _RedisClient_instanceId, _RedisClient_assignsPublisher, _RedisClient_presencePublisher, _RedisClient_userLeavesPublisher, _RedisClient_channelMessagePublisher, _RedisClient_ttlRefreshInterval, _RedisClient_presence_changes_channel_get, _RedisClient_assigns_changes_channel_get, _RedisClient_channel_messages_channel_get, _RedisClient_user_leaves_channel_get, _RedisClient_cleanup, _RedisClient_handleErrors, _RedisClient_getPresenceCacheChannel, _RedisClient_getAssignsCacheChannel, _RedisClient_publishPresenceChange, _RedisClient_publishAssignsChange, _RedisClient_publishChannelMessage, _RedisClient_publishUserLeave, _RedisClient_getPresenceCache, _RedisClient_getAssignsCache, _RedisClient_sendHeartbeat, _RedisClient_startTTLRefresh, _RedisClient_registerInstance, _RedisClient_unregisterInstance, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _RedisClient_handleRedisMessage, _RedisClient_publishCacheMessage, _RedisClient_readCachedData, _RedisClient_subscribeToCacheChanges, _RedisClient_subscribeToChannelMessages, _RedisClient_subscribeToUserLeaves, _RedisClient_handleExit;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisClient {
+    constructor(redisOptions) {
+        _RedisClient_instances.add(this);
+        this.TTL_REFRESH_INTERVAL = 30 * 1000;
+        this.INSTANCE_TTL = 90;
+        _RedisClient_redisClient.set(this, void 0);
+        _RedisClient_pubClient.set(this, void 0);
+        _RedisClient_subClient.set(this, void 0);
+        _RedisClient_instanceId.set(this, void 0);
+        _RedisClient_assignsPublisher.set(this, void 0);
+        _RedisClient_presencePublisher.set(this, void 0);
+        _RedisClient_userLeavesPublisher.set(this, void 0);
+        _RedisClient_channelMessagePublisher.set(this, void 0);
+        _RedisClient_ttlRefreshInterval.set(this, void 0);
+        __classPrivateFieldSet(this, _RedisClient_redisClient, new ioredis_1.default(redisOptions), "f");
+        __classPrivateFieldSet(this, _RedisClient_pubClient, new ioredis_1.default(redisOptions), "f");
+        __classPrivateFieldSet(this, _RedisClient_subClient, new ioredis_1.default(redisOptions), "f");
+        __classPrivateFieldSet(this, _RedisClient_assignsPublisher, new pondsocket_common_1.Subject(), "f");
+        __classPrivateFieldSet(this, _RedisClient_presencePublisher, new pondsocket_common_1.Subject(), "f");
+        __classPrivateFieldSet(this, _RedisClient_userLeavesPublisher, new pondsocket_common_1.Subject(), "f");
+        __classPrivateFieldSet(this, _RedisClient_channelMessagePublisher, new pondsocket_common_1.Subject(), "f");
+        __classPrivateFieldSet(this, _RedisClient_instanceId, (0, pondsocket_common_1.uuid)(), "f");
+    }
+    buildClient(endpointId) {
+        return (channelId) => ({
+            channelId,
+            getPresenceCache: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCache).bind(this, endpointId, channelId),
+            getAssignsCache: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCache).bind(this, endpointId, channelId),
+            publishPresenceChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishPresenceChange).bind(this, endpointId, channelId),
+            publishAssignsChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishAssignsChange).bind(this, endpointId, channelId),
+            publishChannelMessage: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishChannelMessage).bind(this, endpointId, channelId),
+            publishUserLeave: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishUserLeave).bind(this, endpointId, channelId),
+            subscribeToUserLeaves: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToUserLeaves).bind(this, endpointId, channelId),
+            subscribeToPresenceChanges: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToCacheChanges).bind(this, endpointId, channelId, true),
+            subscribeToAssignsChanges: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToCacheChanges).bind(this, endpointId, channelId, false),
+            subscribeToChannelMessages: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToChannelMessages).bind(this, endpointId, channelId),
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleErrors).call(this);
+            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_startTTLRefresh).call(this);
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_registerInstance).call(this);
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToChannels).call(this);
+            process.on('SIGINT', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleExit).bind(this));
+            process.on('SIGTERM', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleExit).bind(this));
+        });
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            clearInterval(__classPrivateFieldGet(this, _RedisClient_ttlRefreshInterval, "f"));
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_unsubscribeFromChannels).call(this);
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_unregisterInstance).call(this);
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_cleanup).call(this);
+        });
+    }
+}
+exports.RedisClient = RedisClient;
+_RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap(), _RedisClient_subClient = new WeakMap(), _RedisClient_instanceId = new WeakMap(), _RedisClient_assignsPublisher = new WeakMap(), _RedisClient_presencePublisher = new WeakMap(), _RedisClient_userLeavesPublisher = new WeakMap(), _RedisClient_channelMessagePublisher = new WeakMap(), _RedisClient_ttlRefreshInterval = new WeakMap(), _RedisClient_instances = new WeakSet(), _RedisClient_presence_changes_channel_get = function _RedisClient_presence_changes_channel_get() {
+    return 'presence_changes';
+}, _RedisClient_assigns_changes_channel_get = function _RedisClient_assigns_changes_channel_get() {
+    return 'assigns_changes';
+}, _RedisClient_channel_messages_channel_get = function _RedisClient_channel_messages_channel_get() {
+    return 'channel_messages';
+}, _RedisClient_user_leaves_channel_get = function _RedisClient_user_leaves_channel_get() {
+    return 'user_leaves';
+}, _RedisClient_cleanup = function _RedisClient_cleanup() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pipeline = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").pipeline();
+        const presenceKeys = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").keys('presence_cache:*');
+        presenceKeys.forEach((key) => pipeline.del(key));
+        const assignsKeys = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").keys('assigns_cache:*');
+        assignsKeys.forEach((key) => pipeline.del(key));
+        yield pipeline.exec();
+    });
+}, _RedisClient_handleErrors = function _RedisClient_handleErrors() {
+    __classPrivateFieldGet(this, _RedisClient_redisClient, "f").on('error', (err) => console.error('Redis client error:', err));
+    __classPrivateFieldGet(this, _RedisClient_pubClient, "f").on('error', (err) => console.error('Redis pub client error:', err));
+    __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('error', (err) => console.error('Redis sub client error:', err));
+}, _RedisClient_getPresenceCacheChannel = function _RedisClient_getPresenceCacheChannel(endpointId, channelId) {
+    return `presence_cache:${endpointId}:${channelId}`;
+}, _RedisClient_getAssignsCacheChannel = function _RedisClient_getAssignsCacheChannel(endpointId, channelId) {
+    return `assigns_cache:${endpointId}:${channelId}`;
+}, _RedisClient_publishPresenceChange = function _RedisClient_publishPresenceChange(endpointId, channelId, userId, state) {
+    const message = {
+        userId,
+        channelId,
+        endpointId,
+        state,
+    };
+    const key = __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get);
+    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCacheChannel).call(this, message.endpointId, message.channelId);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishCacheMessage).call(this, key, cacheKey, message);
+}, _RedisClient_publishAssignsChange = function _RedisClient_publishAssignsChange(endpointId, channelId, userId, state) {
+    const message = {
+        userId,
+        channelId,
+        endpointId,
+        state,
+    };
+    const key = __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get);
+    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCacheChannel).call(this, message.endpointId, message.channelId);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishCacheMessage).call(this, key, cacheKey, message);
+}, _RedisClient_publishChannelMessage = function _RedisClient_publishChannelMessage(endpointId, channelId, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageData = JSON.stringify({
+            endpointId,
+            channelId,
+            message,
+        });
+        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), messageData);
+    });
+}, _RedisClient_publishUserLeave = function _RedisClient_publishUserLeave(endpointId, channelId, userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const message = JSON.stringify({
+            endpointId,
+            channelId,
+            userId,
+        });
+        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), message);
+    });
+}, _RedisClient_getPresenceCache = function _RedisClient_getPresenceCache(endpointId, channelId) {
+    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getPresenceCacheChannel).call(this, endpointId, channelId);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, cacheKey);
+}, _RedisClient_getAssignsCache = function _RedisClient_getAssignsCache(endpointId, channelId) {
+    const cacheKey = __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getAssignsCacheChannel).call(this, endpointId, channelId);
+    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_readCachedData).call(this, cacheKey);
+}, _RedisClient_sendHeartbeat = function _RedisClient_sendHeartbeat() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").expire(`instance:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, this.INSTANCE_TTL);
+    });
+}, _RedisClient_startTTLRefresh = function _RedisClient_startTTLRefresh() {
+    __classPrivateFieldSet(this, _RedisClient_ttlRefreshInterval, setInterval(() => __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_sendHeartbeat).call(this), this.TTL_REFRESH_INTERVAL), "f");
+}, _RedisClient_registerInstance = function _RedisClient_registerInstance() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
+        multi.sadd('distributed_instances:', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"));
+        multi.setex(`instance:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, this.INSTANCE_TTL, '1');
+        yield multi.exec();
+    });
+}, _RedisClient_unregisterInstance = function _RedisClient_unregisterInstance() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const multi = __classPrivateFieldGet(this, _RedisClient_redisClient, "f").multi();
+        multi.srem('distributed_instances', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"));
+        multi.del(`instance:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`);
+        multi.scard('distributed_instances');
+        const results = yield multi.exec();
+        if (results && results[2] && results[2][1] === 0) {
+            // No more instances, clean up
+        }
+    });
+}, _RedisClient_unsubscribeFromChannels = function _RedisClient_unsubscribeFromChannels() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield __classPrivateFieldGet(this, _RedisClient_subClient, "f").unsubscribe(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get));
+    });
+}, _RedisClient_subscribeToChannels = function _RedisClient_subscribeToChannels() {
+    return new Promise((resolve, reject) => {
+        __classPrivateFieldGet(this, _RedisClient_subClient, "f").subscribe(__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get), __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get), (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+        __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('message', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleRedisMessage).bind(this));
+    });
+}, _RedisClient_handleRedisMessage = function _RedisClient_handleRedisMessage(channel, message) {
+    const data = JSON.parse(message);
+    switch (channel) {
+        case __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_presence_changes_channel_get):
+            __classPrivateFieldGet(this, _RedisClient_presencePublisher, "f").publish(data);
+            break;
+        case __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_assigns_changes_channel_get):
+            __classPrivateFieldGet(this, _RedisClient_assignsPublisher, "f").publish(data);
+            break;
+        case __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_channel_messages_channel_get):
+            __classPrivateFieldGet(this, _RedisClient_channelMessagePublisher, "f").publish(data);
+            break;
+        case __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_user_leaves_channel_get):
+            __classPrivateFieldGet(this, _RedisClient_userLeavesPublisher, "f").publish(data);
+            break;
+        default:
+            throw new Error(`Unknown channel: ${channel}`);
+    }
+}, _RedisClient_publishCacheMessage = function _RedisClient_publishCacheMessage(key, cacheKey, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageData = JSON.stringify(message);
+        if (message.state) {
+            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").hset(cacheKey, message.userId, JSON.stringify(message.state));
+        }
+        else {
+            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").hdel(cacheKey, message.userId);
+        }
+        yield __classPrivateFieldGet(this, _RedisClient_pubClient, "f").publish(key, messageData);
+    });
+}, _RedisClient_readCachedData = function _RedisClient_readCachedData(cacheKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const data = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").hgetall(cacheKey);
+            return new Map(Object.entries(data).map(([key, value]) => [key, JSON.parse(value)]));
+        }
+        catch (error) {
+            console.error(error);
+            return new Map();
+        }
+    });
+}, _RedisClient_subscribeToCacheChanges = function _RedisClient_subscribeToCacheChanges(endpoint, channel, presence, callback) {
+    const subject = presence ? __classPrivateFieldGet(this, _RedisClient_presencePublisher, "f") : __classPrivateFieldGet(this, _RedisClient_assignsPublisher, "f");
+    return subject.subscribe((_a) => {
+        var { endpointId, channelId } = _a, data = __rest(_a, ["endpointId", "channelId"]);
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(data);
+        }
+    });
+}, _RedisClient_subscribeToChannelMessages = function _RedisClient_subscribeToChannelMessages(endpoint, channel, callback) {
+    return __classPrivateFieldGet(this, _RedisClient_channelMessagePublisher, "f").subscribe(({ endpointId, channelId, message }) => {
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(message);
+        }
+    });
+}, _RedisClient_subscribeToUserLeaves = function _RedisClient_subscribeToUserLeaves(endpoint, channel, callback) {
+    return __classPrivateFieldGet(this, _RedisClient_userLeavesPublisher, "f").subscribe(({ endpointId, channelId, userId }) => {
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(userId);
+        }
+    });
+}, _RedisClient_handleExit = function _RedisClient_handleExit() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield this.shutdown();
+            process.exit(0);
+        }
+        catch (error) {
+            process.exit(1);
+        }
+    });
+};

package/engines/channelEngine.js

@@ -0,0 +1,163 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ChannelEngine_instances, _ChannelEngine_manager, _ChannelEngine_getUsersFromRecipients;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const httpError_1 = require("../errors/httpError");
+const channel_1 = require("../wrappers/channel");
+class ChannelEngine {
+    constructor(parent, name, manager) {
+        _ChannelEngine_instances.add(this);
+        this.parent = parent;
+        this.name = name;
+        _ChannelEngine_manager.set(this, void 0);
+        __classPrivateFieldSet(this, _ChannelEngine_manager, manager, "f");
+    }
+    get users() {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").userIds;
+    }
+    addUser(userId, assigns, onMessage) {
+        if (this.users.has(userId)) {
+            const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
+            const code = 400;
+            throw new httpError_1.HttpError(code, message);
+        }
+        __classPrivateFieldGet(this, _ChannelEngine_manager, "f").addUser(userId, assigns, onMessage);
+        this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, pondsocket_common_1.Events.ACKNOWLEDGE, {});
+        return this.removeUser.bind(this, userId);
+    }
+    sendMessage(sender, recipient, action, event, payload, requestId = (0, pondsocket_common_1.uuid)()) {
+        if (!this.users.has(sender) && sender !== pondsocket_common_1.SystemSender.CHANNEL) {
+            const message = `ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`;
+            const code = 404;
+            throw new httpError_1.HttpError(code, message);
+        }
+        const channelEvent = {
+            channelName: this.name,
+            requestId,
+            action,
+            event,
+            payload,
+        };
+        const recipients = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender);
+        const internalEvent = Object.assign(Object.assign({}, channelEvent), { recipients });
+        __classPrivateFieldGet(this, _ChannelEngine_manager, "f").broadcast(internalEvent);
+    }
+    broadcastMessage(userId, message) {
+        if (!this.users.has(userId)) {
+            const message = `ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`;
+            const code = 404;
+            throw new httpError_1.HttpError(code, message);
+        }
+        const responseEvent = Object.assign(Object.assign({}, message), { sender: userId, action: pondsocket_common_1.ServerActions.BROADCAST });
+        this.parent.middleware.run(responseEvent, this, (error) => {
+            this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.HANDLER_NOT_FOUND, {
+                message: (error === null || error === void 0 ? void 0 : error.message) || 'A handler did not respond to the event',
+                code: (error === null || error === void 0 ? void 0 : error.statusCode) || 500,
+            }, message.requestId);
+        });
+    }
+    trackPresence(userId, presence) {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").trackPresence(userId, presence);
+    }
+    updatePresence(userId, presence) {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").updatePresence(userId, presence);
+    }
+    removePresence(userId) {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").removePresence(userId);
+    }
+    upsertPresence(userId, presence) {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").upsertPresence(userId, presence);
+    }
+    updateAssigns(userId, assigns) {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").updateAssigns(userId, assigns);
+    }
+    kickUser(userId, reason) {
+        this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, 'kicked_out', {
+            message: reason,
+            code: 403,
+        });
+        this.removeUser(userId);
+        this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, 'kicked', {
+            userId,
+            reason,
+        });
+    }
+    getAssigns() {
+        return Array
+            .from(__classPrivateFieldGet(this, _ChannelEngine_manager, "f").getAllAssigns().entries())
+            .reduce((acc, [id, assigns]) => {
+            acc[id] = assigns;
+            return acc;
+        }, {});
+    }
+    getPresence() {
+        return Array
+            .from(__classPrivateFieldGet(this, _ChannelEngine_manager, "f").getAllPresence().entries())
+            .reduce((acc, [id, presence]) => {
+            acc[id] = presence;
+            return acc;
+        }, {});
+    }
+    destroy(reason) {
+        this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.ERROR, 'destroyed', {
+            message: reason !== null && reason !== void 0 ? reason : 'Channel has been destroyed',
+        });
+        __classPrivateFieldGet(this, _ChannelEngine_manager, "f").close();
+    }
+    removeUser(userId) {
+        const userData = __classPrivateFieldGet(this, _ChannelEngine_manager, "f").removeUser(userId);
+        if (this.parent.leaveCallback) {
+            this.parent.leaveCallback({
+                user: userData,
+                channel: new channel_1.Channel(this),
+            });
+        }
+    }
+    getUser(userId) {
+        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").getUserData(userId);
+    }
+}
+exports.ChannelEngine = ChannelEngine;
+_ChannelEngine_manager = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_getUsersFromRecipients = function _ChannelEngine_getUsersFromRecipients(recipients, sender) {
+    const allUsers = Array.from(this.users);
+    let users;
+    switch (recipients) {
+        case pondsocket_common_1.ChannelReceiver.ALL_USERS:
+            users = allUsers;
+            break;
+        case pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER:
+            if (sender === pondsocket_common_1.SystemSender.CHANNEL) {
+                const message = `ChannelEngine: Invalid sender ${sender} for recipients ${recipients}`;
+                const code = 400;
+                throw new httpError_1.HttpError(code, message);
+            }
+            users = allUsers.filter((user) => user !== sender);
+            break;
+        default:
+            if (!Array.isArray(recipients)) {
+                const message = `ChannelEngine: Invalid recipients ${recipients} must be an array of user ids or ${pondsocket_common_1.ChannelReceiver.ALL_USERS}`;
+                const code = 400;
+                throw new httpError_1.HttpError(code, message);
+            }
+            if (recipients.some((user) => !allUsers.includes(user))) {
+                const message = `ChannelEngine: Invalid user ids in recipients ${recipients}`;
+                const code = 400;
+                throw new httpError_1.HttpError(code, message);
+            }
+            users = recipients;
+            break;
+    }
+    return users;
+};