@mulingai-npm/redis 3.6.0 → 3.7.1

package/dist/enums/redis-database.d.ts

@@ -1,5 +1,6 @@
 export declare enum RedisDatabase {
     MULINGSTREAM_LISTENER = 0,
     MULINGSTREAM_CHUNK = 1,
-    MULINGSTREAM_SPEAKER = 2
+    MULINGSTREAM_SPEAKER = 2,
+    CONTENT_DATA = 3
 }

package/dist/enums/redis-database.js

@@ -6,4 +6,5 @@ var RedisDatabase;
     RedisDatabase[RedisDatabase["MULINGSTREAM_LISTENER"] = 0] = "MULINGSTREAM_LISTENER";
     RedisDatabase[RedisDatabase["MULINGSTREAM_CHUNK"] = 1] = "MULINGSTREAM_CHUNK";
     RedisDatabase[RedisDatabase["MULINGSTREAM_SPEAKER"] = 2] = "MULINGSTREAM_SPEAKER";
+    RedisDatabase[RedisDatabase["CONTENT_DATA"] = 3] = "CONTENT_DATA";
 })(RedisDatabase = exports.RedisDatabase || (exports.RedisDatabase = {}));

package/dist/managers/mulingstream-listener-manager.d.ts

@@ -21,9 +21,5 @@ export declare class MulingstreamListenerManager {
     updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
     updateSocketId(listenerIdOrToken: string, socketId: string): Promise<boolean>;
     getTargetSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
-    /**
-     * Returns an array of unique languages for the given room, from highest frequency to lowest.
-     * If a listener has no language (empty string / undefined), it is ignored.
-     */
     getUniqueLanguagesByRoom(roomId: string): Promise<string[]>;
 }

package/dist/managers/mulingstream-listener-manager.js

@@ -139,10 +139,6 @@ class MulingstreamListenerManager {
         });
         return filteredListeners.map((listener) => listener.socketId);
     }
-    /**
-     * Returns an array of unique languages for the given room, from highest frequency to lowest.
-     * If a listener has no language (empty string / undefined), it is ignored.
-     */
     async getUniqueLanguagesByRoom(roomId) {
         // 1) Fetch all listeners for the room.
         //    (This includes inactive ones, but feel free to filter out isActive === false if you only want active ones.)

package/dist/managers/mulingstream-speaker-manager.d.ts

@@ -15,11 +15,7 @@ export declare class MulingstreamSpeakerManager {
     private redisClient;
     constructor(redisClient: RedisClient);
     private buildLockKey;
-    /** Try to claim the speaker slot for this room.
-     *  @returns true when the lock was acquired, false if someone else holds it.
-     */
     acquireRoomLock(roomId: string, socketId: string, ttl?: number): Promise<boolean>;
-    /** Release the lock if we still own it. */
     releaseRoomLock(roomId: string, socketId: string): Promise<void>;
     private parseHash;
     private serialize;

package/dist/managers/mulingstream-speaker-manager.js

@@ -7,19 +7,12 @@ class MulingstreamSpeakerManager {
     constructor(redisClient) {
         this.redisClient = redisClient;
     }
-    /* ------------------------------------------------------------------ */
-    /* One-speaker-per-room locking helpers                                */
-    /* ------------------------------------------------------------------ */
     buildLockKey(roomId) {
         return `room:${roomId}:speaker_lock`;
     }
-    /** Try to claim the speaker slot for this room.
-     *  @returns true when the lock was acquired, false if someone else holds it.
-     */
     async acquireRoomLock(roomId, socketId, ttl = LOCK_TTL) {
         return this.redisClient.setNxEx(this.buildLockKey(roomId), socketId, ttl);
     }
-    /** Release the lock if we still own it. */
     async releaseRoomLock(roomId, socketId) {
         const lockKey = this.buildLockKey(roomId);
         const current = await this.redisClient.get(lockKey);
@@ -27,9 +20,6 @@ class MulingstreamSpeakerManager {
             await this.redisClient.del(lockKey);
         }
     }
-    /* ------------------------------------------------------------------ */
-    /* Speaker CRUD + queries                                             */
-    /* ------------------------------------------------------------------ */
     parseHash(hash) {
         return {
             speakerId: hash.speakerId,
@@ -210,7 +200,7 @@ class MulingstreamSpeakerManager {
             this.redisClient.srem(`room:${roomId}:speakers`, speakerId),
             this.redisClient.srem(`user:${userId}:speakers`, speakerId),
             this.redisClient.del(`socket:${socketId}:speaker`),
-            this.redisClient.del(this.buildLockKey(roomId)) // ensure lock clears
+            this.redisClient.del(this.buildLockKey(roomId))
         ]);
     }
 }

package/dist/redis-client.d.ts

@@ -5,18 +5,10 @@ export interface RedisConfig {
     password?: string;
     db: number;
 }
-/**
- * Thin wrapper around ioredis that exposes exactly the helpers used by the two
- * managers. All helpers are 1-to-1 pass-through so there is no behavioural
- * change – this merely centralises typing and keeps the rest of the codebase
- * clean.
- */
 export declare class RedisClient {
     private client;
     constructor(config: RedisConfig);
     set(key: string, value: string): Promise<void>;
-    /** Atomic SET with NX + EX.
-     *  @returns true if the key was set, false when it already existed            */
     setNxEx(key: string, value: string, expireSeconds: number): Promise<boolean>;
     get(key: string): Promise<string | null>;
     del(key: string): Promise<number>;

package/dist/redis-client.js

@@ -5,12 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
-/**
- * Thin wrapper around ioredis that exposes exactly the helpers used by the two
- * managers. All helpers are 1-to-1 pass-through so there is no behavioural
- * change – this merely centralises typing and keeps the rest of the codebase
- * clean.
- */
 class RedisClient {
     constructor(config) {
         this.client = new ioredis_1.default({
@@ -23,14 +17,9 @@ class RedisClient {
             console.error('Redis error:', err);
         });
     }
-    /* ----------------------------------------------------------------------- */
-    /* Primitive string helpers                                                */
-    /* ----------------------------------------------------------------------- */
     async set(key, value) {
         await this.client.set(key, value);
     }
-    /** Atomic SET with NX + EX.
-     *  @returns true if the key was set, false when it already existed            */
     async setNxEx(key, value, expireSeconds) {
         // correct order: 'EX', ttl, 'NX'
         const res = (await this.client.set(key, value, 'EX', expireSeconds, 'NX'));
@@ -48,9 +37,6 @@ class RedisClient {
     async expire(key, seconds) {
         return this.client.expire(key, seconds);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Set helpers                                                             */
-    /* ----------------------------------------------------------------------- */
     async sadd(key, ...values) {
         return this.client.sadd(key, values);
     }
@@ -60,18 +46,12 @@ class RedisClient {
     async smembers(key) {
         return this.client.smembers(key);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Hash helpers                                                            */
-    /* ----------------------------------------------------------------------- */
     async hset(key, data) {
         return this.client.hset(key, data);
     }
     async hgetall(key) {
         return this.client.hgetall(key);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Sorted-set helpers                                                      */
-    /* ----------------------------------------------------------------------- */
     async zadd(key, score, member) {
         return this.client.zadd(key, score, member);
     }
@@ -87,24 +67,15 @@ class RedisClient {
     async zrem(key, ...members) {
         return this.client.zrem(key, members);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Scan (pattern search)                                                   */
-    /* ----------------------------------------------------------------------- */
     async scan(cursor, pattern, count = 1000) {
         return this.client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
     }
     async keys(pattern) {
         return this.client.keys(pattern);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Pipeline                                                                */
-    /* ----------------------------------------------------------------------- */
     pipeline() {
         return this.client.pipeline();
     }
-    /* ----------------------------------------------------------------------- */
-    /* Misc                                                                    */
-    /* ----------------------------------------------------------------------- */
     async unlink(...keys) {
         // unlink exists on Redis ≥4 and is supported by ioredis but not typed in
         // older versions – we cast to any.
@@ -112,7 +83,6 @@ class RedisClient {
         // @ts-ignore – runtime command exists even if typings lag behind.
         return this.client.unlink(...keys);
     }
-    /* JSON commands (RedisJSON module) -------------------------------------- */
     async jsonSet(key, path, value) {
         const result = await this.client.call('JSON.SET', key, path, JSON.stringify(value));
         return result;
@@ -135,9 +105,6 @@ class RedisClient {
     async jsonArrPop(key, path, index) {
         return index !== undefined ? this.client.call('JSON.ARRPOP', key, path, index) : this.client.call('JSON.ARRPOP', key, path);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Dangerous! – flush helpers                                              */
-    /* ----------------------------------------------------------------------- */
     async flushAll() {
         console.warn('Flushing all Redis data!');
         return this.client.flushall();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mulingai-npm/redis",
-    "version": "3.6.0",
+    "version": "3.7.1",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {