@mulingai-npm/redis 2.12.4 → 3.0.1

package/README.md

@@ -0,0 +1,7 @@
+# Redis CLI
+
+docker exec -it local-redis redis-cli
+
+## choose DB
+
+127.0.0.1:6379> SELECT 1

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

@@ -0,0 +1,17 @@
+import { MulingstreamChunkManager, MulingstreamChunkData } from '../managers/mulingstream-chunk-manager';
+export interface ChunkLogOptions {
+    chunkNumber?: boolean;
+    roomId?: boolean;
+    language?: boolean;
+    finalTranscription?: boolean;
+    sttStatus?: boolean;
+    translation?: boolean;
+    tts?: boolean;
+    retryMs?: number;
+    label?: string;
+}
+export declare class MulingstreamChunkLogger extends MulingstreamChunkManager {
+    logChunk(roomId: string, chunkNumber: number, opts?: ChunkLogOptions): Promise<void>;
+    logChunks(roomId: string, opts?: ChunkLogOptions): Promise<Record<string, unknown>[]>;
+    mapChunk(chunk: MulingstreamChunkData, cfg?: ChunkLogOptions): Record<string, unknown>;
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamChunkLogger = void 0;
+const mulingstream_chunk_manager_1 = require("../managers/mulingstream-chunk-manager");
+const defaults = {
+    chunkNumber: true,
+    roomId: true,
+    language: true,
+    finalTranscription: true,
+    sttStatus: true,
+    translation: false,
+    tts: false,
+    retryMs: 100,
+    label: ''
+};
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class MulingstreamChunkLogger extends mulingstream_chunk_manager_1.MulingstreamChunkManager {
+    /* ------------ one chunk ------------------------------------ */
+    /* ------------ one chunk ------------------------------------ */
+    async logChunk(roomId, chunkNumber, opts = {}) {
+        const cfg = { ...defaults, ...opts };
+        const prefix = cfg.label ? `[${cfg.label}] ` : '';
+        let chunk = await this.getMulingstreamChunkById(roomId, chunkNumber);
+        if (!chunk) {
+            await sleep(cfg.retryMs);
+            chunk = await this.getMulingstreamChunkById(roomId, chunkNumber);
+        }
+        if (!chunk) {
+            console.log(`${prefix}[logger] room ${roomId} chunk ${chunkNumber} not found`);
+            return;
+        }
+        if (cfg.label)
+            console.log(prefix.trim()); // single-line label
+        console.dir(this.mapChunk(chunk, cfg), { depth: null, colors: true });
+    }
+    /* ------------ all chunks in room ---------------------------- */
+    async logChunks(roomId, opts = {}) {
+        const cfg = { ...defaults, ...opts };
+        const prefix = cfg.label ? `[${cfg.label}] ` : '';
+        let chunks = await this.getRoomById(roomId);
+        if (!(chunks === null || chunks === void 0 ? void 0 : chunks.length)) {
+            await sleep(cfg.retryMs);
+            chunks = await this.getRoomById(roomId);
+        }
+        if (!(chunks === null || chunks === void 0 ? void 0 : chunks.length)) {
+            console.log(`${prefix}[logger] room ${roomId} is empty / not found`);
+            return [];
+        }
+        const view = chunks.map((c) => this.mapChunk(c, cfg));
+        if (cfg.label)
+            console.log(prefix.trim());
+        console.dir(view, { depth: null, colors: true });
+        return view;
+    }
+    /* ------------ filter helper -------------------------------- */
+    mapChunk(chunk, cfg = {}) {
+        const o = { ...defaults, ...cfg };
+        const out = {};
+        if (o.roomId)
+            out.roomId = chunk.roomId;
+        if (o.chunkNumber)
+            out.chunkNumber = chunk.chunkNumber;
+        if (o.language)
+            out.language = chunk.language;
+        if (o.finalTranscription)
+            out.finalTranscription = chunk.finalTranscription;
+        if (o.sttStatus)
+            out.sttStatus = chunk.sttStatus;
+        if (o.translation)
+            out.translation = chunk.translation;
+        if (o.tts)
+            out.tts = chunk.tts;
+        return out;
+    }
+}
+exports.MulingstreamChunkLogger = MulingstreamChunkLogger;

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

@@ -0,0 +1,83 @@
+import { RedisClient } from '../redis-client';
+import type { StepStatus, SttProvider, MulingstreamChunkManager } from '../managers/mulingstream-chunk-manager';
+type CommandArgs = {
+    addMulingstreamChunk: Parameters<MulingstreamChunkManager['addMulingstreamChunk']>[0];
+    updateStt: {
+        chunkNumber: number;
+        sttProvider: SttProvider;
+        options: {
+            transcription?: string;
+            sttStatus?: StepStatus;
+        };
+    };
+    updateSttObject: {
+        chunkNumber: number;
+        newStt: Record<string, {
+            transcription: string;
+            status: StepStatus;
+        }>;
+    };
+    discardStt: {
+        chunkNumber: number;
+    };
+    updateFinalTranscription: {
+        chunkNumber: number;
+        options: {
+            transcription?: string;
+            sttStatus?: StepStatus;
+        };
+    };
+    discardPostStt: {
+        chunkNumber: number;
+    };
+    discardLanguage: {
+        chunkNumber: number;
+        language: string;
+    };
+    discardLanguages: {
+        chunkNumber: number;
+        options: {
+            translation?: string[];
+            tts?: string[];
+        };
+    };
+    updateTranslation: {
+        chunkNumber: number;
+        language: string;
+        options: {
+            translation?: string;
+            status?: StepStatus;
+        };
+    };
+    updateTranslationInBulk: {
+        chunkNumber: number;
+        translations: Record<string, string>;
+        status?: StepStatus;
+    };
+    updateTts: {
+        chunkNumber: number;
+        language: string;
+        options: {
+            ttsAudioPath?: string;
+            status?: StepStatus;
+            isEmitted?: boolean;
+            totalCheck?: number;
+        };
+    };
+    increaseTotalCheck: {
+        chunkNumber: number;
+        language: string;
+    };
+    /** read + write: may set some tts[].status = 'DISCARDED' */
+    getAllReadyTts: {
+        language: string;
+    };
+};
+export type OpName = keyof CommandArgs;
+export interface ChunkCommand<O extends OpName = OpName> {
+    op: O;
+    args: CommandArgs[O];
+    ts?: number;
+}
+export declare function enqueueCommand<O extends OpName>(redis: RedisClient, roomId: string, command: ChunkCommand<O>): Promise<string>;
+export {};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueueCommand = void 0;
+/* ------------------------------------------------------------------ */
+/* 3. enqueueCommand helper                                            */
+/* ------------------------------------------------------------------ */
+async function enqueueCommand(redis, roomId, command) {
+    var _a;
+    const streamKey = `room:${roomId}:chunkCmds`;
+    return redis.xadd(streamKey, '*', 'cmd', JSON.stringify({ ...command, ts: (_a = command.ts) !== null && _a !== void 0 ? _a : Date.now() }));
+}
+exports.enqueueCommand = enqueueCommand;

package/package.json

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