@mulingai-npm/redis 1.4.0 → 1.6.1

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

@@ -1,5 +1,5 @@
 import { RedisClient } from '../redis-client';
-type AudioSttStatus = 'RECEIVED' | 'DISCARDED' | 'READY' | 'USED';
+type AudioSttStatus = 'RECEIVED' | 'DISCARDED' | 'EMPTY' | 'READY' | 'USED';
 export type AudioSttData = {
     audioSttId: string;
     roomId: string;
@@ -11,6 +11,7 @@ export type AudioSttData = {
     isLast: boolean;
     language: string;
     theme: string;
+    services: string[];
     azureTranscription?: string;
     whisperTranscription?: string;
     googleTranscription?: string;
@@ -27,5 +28,6 @@ export declare class AudioSttManager {
     getAllAudioSttByRoom(roomId: string): Promise<AudioSttData[]>;
     getAudioStt(audioSttId: string): Promise<AudioSttData | null>;
     updateAudioSttStatus(audioSttId: string, status: AudioSttStatus): Promise<boolean>;
+    updateAudioSttAzureTranscription(audioSttId: string, azureTranscription: string, status: AudioSttStatus): Promise<boolean>;
 }
 export {};

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

@@ -19,6 +19,7 @@ class AudioSttManager {
             isLast: data.isLast === 'true',
             language: data.language,
             theme: data.theme,
+            services: data.services ? JSON.parse(data.services) : [],
             azureTranscription: data.azureTranscription || undefined,
             whisperTranscription: data.whisperTranscription || undefined,
             googleTranscription: data.googleTranscription || undefined,
@@ -33,6 +34,7 @@ class AudioSttManager {
     // - Optionally sets an expiration (4h).
     async addAudioStt(sttData) {
         const audioSttId = `[${sttData.roomId}]-[${(0, uuid_1.v4)()}]`;
+        const servicesJson = sttData.services ? JSON.stringify(sttData.services) : '[]';
         // Add audioSttId to the set for that room
         await this.redisClient.sadd(`room:${sttData.roomId}:audioStt`, audioSttId);
         // Store audio-stt data in a hash
@@ -47,6 +49,7 @@ class AudioSttManager {
             isLast: sttData.isLast.toString(),
             language: sttData.language,
             theme: sttData.theme,
+            services: servicesJson,
             processingStart: Date.now().toString(),
             totalStatusCheck: (0).toString(),
             status: 'RECEIVED'
@@ -110,5 +113,19 @@ class AudioSttManager {
         });
         return true;
     }
+    async updateAudioSttAzureTranscription(audioSttId, azureTranscription, status) {
+        // Attempt to fetch the data first
+        const data = await this.redisClient.hgetall(`audioStt:${audioSttId}`);
+        if (!data || !data.audioSttId) {
+            // AudioStt either doesn’t exist or has expired
+            return false;
+        }
+        // Update the azureTranscription and status fields
+        await this.redisClient.hset(`audioStt:${audioSttId}`, {
+            azureTranscription,
+            status
+        });
+        return true;
+    }
 }
 exports.AudioSttManager = AudioSttManager;

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

@@ -0,0 +1,60 @@
+import { RedisClient } from '../redis-client';
+export type SttStatus = 'INIT' | 'DISCARDED' | 'READY' | 'USED';
+export type TranslationStatus = 'INIT' | 'DISCARDED' | 'READY' | 'USED';
+export type TtsStatus = 'INIT' | 'DISCARDED' | 'READY' | 'USED';
+export type MulingstreamChunkStatus = 'INIT' | 'DISCARDED' | 'USED';
+export type MulingstreamChunkData = {
+    mulingstreamChunkId: string;
+    roomId: string;
+    chunkNumber: number;
+    language: string;
+    mulingstreamChunkStatus: MulingstreamChunkStatus;
+    audioChunk: {
+        start: number;
+        end: number;
+        duration: number;
+        isFirst: boolean;
+        isLast: boolean;
+        theme: string;
+        processingStart: number;
+    };
+    stt: {
+        services: string[];
+        azureTranscription?: string;
+        whisperTranscription?: string;
+        googleTranscription?: string;
+        finalTranscription: string;
+        status: SttStatus;
+    };
+    postStt: {
+        [language: string]: {
+            translation: string;
+            translationStatus: TranslationStatus;
+            ttsAudioPath: string;
+            ttsStatus: TtsStatus;
+            isEmitted: boolean;
+        };
+    };
+};
+export declare class MulingstreamChunkManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHashData;
+    addMulingstreamChunk(params: {
+        roomId: string;
+        chunkNumber: number;
+        language: string;
+        start: number;
+        end: number;
+        duration: number;
+        isFirst: boolean;
+        isLast: boolean;
+        theme: string;
+        services: string[];
+        postSttLanguages: string[];
+    }): Promise<string>;
+    getMulingstreamChunks(): Promise<MulingstreamChunkData[]>;
+    getMulingstreamChunk(mulingstreamChunkId: string): Promise<MulingstreamChunkData | null>;
+    getMulingstreamChunksByRoom(roomId: string): Promise<MulingstreamChunkData[]>;
+    getByChunkNumber(chunkNumber: number, roomId: string): Promise<MulingstreamChunkData | null>;
+}

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamChunkManager = void 0;
+const uuid_1 = require("uuid");
+const EXPIRATION = 4 * 60 * 60; // 4 hours in seconds
+class MulingstreamChunkManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        // Parse nested JSON fields
+        const audioChunk = JSON.parse(data.audioChunk);
+        const stt = JSON.parse(data.stt);
+        const postStt = JSON.parse(data.postStt);
+        return {
+            mulingstreamChunkId: data.mulingstreamChunkId,
+            roomId: data.roomId,
+            chunkNumber: parseInt(data.chunkNumber, 10),
+            language: data.language,
+            mulingstreamChunkStatus: data.mulingstreamChunkStatus,
+            audioChunk,
+            stt,
+            postStt
+        };
+    }
+    // Adds a new mulingstream chunk.
+    // - Creates a unique mulingstreamChunkId.
+    // - Stores the chunk data in a Redis hash under `mulingstreamChunk:{mulingstreamChunkId}`.
+    // - Applies an expiration (4h).
+    async addMulingstreamChunk(params) {
+        const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, services, postSttLanguages } = params;
+        const mulingstreamChunkId = `[${roomId}]-[${chunkNumber}]-[${(0, uuid_1.v4)()}]`;
+        // Prepare the nested objects
+        const audioChunk = {
+            start,
+            end,
+            duration,
+            isFirst,
+            isLast,
+            theme,
+            processingStart: Date.now()
+        };
+        const stt = {
+            services,
+            azureTranscription: '',
+            whisperTranscription: '',
+            googleTranscription: '',
+            finalTranscription: '',
+            status: 'INIT'
+        };
+        // Build postStt object keyed by each language
+        const postStt = {};
+        for (const lang of postSttLanguages) {
+            postStt[lang] = {
+                translation: '',
+                translationStatus: 'INIT',
+                ttsAudioPath: '',
+                ttsStatus: 'INIT',
+                isEmitted: false
+            };
+        }
+        // Store the data in a Redis hash
+        await this.redisClient.hset(`mulingstreamChunk:${mulingstreamChunkId}`, {
+            mulingstreamChunkId,
+            roomId,
+            chunkNumber: chunkNumber.toString(),
+            language,
+            mulingstreamChunkStatus: 'INIT',
+            audioChunk: JSON.stringify(audioChunk),
+            stt: JSON.stringify(stt),
+            postStt: JSON.stringify(postStt)
+        });
+        // set expiration
+        await this.redisClient.expire(`mulingstreamChunk:${mulingstreamChunkId}`, EXPIRATION);
+        return mulingstreamChunkId;
+    }
+    // Retrieves all mulingstream chunks by scanning keys `mulingstreamChunk:*`.
+    async getMulingstreamChunks() {
+        const keys = await this.redisClient.keys('mulingstreamChunk:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.mulingstreamChunkId) {
+                results.push(this.parseHashData(data));
+            }
+        }
+        return results;
+    }
+    // Retrieves a single mulingstream chunk by ID.
+    async getMulingstreamChunk(mulingstreamChunkId) {
+        const data = await this.redisClient.hgetall(`mulingstreamChunk:${mulingstreamChunkId}`);
+        if (!data || !data.mulingstreamChunkId) {
+            return null;
+        }
+        return this.parseHashData(data);
+    }
+    // Retrieves all mulingstream chunks for a specific room by pattern matching keys `mulingstreamChunk:[roomId]-*`.
+    async getMulingstreamChunksByRoom(roomId) {
+        const pattern = `mulingstreamChunk:[${roomId}]-*`;
+        const keys = await this.redisClient.keys(pattern);
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (!data || !data.mulingstreamChunkId) {
+                continue;
+            }
+            results.push(this.parseHashData(data));
+        }
+        return results;
+    }
+    // Retrieves a mulingstream chunk by (roomId, chunkNumber).
+    // Since mulingstreamChunkId = `[${roomId}]-[${chunkNumber}]-[uuid]`, we can pattern-match on keys.
+    async getByChunkNumber(chunkNumber, roomId) {
+        const pattern = `mulingstreamChunk:[${roomId}]-[${chunkNumber}]-*`;
+        const keys = await this.redisClient.keys(pattern);
+        if (!keys || keys.length === 0) {
+            return null;
+        }
+        // If multiple match, return the first
+        const data = await this.redisClient.hgetall(keys[0]);
+        if (!data || !data.mulingstreamChunkId) {
+            return null;
+        }
+        return this.parseHashData(data);
+    }
+}
+exports.MulingstreamChunkManager = MulingstreamChunkManager;

package/package.json

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