@eleven-am/pondsocket 0.1.197 → 0.1.198

package/wrappers/channel.js

@@ -19,48 +19,84 @@ class Channel {
         _Channel_engine.set(this, void 0);
         __classPrivateFieldSet(this, _Channel_engine, engine, "f");
     }
+    /**
+     * Gets a user's data
+     */
     getUserData(userId) {
-        return __classPrivateFieldGet(this, _Channel_engine, "f").getUser(userId);
+        return __classPrivateFieldGet(this, _Channel_engine, "f").getUserData(userId);
     }
+    /**
+     * Gets all presence data
+     */
     getPresences() {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getPresence();
     }
+    /**
+     * Gets all assigns data
+     */
     getAssigns() {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getAssigns();
     }
+    /**
+     * Broadcasts a message to all users
+     */
     broadcast(event, payload) {
         __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
+    /**
+     * Broadcasts a message from a specific user to all others
+     */
     broadcastFrom(userId, event, payload) {
         __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
+    /**
+     * Broadcasts a message to specific users
+     */
     broadcastTo(userIds, event, payload) {
         const users = Array.isArray(userIds) ? userIds : [userIds];
         __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
+    /**
+     * Kicks a user from the channel
+     */
     evictUser(userId, reason) {
         __classPrivateFieldGet(this, _Channel_engine, "f").kickUser(userId, reason !== null && reason !== void 0 ? reason : 'You have been banned from the channel');
         return this;
     }
+    /**
+     * Tracks a user's presence
+     */
     trackPresence(userId, presence) {
         __classPrivateFieldGet(this, _Channel_engine, "f").trackPresence(userId, presence);
         return this;
     }
+    /**
+     * Updates a user's presence
+     */
     updatePresence(userId, presence) {
         __classPrivateFieldGet(this, _Channel_engine, "f").updatePresence(userId, presence);
         return this;
     }
+    /**
+     * Removes a user's presence
+     */
     removePresence(userId) {
         __classPrivateFieldGet(this, _Channel_engine, "f").removePresence(userId);
         return this;
     }
+    /**
+     * Adds or updates a user's presence
+     */
     upsertPresence(userId, presence) {
         __classPrivateFieldGet(this, _Channel_engine, "f").upsertPresence(userId, presence);
         return this;
     }
+    /**
+     * Updates a user's assigns
+     */
     updateAssigns(userId, assigns) {
         __classPrivateFieldGet(this, _Channel_engine, "f").updateAssigns(userId, assigns);
         return this;

package/wrappers/pondChannel.js

@@ -28,6 +28,10 @@ class PondChannel {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").onLeave(callback);
         return this;
     }
+    onOutgoing(event, handler) {
+        __classPrivateFieldGet(this, _PondChannel_lobby, "f").handleOutgoingEvent(event, handler);
+        return this;
+    }
     getChannel(channelName) {
         try {
             return __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName);

package/abstracts/redisClient.js

@@ -1,499 +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());
-    });
-};
-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_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_stateSyncInterval, _RedisClient_ttlBuffer, _RedisClient_presence_changes_channel_get, _RedisClient_assigns_changes_channel_get, _RedisClient_channel_messages_channel_get, _RedisClient_user_leaves_channel_get, _RedisClient_handleErrors, _RedisClient_registerInstance, _RedisClient_unregisterInstance, _RedisClient_cleanupDisconnectedClients, _RedisClient_startPeriodicCleanup, _RedisClient_startHeartbeat, _RedisClient_unsubscribeFromChannels, _RedisClient_subscribeToChannels, _RedisClient_handleRedisMessage, _RedisClient_getPresenceCacheChannel, _RedisClient_getAssignsCacheChannel, _RedisClient_subscribeToCacheChanges, _RedisClient_subscribeToChannelMessages, _RedisClient_subscribeToUserLeaves, _RedisClient_subscribeToStateSync, _RedisClient_publishPresenceChange, _RedisClient_publishAssignsChange, _RedisClient_publishChannelMessage, _RedisClient_publishUserLeave, _RedisClient_publishCacheMessage, _RedisClient_emitStateSyncEvent, _RedisClient_getActiveInstances, _RedisClient_getCachedInstances, _RedisClient_generateCache, _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(config) {
-        var _a;
-        _RedisClient_instances.add(this);
-        _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);
-        _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_stateSyncPublisher.set(this, void 0);
-        _RedisClient_heartbeatTimer.set(this, void 0);
-        _RedisClient_cleanupTimer.set(this, void 0);
-        _RedisClient_stateSyncInterval.set(this, void 0);
-        _RedisClient_ttlBuffer.set(this, 5);
-        const baseTtl = (_a = config.instanceTtl) !== null && _a !== void 0 ? _a : 90;
-        const milliseconds = baseTtl * 1000;
-        __classPrivateFieldSet(this, _RedisClient_stateSyncInterval, milliseconds, "f");
-        __classPrivateFieldSet(this, _RedisClient_cleanupInterval, milliseconds * 2, "f");
-        __classPrivateFieldSet(this, _RedisClient_heartbeatInterval, milliseconds / 3, "f");
-        __classPrivateFieldSet(this, _RedisClient_instanceTtl, baseTtl + __classPrivateFieldGet(this, _RedisClient_ttlBuffer, "f"), "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,
-            publishUserLeave: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishUserLeave).bind(this, endpointId, channelId),
-            subscribeToStateSync: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToStateSync).bind(this, endpointId, channelId),
-            publishAssignsChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishAssignsChange).bind(this, endpointId, channelId),
-            publishPresenceChange: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishPresenceChange).bind(this, endpointId, channelId),
-            publishChannelMessage: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_publishChannelMessage).bind(this, endpointId, channelId),
-            subscribeToUserLeaves: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToUserLeaves).bind(this, endpointId, channelId),
-            subscribeToChannelMessages: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_subscribeToChannelMessages).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),
-        });
-    }
-    initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_handleErrors).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));
-        });
-    }
-    shutdown() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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);
-        });
-    }
-}
-exports.RedisClient = RedisClient;
-_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_stateSyncInterval = new WeakMap(), _RedisClient_ttlBuffer = 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_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_registerInstance = function _RedisClient_registerInstance() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const now = Date.now().toString();
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").set(`heartbeat:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}`, now, 'EX', __classPrivateFieldGet(this, _RedisClient_instanceTtl, "f"));
-        }
-        catch (error) {
-            throw new redisError_1.RedisError(`Error registering instance: ${error}`);
-        }
-    });
-}, _RedisClient_unregisterInstance = function _RedisClient_unregisterInstance() {
-    return __awaiter(this, arguments, void 0, function* (instanceId = __classPrivateFieldGet(this, _RedisClient_instanceId, "f")) {
-        const script = `
-            -- Delete heartbeat
-            redis.call('DEL', 'heartbeat:' .. ARGV[1])
-            
-            -- Delete all cache keys in one SCAN operation
-            local cursor = '0'
-            repeat
-                local result = redis.call('SCAN', cursor, 'MATCH', '*_cache:' .. ARGV[1] .. ':*', 'COUNT', 100)
-                cursor = result[1]
-                local keys = result[2]
-                if #keys > 0 then
-                    redis.call('DEL', unpack(keys))
-                end
-            until cursor == '0'
-            
-            return 1
-        `;
-        try {
-            yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, instanceId);
-        }
-        catch (_a) {
-            // no-op as we're shutting down
-        }
-    });
-}, _RedisClient_cleanupDisconnectedClients = function _RedisClient_cleanupDisconnectedClients() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const script = `
-            -- Array of instance IDs that have cache data but no heartbeat
-            local dead_instances = cjson.decode(ARGV[1])
-            local affected_channels = {}
-            local keys_to_delete = {}
-            local batch_size = 100
-            
-            -- Process each dead instance
-            for _, instance_id in ipairs(dead_instances) do
-                -- Find and process all cache keys for this instance
-                local cache_cursor = '0'
-                repeat
-                    local result = redis.call('SCAN', cache_cursor, 'MATCH', '*_cache:' .. instance_id .. ':*', 'COUNT', batch_size)
-                    cache_cursor = result[1]
-                    
-                    for _, key in ipairs(result[2]) do
-                        -- Extract channel info before deletion
-                        local _, _, endpoint_id, channel_id = string.match(key, '_cache:[^:]+:([^:]+):([^:]+)')
-                        if endpoint_id and channel_id then
-                            affected_channels[endpoint_id .. ":" .. channel_id] = true
-                        end
-                        
-                        -- Add to deletion batch
-                        table.insert(keys_to_delete, key)
-                        
-                        -- If batch is full, process it
-                        if #keys_to_delete >= batch_size then
-                            redis.call('DEL', unpack(keys_to_delete))
-                            keys_to_delete = {}
-                        end
-                    end
-                until cache_cursor == '0'
-            end
-            
-            -- Delete any remaining keys
-            if #keys_to_delete > 0 then
-                redis.call('DEL', unpack(keys_to_delete))
-            end
-            
-            -- Convert affected_channels to array
-            local channels = {}
-            for pair in pairs(affected_channels) do
-                table.insert(channels, pair)
-            end
-            
-            return channels
-        `;
-        try {
-            const [activeInstances, cachedInstances] = yield Promise.all([
-                __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getActiveInstances).call(this),
-                __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getCachedInstances).call(this),
-            ]);
-            const deadInstances = cachedInstances.filter((id) => !activeInstances.includes(id));
-            if (deadInstances.length === 0) {
-                return;
-            }
-            const affectedChannels = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, JSON.stringify(deadInstances));
-            if (affectedChannels.length > 0) {
-                const promises = affectedChannels.map((pair) => {
-                    const [endpointId, channelId] = pair.split(':');
-                    return __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpointId, channelId);
-                });
-                yield Promise.all(promises);
-            }
-        }
-        catch (error) {
-            console.error('Error cleaning up disconnected clients:', error);
-        }
-    });
-}, _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_cleanupDisconnectedClients).call(this);
-        }
-        catch (error) {
-            console.error('Error in periodic cleanup:', error);
-        }
-    }), __classPrivateFieldGet(this, _RedisClient_cleanupInterval, "f")), "f");
-}, _RedisClient_startHeartbeat = function _RedisClient_startHeartbeat() {
-    __classPrivateFieldSet(this, _RedisClient_heartbeatTimer, setInterval(() => __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_registerInstance).call(this);
-        }
-        catch (error) {
-            console.error('Error performing heartbeat:', error);
-        }
-    }), __classPrivateFieldGet(this, _RedisClient_heartbeatInterval, "f")), "f");
-}, _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_getPresenceCacheChannel = function _RedisClient_getPresenceCacheChannel(endpointId, channelId) {
-    return `presence_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
-}, _RedisClient_getAssignsCacheChannel = function _RedisClient_getAssignsCacheChannel(endpointId, channelId) {
-    return `assigns_cache:${__classPrivateFieldGet(this, _RedisClient_instanceId, "f")}:${endpointId}:${channelId}`;
-}, _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_subscribeToStateSync = function _RedisClient_subscribeToStateSync(endpoint, channel, callback) {
-    const interval = setInterval(() => __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_emitStateSyncEvent).call(this, endpoint, channel), __classPrivateFieldGet(this, _RedisClient_stateSyncInterval, "f"));
-    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, true);
-    return () => {
-        clearInterval(interval);
-        subscription();
-    };
-}, _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_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);
-        const state = message.state ? JSON.stringify(message.state) : '';
-        yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 2, cacheKey, key, messageData, message.userId, state);
-    });
-}, _RedisClient_emitStateSyncEvent = function _RedisClient_emitStateSyncEvent(endpointId_1, channelId_1) {
-    return __awaiter(this, arguments, void 0, function* (endpointId, channelId, initialFetch = false) {
-        const script = `
-            local instances = ARGV[1]
-            local presence_data = {}
-            local assigns_data = {}
-            
-            -- Parse instance IDs array
-            local instance_ids = cjson.decode(instances)
-            
-            for _, instance in ipairs(instance_ids) do
-                local presence_key = 'presence_cache:' .. instance .. ':' .. ARGV[2] .. ':' .. ARGV[3]
-                local assigns_key = 'assigns_cache:' .. instance .. ':' .. ARGV[2] .. ':' .. ARGV[3]
-                
-                -- Get all presence data for this instance and channel
-                local presence = redis.call('HGETALL', presence_key)
-                for i = 1, #presence, 2 do
-                    presence_data[presence[i]] = presence[i + 1]
-                end
-                
-                -- Get all assigns data for this instance and channel
-                local assigns = redis.call('HGETALL', assigns_key)
-                for i = 1, #assigns, 2 do
-                    assigns_data[assigns[i]] = assigns[i + 1]
-                end
-            end
-            
-            return {cjson.encode(presence_data), cjson.encode(assigns_data)}
-        `;
-        try {
-            // Get active instances
-            const activeInstances = yield __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_getActiveInstances).call(this);
-            // Get the data using our active instances
-            const [presenceData, assignsData] = yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0, JSON.stringify(activeInstances), endpointId, channelId);
-            const event = {
-                endpointId,
-                channelId,
-                initialFetch,
-                presence: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_generateCache).call(this, presenceData),
-                assigns: __classPrivateFieldGet(this, _RedisClient_instances, "m", _RedisClient_generateCache).call(this, assignsData),
-            };
-            __classPrivateFieldGet(this, _RedisClient_stateSyncPublisher, "f").publish(event);
-        }
-        catch (error) {
-            console.error('Error emitting state sync event:', error);
-        }
-    });
-}, _RedisClient_getActiveInstances = function _RedisClient_getActiveInstances() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const script = `
-            local active_instances = {}
-            
-            local cursor = '0'
-            repeat
-                local result = redis.call('SCAN', cursor, 'MATCH', 'heartbeat:*', 'COUNT', 100)
-                cursor = result[1]
-                
-                for _, key in ipairs(result[2]) do
-                    local id = string.match(key, 'heartbeat:([^:]+)')
-                    if id then
-                        table.insert(active_instances, id)
-                    end
-                end
-            until cursor == '0'
-            
-            return active_instances
-        `;
-        try {
-            return yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0);
-        }
-        catch (error) {
-            console.error('Error getting active instances:', error);
-            return [];
-        }
-    });
-}, _RedisClient_getCachedInstances = function _RedisClient_getCachedInstances() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const script = `
-            local seen = {}
-            local cached_instances = {}
-            
-            local cursor = '0'
-            repeat
-                local result = redis.call('SCAN', cursor, 'MATCH', '*_cache:*', 'COUNT', 100)
-                cursor = result[1]
-                
-                for _, key in ipairs(result[2]) do
-                    local id = string.match(key, '_cache:([^:]+)')
-                    if id and not seen[id] then
-                        seen[id] = true
-                        table.insert(cached_instances, id)
-                    end
-                end
-            until cursor == '0'
-            
-            return cached_instances
-        `;
-        try {
-            return yield __classPrivateFieldGet(this, _RedisClient_redisClient, "f").eval(script, 0);
-        }
-        catch (error) {
-            console.error('Error getting cached instances:', error);
-            return [];
-        }
-    });
-}, _RedisClient_generateCache = function _RedisClient_generateCache(data) {
-    const first = Object.entries(JSON.parse(data));
-    const second = first.map(([key, value]) => [key, JSON.parse(String(value))]);
-    return new Map(second);
-}, _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/errors/redisError.js

@@ -1,10 +0,0 @@
-"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;