@mulingai-npm/redis 3.4.1 → 3.5.0

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

@@ -1,225 +1,217 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MulingstreamSpeakerManager = void 0;
-const EXPIRATION = 24 * 60 * 60; // 24h
-class MulingstreamSpeakerManager {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-    parseHash(hash) {
-        return {
-            speakerId: hash.speakerId,
-            userId: hash.userId,
-            roomId: hash.roomId,
-            socketId: hash.socketId,
-            sourceLanguage: hash.sourceLanguage,
-            theme: hash.theme,
-            prompts: hash.prompts,
-            recordingsDuration: parseInt(hash.recordingsDuration, 10) || 0,
-            targetLanguages: JSON.parse(hash.targetLanguages || '[]'),
-            timestamp: hash.timestamp
-        };
-    }
-    serialize(data) {
-        return {
-            speakerId: data.speakerId,
-            userId: data.userId,
-            roomId: data.roomId,
-            socketId: data.socketId,
-            sourceLanguage: data.sourceLanguage,
-            theme: data.theme,
-            prompts: data.prompts,
-            recordingsDuration: data.recordingsDuration.toString(),
-            targetLanguages: JSON.stringify(data.targetLanguages),
-            timestamp: data.timestamp
-        };
-    }
-    buildId(roomId, userId, socketId) {
-        return `[${roomId}]-[${userId}]-[${socketId}]`;
-    }
-    buildKey(speakerId) {
-        return `speaker:${speakerId}`;
-    }
-    async addSpeaker(payload) {
-        const speakerId = this.buildId(payload.roomId, payload.userId, payload.socketId);
-        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 removeSpeakerBySocketId(socketId) {
-        const speakerId = await this.redisClient.get(`socket:${socketId}:speaker`);
-        if (speakerId === null) {
-            return false;
-        }
-        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;
-    }
-    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 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 hash = await this.redisClient.hgetall(this.buildKey(speakerId));
-        if (hash !== null && Object.keys(hash).length > 0) {
-            return this.parseHash(hash);
-        }
-        // hash expired: tidy indexes
-        await this.cleanIndexes(speakerId);
-        return 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 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 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;
-    }
-    async getSpeakersLength(roomId) {
-        const speakers = await this.getSpeakersByRoomId(roomId);
-        return speakers.length;
-    }
-    async isRoomEmpty(roomId) {
-        const totalSpeakers = await this.getSpeakersLength(roomId);
-        return totalSpeakers === 0;
-    }
-    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(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(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;
-    }
-    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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamSpeakerManager = void 0;
+const EXPIRATION = 24 * 60 * 60; // 24h
+const LOCK_TTL = 30; // seconds
+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);
+        if (current === socketId) {
+            await this.redisClient.del(lockKey);
+        }
+    }
+    /* ------------------------------------------------------------------ */
+    /* Speaker CRUD + queries                                             */
+    /* ------------------------------------------------------------------ */
+    parseHash(hash) {
+        return {
+            speakerId: hash.speakerId,
+            userId: hash.userId,
+            roomId: hash.roomId,
+            socketId: hash.socketId,
+            sourceLanguage: hash.sourceLanguage,
+            theme: hash.theme,
+            prompts: hash.prompts,
+            recordingsDuration: parseInt(hash.recordingsDuration, 10) || 0,
+            targetLanguages: JSON.parse(hash.targetLanguages || '[]'),
+            timestamp: hash.timestamp
+        };
+    }
+    serialize(data) {
+        return {
+            speakerId: data.speakerId,
+            userId: data.userId,
+            roomId: data.roomId,
+            socketId: data.socketId,
+            sourceLanguage: data.sourceLanguage,
+            theme: data.theme,
+            prompts: data.prompts,
+            recordingsDuration: data.recordingsDuration.toString(),
+            targetLanguages: JSON.stringify(data.targetLanguages),
+            timestamp: data.timestamp
+        };
+    }
+    buildId(roomId, userId, socketId) {
+        return `[${roomId}]-[${userId}]-[${socketId}]`;
+    }
+    buildKey(speakerId) {
+        return `speaker:${speakerId}`;
+    }
+    async addSpeaker(payload) {
+        const speakerId = this.buildId(payload.roomId, payload.userId, payload.socketId);
+        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);
+        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 removeSpeakerBySocketId(socketId) {
+        const speakerId = await this.redisClient.get(`socket:${socketId}:speaker`);
+        if (speakerId === null)
+            return false;
+        return this.removeSpeakerById(speakerId);
+    }
+    async removeSpeakersByUserId(userId) {
+        const ids = await this.redisClient.smembers(`user:${userId}:speakers`);
+        let deleted = 0;
+        for (const id of ids)
+            if (await this.removeSpeakerById(id))
+                deleted += 1;
+        return deleted;
+    }
+    async removeSpeakersByRoomId(roomId) {
+        const ids = await this.redisClient.smembers(`room:${roomId}:speakers`);
+        let deleted = 0;
+        for (const id of ids)
+            if (await this.removeSpeakerById(id))
+                deleted += 1;
+        return deleted;
+    }
+    async removeSpeakerById(speakerId) {
+        const key = this.buildKey(speakerId);
+        const data = await this.redisClient.hgetall(key);
+        if (data === null || Object.keys(data).length === 0) {
+            await this.cleanIndexes(speakerId);
+            return false;
+        }
+        await this.redisClient.del(key);
+        await this.cleanIndexes(speakerId);
+        return true;
+    }
+    async getSpeakerBySpeakerId(speakerId) {
+        const key = this.buildKey(speakerId);
+        const hash = await this.redisClient.hgetall(key);
+        if (hash === null || Object.keys(hash).length === 0) {
+            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 hash = await this.redisClient.hgetall(this.buildKey(speakerId));
+        if (hash !== null && Object.keys(hash).length > 0)
+            return this.parseHash(hash);
+        await this.cleanIndexes(speakerId);
+        return 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 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 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;
+    }
+    async getSpeakersLength(roomId) {
+        return (await this.getSpeakersByRoomId(roomId)).length;
+    }
+    async isRoomEmpty(roomId) {
+        return (await this.getSpeakersLength(roomId)) === 0;
+    }
+    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(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(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;
+    }
+    async cleanIndexes(speakerId) {
+        const parts = speakerId.substring(1, speakerId.length - 1).split(']-['); // ['roomId','userId','socketId']
+        if (parts.length !== 3)
+            return;
+        const [roomId, userId, socketId] = parts;
+        await Promise.all([
+            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
+        ]);
+    }
+}
+exports.MulingstreamSpeakerManager = MulingstreamSpeakerManager;

package/dist/redis-client.d.ts

@@ -1,44 +1,47 @@
-import IORedis from 'ioredis';
-export interface RedisConfig {
-    host: string;
-    port: number;
-    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>;
-    get(key: string): Promise<string | null>;
-    del(key: string): Promise<number>;
-    exists(key: string): Promise<number>;
-    expire(key: string, seconds: number): Promise<number>;
-    sadd(key: string, ...values: string[]): Promise<number>;
-    srem(key: string, ...values: string[]): Promise<number>;
-    smembers(key: string): Promise<string[]>;
-    hset(key: string, data: Record<string, string>): Promise<number>;
-    hgetall(key: string): Promise<Record<string, string>>;
-    zadd(key: string, score: number, member: string): Promise<number>;
-    zrange(key: string, start: number, stop: number): Promise<string[]>;
-    zremrangebyrank(key: string, start: number, stop: number): Promise<number>;
-    zrangebyscore(key: string, min: number | string, max: number | string): Promise<string[]>;
-    zrem(key: string, ...members: string[]): Promise<number>;
-    scan(cursor: number, pattern: string, count?: number): Promise<[string, string[]]>;
-    keys(pattern: string): Promise<string[]>;
-    pipeline(): ReturnType<IORedis['pipeline']>;
-    unlink(...keys: string[]): Promise<number>;
-    jsonSet<T>(key: string, path: string, value: T): Promise<string>;
-    jsonGet<T>(key: string, path: string): Promise<T | null>;
-    jsonDel(key: string, path: string): Promise<number>;
-    jsonArrAppend<T>(key: string, path: string, ...values: T[]): Promise<number>;
-    jsonArrLen(key: string, path: string): Promise<number | null>;
-    jsonArrPop(key: string, path: string, index?: number): Promise<any>;
-    flushAll(): Promise<string>;
-    flushDb(): Promise<string>;
-}
+import IORedis from 'ioredis';
+export interface RedisConfig {
+    host: string;
+    port: number;
+    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>;
+    exists(key: string): Promise<number>;
+    expire(key: string, seconds: number): Promise<number>;
+    sadd(key: string, ...values: string[]): Promise<number>;
+    srem(key: string, ...values: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    hset(key: string, data: Record<string, string>): Promise<number>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    zadd(key: string, score: number, member: string): Promise<number>;
+    zrange(key: string, start: number, stop: number): Promise<string[]>;
+    zremrangebyrank(key: string, start: number, stop: number): Promise<number>;
+    zrangebyscore(key: string, min: number | string, max: number | string): Promise<string[]>;
+    zrem(key: string, ...members: string[]): Promise<number>;
+    scan(cursor: number, pattern: string, count?: number): Promise<[string, string[]]>;
+    keys(pattern: string): Promise<string[]>;
+    pipeline(): ReturnType<IORedis['pipeline']>;
+    unlink(...keys: string[]): Promise<number>;
+    jsonSet<T>(key: string, path: string, value: T): Promise<string>;
+    jsonGet<T>(key: string, path: string): Promise<T | null>;
+    jsonDel(key: string, path: string): Promise<number>;
+    jsonArrAppend<T>(key: string, path: string, ...values: T[]): Promise<number>;
+    jsonArrLen(key: string, path: string): Promise<number | null>;
+    jsonArrPop(key: string, path: string, index?: number): Promise<any>;
+    flushAll(): Promise<string>;
+    flushDb(): Promise<string>;
+}