@mulingai-npm/redis 1.3.0 → 1.3.2

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

@@ -1,3 +1,4 @@
 export declare enum RedisDatabase {
-    MULINGSTREAM_LISTENER = 0
+    MULINGSTREAM_LISTENER = 0,
+    AUDIO_STT = 1
 }

package/dist/enums/redis-database.js

@@ -4,4 +4,5 @@ exports.RedisDatabase = void 0;
 var RedisDatabase;
 (function (RedisDatabase) {
     RedisDatabase[RedisDatabase["MULINGSTREAM_LISTENER"] = 0] = "MULINGSTREAM_LISTENER";
+    RedisDatabase[RedisDatabase["AUDIO_STT"] = 1] = "AUDIO_STT";
 })(RedisDatabase = exports.RedisDatabase || (exports.RedisDatabase = {}));

package/dist/managers/audio-chunk-manager.d.ts

@@ -0,0 +1,24 @@
+import { RedisClient } from '../redis-client';
+export type MulingstreamListenerData = {
+    listenerId: string;
+    roomId: string;
+    socketId?: string;
+    token: string;
+    name?: string;
+    firstJoined: number;
+    language?: string;
+    isActive?: boolean;
+};
+export declare class MulingstreamListenerManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHashData;
+    addListener(listenerData: Omit<MulingstreamListenerData, 'listenerId'>): Promise<string>;
+    getAllListeners(): Promise<MulingstreamListenerData[]>;
+    getListenersByRoom(roomId: string): Promise<MulingstreamListenerData[]>;
+    getListener(listenerIdOrToken: string): Promise<MulingstreamListenerData | null>;
+    removeListenerByToken(token: string): Promise<boolean>;
+    updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
+    updateSocketId(listenerIdOrToken: string, socketId: string): Promise<boolean>;
+    getTargetSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
+}

package/dist/managers/audio-chunk-manager.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamListenerManager = void 0;
+const uuid_1 = require("uuid");
+const EXPIRATION = 24 * 60 * 60; // 24 hours in seconds
+class MulingstreamListenerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        return {
+            listenerId: data.listenerId,
+            roomId: data.roomId,
+            socketId: data.socketId || '',
+            token: data.token,
+            name: data.name || '',
+            firstJoined: parseInt(data.firstJoined, 10),
+            language: data.language || '',
+            isActive: data.isActive === 'true'
+        };
+    }
+    // Creates a new listener.
+    // -Generates a unique listenerId and adds it to the room's set.
+    // -Stores the listener data in a Redis hash under `listener:{listenerId}`.
+    async addListener(listenerData) {
+        var _a, _b, _c;
+        // You can combine roomId + uuid, or just a uuid, up to you:
+        const listenerId = `[${listenerData.roomId}]-[${(0, uuid_1.v4)()}]`;
+        // Add listenerId to the set for that room
+        await this.redisClient.sadd(`room:${listenerData.roomId}:listeners`, listenerId);
+        // Store listener data in a hash
+        await this.redisClient.hset(`listener:${listenerId}`, {
+            listenerId,
+            roomId: listenerData.roomId,
+            socketId: (_a = listenerData.socketId) !== null && _a !== void 0 ? _a : '',
+            token: listenerData.token,
+            name: (_b = listenerData.name) !== null && _b !== void 0 ? _b : '',
+            firstJoined: listenerData.firstJoined.toString(),
+            language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
+            isActive: 'true'
+        });
+        // expire listener
+        await this.redisClient.expire(`listener:${listenerId}`, EXPIRATION);
+        return listenerId;
+    }
+    async getAllListeners() {
+        // get all keys that match 'listener:*'
+        // TODO: if we have many keys, consider using SCAN instead of KEYS to avoid performance issues.
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        // fetch each hash with HGETALL
+        const listeners = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListenersByRoom(roomId) {
+        // get the set of listener IDs
+        const listenerIds = await this.redisClient.smembers(`room:${roomId}:listeners`);
+        if (!listenerIds || listenerIds.length === 0) {
+            return [];
+        }
+        const listeners = [];
+        for (const id of listenerIds) {
+            // get hash data
+            const data = await this.redisClient.hgetall(`listener:${id}`);
+            // if the hash doesn't exist, it may have expired, so remove from the set
+            if (!data || Object.keys(data).length === 0) {
+                await this.redisClient.srem(`room:${roomId}:listeners`, id);
+                continue;
+            }
+            // otherwise, parse and keep it
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListener(listenerIdOrToken) {
+        // try direct lookup by listenerId:
+        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
+        if (directData && directData.listenerId) {
+            return this.parseHashData(directData);
+        }
+        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return null;
+        }
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.token === listenerIdOrToken) {
+                return this.parseHashData(data);
+            }
+        }
+        return null;
+    }
+    async removeListenerByToken(token) {
+        // find the listener by token
+        const listener = await this.getListener(token);
+        if (!listener) {
+            return false;
+        }
+        // remove the listener ID from the room's set
+        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
+        // remove the listener data (the hash)
+        await this.redisClient.del(`listener:${listener.listenerId}`);
+        return true;
+    }
+    async updateNameLanguage(listenerIdOrToken, name, language) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            name,
+            language
+        });
+        return true;
+    }
+    async updateSocketId(listenerIdOrToken, socketId) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            socketId
+        });
+        return true;
+    }
+    async getTargetSocketIdsByRoomLanguage(roomId, language) {
+        const listeners = await this.getListenersByRoom(roomId);
+        const filteredListeners = listeners.filter((listener) => {
+            return listener.isActive === true && listener.language === language && listener.socketId && listener.socketId.trim() !== '';
+        });
+        return filteredListeners.map((listener) => listener.socketId);
+    }
+}
+exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/dist/managers/audio-stt-manager.d.ts

@@ -0,0 +1,28 @@
+import { RedisClient } from '../redis-client';
+export type AudioSttData = {
+    audioSttId: string;
+    roomId: string;
+    start: number;
+    end: number;
+    duration: number;
+    chunkNumber: number;
+    isFirst: boolean;
+    isLast: boolean;
+    language: string;
+    theme: string;
+    azureTranscription?: string;
+    whisperTranscription?: string;
+    googleTranscription?: string;
+    processingStart: number;
+    totalStatusCheck: number;
+    status: 'RECEIVED' | 'DISCARDED' | 'READY' | 'USED';
+};
+export declare class AudioSttManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHashData;
+    addAudioStt(sttData: Omit<AudioSttData, 'audioSttId' | 'processingStart' | 'totalStatusCheck' | 'status'>): Promise<string>;
+    getAllAudioStt(): Promise<AudioSttData[]>;
+    getAllAudioSttByRoom(roomId: string): Promise<AudioSttData[]>;
+    getAudioStt(audioSttId: string): Promise<AudioSttData | null>;
+}

package/dist/managers/audio-stt-manager.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioSttManager = void 0;
+const uuid_1 = require("uuid");
+const EXPIRATION = 4 * 60 * 60; // 4 hours in seconds
+class AudioSttManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        return {
+            audioSttId: data.audioSttId,
+            roomId: data.roomId,
+            start: parseInt(data.start, 10),
+            end: parseInt(data.end, 10),
+            duration: parseInt(data.duration, 10),
+            chunkNumber: parseInt(data.chunkNumber, 10),
+            isFirst: data.isFirst === 'true',
+            isLast: data.isLast === 'true',
+            language: data.language,
+            theme: data.theme,
+            azureTranscription: data.azureTranscription || undefined,
+            whisperTranscription: data.whisperTranscription || undefined,
+            googleTranscription: data.googleTranscription || undefined,
+            processingStart: parseInt(data.processingStart, 10),
+            totalStatusCheck: parseInt(data.totalStatusCheck, 10),
+            status: data.status
+        };
+    }
+    // Creates a new audio-stt entry.
+    // - Generates a unique audioSttId and adds it to the room’s set.
+    // - Stores the data in a Redis hash under `audioStt:{audioSttId}`.
+    // - Optionally sets an expiration (4h).
+    async addAudioStt(sttData) {
+        const audioSttId = `[${sttData.roomId}]-[${(0, uuid_1.v4)()}]`;
+        // Add audioSttId to the set for that room
+        await this.redisClient.sadd(`room:${sttData.roomId}:audioStt`, audioSttId);
+        // Store audio-stt data in a hash
+        await this.redisClient.hset(`audioStt:${audioSttId}`, {
+            audioSttId,
+            roomId: sttData.roomId,
+            start: sttData.start.toString(),
+            end: sttData.end.toString(),
+            duration: sttData.duration.toString(),
+            chunkNumber: sttData.chunkNumber.toString(),
+            isFirst: sttData.isFirst.toString(),
+            isLast: sttData.isLast.toString(),
+            language: sttData.language,
+            theme: sttData.theme,
+            processingStart: Date.now().toString(),
+            totalStatusCheck: (0).toString(),
+            status: 'RECEIVED'
+        });
+        // Set expiration if desired
+        await this.redisClient.expire(`audioStt:${audioSttId}`, EXPIRATION);
+        return audioSttId;
+    }
+    // Retrieves *all* audio-stt entries by scanning the keys that match `audioStt:*`
+    async getAllAudioStt() {
+        const keys = await this.redisClient.keys('audioStt:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.audioSttId) {
+                results.push(this.parseHashData(data));
+            }
+        }
+        return results;
+    }
+    // Retrieves all audio-stt entries for a specific room by looking up
+    // the set `room:{roomId}:audioStt` and then fetching each hash.
+    async getAllAudioSttByRoom(roomId) {
+        const audioSttIds = await this.redisClient.smembers(`room:${roomId}:audioStt`);
+        if (!audioSttIds || audioSttIds.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (const id of audioSttIds) {
+            const data = await this.redisClient.hgetall(`audioStt:${id}`);
+            // if the hash doesn't exist, it may have expired, so remove from the set
+            if (!data || Object.keys(data).length === 0) {
+                await this.redisClient.srem(`room:${roomId}:audioStt`, id);
+                continue;
+            }
+            results.push(this.parseHashData(data));
+        }
+        return results;
+    }
+    // Retrieves a single audio-stt entry by ID.
+    async getAudioStt(audioSttId) {
+        const data = await this.redisClient.hgetall(`audioStt:${audioSttId}`);
+        if (!data || !data.audioSttId) {
+            return null;
+        }
+        return this.parseHashData(data);
+    }
+}
+exports.AudioSttManager = AudioSttManager;

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

@@ -0,0 +1,24 @@
+import { RedisClient } from '../redis-client';
+export type MulingstreamListenerData = {
+    listenerId: string;
+    roomId: string;
+    socketId?: string;
+    token: string;
+    name?: string;
+    firstJoined: number;
+    language?: string;
+    isActive?: boolean;
+};
+export declare class MulingstreamListenerManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHashData;
+    addListener(listenerData: Omit<MulingstreamListenerData, 'listenerId'>): Promise<string>;
+    getAllListeners(): Promise<MulingstreamListenerData[]>;
+    getListenersByRoom(roomId: string): Promise<MulingstreamListenerData[]>;
+    getListener(listenerIdOrToken: string): Promise<MulingstreamListenerData | null>;
+    removeListenerByToken(token: string): Promise<boolean>;
+    updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
+    updateSocketId(listenerIdOrToken: string, socketId: string): Promise<boolean>;
+    getTargetSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamListenerManager = void 0;
+const uuid_1 = require("uuid");
+const EXPIRATION = 24 * 60 * 60; // 24 hours in seconds
+class MulingstreamListenerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        return {
+            listenerId: data.listenerId,
+            roomId: data.roomId,
+            socketId: data.socketId || '',
+            token: data.token,
+            name: data.name || '',
+            firstJoined: parseInt(data.firstJoined, 10),
+            language: data.language || '',
+            isActive: data.isActive === 'true'
+        };
+    }
+    // Creates a new listener.
+    // -Generates a unique listenerId and adds it to the room's set.
+    // -Stores the listener data in a Redis hash under `listener:{listenerId}`.
+    async addListener(listenerData) {
+        var _a, _b, _c;
+        // You can combine roomId + uuid, or just a uuid, up to you:
+        const listenerId = `[${listenerData.roomId}]-[${(0, uuid_1.v4)()}]`;
+        // Add listenerId to the set for that room
+        await this.redisClient.sadd(`room:${listenerData.roomId}:listeners`, listenerId);
+        // Store listener data in a hash
+        await this.redisClient.hset(`listener:${listenerId}`, {
+            listenerId,
+            roomId: listenerData.roomId,
+            socketId: (_a = listenerData.socketId) !== null && _a !== void 0 ? _a : '',
+            token: listenerData.token,
+            name: (_b = listenerData.name) !== null && _b !== void 0 ? _b : '',
+            firstJoined: listenerData.firstJoined.toString(),
+            language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
+            isActive: 'true'
+        });
+        // expire listener
+        await this.redisClient.expire(`listener:${listenerId}`, EXPIRATION);
+        return listenerId;
+    }
+    async getAllListeners() {
+        // get all keys that match 'listener:*'
+        // TODO: if we have many keys, consider using SCAN instead of KEYS to avoid performance issues.
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        // fetch each hash with HGETALL
+        const listeners = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListenersByRoom(roomId) {
+        // get the set of listener IDs
+        const listenerIds = await this.redisClient.smembers(`room:${roomId}:listeners`);
+        if (!listenerIds || listenerIds.length === 0) {
+            return [];
+        }
+        const listeners = [];
+        for (const id of listenerIds) {
+            // get hash data
+            const data = await this.redisClient.hgetall(`listener:${id}`);
+            // if the hash doesn't exist, it may have expired, so remove from the set
+            if (!data || Object.keys(data).length === 0) {
+                await this.redisClient.srem(`room:${roomId}:listeners`, id);
+                continue;
+            }
+            // otherwise, parse and keep it
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListener(listenerIdOrToken) {
+        // try direct lookup by listenerId:
+        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
+        if (directData && directData.listenerId) {
+            return this.parseHashData(directData);
+        }
+        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return null;
+        }
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.token === listenerIdOrToken) {
+                return this.parseHashData(data);
+            }
+        }
+        return null;
+    }
+    async removeListenerByToken(token) {
+        // find the listener by token
+        const listener = await this.getListener(token);
+        if (!listener) {
+            return false;
+        }
+        // remove the listener ID from the room's set
+        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
+        // remove the listener data (the hash)
+        await this.redisClient.del(`listener:${listener.listenerId}`);
+        return true;
+    }
+    async updateNameLanguage(listenerIdOrToken, name, language) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            name,
+            language
+        });
+        return true;
+    }
+    async updateSocketId(listenerIdOrToken, socketId) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            socketId
+        });
+        return true;
+    }
+    async getTargetSocketIdsByRoomLanguage(roomId, language) {
+        const listeners = await this.getListenersByRoom(roomId);
+        const filteredListeners = listeners.filter((listener) => {
+            return listener.isActive === true && listener.language === language && listener.socketId && listener.socketId.trim() !== '';
+        });
+        return filteredListeners.map((listener) => listener.socketId);
+    }
+}
+exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/dist/managers/stt-manager.d.ts

@@ -0,0 +1,24 @@
+import { RedisClient } from '../redis-client';
+export type MulingstreamListenerData = {
+    listenerId: string;
+    roomId: string;
+    socketId?: string;
+    token: string;
+    name?: string;
+    firstJoined: number;
+    language?: string;
+    isActive?: boolean;
+};
+export declare class MulingstreamListenerManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHashData;
+    addListener(listenerData: Omit<MulingstreamListenerData, 'listenerId'>): Promise<string>;
+    getAllListeners(): Promise<MulingstreamListenerData[]>;
+    getListenersByRoom(roomId: string): Promise<MulingstreamListenerData[]>;
+    getListener(listenerIdOrToken: string): Promise<MulingstreamListenerData | null>;
+    removeListenerByToken(token: string): Promise<boolean>;
+    updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
+    updateSocketId(listenerIdOrToken: string, socketId: string): Promise<boolean>;
+    getTargetSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
+}

package/dist/managers/stt-manager.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamListenerManager = void 0;
+const uuid_1 = require("uuid");
+const EXPIRATION = 24 * 60 * 60; // 24 hours in seconds
+class MulingstreamListenerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        return {
+            listenerId: data.listenerId,
+            roomId: data.roomId,
+            socketId: data.socketId || '',
+            token: data.token,
+            name: data.name || '',
+            firstJoined: parseInt(data.firstJoined, 10),
+            language: data.language || '',
+            isActive: data.isActive === 'true'
+        };
+    }
+    // Creates a new listener.
+    // -Generates a unique listenerId and adds it to the room's set.
+    // -Stores the listener data in a Redis hash under `listener:{listenerId}`.
+    async addListener(listenerData) {
+        var _a, _b, _c;
+        // You can combine roomId + uuid, or just a uuid, up to you:
+        const listenerId = `[${listenerData.roomId}]-[${(0, uuid_1.v4)()}]`;
+        // Add listenerId to the set for that room
+        await this.redisClient.sadd(`room:${listenerData.roomId}:listeners`, listenerId);
+        // Store listener data in a hash
+        await this.redisClient.hset(`listener:${listenerId}`, {
+            listenerId,
+            roomId: listenerData.roomId,
+            socketId: (_a = listenerData.socketId) !== null && _a !== void 0 ? _a : '',
+            token: listenerData.token,
+            name: (_b = listenerData.name) !== null && _b !== void 0 ? _b : '',
+            firstJoined: listenerData.firstJoined.toString(),
+            language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
+            isActive: 'true'
+        });
+        // expire listener
+        await this.redisClient.expire(`listener:${listenerId}`, EXPIRATION);
+        return listenerId;
+    }
+    async getAllListeners() {
+        // get all keys that match 'listener:*'
+        // TODO: if we have many keys, consider using SCAN instead of KEYS to avoid performance issues.
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        // fetch each hash with HGETALL
+        const listeners = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListenersByRoom(roomId) {
+        // get the set of listener IDs
+        const listenerIds = await this.redisClient.smembers(`room:${roomId}:listeners`);
+        if (!listenerIds || listenerIds.length === 0) {
+            return [];
+        }
+        const listeners = [];
+        for (const id of listenerIds) {
+            // get hash data
+            const data = await this.redisClient.hgetall(`listener:${id}`);
+            // if the hash doesn't exist, it may have expired, so remove from the set
+            if (!data || Object.keys(data).length === 0) {
+                await this.redisClient.srem(`room:${roomId}:listeners`, id);
+                continue;
+            }
+            // otherwise, parse and keep it
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListener(listenerIdOrToken) {
+        // try direct lookup by listenerId:
+        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
+        if (directData && directData.listenerId) {
+            return this.parseHashData(directData);
+        }
+        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return null;
+        }
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.token === listenerIdOrToken) {
+                return this.parseHashData(data);
+            }
+        }
+        return null;
+    }
+    async removeListenerByToken(token) {
+        // find the listener by token
+        const listener = await this.getListener(token);
+        if (!listener) {
+            return false;
+        }
+        // remove the listener ID from the room's set
+        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
+        // remove the listener data (the hash)
+        await this.redisClient.del(`listener:${listener.listenerId}`);
+        return true;
+    }
+    async updateNameLanguage(listenerIdOrToken, name, language) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            name,
+            language
+        });
+        return true;
+    }
+    async updateSocketId(listenerIdOrToken, socketId) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            socketId
+        });
+        return true;
+    }
+    async getTargetSocketIdsByRoomLanguage(roomId, language) {
+        const listeners = await this.getListenersByRoom(roomId);
+        const filteredListeners = listeners.filter((listener) => {
+            return listener.isActive === true && listener.language === language && listener.socketId && listener.socketId.trim() !== '';
+        });
+        return filteredListeners.map((listener) => listener.socketId);
+    }
+}
+exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/package.json

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