@eleven-am/pondsocket 0.1.177 → 0.1.179

package/abstracts/redisClient.js

@@ -33,16 +33,19 @@ var __rest = (this && this.__rest) || function (s, e) {
 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;
+var _RedisClient_instances, _RedisClient_heartbeatInterval, _RedisClient_cleanupInterval, _RedisClient_instanceTtl, _RedisClient_redisClient, _RedisClient_pubClient, _RedisClient_subClient, _RedisClient_instanceId, _RedisClient_assignsPublisher, _RedisClient_presencePublisher, _RedisClient_userLeavesPublisher, _RedisClient_channelMessagePublisher, _RedisClient_stateSyncPublisher, _RedisClient_heartbeatTimer, _RedisClient_cleanupTimer, _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_registerInstance, _RedisClient_unregisterInstance, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _RedisClient_startHeartbeat, _RedisClient_startPeriodicCleanup, _RedisClient_performConsistencyCheck, _RedisClient_handleRedisMessage, _RedisClient_publishCacheMessage, _RedisClient_emitStateSyncEvent, _RedisClient_subscribeToCacheChanges, _RedisClient_subscribeToChannelMessages, _RedisClient_subscribeToUserLeaves, _RedisClient_subscribeToStateSync, _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"));
+const redisError_1 = require("../errors/redisError");
 class RedisClient {
-    constructor(redisOptions) {
+    constructor(config) {
+        var _a, _b, _c;
         _RedisClient_instances.add(this);
-        this.TTL_REFRESH_INTERVAL = 30 * 1000;
-        this.INSTANCE_TTL = 90;
+        _RedisClient_heartbeatInterval.set(this, void 0);
+        _RedisClient_cleanupInterval.set(this, void 0);
+        _RedisClient_instanceTtl.set(this, void 0);
         _RedisClient_redisClient.set(this, void 0);
         _RedisClient_pubClient.set(this, void 0);
         _RedisClient_subClient.set(this, void 0);
@@ -51,21 +54,25 @@ class RedisClient {
         _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");
+        _RedisClient_stateSyncPublisher.set(this, void 0);
+        _RedisClient_heartbeatTimer.set(this, void 0);
+        _RedisClient_cleanupTimer.set(this, void 0);
+        __classPrivateFieldSet(this, _RedisClient_instanceTtl, (_a = config.instanceTtl) !== null && _a !== void 0 ? _a : 90, "f");
+        __classPrivateFieldSet(this, _RedisClient_heartbeatInterval, (_b = config.heartbeatInterval) !== null && _b !== void 0 ? _b : 10 * 1000, "f");
+        __classPrivateFieldSet(this, _RedisClient_cleanupInterval, (_c = config.cleanupInterval) !== null && _c !== void 0 ? _c : 60 * 1000, "f");
+        __classPrivateFieldSet(this, _RedisClient_redisClient, new ioredis_1.default(config), "f");
+        __classPrivateFieldSet(this, _RedisClient_pubClient, new ioredis_1.default(config), "f");
+        __classPrivateFieldSet(this, _RedisClient_subClient, new ioredis_1.default(config), "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_stateSyncPublisher, 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),
@@ -74,13 +81,15 @@ class RedisClient {
             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),
+            subscribeToStateSync: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToStateSync).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);
+            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_startHeartbeat).call(this);
+            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_startPeriodicCleanup).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));
@@ -88,7 +97,8 @@ class RedisClient {
     }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
-            clearInterval(__classPrivateFieldGet(this, _RedisClient_ttlRefreshInterval, "f"));
+            clearInterval(__classPrivateFieldGet(this, _RedisClient_heartbeatTimer, "f"));
+            clearInterval(__classPrivateFieldGet(this, _RedisClient_cleanupTimer, "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);
@@ -96,7 +106,7 @@ class RedisClient {
     }
 }
 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() {
+_RedisClient_heartbeatInterval = new WeakMap(), _RedisClient_cleanupInterval = new WeakMap(), _RedisClient_instanceTtl = new WeakMap(), _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_stateSyncPublisher = new WeakMap(), _RedisClient_heartbeatTimer = new WeakMap(), _RedisClient_cleanupTimer = 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';
@@ -118,9 +128,9 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
     __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}`;
+    return `presence_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
 }, _RedisClient_getAssignsCacheChannel = function _RedisClient_getAssignsCacheChannel(endpointId, channelId) {
-    return `assigns_cache:${endpointId}:${channelId}`;
+    return `assigns_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
 }, _RedisClient_publishPresenceChange = function _RedisClient_publishPresenceChange(endpointId, channelId, userId, state) {
     const message = {
         userId,
@@ -159,34 +169,28 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
         });
         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();
+        multi.sadd('distributed_instances', __classPrivateFieldGet(this, _RedisClient_instanceId, "f"));
+        multi.set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, Date.now().toString(), 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
+        try {
+            yield multi.exec();
+        }
+        catch (error) {
+            throw new redisError_1.RedisError('Error registering instance');
+        }
     });
 }, _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
+        multi.del(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`);
+        try {
+            yield multi.exec();
+        }
+        catch (_a) {
+            // no-op as we're shutting down
         }
     });
 }, _RedisClient_unsubscribeFromChannels = function _RedisClient_unsubscribeFromChannels() {
@@ -205,6 +209,64 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
         });
         __classPrivateFieldGet(this, _RedisClient_subClient, "f").on('message', __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleRedisMessage).bind(this));
     });
+}, _RedisClient_startHeartbeat = function _RedisClient_startHeartbeat() {
+    __classPrivateFieldSet(this, _RedisClient_heartbeatTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, Date.now().toString(), 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
+        }
+        catch (error) {
+            throw new redisError_1.RedisError('Error setting heartbeat');
+        }
+    }), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f")), "f");
+}, _RedisClient_startPeriodicCleanup = function _RedisClient_startPeriodicCleanup() {
+    __classPrivateFieldSet(this, _RedisClient_cleanupTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_performConsistencyCheck).call(this);
+        }
+        catch (error) {
+            throw new redisError_1.RedisError('Error performing consistency check');
+        }
+    }), __classPrivateFieldGet(this, _RedisClient_cleanupInterval, "f")), "f");
+}, _RedisClient_performConsistencyCheck = function _RedisClient_performConsistencyCheck() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const consistencyCheckScript = `
+            local active_instances = redis.call('SMEMBERS', 'distributed_instances')
+            local all_keys = redis.call('KEYS', '*_cache:*')
+            local inactive_keys = {}
+            local unique_pairs = {}
+            
+            for _, key in ipairs(all_keys) do
+                local parts = {}
+                for part in string.gmatch(key, '[^:]+') do
+                    table.insert(parts, part)
+                end
+                local instance_id, endpoint_id, channel_id = parts[2], parts[3], parts[4]
+                
+                if not (active_instances[instance_id]) then
+                    table.insert(inactive_keys, key)
+                    local pair = endpoint_id .. ':' .. channel_id
+                    unique_pairs[pair] = true
+                end
+            end
+            
+            if #inactive_keys > 0 then
+                redis.call('DEL', unpack(inactive_keys))
+            end
+            
+            local unique_pairs_list = {}
+            for pair in pairs(unique_pairs) do
+                table.insert(unique_pairs_list, pair)
+            end
+            
+            return unique_pairs_list
+        `;
+        const [uniquePairs] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(consistencyCheckScript, 0);
+        const promises = uniquePairs.map((pair) => {
+            const [endpointId, channelId] = pair.split(':');
+            return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpointId, channelId);
+        });
+        yield Promise.all(promises);
+    });
 }, _RedisClient_handleRedisMessage = function _RedisClient_handleRedisMessage(channel, message) {
     const data = JSON.parse(message);
     switch (channel) {
@@ -225,25 +287,58 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
     }
 }, _RedisClient_publishCacheMessage = function _RedisClient_publishCacheMessage(key, cacheKey, message) {
     return __awaiter(this, void 0, void 0, function* () {
+        const script = `
+            local messageData = ARGV[1]
+            local userId = ARGV[2]
+            local state = ARGV[3]
+            
+            if state ~= '' then
+                redis.call('HSET', KEYS[1], userId, state)
+            else
+                redis.call('HDEL', KEYS[1], userId)
+            end
+            
+            redis.call('PUBLISH', KEYS[2], messageData)
+            
+            return 1
+        `;
         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);
+        const state = message.state ? JSON.stringify(message.state) : '';
+        yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 2, cacheKey, key, messageData, message.userId, state);
     });
-}, _RedisClient_readCachedData = function _RedisClient_readCachedData(cacheKey) {
+}, _RedisClient_emitStateSyncEvent = function _RedisClient_emitStateSyncEvent(endpointId, channelId) {
     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();
-        }
+        const script = `
+            local active_instances = redis.call('SMEMBERS', 'distributed_instances')
+            local presence_data = {}
+            local assigns_data = {}
+            
+            for _, instance in ipairs(active_instances) do
+                local presence_key = 'presence_cache:' .. instance .. ':' .. ARGV[1] .. ':' .. ARGV[2]
+                local assigns_key = 'assigns_cache:' .. instance .. ':' .. ARGV[1] .. ':' .. ARGV[2]
+                
+                local presence = redis.call('HGETALL', presence_key)
+                local assigns = redis.call('HGETALL', assigns_key)
+                
+                for i = 1, #presence, 2 do
+                    presence_data[presence[i]] = presence[i+1]
+                end
+                
+                for i = 1, #assigns, 2 do
+                    assigns_data[assigns[i]] = assigns[i+1]
+                end
+            end
+            
+            return {cjson.encode(presence_data), cjson.encode(assigns_data)}
+        `;
+        const [presenceData, assignsData] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, endpointId, channelId);
+        const event = {
+            endpointId,
+            channelId,
+            presence: new Map(Object.entries(JSON.parse(presenceData))),
+            assigns: new Map(Object.entries(JSON.parse(assignsData))),
+        };
+        __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").publish(event);
     });
 }, _RedisClient_subscribeToCacheChanges = function _RedisClient_subscribeToCacheChanges(endpoint, channel, presence, callback) {
     const subject = presence ? __classPrivateFieldGet(this, _RedisClient_presencePublisher, "f") : __classPrivateFieldGet(this, _RedisClient_assignsPublisher, "f");
@@ -265,6 +360,19 @@ _RedisClient_redisClient = new WeakMap(), _RedisClient_pubClient = new WeakMap()
             return callback(userId);
         }
     });
+}, _RedisClient_subscribeToStateSync = function _RedisClient_subscribeToStateSync(endpoint, channel, callback) {
+    const interval = setInterval(() => __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f") * 10);
+    const subscription = __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").subscribe((_a) => {
+        var { endpointId, channelId } = _a, data = __rest(_a, ["endpointId", "channelId"]);
+        if (endpointId === endpoint && channelId === channel) {
+            return callback(data);
+        }
+    });
+    void __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel);
+    return () => {
+        clearInterval(interval);
+        subscription();
+    };
 }, _RedisClient_handleExit = function _RedisClient_handleExit() {
     return __awaiter(this, void 0, void 0, function* () {
         try {

package/engines/endpointEngine.js

@@ -1,13 +1,4 @@
 "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");
@@ -45,7 +36,7 @@ class EndpointEngine {
     }
     createChannel(path, handler) {
         const pondChannel = new lobbyEngine_1.LobbyEngine(this);
-        __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => __awaiter(this, void 0, void 0, function* () {
+        __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
             if (event) {
                 const options = {
@@ -54,13 +45,13 @@ class EndpointEngine {
                     params: event,
                     joinParams,
                 };
-                const channel = yield pondChannel.getOrCreateChannel(user.channelName);
+                const channel = pondChannel.getOrCreateChannel(user.channelName);
                 const request = new joinRequest_1.JoinRequest(options, channel);
                 const response = new joinResponse_1.JoinResponse(user, channel);
                 return handler(request, response, next);
             }
             next();
-        }));
+        });
         __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, pondChannel);
         return new pondChannel_1.PondChannel(pondChannel);
     }

package/engines/lobbyEngine.js

@@ -1,13 +1,4 @@
 "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");
@@ -69,11 +60,9 @@ exports.LobbyEngine = LobbyEngine;
 _LobbyEngine_channels = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_getChannel = function _LobbyEngine_getChannel(channelName) {
     return __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName) || null;
 }, _LobbyEngine_createChannel = function _LobbyEngine_createChannel(channelName) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const onManagerClose = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete.bind(__classPrivateFieldGet(this, _LobbyEngine_channels, "f"), channelName);
-        const manager = yield this.parent.createManager(channelName, onManagerClose);
-        const channel = new channelEngine_1.ChannelEngine(this, channelName, manager);
-        __classPrivateFieldGet(this, _LobbyEngine_channels, "f").set(channelName, channel);
-        return channel;
-    });
+    const onManagerClose = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete.bind(__classPrivateFieldGet(this, _LobbyEngine_channels, "f"), channelName);
+    const manager = this.parent.createManager(channelName, onManagerClose);
+    const channel = new channelEngine_1.ChannelEngine(this, channelName, manager);
+    __classPrivateFieldGet(this, _LobbyEngine_channels, "f").set(channelName, channel);
+    return channel;
 };

package/errors/httpError.js

@@ -6,6 +6,39 @@ class HttpError extends Error {
         super(message);
         this.statusCode = statusCode;
         this.name = 'HttpError';
+        this.statusText = HttpError.getStatusText(statusCode);
+    }
+    static getStatusText(statusCode) {
+        switch (statusCode) {
+            case 400:
+                return 'Bad Request';
+            case 401:
+                return 'Unauthorized';
+            case 403:
+                return 'Forbidden';
+            case 404:
+                return 'Not Found';
+            case 405:
+                return 'Method Not Allowed';
+            case 406:
+                return 'Not Acceptable';
+            case 409:
+                return 'Conflict';
+            case 429:
+                return 'Too Many Requests';
+            case 500:
+                return 'Internal Server Error';
+            case 501:
+                return 'Not Implemented';
+            case 502:
+                return 'Bad Gateway';
+            case 503:
+                return 'Service Unavailable';
+            case 504:
+                return 'Gateway Timeout';
+            default:
+                return 'Unknown Error';
+        }
     }
 }
 exports.HttpError = HttpError;

package/errors/redisError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisError = void 0;
+class RedisError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RedisError';
+    }
+}
+exports.RedisError = RedisError;

package/index.js

@@ -1,4 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisError = void 0;
 const server_1 = require("./server/server");
+var redisError_1 = require("./errors/redisError");
+Object.defineProperty(exports, "RedisError", { enumerable: true, get: function () { return redisError_1.RedisError; } });
 exports.default = server_1.PondSocket;

package/managers/distributedManager.js

@@ -1,13 +1,4 @@
 "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");
@@ -66,44 +57,42 @@ class DistributedManager extends manager_1.Manager {
         __classPrivateFieldGet(this, _DistributedManager_client, "f").publishChannelMessage(message);
     }
     initialize(unsubscribe) {
-        const _super = Object.create(null, {
-            initialize: { get: () => super.initialize }
+        super.initialize(unsubscribe);
+        const leaveSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToUserLeaves((userId) => {
+            var _a;
+            (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
+            this.userSubscriptions.delete(userId);
+        });
+        const presenceSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToPresenceChanges(({ userId, state }) => {
+            if (state) {
+                this.presenceCache.set(userId, state);
+            }
+            else {
+                this.presenceCache.delete(userId);
+            }
+        });
+        const assignSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToAssignsChanges(({ userId, state }) => {
+            if (state) {
+                this.assignsCache.set(userId, state);
+            }
+            else {
+                this.assignsCache.delete(userId);
+            }
+        });
+        const messageSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToChannelMessages((message) => {
+            this.publisher.publish(message);
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.initialize.call(this, unsubscribe);
-            this.presenceCache = yield __classPrivateFieldGet(this, _DistributedManager_client, "f").getPresenceCache();
-            this.assignsCache = yield __classPrivateFieldGet(this, _DistributedManager_client, "f").getAssignsCache();
-            const leaveSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToUserLeaves((userId) => {
-                var _a;
-                (_a = this.userSubscriptions.get(userId)) === null || _a === void 0 ? void 0 : _a();
-                this.userSubscriptions.delete(userId);
-            });
-            const presenceSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToPresenceChanges(({ userId, state }) => {
-                if (state) {
-                    this.presenceCache.set(userId, state);
-                }
-                else {
-                    this.presenceCache.delete(userId);
-                }
-            });
-            const assignSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToAssignsChanges(({ userId, state }) => {
-                if (state) {
-                    this.assignsCache.set(userId, state);
-                }
-                else {
-                    this.assignsCache.delete(userId);
-                }
-            });
-            const messageSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToChannelMessages((message) => {
-                this.publisher.publish(message);
-            });
-            __classPrivateFieldSet(this, _DistributedManager_subscriptions, () => {
-                leaveSubscription();
-                presenceSubscription();
-                assignSubscription();
-                messageSubscription();
-            }, "f");
+        const stateSyncSubscription = __classPrivateFieldGet(this, _DistributedManager_client, "f").subscribeToStateSync((state) => {
+            this.assignsCache = new Map(state.assigns);
+            this.presenceCache = new Map(state.presence);
         });
+        __classPrivateFieldSet(this, _DistributedManager_subscriptions, () => {
+            leaveSubscription();
+            presenceSubscription();
+            assignSubscription();
+            messageSubscription();
+            stateSyncSubscription();
+        }, "f");
     }
     close() {
         var _a;

package/managers/manager.js

@@ -52,7 +52,6 @@ class Manager {
     }
     initialize(unsubscribe) {
         __classPrivateFieldSet(this, _Manager_onClose, unsubscribe, "f");
-        return Promise.resolve();
     }
     getPresence(userId) {
         return this.presenceCache.get(userId) || null;

package/managers/managerFactory.js

@@ -1,31 +1,20 @@
 "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 });
 exports.ManagerFactory = void 0;
 const distributedManager_1 = require("./distributedManager");
 const localManager_1 = require("./localManager");
 class ManagerFactory {
     static create(channelId, clientFactory, onClose) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let manager;
-            if (clientFactory) {
-                const client = clientFactory(channelId);
-                manager = new distributedManager_1.DistributedManager(client);
-            }
-            else {
-                manager = new localManager_1.LocalManager(channelId);
-            }
-            yield manager.initialize(onClose);
-            return manager;
-        });
+        let manager;
+        if (clientFactory) {
+            const client = clientFactory(channelId);
+            manager = new distributedManager_1.DistributedManager(client);
+        }
+        else {
+            manager = new localManager_1.LocalManager(channelId);
+        }
+        manager.initialize(onClose);
+        return manager;
     }
 }
 exports.ManagerFactory = ManagerFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.177",
+  "version": "0.1.179",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -49,7 +49,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-node": "^0.3.9",
     "eslint-plugin-file-progress": "^1.5.0",
-    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-prettier": "^5.2.1",
     "jest": "^29.7.0",
     "nodemon": "^3.1.7",

package/types.d.ts

@@ -23,6 +23,9 @@ export interface RedisOptions {
     db?: number;
     username?: string;
     password?: string;
+    instanceTtl?: number;
+    heartbeatInterval?: number;
+    cleanupInterval?: number;
 }
 
 export interface LeaveEvent<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
@@ -472,3 +475,7 @@ export declare class EventResponse<EventType extends PondEventMap = PondEventMap
      */
     evictUser(reason: string, userId?: string): EventResponse;
 }
+
+export declare class RedisError extends Error {
+    constructor(message: string);
+}