@mulingai-npm/redis 2.6.0 → 2.9.0

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

@@ -36,6 +36,7 @@ export type MulingstreamChunkData = {
             ttsAudioPath: string;
             status: StepStatus;
             isEmitted: boolean;
+            totalCheck: number;
         };
     };
 };
@@ -92,7 +93,10 @@ export declare class MulingstreamChunkManager {
         status: StepStatus;
     }>): Promise<boolean>;
     discardStt(roomId: string, chunkNumber: number): Promise<boolean>;
-    updateFinalTranscription(roomId: string, chunkNumber: number, transcription: string | null, sttStatus: StepStatus | null): Promise<MulingstreamChunkData | null>;
+    updateFinalTranscription(roomId: string, chunkNumber: number, options: {
+        transcription?: string;
+        sttStatus?: StepStatus;
+    }): Promise<MulingstreamChunkData | null>;
     /**
      * Discards all post-STT steps for a given chunk:
      * sets all translation[].status & tts[].status to "DISCARDED".
@@ -102,10 +106,21 @@ export declare class MulingstreamChunkManager {
      * Discards a specific language in both translation and tts for a chunk.
      */
     discardLanguage(roomId: string, chunkNumber: number, language: string): Promise<boolean>;
+    discardLanguages(roomId: string, chunkNumber: number, options: {
+        translation?: string[];
+        tts?: string[];
+    }): Promise<MulingstreamChunkData | null>;
     updateTranslation(roomId: string, chunkNumber: number, language: string, options: {
         translation?: string;
         status?: StepStatus;
-    }): Promise<boolean>;
+    }): Promise<MulingstreamChunkData | null>;
     updateTranslationInBulk(roomId: string, chunkNumber: number, translations: Record<string, string>, status?: StepStatus): Promise<MulingstreamChunkData | null>;
+    updateTts(roomId: string, chunkNumber: number, language: string, options: {
+        ttsAudioPath?: string;
+        status?: StepStatus;
+        isEmitted?: boolean;
+        totalCheck?: number;
+    }): Promise<MulingstreamChunkData | null>;
+    increaseTotalCheck(roomId: string, chunkNumber: number, language: string): Promise<MulingstreamChunkData | null>;
     areTranslationsProcessed(roomId: string, chunkNumber: number): Promise<boolean>;
 }

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

@@ -79,7 +79,8 @@ class MulingstreamChunkManager {
             tts[lang] = {
                 ttsAudioPath: '',
                 status: 'INIT',
-                isEmitted: false
+                isEmitted: false,
+                totalCheck: 0
             };
         }
         const newChunk = {
@@ -193,22 +194,23 @@ class MulingstreamChunkManager {
         await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
         return true;
     }
-    async updateFinalTranscription(roomId, chunkNumber, transcription, sttStatus) {
+    async updateFinalTranscription(roomId, chunkNumber, options) {
+        // 1) fetch room’s chunks
         const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
+        if (!chunks)
             return null;
-        }
+        // 2) locate the chunk
         const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1) {
+        if (idx === -1)
             return null;
+        // 3) apply updates only when the key is present
+        if (options.transcription !== undefined) {
+            chunks[idx].finalTranscription = options.transcription;
         }
-        // mutate only when a non-null value is supplied
-        if (transcription !== null) {
-            chunks[idx].finalTranscription = transcription;
-        }
-        if (sttStatus !== null) {
-            chunks[idx].sttStatus = sttStatus;
+        if (options.sttStatus !== undefined) {
+            chunks[idx].sttStatus = options.sttStatus;
         }
+        // 4) persist and return
         await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
         return chunks[idx];
     }
@@ -257,30 +259,61 @@ class MulingstreamChunkManager {
         await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
         return true;
     }
-    async updateTranslation(roomId, chunkNumber, language, options) {
-        // Fetch all chunks for this room
+    async discardLanguages(roomId, chunkNumber, options) {
+        // 1) fetch the room’s chunks
         const chunks = await this.getMulingstreamChunksByRoom(roomId);
         if (!chunks)
-            return false;
-        // Locate the target chunk
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        const chunk = chunks[chunkIndex];
-        // Make sure the requested language exists in this chunk
-        if (!chunk.translation[language]) {
-            return false;
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        const chunk = chunks[idx];
+        // 3) discard the requested translation languages
+        if (options.translation) {
+            for (const lang of options.translation) {
+                if (chunk.translation[lang]) {
+                    chunk.translation[lang].status = 'DISCARDED';
+                }
+            }
+        }
+        // 4) discard the requested TTS languages
+        if (options.tts) {
+            for (const lang of options.tts) {
+                if (chunk.tts[lang]) {
+                    chunk.tts[lang].status = 'DISCARDED';
+                }
+            }
         }
+        // 5) persist and return
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async updateTranslation(roomId, chunkNumber, language, options) {
+        // 1) fetch the room’s chunks
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        const chunk = chunks[idx];
+        // 3) ensure the requested language exists
+        if (!chunk.translation[language])
+            return null;
+        // 4) apply updates only for provided keys
         if (options.translation !== undefined) {
             chunk.translation[language].translation = options.translation;
         }
         if (options.status !== undefined) {
             chunk.translation[language].status = options.status;
         }
-        // Persist the whole array back to Redis
-        chunks[chunkIndex] = chunk;
+        // 5) persist and return
+        chunks[idx] = chunk;
         await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
+        return chunk;
     }
     async updateTranslationInBulk(roomId, chunkNumber, translations, status = 'READY') {
         // 1) fetch the room array
@@ -307,6 +340,55 @@ class MulingstreamChunkManager {
         await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
         return chunk;
     }
+    async updateTts(roomId, chunkNumber, language, options) {
+        // 1) fetch the room’s chunks
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks)
+            return null;
+        // 2) locate the chunk
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1)
+            return null;
+        const chunk = chunks[idx];
+        // 3) ensure the language exists in the TTS map
+        if (!chunk.tts[language])
+            return null;
+        // 4) apply only the provided keys
+        if (options.ttsAudioPath !== undefined) {
+            chunk.tts[language].ttsAudioPath = options.ttsAudioPath;
+        }
+        if (options.status !== undefined) {
+            chunk.tts[language].status = options.status;
+        }
+        if (options.isEmitted !== undefined) {
+            chunk.tts[language].isEmitted = options.isEmitted;
+        }
+        if (options.totalCheck !== undefined) {
+            chunk.tts[language].totalCheck = options.totalCheck;
+        }
+        // 5) persist and return the updated chunk
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
+    async increaseTotalCheck(roomId, chunkNumber, language) {
+        const chunks = await this.getMulingstreamChunksByRoom(roomId);
+        if (!chunks) {
+            return null;
+        }
+        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
+        if (idx === -1) {
+            return null;
+        }
+        const chunk = chunks[idx];
+        if (!chunk.tts[language]) {
+            return null;
+        }
+        chunk.tts[language].totalCheck += 1;
+        chunks[idx] = chunk;
+        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        return chunk;
+    }
     async areTranslationsProcessed(roomId, chunkNumber) {
         const chunk = await this.getMulingstreamChunkById(roomId, chunkNumber);
         if (!chunk) {

package/package.json

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