@mulingai-npm/redis 2.4.0 → 2.5.0

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

@@ -9,20 +9,28 @@ export type MulingstreamSpeakerData = {
     prompts: string;
     recordingsDuration: number;
     targetLanguages: string[];
+    timestamp: string;
 };
 export declare class MulingstreamSpeakerManager {
     private redisClient;
     constructor(redisClient: RedisClient);
-    private parseHashData;
+    private parseHash;
     private serialize;
-    private buildKey;
     private buildId;
-    addSpeaker(payload: Omit<MulingstreamSpeakerData, 'speakerId'>): Promise<string>;
-    removeSpeaker(roomId: string, socketId: string): Promise<boolean>;
-    getSpeakersByRoom(roomId: string): Promise<MulingstreamSpeakerData[]>;
-    getSpeakerBySocketId(roomId: string, socketId: string): Promise<MulingstreamSpeakerData | null>;
-    getSpeakerByUserId(roomId: string, userId: string): Promise<MulingstreamSpeakerData | null>;
-    updateSourceLanguage(roomId: string, socketId: string, newLang: string): Promise<boolean>;
-    updateTargetLanguages(roomId: string, socketId: string, languages: string[]): Promise<boolean>;
-    increaseRecordingDuration(roomId: string, socketId: string, delta: number): Promise<number>;
+    private buildKey;
+    addSpeaker(payload: Omit<MulingstreamSpeakerData, 'speakerId' | 'timestamp'>): Promise<string>;
+    removeSpeakerBySocketId(socketId: string): Promise<boolean>;
+    removeSpeakersByUserId(userId: string): Promise<number>;
+    removeSpeakersByRoomId(roomId: string): Promise<number>;
+    /** internal: remove hash + all index references */
+    private removeSpeakerById;
+    getSpeakerBySpeakerId(speakerId: string): Promise<MulingstreamSpeakerData | null>;
+    getSpeakerBySocketId(socketId: string): Promise<MulingstreamSpeakerData | null>;
+    getSpeakersByRoomId(roomId: string): Promise<MulingstreamSpeakerData[]>;
+    getSpeakersByUserId(userId: string): Promise<MulingstreamSpeakerData[]>;
+    getSpeakerByUserRoom(roomId: string, userId: string): Promise<MulingstreamSpeakerData | null>;
+    updateSourceLanguage(socketId: string, newLang: string): Promise<boolean>;
+    updateTargetLanguages(socketId: string, languages: string[]): Promise<boolean>;
+    increaseRecordingDuration(socketId: string, delta: number): Promise<number>;
+    private cleanIndexes;
 }

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

@@ -6,7 +6,8 @@ class MulingstreamSpeakerManager {
     constructor(redisClient) {
         this.redisClient = redisClient;
     }
-    parseHashData(hash) {
+    /* ------------------------------------------------ helpers */
+    parseHash(hash) {
         return {
             speakerId: hash.speakerId,
             userId: hash.userId,
@@ -16,7 +17,8 @@ class MulingstreamSpeakerManager {
             theme: hash.theme,
             prompts: hash.prompts,
             recordingsDuration: parseInt(hash.recordingsDuration, 10) || 0,
-            targetLanguages: JSON.parse(hash.targetLanguages || '[]')
+            targetLanguages: JSON.parse(hash.targetLanguages || '[]'),
+            timestamp: hash.timestamp
         };
     }
     serialize(data) {
@@ -29,79 +31,194 @@ class MulingstreamSpeakerManager {
             theme: data.theme,
             prompts: data.prompts,
             recordingsDuration: data.recordingsDuration.toString(),
-            targetLanguages: JSON.stringify(data.targetLanguages)
+            targetLanguages: JSON.stringify(data.targetLanguages),
+            timestamp: data.timestamp
         };
     }
-    buildKey(speakerId) {
-        return `speaker:${speakerId}`;
-    }
     buildId(roomId, userId, socketId) {
         return `[${roomId}]-[${userId}]-[${socketId}]`;
     }
+    buildKey(speakerId) {
+        return `speaker:${speakerId}`;
+    }
+    /* ------------------------------------------------ insert */
     async addSpeaker(payload) {
         const speakerId = this.buildId(payload.roomId, payload.userId, payload.socketId);
-        await this.redisClient.hset(this.buildKey(speakerId), this.serialize({ ...payload, speakerId }));
-        await this.redisClient.expire(this.buildKey(speakerId), EXPIRATION);
+        const key = this.buildKey(speakerId);
+        const speakerData = {
+            ...payload,
+            speakerId,
+            timestamp: new Date(Date.now()).toISOString()
+        };
+        await this.redisClient.hset(key, this.serialize(speakerData));
+        await this.redisClient.expire(key, EXPIRATION);
+        // index sets / mapping
+        await this.redisClient.sadd(`room:${payload.roomId}:speakers`, speakerId);
+        await this.redisClient.sadd(`user:${payload.userId}:speakers`, speakerId);
+        await this.redisClient.set(`socket:${payload.socketId}:speaker`, speakerId);
+        await this.redisClient.expire(`socket:${payload.socketId}:speaker`, EXPIRATION);
         return speakerId;
     }
-    async removeSpeaker(roomId, socketId) {
-        const speaker = await this.getSpeakerBySocketId(roomId, socketId);
-        if (!speaker) {
+    /* ------------------------------------------------ remove helpers */
+    async removeSpeakerBySocketId(socketId) {
+        const speakerId = await this.redisClient.get(`socket:${socketId}:speaker`);
+        if (speakerId === null) {
             return false;
         }
-        await this.redisClient.del(this.buildKey(speaker.speakerId));
+        const removed = await this.removeSpeakerById(speakerId);
+        return removed;
+    }
+    async removeSpeakersByUserId(userId) {
+        const ids = await this.redisClient.smembers(`user:${userId}:speakers`);
+        if (ids.length === 0) {
+            return 0;
+        }
+        let deletedCount = 0;
+        for (const id of ids) {
+            if (await this.removeSpeakerById(id)) {
+                deletedCount += 1;
+            }
+        }
+        return deletedCount;
+    }
+    async removeSpeakersByRoomId(roomId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        if (ids.length === 0) {
+            return 0;
+        }
+        let deletedCount = 0;
+        for (const id of ids) {
+            if (await this.removeSpeakerById(id)) {
+                deletedCount += 1;
+            }
+        }
+        return deletedCount;
+    }
+    /** internal: remove hash + all index references */
+    async removeSpeakerById(speakerId) {
+        const key = this.buildKey(speakerId);
+        const data = await this.redisClient.hgetall(key);
+        if (data === null || Object.keys(data).length === 0) {
+            // already gone; clean indexes anyway
+            await this.cleanIndexes(speakerId);
+            return false;
+        }
+        await this.redisClient.del(key);
+        await this.cleanIndexes(speakerId);
         return true;
     }
-    async getSpeakersByRoom(roomId) {
-        const keys = await this.redisClient.keys(`speaker:[${roomId}]-*`);
-        if (!keys.length) {
-            return [];
+    /* ------------------------------------------------ lookup helpers */
+    async getSpeakerBySpeakerId(speakerId) {
+        const key = this.buildKey(speakerId);
+        const hash = await this.redisClient.hgetall(key);
+        if (hash === null || Object.keys(hash).length === 0) {
+            /* the hash has expired or was never there – remove any stray index refs */
+            await this.cleanIndexes(speakerId);
+            return null;
+        }
+        return this.parseHash(hash);
+    }
+    async getSpeakerBySocketId(socketId) {
+        const speakerId = await this.redisClient.get(`socket:${socketId}:speaker`);
+        if (speakerId === null) {
+            return null;
         }
-        const out = [];
-        for (const k of keys) {
-            const hash = await this.redisClient.hgetall(k);
-            if (hash && Object.keys(hash).length)
-                out.push(this.parseHashData(hash));
+        const hash = await this.redisClient.hgetall(this.buildKey(speakerId));
+        if (hash !== null && Object.keys(hash).length > 0) {
+            return this.parseHash(hash);
         }
-        return out;
+        // hash expired: tidy indexes
+        await this.cleanIndexes(speakerId);
+        return null;
     }
-    async getSpeakerBySocketId(roomId, socketId) {
-        var _a;
-        const speakers = await this.getSpeakersByRoom(roomId);
-        return (_a = speakers.find((s) => s.socketId === socketId)) !== null && _a !== void 0 ? _a : null;
+    async getSpeakersByRoomId(roomId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        const result = [];
+        for (const id of ids) {
+            const hash = await this.redisClient.hgetall(this.buildKey(id));
+            if (hash !== null && Object.keys(hash).length > 0) {
+                result.push(this.parseHash(hash));
+            }
+            else {
+                await this.cleanIndexes(id);
+            }
+        }
+        return result;
     }
-    async getSpeakerByUserId(roomId, userId) {
-        var _a;
-        const speakers = await this.getSpeakersByRoom(roomId);
-        return (_a = speakers.find((s) => s.userId === userId)) !== null && _a !== void 0 ? _a : null;
+    async getSpeakersByUserId(userId) {
+        const ids = await this.redisClient.smembers(`user:${userId}:speakers`);
+        const result = [];
+        for (const id of ids) {
+            const hash = await this.redisClient.hgetall(this.buildKey(id));
+            if (hash !== null && Object.keys(hash).length > 0) {
+                result.push(this.parseHash(hash));
+            }
+            else {
+                await this.cleanIndexes(id);
+            }
+        }
+        return result;
     }
-    async updateSourceLanguage(roomId, socketId, newLang) {
-        const speaker = await this.getSpeakerBySocketId(roomId, socketId);
-        if (!speaker)
+    async getSpeakerByUserRoom(roomId, userId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        for (const id of ids) {
+            if (id.includes(`]-[${userId}]-[`)) {
+                const hash = await this.redisClient.hgetall(this.buildKey(id));
+                if (hash !== null && Object.keys(hash).length > 0) {
+                    return this.parseHash(hash);
+                }
+                await this.cleanIndexes(id);
+                return null;
+            }
+        }
+        return null;
+    }
+    /* ------------------------------------------------ update helpers */
+    async updateSourceLanguage(socketId, newLang) {
+        const speaker = await this.getSpeakerBySocketId(socketId);
+        if (speaker === null) {
             return false;
+        }
         await this.redisClient.hset(this.buildKey(speaker.speakerId), {
             sourceLanguage: newLang
         });
         return true;
     }
-    async updateTargetLanguages(roomId, socketId, languages) {
-        const speaker = await this.getSpeakerBySocketId(roomId, socketId);
-        if (!speaker)
+    async updateTargetLanguages(socketId, languages) {
+        const speaker = await this.getSpeakerBySocketId(socketId);
+        if (speaker === null) {
             return false;
+        }
         await this.redisClient.hset(this.buildKey(speaker.speakerId), {
             targetLanguages: JSON.stringify(languages)
         });
         return true;
     }
-    async increaseRecordingDuration(roomId, socketId, delta) {
-        const speaker = await this.getSpeakerBySocketId(roomId, socketId);
-        if (!speaker)
+    async increaseRecordingDuration(socketId, delta) {
+        const speaker = await this.getSpeakerBySocketId(socketId);
+        if (speaker === null) {
             return -1;
+        }
         speaker.recordingsDuration += delta;
         await this.redisClient.hset(this.buildKey(speaker.speakerId), {
             recordingsDuration: speaker.recordingsDuration.toString()
         });
         return speaker.recordingsDuration;
     }
+    /* ------------------------------------------------ index cleanup */
+    async cleanIndexes(speakerId) {
+        const parts = speakerId
+            .substring(1, speakerId.length - 1) // remove outer [...]
+            .split(']-['); // ['roomId','userId','socketId']
+        if (parts.length !== 3) {
+            return;
+        }
+        const roomId = parts[0];
+        const userId = parts[1];
+        const socketId = parts[2];
+        await this.redisClient.srem(`room:${roomId}:speakers`, speakerId);
+        await this.redisClient.srem(`user:${userId}:speakers`, speakerId);
+        await this.redisClient.del(`socket:${socketId}:speaker`);
+    }
 }
 exports.MulingstreamSpeakerManager = MulingstreamSpeakerManager;

package/dist/redis-client.js

@@ -52,10 +52,11 @@ class RedisClient {
     }
     // flush methods
     async flushAll() {
-        console.log('Removing all data!');
+        console.log('Flushing All Redis Data!');
         return this.client.flushall();
     }
     async flushDb() {
+        console.log('Flushing Redis Data from DB!');
         return this.client.flushdb();
     }
     async expire(key, seconds) {

package/package.json

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