@mulingai-npm/redis 3.2.1 → 3.3.0

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]: {
@@ -70,7 +69,6 @@ export declare class MulingstreamChunkManager {
         duration: number;
         isFirst: boolean;
         isLast: boolean;
-        theme: string;
         sttProviders: SttProvider[];
         targetLanguages: string[];
         shortCodeTargetLanguages: string[];
@@ -78,6 +76,7 @@ export declare class MulingstreamChunkManager {
     private getChunkId;
     getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
     private withChunk;
+    updateAudioFilePath(roomId: string, n: number, audioFilePath: string): Promise<boolean>;
     updateStt(roomId: string, n: number, service: SttService, opt: {
         transcription?: string;
         sttStatus?: StepStatus;

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;
     }
-    /* ---------------------------------------------------------------------- */
-    /*                           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,7 +91,7 @@ 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 = {};
@@ -148,7 +134,6 @@ class MulingstreamChunkManager {
             await trim.exec();
         }
     }
-    /* --------------------------- 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 +145,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)
@@ -178,12 +161,19 @@ class MulingstreamChunkManager {
             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;
     }
+    async updateAudioFilePath(roomId, n, audioFilePath) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            c.audioChunk.audioFilePath = audioFilePath;
+            return true;
+        })) === true);
+    }
     async updateStt(roomId, n, service, opt) {
         return ((await this.withChunk(roomId, n, (c) => {
             if (!c.stt[service])
@@ -304,7 +294,6 @@ class MulingstreamChunkManager {
         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.1",
+    "version": "3.3.0",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {