@mulingai-npm/redis 3.2.2 → 3.4.0

package/dist/loggers/mulingstream-chunk-logger.d.ts

@@ -7,6 +7,7 @@ export interface ChunkLogOptions {
     processLength?: boolean;
     finalTranscription?: boolean;
     sttStatus?: boolean;
+    audioFilePath?: boolean;
     stt?: boolean;
     translation?: boolean;
     tts?: boolean;

package/dist/loggers/mulingstream-chunk-logger.js

@@ -5,6 +5,7 @@ const mulingstream_chunk_manager_1 = require("../managers/mulingstream-chunk-man
 const defaults = {
     chunkId: false,
     chunkNumber: true,
+    audioFilePath: true,
     roomId: false,
     processLength: false,
     language: false,
@@ -61,6 +62,8 @@ class MulingstreamChunkLogger extends mulingstream_chunk_manager_1.MulingstreamC
             out.roomId = chunk.roomId;
         if (o.chunkNumber)
             out.chunkNumber = chunk.chunkNumber;
+        if (o.audioFilePath)
+            out.audioFilePath = chunk.audioChunk.audioFilePath;
         if (o.processLength)
             out.processLength = Date.now() - chunk.createdAt + 'ms';
         if (o.language)

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

@@ -22,8 +22,7 @@ export type MulingstreamChunkData = {
         duration: number;
         isFirst: boolean;
         isLast: boolean;
-        theme: string;
-        processingStart: number;
+        audioFilePath: string;
     };
     stt: {
         [service: string]: {
@@ -43,7 +42,6 @@ export type MulingstreamChunkData = {
             ttsAudioPath: string;
             status: StepStatus;
             isEmitted: boolean;
-            totalCheck: number;
         };
     };
 };
@@ -70,46 +68,44 @@ export declare class MulingstreamChunkManager {
         duration: number;
         isFirst: boolean;
         isLast: boolean;
-        theme: string;
         sttProviders: SttProvider[];
         targetLanguages: string[];
         shortCodeTargetLanguages: string[];
-    }): Promise<void>;
+    }): Promise<MulingstreamChunkData>;
     private getChunkId;
     getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
     private withChunk;
+    updateAudioFilePath(roomId: string, chunkNumber: number, audioFilePath: string): Promise<MulingstreamChunkData | null>;
     updateStt(roomId: string, n: number, service: SttService, opt: {
         transcription?: string;
         sttStatus?: StepStatus;
-    }): Promise<boolean>;
+    }): Promise<MulingstreamChunkData | null>;
     updateSttObject(roomId: string, n: number, newStt: Record<string, {
         transcription: string;
         model?: string;
         status: StepStatus;
-    }>): Promise<boolean>;
-    discardStt(roomId: string, n: number): Promise<boolean>;
+    }>): Promise<MulingstreamChunkData | null>;
+    discardStt(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
     updateFinalTranscription(roomId: string, n: number, opt: {
         transcription?: string;
         sttStatus?: StepStatus;
-    }): Promise<MulingstreamChunkData>;
-    discardPostStt(roomId: string, n: number): Promise<boolean>;
-    discardLanguage(roomId: string, n: number, lang: string): Promise<boolean>;
+    }): Promise<MulingstreamChunkData | null>;
+    discardPostStt(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
+    discardLanguage(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData | null>;
     discardLanguages(roomId: string, n: number, opt: {
         translation?: string[];
         tts?: string[];
-    }): Promise<MulingstreamChunkData>;
+    }): Promise<MulingstreamChunkData | null>;
     updateTranslation(roomId: string, n: number, lang: string, opt: {
         translation?: string;
         status?: StepStatus;
-    }): Promise<MulingstreamChunkData>;
-    updateTranslationInBulk(roomId: string, n: number, dict: Record<string, string>, status?: StepStatus): Promise<MulingstreamChunkData>;
+    }): Promise<MulingstreamChunkData | null>;
+    updateTranslationInBulk(roomId: string, n: number, dict: Record<string, string>, status?: StepStatus): Promise<MulingstreamChunkData | null>;
     updateTts(roomId: string, n: number, lang: string, opt: {
         ttsAudioPath?: string;
         status?: StepStatus;
         isEmitted?: boolean;
-        totalCheck?: number;
-    }): Promise<MulingstreamChunkData>;
-    increaseTotalCheck(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData>;
+    }): Promise<MulingstreamChunkData | null>;
     areTranslationsProcessed(roomId: string, n: number): Promise<boolean>;
     getAllReadyTts(roomId: string, lang: string): Promise<MulingstreamChunkData[]>;
 }

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

@@ -2,19 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MulingstreamChunkManager = void 0;
 const uuid_1 = require("uuid");
-/* -------------------------------------------------------------------------- */
-/*                                Constants                                   */
-/* -------------------------------------------------------------------------- */
-const EXPIRATION = 12 * 60 * 60; // 12 h
-const ROOM_ARRAY_LENGTH = 50; // keep last 50 chunks
-/* -------------------------------------------------------------------------- */
-/*                               Main class                                   */
-/* -------------------------------------------------------------------------- */
+const EXPIRATION = 12 * 60 * 60;
+const ROOM_ARRAY_LENGTH = 50;
 class MulingstreamChunkManager {
     constructor(redisClient) {
         this.redisClient = redisClient;
     }
-    /* ----------------------------- key helpers ----------------------------- */
     roomZsetKey(roomId) {
         return `room:${roomId}:chunks`;
     }
@@ -24,7 +17,6 @@ class MulingstreamChunkManager {
     generateChunkId(roomId, chunkNumber) {
         return `[${roomId}]-[${chunkNumber}]-[${(0, uuid_1.v4)()}]`;
     }
-    /* --------------------------- (de)serialization -------------------------- */
     serialize(value) {
         return JSON.stringify(value);
     }
@@ -49,14 +41,9 @@ class MulingstreamChunkManager {
             tts: this.deserialize(h.tts)
         };
     }
-    /* ------------------------------ timeouts ------------------------------- */
     getTimeout(start, end) {
-        return 30000;
+        return 25000;
     }
-    /* ---------------------------------------------------------------------- */
-    /*                           Public API (same)                            */
-    /* ---------------------------------------------------------------------- */
-    /* Room helpers ---------------------------------------------------------- */
     async initRoom(roomId) {
         const exists = await this.redisClient.exists(this.roomZsetKey(roomId));
         if (exists)
@@ -82,10 +69,9 @@ class MulingstreamChunkManager {
     getRoomById(roomId) {
         return this.getMulingstreamChunksByRoom(roomId);
     }
-    /* ------------------------- chunk insertion ---------------------------- */
     async addMulingstreamChunk(params) {
         var _a, _b;
-        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
+        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
         if (chunkNumber === 1) {
             const old = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
             if (old.length) {
@@ -105,15 +91,32 @@ class MulingstreamChunkManager {
             }
         }
         const chunkId = this.generateChunkId(roomId, chunkNumber);
-        const audioChunk = { start, end, duration, isFirst, isLast, theme, processingStart: Date.now() };
+        const audioChunk = { start, end, duration, isFirst, isLast, audioFilePath: '' };
         const stt = {};
         sttProviders.forEach((p) => (stt[p.service] = { transcription: '', model: p.model, status: 'INIT' }));
         const translation = {};
         const tts = {};
         shortCodeTargetLanguages.forEach((l) => {
             translation[l] = { translation: '', status: 'INIT' };
-            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
+            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false };
         });
+        const createdAt = Date.now();
+        const chunk = {
+            chunkId,
+            roomId,
+            chunkNumber,
+            language,
+            sttProviders,
+            targetLanguages,
+            shortCodeTargetLanguages,
+            finalTranscription: '',
+            sttStatus: 'INIT',
+            createdAt,
+            audioChunk,
+            stt,
+            translation,
+            tts
+        };
         const hash = {
             chunkId,
             roomId,
@@ -124,7 +127,7 @@ class MulingstreamChunkManager {
             shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
             finalTranscription: '',
             sttStatus: 'INIT',
-            createdAt: String(Date.now()),
+            createdAt: String(createdAt),
             audioChunk: this.serialize(audioChunk),
             stt: this.serialize(stt),
             translation: this.serialize(translation),
@@ -147,8 +150,8 @@ class MulingstreamChunkManager {
             oldIds.forEach((cid) => trim.unlink(this.chunkHashKey(cid)));
             await trim.exec();
         }
+        return chunk;
     }
-    /* --------------------------- helper lookup ---------------------------- */
     async getChunkId(roomId, n) {
         const ids = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), n, n);
         return ids.length ? ids[0] : null;
@@ -160,8 +163,6 @@ class MulingstreamChunkManager {
         const raw = await this.redisClient.hgetall(this.chunkHashKey(cid));
         return raw.chunkId ? this.hashToChunk(raw) : null;
     }
-    /* ------------------------------ Updaters ------------------------------ */
-    /* helper to fetch-mutate-save one chunk */
     async withChunk(roomId, n, fn) {
         const cid = await this.getChunkId(roomId, n);
         if (!cid)
@@ -171,46 +172,49 @@ class MulingstreamChunkManager {
         if (!raw.chunkId)
             return null;
         const chunk = this.hashToChunk(raw);
-        const out = await fn(chunk);
+        await fn(chunk);
         const p = this.redisClient.pipeline();
         p.hset(key, {
             finalTranscription: chunk.finalTranscription,
             sttStatus: chunk.sttStatus,
             stt: this.serialize(chunk.stt),
             translation: this.serialize(chunk.translation),
-            tts: this.serialize(chunk.tts)
+            tts: this.serialize(chunk.tts),
+            audioChunk: this.serialize(chunk.audioChunk)
         });
         p.expire(key, EXPIRATION);
         await p.exec();
-        return out;
+        return chunk;
+    }
+    async updateAudioFilePath(roomId, chunkNumber, audioFilePath) {
+        return this.withChunk(roomId, chunkNumber, (chunk) => {
+            chunk.audioChunk.audioFilePath = audioFilePath;
+        });
     }
     async updateStt(roomId, n, service, opt) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             if (!c.stt[service])
-                return false;
+                return;
             if (opt.transcription !== undefined)
                 c.stt[service].transcription = opt.transcription;
             if (opt.sttStatus !== undefined)
                 c.stt[service].status = opt.sttStatus;
-            return true;
-        })) === true);
+        });
     }
     async updateSttObject(roomId, n, newStt) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             c.stt = newStt;
-            return true;
-        })) === true);
+        });
     }
     async discardStt(roomId, n) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             Object.keys(c.stt).forEach((p) => {
                 c.stt[p].transcription = '';
                 c.stt[p].status = 'DISCARDED';
             });
             c.finalTranscription = '';
             c.sttStatus = 'DISCARDED';
-            return true;
-        })) === true);
+        });
     }
     async updateFinalTranscription(roomId, n, opt) {
         return this.withChunk(roomId, n, (c) => {
@@ -218,24 +222,21 @@ class MulingstreamChunkManager {
                 c.finalTranscription = opt.transcription;
             if (opt.sttStatus !== undefined)
                 c.sttStatus = opt.sttStatus;
-            return c;
         });
     }
     async discardPostStt(roomId, n) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             Object.values(c.translation).forEach((t) => (t.status = 'DISCARDED'));
             Object.values(c.tts).forEach((t) => (t.status = 'DISCARDED'));
-            return true;
-        })) === true);
+        });
     }
     async discardLanguage(roomId, n, lang) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             if (c.translation[lang])
                 c.translation[lang].status = 'DISCARDED';
             if (c.tts[lang])
                 c.tts[lang].status = 'DISCARDED';
-            return true;
-        })) === true);
+        });
     }
     async discardLanguages(roomId, n, opt) {
         return this.withChunk(roomId, n, (c) => {
@@ -250,19 +251,17 @@ class MulingstreamChunkManager {
                 if (e && e.status === 'INIT')
                     e.status = 'DISCARDED';
             });
-            return c;
         });
     }
     async updateTranslation(roomId, n, lang, opt) {
         return this.withChunk(roomId, n, (c) => {
             const e = c.translation[lang];
             if (!e)
-                return null;
+                return;
             if (opt.translation !== undefined)
                 e.translation = opt.translation;
             if (opt.status !== undefined)
                 e.status = opt.status;
-            return c;
         });
     }
     async updateTranslationInBulk(roomId, n, dict, status = 'READY') {
@@ -273,38 +272,25 @@ class MulingstreamChunkManager {
                 c.translation[l].translation = txt;
                 c.translation[l].status = status;
             });
-            return c;
         });
     }
     async updateTts(roomId, n, lang, opt) {
         return this.withChunk(roomId, n, (c) => {
             const e = c.tts[lang];
             if (!e)
-                return null;
+                return;
             if (opt.ttsAudioPath !== undefined)
                 e.ttsAudioPath = opt.ttsAudioPath;
             if (opt.status !== undefined)
                 e.status = opt.status;
             if (opt.isEmitted !== undefined)
                 e.isEmitted = opt.isEmitted;
-            if (opt.totalCheck !== undefined)
-                e.totalCheck = opt.totalCheck;
-            return c;
-        });
-    }
-    async increaseTotalCheck(roomId, n, lang) {
-        return this.withChunk(roomId, n, (c) => {
-            if (!c.tts[lang])
-                return null;
-            c.tts[lang].totalCheck += 1;
-            return c;
         });
     }
     async areTranslationsProcessed(roomId, n) {
         const c = await this.getMulingstreamChunkById(roomId, n);
         return !!c && Object.values(c.translation).every((t) => t.status !== 'INIT');
     }
-    /* -------------------------- READY-TTS sequence ------------------------- */
     async getAllReadyTts(roomId, lang) {
         var _a;
         const chunks = (_a = (await this.getMulingstreamChunksByRoom(roomId))) !== null && _a !== void 0 ? _a : [];

package/package.json

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