@mulingai-npm/redis 3.0.0 → 3.0.2

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,20 @@
+import { MulingstreamChunkManager, MulingstreamChunkData } from '../managers/mulingstream-chunk-manager';
+export interface ChunkLogOptions {
+    chunkId?: boolean;
+    chunkNumber?: boolean;
+    roomId?: boolean;
+    language?: boolean;
+    processLength?: boolean;
+    finalTranscription?: boolean;
+    sttStatus?: boolean;
+    stt?: 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,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamChunkLogger = void 0;
+const mulingstream_chunk_manager_1 = require("../managers/mulingstream-chunk-manager");
+const defaults = {
+    chunkId: false,
+    chunkNumber: true,
+    roomId: false,
+    processLength: false,
+    language: false,
+    finalTranscription: true,
+    sttStatus: true,
+    stt: false,
+    translation: false,
+    tts: true,
+    retryMs: undefined,
+    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.chunkId)
+            out.chunkId = chunk.chunkId;
+        if (o.roomId)
+            out.roomId = chunk.roomId;
+        if (o.chunkNumber)
+            out.chunkNumber = chunk.chunkNumber;
+        if (o.processLength)
+            out.processLength = Date.now() - chunk.createdAt + 'ms';
+        if (o.language)
+            out.language = chunk.language;
+        if (o.finalTranscription)
+            out.finalTranscription = chunk.finalTranscription;
+        if (o.sttStatus)
+            out.sttStatus = chunk.sttStatus;
+        if (o.stt)
+            out.stt = chunk.stt;
+        if (o.translation)
+            out.translation = chunk.translation;
+        if (o.tts)
+            out.tts = chunk.tts;
+        return out;
+    }
+}
+exports.MulingstreamChunkLogger = MulingstreamChunkLogger;

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

@@ -2,6 +2,7 @@ import { RedisClient } from '../redis-client';
 export type StepStatus = 'INIT' | 'DISCARDED' | 'READY' | 'USED';
 export type SttProvider = 'azure' | 'whisper' | 'google' | 'aws';
 export type MulingstreamChunkData = {
+    chunkId: string;
     roomId: string;
     chunkNumber: number;
     language: string;
@@ -44,25 +45,17 @@ export type MulingstreamChunkData = {
 export declare class MulingstreamChunkManager {
     private redisClient;
     constructor(redisClient: RedisClient);
+    private roomZsetKey;
+    private chunkHashKey;
+    private generateChunkId;
+    private serialize;
+    private deserialize;
+    private hashToChunk;
     private getTimeout;
-    /**
-     * Initializes a room in Redis as an empty JSON array.
-     * If the key [roomId] already exists, we do NOT overwrite it.
-     * Returns true if room was created, false if room already existed.
-     */
     initRoom(roomId: string): Promise<boolean>;
-    /**
-     * Returns all rooms. This is naive if you store many other keys in Redis,
-     * because we search keys for pattern "[*]".
-     * Adjust as needed if you have a separate naming prefix.
-     */
     getRooms(): Promise<string[]>;
-    /**
-     * Returns the entire array of chunks for the given roomId,
-     * or null if the room doesn't exist in Redis.
-     */
     getMulingstreamChunksByRoom(roomId: string): Promise<MulingstreamChunkData[] | null>;
-    getRoomById(roomId: string): Promise<MulingstreamChunkData[] | null>;
+    getRoomById(roomId: string): Promise<MulingstreamChunkData[]>;
     addMulingstreamChunk(params: {
         roomId: string;
         chunkNumber: number;
@@ -77,53 +70,40 @@ export declare class MulingstreamChunkManager {
         targetLanguages: string[];
         shortCodeTargetLanguages: string[];
     }): Promise<void>;
-    /**
-     * Given roomId and chunkNumber, return the single chunk from the array
-     * or null if not found.
-     */
-    getMulingstreamChunkById(roomId: string, chunkNumber: number): Promise<MulingstreamChunkData | null>;
-    /**
-     * Update STT fields for a given chunk.
-     * If transcription or sttStatus is null, skip that field.
-     */
-    updateStt(roomId: string, chunkNumber: number, sttProvider: SttProvider, options: {
+    private getChunkId;
+    getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
+    private withChunk;
+    updateStt(roomId: string, n: number, provider: SttProvider, opt: {
         transcription?: string;
         sttStatus?: StepStatus;
     }): Promise<boolean>;
-    updateSttObject(roomId: string, chunkNumber: number, newStt: Record<string, {
+    updateSttObject(roomId: string, n: number, newStt: Record<string, {
         transcription: string;
         status: StepStatus;
     }>): Promise<boolean>;
-    discardStt(roomId: string, chunkNumber: number): Promise<boolean>;
-    updateFinalTranscription(roomId: string, chunkNumber: number, options: {
+    discardStt(roomId: string, n: number): Promise<boolean>;
+    updateFinalTranscription(roomId: string, n: number, opt: {
         transcription?: string;
         sttStatus?: StepStatus;
-    }): Promise<MulingstreamChunkData | null>;
-    /**
-     * Discards all post-STT steps for a given chunk:
-     * sets all translation[].status & tts[].status to "DISCARDED".
-     */
-    discardPostStt(roomId: string, chunkNumber: number): Promise<boolean>;
-    /**
-     * 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: {
+    }): Promise<MulingstreamChunkData>;
+    discardPostStt(roomId: string, n: number): Promise<boolean>;
+    discardLanguage(roomId: string, n: number, lang: string): Promise<boolean>;
+    discardLanguages(roomId: string, n: number, opt: {
         translation?: string[];
         tts?: string[];
-    }): Promise<MulingstreamChunkData | null>;
-    updateTranslation(roomId: string, chunkNumber: number, language: string, options: {
+    }): Promise<MulingstreamChunkData>;
+    updateTranslation(roomId: string, n: number, lang: string, opt: {
         translation?: string;
         status?: StepStatus;
-    }): 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: {
+    }): Promise<MulingstreamChunkData>;
+    updateTranslationInBulk(roomId: string, n: number, dict: Record<string, string>, status?: StepStatus): Promise<MulingstreamChunkData>;
+    updateTts(roomId: string, n: number, lang: string, opt: {
         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>;
-    getAllReadyTts(roomId: string, language: string): Promise<MulingstreamChunkData[]>;
+    }): Promise<MulingstreamChunkData>;
+    increaseTotalCheck(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData>;
+    areTranslationsProcessed(roomId: string, n: number): Promise<boolean>;
+    getAllReadyTts(roomId: string, lang: string): Promise<MulingstreamChunkData[]>;
 }

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

@@ -1,452 +1,346 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MulingstreamChunkManager = void 0;
-const EXPIRATION = 12 * 60 * 60; // 12 hours in seconds
-const ROOM_ARRAY_LENGTH = 50; // keep only the last 5 elements
+const uuid_1 = require("uuid");
+/* -------------------------------------------------------------------------- */
+/*                                Constants                                   */
+/* -------------------------------------------------------------------------- */
+const EXPIRATION = 12 * 60 * 60; // 12 h
+const ROOM_ARRAY_LENGTH = 50; // keep last 50 chunks
+/* -------------------------------------------------------------------------- */
+/*                               Main class                                   */
+/* -------------------------------------------------------------------------- */
 class MulingstreamChunkManager {
     constructor(redisClient) {
         this.redisClient = redisClient;
     }
-    getTimeout(audioStart, audioEnd) {
-        const audioChunkLength = audioEnd - audioStart;
-        if (audioChunkLength < 1000) {
-            return 1500;
-        }
-        else if (audioChunkLength >= 1000 && audioChunkLength < 3000) {
-            return 3000;
-        }
-        else if (audioChunkLength >= 3000 && audioChunkLength < 5000) {
-            return 7000;
-        }
-        else if (audioChunkLength >= 5000 && audioChunkLength < 8000) {
-            return 10000;
-        }
-        else if (audioChunkLength >= 8000 && audioChunkLength < 12000) {
-            return 15000;
-        }
-        else if (audioChunkLength >= 12000 && audioChunkLength < 20000) {
-            return 20000;
-        }
-        else {
-            return 30000;
-        }
+    /* ----------------------------- key helpers ----------------------------- */
+    roomZsetKey(roomId) {
+        return `room:${roomId}:chunks`;
+    }
+    chunkHashKey(chunkId) {
+        return `chunk:${chunkId}`;
+    }
+    generateChunkId(roomId, chunkNumber) {
+        return `[${roomId}]-[${chunkNumber}]-[${(0, uuid_1.v4)()}]`;
+    }
+    /* --------------------------- (de)serialization -------------------------- */
+    serialize(value) {
+        return JSON.stringify(value);
+    }
+    deserialize(v) {
+        return v ? JSON.parse(v) : undefined;
+    }
+    hashToChunk(h) {
+        return {
+            chunkId: h.chunkId,
+            roomId: h.roomId,
+            chunkNumber: parseInt(h.chunkNumber, 10),
+            language: h.language,
+            sttProviders: this.deserialize(h.sttProviders),
+            targetLanguages: this.deserialize(h.targetLanguages),
+            shortCodeTargetLanguages: this.deserialize(h.shortCodeTargetLanguages),
+            finalTranscription: h.finalTranscription,
+            sttStatus: h.sttStatus,
+            createdAt: parseInt(h.createdAt, 10),
+            audioChunk: this.deserialize(h.audioChunk),
+            stt: this.deserialize(h.stt),
+            translation: this.deserialize(h.translation),
+            tts: this.deserialize(h.tts)
+        };
+    }
+    /* ------------------------------ timeouts ------------------------------- */
+    getTimeout(start, end) {
+        // const len = end - start;
+        // if (len < 1_000) return 1_500;
+        // if (len < 3_000) return 3_000;
+        // if (len < 5_000) return 7_000;
+        // if (len < 8_000) return 10_000;
+        // if (len < 12_000) return 15_000;
+        // if (len < 20_000) return 20_000;
+        return 25000;
     }
-    /**
-     * Initializes a room in Redis as an empty JSON array.
-     * If the key [roomId] already exists, we do NOT overwrite it.
-     * Returns true if room was created, false if room already existed.
-     */
+    /* ---------------------------------------------------------------------- */
+    /*                           Public API (same)                            */
+    /* ---------------------------------------------------------------------- */
+    /* Room helpers ---------------------------------------------------------- */
     async initRoom(roomId) {
-        // Check if the key already exists (JSON.GET)
-        const isRoomExisting = await this.redisClient.jsonGet(`[${roomId}]`, '.');
-        if (isRoomExisting !== null) {
+        const exists = await this.redisClient.exists(this.roomZsetKey(roomId));
+        if (exists)
             return false;
-        }
-        // Create an empty array at the root
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', []);
-        await this.redisClient.expire(`[${roomId}]`, EXPIRATION);
+        await this.redisClient.expire(this.roomZsetKey(roomId), EXPIRATION);
         return true;
     }
-    /**
-     * Returns all rooms. This is naive if you store many other keys in Redis,
-     * because we search keys for pattern "[*]".
-     * Adjust as needed if you have a separate naming prefix.
-     */
     async getRooms() {
-        // e.g., if we store everything as [foo], [bar], etc., we do:
-        const rooms = await this.redisClient.keys('\\[*\\]');
-        // This returns the raw keys, e.g. ['[myRoom]', '[anotherRoom]']
-        // We might want to strip off the brackets:
-        return rooms.map((k) => k.replace(/^\[|\]$/g, ''));
+        const keys = await this.redisClient.keys('room:*:chunks');
+        return keys.map((k) => k.replace(/^room:(.*):chunks$/, '$1'));
     }
-    /**
-     * Returns the entire array of chunks for the given roomId,
-     * or null if the room doesn't exist in Redis.
-     */
     async getMulingstreamChunksByRoom(roomId) {
-        // JSON.GET [roomId] .
-        const chunks = await this.redisClient.jsonGet(`[${roomId}]`, '.');
-        if (chunks === null) {
+        const ids = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
+        if (!ids.length)
             return null;
-        }
-        return chunks;
+        const pipe = this.redisClient.pipeline();
+        ids.forEach((cid) => pipe.hgetall(this.chunkHashKey(cid)));
+        const res = await pipe.exec();
+        return res.map(([, d]) => this.hashToChunk(d));
     }
-    async getRoomById(roomId) {
+    getRoomById(roomId) {
         return this.getMulingstreamChunksByRoom(roomId);
     }
+    /* ------------------------- chunk insertion ---------------------------- */
     async addMulingstreamChunk(params) {
-        var _a;
         const { roomId, chunkNumber, language, start, end, duration, isFirst, isLast, theme, sttProviders, targetLanguages, shortCodeTargetLanguages } = params;
-        /* ---------- build chunk skeleton ---------- */
-        const audioChunk = {
-            start,
-            end,
-            duration,
-            isFirst,
-            isLast,
-            theme,
-            processingStart: Date.now()
-        };
-        const stt = {};
-        for (const p of sttProviders) {
-            stt[p] = { transcription: '', status: 'INIT' };
+        /* ---------- reset room on first chunk ---------- */
+        if (chunkNumber === 1) {
+            const old = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
+            if (old.length) {
+                const p = this.redisClient.pipeline();
+                old.forEach((cid) => p.unlink(this.chunkHashKey(cid)));
+                p.del(this.roomZsetKey(roomId));
+                await p.exec();
+            }
+        }
+        else {
+            // remove older duplicate with same chunkNumber
+            const dup = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), chunkNumber, chunkNumber);
+            if (dup.length) {
+                const p = this.redisClient.pipeline();
+                dup.forEach((cid) => p.unlink(this.chunkHashKey(cid)));
+                p.zrem(this.roomZsetKey(roomId), ...dup);
+                await p.exec();
+            }
         }
+        /* ---------- build new chunk ---------- */
+        const chunkId = this.generateChunkId(roomId, chunkNumber);
+        const audioChunk = { start, end, duration, isFirst, isLast, theme, processingStart: Date.now() };
+        const stt = {};
+        sttProviders.forEach((p) => (stt[p] = { transcription: '', status: 'INIT' }));
         const translation = {};
         const tts = {};
-        for (const lang of shortCodeTargetLanguages) {
-            translation[lang] = { translation: '', status: 'INIT' };
-            tts[lang] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
-        }
-        const newChunk = {
+        shortCodeTargetLanguages.forEach((l) => {
+            translation[l] = { translation: '', status: 'INIT' };
+            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
+        });
+        const hash = {
+            chunkId,
             roomId,
-            chunkNumber,
+            chunkNumber: String(chunkNumber),
             language,
-            sttProviders,
-            targetLanguages,
-            shortCodeTargetLanguages,
+            sttProviders: this.serialize(sttProviders),
+            targetLanguages: this.serialize(targetLanguages),
+            shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
             finalTranscription: '',
             sttStatus: 'INIT',
-            createdAt: Date.now(),
-            audioChunk,
-            stt,
-            translation,
-            tts
+            createdAt: String(Date.now()),
+            audioChunk: this.serialize(audioChunk),
+            stt: this.serialize(stt),
+            translation: this.serialize(translation),
+            tts: this.serialize(tts)
         };
-        /* ---------- pull existing room array ---------- */
-        let chunks = (_a = (await this.redisClient.jsonGet(`[${roomId}]`, '.'))) !== null && _a !== void 0 ? _a : [];
-        /* ---------- reset the room if this is the first chunk ---------- */
-        if (chunkNumber === 1) {
-            chunks = []; // start fresh
+        /* ---------- write + trim (pipeline) ---------- */
+        const pipe = this.redisClient.pipeline();
+        pipe.hset(this.chunkHashKey(chunkId), hash);
+        pipe.expire(this.chunkHashKey(chunkId), EXPIRATION);
+        pipe.zadd(this.roomZsetKey(roomId), chunkNumber, chunkId);
+        pipe.expire(this.roomZsetKey(roomId), EXPIRATION);
+        pipe.zrange(this.roomZsetKey(roomId), 0, -ROOM_ARRAY_LENGTH - 1, 'WITHSCORES');
+        const execResults = await pipe.exec();
+        const oldPairs = execResults[4][1]; // [id1, score1, id2, score2, ...]
+        if (Array.isArray(oldPairs) && oldPairs.length) {
+            const oldIds = [];
+            for (let i = 0; i < oldPairs.length; i += 2)
+                oldIds.push(oldPairs[i]);
+            const trim = this.redisClient.pipeline();
+            trim.zrem(this.roomZsetKey(roomId), ...oldIds);
+            oldIds.forEach((cid) => trim.unlink(this.chunkHashKey(cid)));
+            await trim.exec();
         }
-        /* ---------- insert / replace ---------- */
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx !== -1) {
-            chunks[idx] = newChunk;
-        }
-        else {
-            chunks.push(newChunk);
-            if (chunks.length > ROOM_ARRAY_LENGTH)
-                chunks.shift();
-        }
-        /* ---------- persist ---------- */
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        await this.redisClient.expire(`[${roomId}]`, EXPIRATION);
     }
-    /**
-     * Given roomId and chunkNumber, return the single chunk from the array
-     * or null if not found.
-     */
-    async getMulingstreamChunkById(roomId, chunkNumber) {
-        // Retrieve the entire array
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
+    /* --------------------------- helper lookup ---------------------------- */
+    async getChunkId(roomId, n) {
+        const ids = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), n, n);
+        return ids.length ? ids[0] : null;
+    }
+    async getMulingstreamChunkById(roomId, n) {
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
             return null;
-        // Find by chunkNumber
-        const chunk = chunks.find((c) => c.chunkNumber === chunkNumber);
-        return chunk || null;
+        const raw = await this.redisClient.hgetall(this.chunkHashKey(cid));
+        return raw.chunkId ? this.hashToChunk(raw) : null;
     }
-    /**
-     * Update STT fields for a given chunk.
-     * If transcription or sttStatus is null, skip that field.
-     */
-    async updateStt(roomId, chunkNumber, sttProvider, options) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return false;
-        // Find the chunk
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        const chunk = chunks[chunkIndex];
-        // If this stt provider doesn't exist, ignore
-        if (!chunk.stt[sttProvider])
-            return false;
-        // Update
-        if (options.transcription != null) {
-            chunk.stt[sttProvider].transcription = options.transcription;
-        }
-        if (options.sttStatus != null) {
-            chunk.stt[sttProvider].status = options.sttStatus;
-        }
-        // Write back
-        chunks[chunkIndex] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
+    /* ------------------------------ Updaters ------------------------------ */
+    /* helper to fetch-mutate-save one chunk */
+    async withChunk(roomId, n, fn) {
+        const cid = await this.getChunkId(roomId, n);
+        if (!cid)
+            return null;
+        const key = this.chunkHashKey(cid);
+        const raw = await this.redisClient.hgetall(key);
+        if (!raw.chunkId)
+            return null;
+        const chunk = this.hashToChunk(raw);
+        const out = 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)
+        });
+        p.expire(key, EXPIRATION);
+        await p.exec();
+        return out;
     }
-    async updateSttObject(roomId, chunkNumber, newStt) {
-        // Fetch all chunks in the room
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return false;
-        }
-        // Locate the target chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1) {
-            return false;
-        }
-        // Replace the stt object
-        chunks[idx].stt = newStt;
-        // Persist back to Redis
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
+    /* ---- specific update methods (same signatures as before) ---- */
+    async updateStt(roomId, n, provider, opt) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            if (!c.stt[provider])
+                return false;
+            if (opt.transcription !== undefined)
+                c.stt[provider].transcription = opt.transcription;
+            if (opt.sttStatus !== undefined)
+                c.stt[provider].status = opt.sttStatus;
+            return true;
+        })) === true);
     }
-    async discardStt(roomId, chunkNumber) {
-        // Fetch all chunks in this room
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return false;
-        }
-        // Locate the desired chunk
-        const idx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (idx === -1) {
-            return false;
-        }
-        const chunk = chunks[idx];
-        // Reset every STT provider entry
-        for (const provider of Object.keys(chunk.stt)) {
-            chunk.stt[provider].transcription = '';
-            chunk.stt[provider].status = 'DISCARDED';
-        }
-        // Reset aggregate STT fields
-        chunk.finalTranscription = '';
-        chunk.sttStatus = 'DISCARDED';
-        // Persist back to Redis
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
+    async updateSttObject(roomId, n, newStt) {
+        return ((await this.withChunk(roomId, n, (c) => {
+            c.stt = newStt;
+            return true;
+        })) === true);
     }
-    async updateFinalTranscription(roomId, chunkNumber, options) {
-        // 1) fetch 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;
-        // 3) apply updates only when the key is present
-        if (options.transcription !== undefined) {
-            chunks[idx].finalTranscription = options.transcription;
-        }
-        if (options.sttStatus !== undefined) {
-            chunks[idx].sttStatus = options.sttStatus;
-        }
-        // 4) persist and return
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunks[idx];
+    async discardStt(roomId, n) {
+        return ((await 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);
     }
-    /**
-     * Discards all post-STT steps for a given chunk:
-     * sets all translation[].status & tts[].status to "DISCARDED".
-     */
-    async discardPostStt(roomId, chunkNumber) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return false;
-        // Find chunk
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        // Discard translation & TTS statuses
-        const chunk = chunks[chunkIndex];
-        for (const lang of Object.keys(chunk.translation)) {
-            chunk.translation[lang].status = 'DISCARDED';
-        }
-        for (const lang of Object.keys(chunk.tts)) {
-            chunk.tts[lang].status = 'DISCARDED';
-        }
-        chunks[chunkIndex] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
+    async updateFinalTranscription(roomId, n, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            if (opt.transcription !== undefined)
+                c.finalTranscription = opt.transcription;
+            if (opt.sttStatus !== undefined)
+                c.sttStatus = opt.sttStatus;
+            return c;
+        });
     }
-    /**
-     * Discards a specific language in both translation and tts for a chunk.
-     */
-    async discardLanguage(roomId, chunkNumber, language) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks)
-            return false;
-        const chunkIndex = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIndex === -1)
-            return false;
-        const chunk = chunks[chunkIndex];
-        if (chunk.translation[language]) {
-            chunk.translation[language].status = 'DISCARDED';
-        }
-        if (chunk.tts[language]) {
-            chunk.tts[language].status = 'DISCARDED';
-        }
-        chunks[chunkIndex] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return true;
+    async discardPostStt(roomId, n) {
+        return ((await 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 discardLanguages(roomId, chunkNumber, options) {
-        // 1) fetch 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) discard translation languages still in INIT
-        if (options.translation) {
-            for (const lang of options.translation) {
-                const entry = chunk.translation[lang];
-                if (entry && entry.status === 'INIT') {
-                    entry.status = 'DISCARDED';
-                }
-            }
-        }
-        // 4) discard TTS languages still in INIT
-        if (options.tts) {
-            for (const lang of options.tts) {
-                const entry = chunk.tts[lang];
-                if (entry && entry.status === 'INIT') {
-                    entry.status = 'DISCARDED';
-                }
-            }
-        }
-        // 5) persist and return
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
+    async discardLanguage(roomId, n, lang) {
+        return ((await 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 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;
-        }
-        // 5) persist and return
-        chunks[idx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
+    async discardLanguages(roomId, n, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            var _a, _b;
+            (_a = opt.translation) === null || _a === void 0 ? void 0 : _a.forEach((l) => {
+                const e = c.translation[l];
+                if (e && e.status === 'INIT')
+                    e.status = 'DISCARDED';
+            });
+            (_b = opt.tts) === null || _b === void 0 ? void 0 : _b.forEach((l) => {
+                const e = c.tts[l];
+                if (e && e.status === 'INIT')
+                    e.status = 'DISCARDED';
+            });
+            return c;
+        });
     }
-    async updateTranslationInBulk(roomId, chunkNumber, translations, status = 'READY') {
-        // 1) fetch the room array
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!chunks) {
-            return null;
-        }
-        // 2) locate the target chunk
-        const chunkIdx = chunks.findIndex((c) => c.chunkNumber === chunkNumber);
-        if (chunkIdx === -1) {
-            return null;
-        }
-        const chunk = chunks[chunkIdx];
-        // 3) apply updates only for the languages provided
-        for (const [lang, translationText] of Object.entries(translations)) {
-            if (!chunk.translation[lang]) {
-                continue;
-            }
-            chunk.translation[lang].translation = translationText;
-            chunk.translation[lang].status = status;
-        }
-        // 4) write the full room array back to Redis
-        chunks[chunkIdx] = chunk;
-        await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
-        return chunk;
+    async updateTranslation(roomId, n, lang, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            const e = c.translation[lang];
+            if (!e)
+                return null;
+            if (opt.translation !== undefined)
+                e.translation = opt.translation;
+            if (opt.status !== undefined)
+                e.status = opt.status;
+            return c;
+        });
     }
-    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 updateTranslationInBulk(roomId, n, dict, status = 'READY') {
+        return this.withChunk(roomId, n, (c) => {
+            Object.entries(dict).forEach(([l, txt]) => {
+                if (!c.translation[l])
+                    return;
+                c.translation[l].translation = txt;
+                c.translation[l].status = status;
+            });
+            return c;
+        });
     }
-    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 updateTts(roomId, n, lang, opt) {
+        return this.withChunk(roomId, n, (c) => {
+            const e = c.tts[lang];
+            if (!e)
+                return null;
+            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 areTranslationsProcessed(roomId, chunkNumber) {
-        const chunk = await this.getMulingstreamChunkById(roomId, chunkNumber);
-        if (!chunk) {
-            return false;
-        }
-        return Object.values(chunk.translation).every((t) => t.status !== 'INIT');
+    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 getAllReadyTts(roomId, language) {
-        const chunks = await this.getMulingstreamChunksByRoom(roomId);
-        if (!(chunks === null || chunks === void 0 ? void 0 : chunks.length))
+    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 : [];
+        if (!chunks.length)
             return [];
-        // chunks are received in consecutive order already, no need for sorting for now (maybe in the future we have more speaker in a room, so we may need sorting)
-        // chunks.sort((a, b) => a.chunkNumber - b.chunkNumber);
-        /* ---- isolate the tail where the language exists ---- */
-        let lastLangIdx = -1;
-        for (let i = chunks.length - 1; i >= 0; i--) {
-            if (chunks[i].tts[language]) {
-                lastLangIdx = i;
+        chunks.sort((a, b) => a.chunkNumber - b.chunkNumber);
+        /* isolate window where lang exists */
+        let lastIdx = -1;
+        for (let i = chunks.length - 1; i >= 0; i--)
+            if (chunks[i].tts[lang]) {
+                lastIdx = i;
                 break;
             }
-        }
-        if (lastLangIdx === -1)
+        if (lastIdx === -1)
             return [];
-        let firstLangIdx = lastLangIdx;
-        for (let i = lastLangIdx - 1; i >= 0; i--) {
-            if (!chunks[i].tts[language])
+        let firstIdx = lastIdx;
+        for (let i = lastIdx - 1; i >= 0; i--) {
+            if (!chunks[i].tts[lang])
                 break;
-            firstLangIdx = i;
+            firstIdx = i;
         }
-        const window = chunks.slice(firstLangIdx, lastLangIdx + 1);
-        /* ---- find last USED / DISCARDED in that window ---- */
+        const window = chunks.slice(firstIdx, lastIdx + 1);
+        /* find last USED/DISCARDED */
         let lastDone = -1;
         for (let i = window.length - 1; i >= 0; i--) {
-            const st = window[i].tts[language].status;
-            if (st === 'USED' || st === 'DISCARDED') {
+            const s = window[i].tts[lang].status;
+            if (s === 'USED' || s === 'DISCARDED') {
                 lastDone = i;
                 break;
             }
@@ -455,30 +349,28 @@ class MulingstreamChunkManager {
         let blocked = false;
         const now = Date.now();
         for (let i = lastDone + 1; i < window.length; i++) {
-            const entry = window[i].tts[language];
-            const audioChunk = window[i].audioChunk;
+            const entry = window[i].tts[lang];
+            const audio = window[i].audioChunk;
             if (entry.status === 'INIT') {
-                const timeout = this.getTimeout(audioChunk.start, audioChunk.end);
-                console.log('AUDIO LENGTH: ', audioChunk.end - audioChunk.start, ' TIMEOUT BASED ON AUDIO LENGTH: ', timeout, ' SINCE CREATED UNTIL NOW: ', now - window[i].createdAt);
-                if (now - window[i].createdAt > timeout) {
+                if (now - window[i].createdAt > this.getTimeout(audio.start, audio.end))
                     entry.status = 'DISCARDED';
-                }
-                else {
+                else
                     blocked = true;
-                }
                 continue;
             }
             if (entry.status === 'READY') {
                 if (blocked)
-                    break; // earlier INIT still pending
+                    break;
                 ready.push(window[i]);
                 continue;
             }
-            break; // unexpected USED / DISCARDED
+            break; // got USED/DISCARDED unexpectedly
         }
-        // persist any DISCARDED changes we made
-        if (ready.length === 0 || blocked) {
-            await this.redisClient.jsonSet(`[${roomId}]`, '.', chunks);
+        /* persist DISCARDED changes (if any) */
+        if (!ready.length || blocked) {
+            const p = this.redisClient.pipeline();
+            window.forEach((c) => p.hset(this.chunkHashKey(c.chunkId), { tts: this.serialize(c.tts) }));
+            await p.exec();
         }
         return ready;
     }

package/dist/redis-client.d.ts

@@ -1,29 +1,44 @@
+import IORedis from 'ioredis';
 export interface RedisConfig {
     host: string;
     port: number;
     password?: string;
     db: number;
 }
+/**
+ * Thin wrapper around ioredis that exposes exactly the helpers used by the two
+ * managers. All helpers are 1‑to‑1 pass‑through so there is no behavioural
+ * change – this merely centralises typing and keeps the rest of the codebase
+ * clean.
+ */
 export declare class RedisClient {
     private client;
     constructor(config: RedisConfig);
     set(key: string, value: string): Promise<void>;
     get(key: string): Promise<string | null>;
     del(key: string): Promise<number>;
+    exists(key: string): Promise<number>;
+    expire(key: string, seconds: number): Promise<number>;
     sadd(key: string, ...values: string[]): Promise<number>;
     srem(key: string, ...values: string[]): Promise<number>;
     smembers(key: string): Promise<string[]>;
-    keys(pattern: string): Promise<string[]>;
     hset(key: string, data: Record<string, string>): Promise<number>;
     hgetall(key: string): Promise<Record<string, string>>;
-    flushAll(): Promise<string>;
-    flushDb(): Promise<string>;
-    expire(key: string, seconds: number): Promise<number>;
+    zadd(key: string, score: number, member: string): Promise<number>;
+    zrange(key: string, start: number, stop: number): Promise<string[]>;
+    zremrangebyrank(key: string, start: number, stop: number): Promise<number>;
+    zrangebyscore(key: string, min: number | string, max: number | string): Promise<string[]>;
+    zrem(key: string, ...members: string[]): Promise<number>;
+    scan(cursor: number, pattern: string, count?: number): Promise<[string, string[]]>;
+    keys(pattern: string): Promise<string[]>;
+    pipeline(): ReturnType<IORedis['pipeline']>;
+    unlink(...keys: string[]): Promise<number>;
     jsonSet<T>(key: string, path: string, value: T): Promise<string>;
     jsonGet<T>(key: string, path: string): Promise<T | null>;
     jsonDel(key: string, path: string): Promise<number>;
     jsonArrAppend<T>(key: string, path: string, ...values: T[]): Promise<number>;
     jsonArrLen(key: string, path: string): Promise<number | null>;
     jsonArrPop(key: string, path: string, index?: number): Promise<any>;
-    xadd(key: string, id: string, ...fieldValues: (string | number)[]): Promise<string>;
+    flushAll(): Promise<string>;
+    flushDb(): Promise<string>;
 }

package/dist/redis-client.js

@@ -5,6 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
+/**
+ * Thin wrapper around ioredis that exposes exactly the helpers used by the two
+ * managers. All helpers are 1‑to‑1 pass‑through so there is no behavioural
+ * change – this merely centralises typing and keeps the rest of the codebase
+ * clean.
+ */
 class RedisClient {
     constructor(config) {
         this.client = new ioredis_1.default({
@@ -17,7 +23,9 @@ class RedisClient {
             console.error('Redis error:', err);
         });
     }
-    // existing set/get
+    /* ----------------------------------------------------------------------- */
+    /* Primitive string helpers                                                */
+    /* ----------------------------------------------------------------------- */
     async set(key, value) {
         await this.client.set(key, value);
     }
@@ -27,75 +35,109 @@ class RedisClient {
     async del(key) {
         return this.client.del(key);
     }
-    // Insert one or more values into a set
+    async exists(key) {
+        return this.client.exists(key);
+    }
+    async expire(key, seconds) {
+        return this.client.expire(key, seconds);
+    }
+    /* ----------------------------------------------------------------------- */
+    /* Set helpers                                                             */
+    /* ----------------------------------------------------------------------- */
     async sadd(key, ...values) {
         return this.client.sadd(key, values);
     }
     async srem(key, ...values) {
         return this.client.srem(key, values);
     }
-    // Get all set members
     async smembers(key) {
         return this.client.smembers(key);
     }
-    // Search for all keys matching a pattern
-    // NOTE: If you have lots of keys in Redis, you should look into using SCAN instead of KEYS
-    async keys(pattern) {
-        return this.client.keys(pattern);
-    }
-    // add these methods for hash, sets, keys, etc.
+    /* ----------------------------------------------------------------------- */
+    /* Hash helpers                                                            */
+    /* ----------------------------------------------------------------------- */
     async hset(key, data) {
         return this.client.hset(key, data);
     }
     async hgetall(key) {
         return this.client.hgetall(key);
     }
-    // flush methods
-    async flushAll() {
-        console.log('Flushing All Redis Data!');
-        return this.client.flushall();
+    /* ----------------------------------------------------------------------- */
+    /* Sorted‑set helpers                                                      */
+    /* ----------------------------------------------------------------------- */
+    async zadd(key, score, member) {
+        return this.client.zadd(key, score, member);
     }
-    async flushDb() {
-        console.log('Flushing Redis Data from DB!');
-        return this.client.flushdb();
+    async zrange(key, start, stop) {
+        return this.client.zrange(key, start, stop);
     }
-    async expire(key, seconds) {
-        return this.client.expire(key, seconds);
+    async zremrangebyrank(key, start, stop) {
+        return this.client.zremrangebyrank(key, start, stop);
     }
+    async zrangebyscore(key, min, max) {
+        return this.client.zrangebyscore(key, min, max);
+    }
+    async zrem(key, ...members) {
+        return this.client.zrem(key, members);
+    }
+    /* ----------------------------------------------------------------------- */
+    /* Scan (pattern search)                                                   */
+    /* ----------------------------------------------------------------------- */
+    async scan(cursor, pattern, count = 1000) {
+        return this.client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
+    }
+    async keys(pattern) {
+        return this.client.keys(pattern);
+    }
+    /* ----------------------------------------------------------------------- */
+    /* Pipeline                                                                */
+    /* ----------------------------------------------------------------------- */
+    pipeline() {
+        return this.client.pipeline();
+    }
+    /* ----------------------------------------------------------------------- */
+    /* Misc                                                                    */
+    /* ----------------------------------------------------------------------- */
+    async unlink(...keys) {
+        // unlink exists on Redis ≥4 and is supported by ioredis but not typed in
+        // older versions – we cast to any.
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore – runtime command exists even if typings lag behind.
+        return this.client.unlink(...keys);
+    }
+    /* JSON commands (RedisJSON module) -------------------------------------- */
     async jsonSet(key, path, value) {
         const result = await this.client.call('JSON.SET', key, path, JSON.stringify(value));
         return result;
     }
     async jsonGet(key, path) {
-        const result = (await this.client.call('JSON.GET', key, path));
-        if (!result) {
-            return null;
-        }
-        return JSON.parse(result);
+        const raw = (await this.client.call('JSON.GET', key, path));
+        return raw ? JSON.parse(raw) : null;
     }
     async jsonDel(key, path) {
-        const result = await this.client.call('JSON.DEL', key, path);
-        return Number(result);
+        return Number(await this.client.call('JSON.DEL', key, path));
     }
     async jsonArrAppend(key, path, ...values) {
-        const stringifiedValues = values.map((v) => JSON.stringify(v));
-        const result = await this.client.call('JSON.ARRAPPEND', key, path, ...stringifiedValues);
-        return Number(result);
+        const stringified = values.map((v) => JSON.stringify(v));
+        return Number(await this.client.call('JSON.ARRAPPEND', key, path, ...stringified));
     }
     async jsonArrLen(key, path) {
-        const result = await this.client.call('JSON.ARRLEN', key, path);
-        return result === null ? null : Number(result);
+        const len = await this.client.call('JSON.ARRLEN', key, path);
+        return len === null ? null : Number(len);
     }
     async jsonArrPop(key, path, index) {
-        if (index !== undefined) {
-            return this.client.call('JSON.ARRPOP', key, path, index);
-        }
-        return this.client.call('JSON.ARRPOP', key, path);
-    }
-    async xadd(key, id, ...fieldValues) {
-        // IORedis already supports XADD natively
-        //   key   id ('*' for autogenerated)  field1 value1 field2 value2 ...
-        return this.client.xadd(key, id, ...fieldValues);
+        return index !== undefined ? this.client.call('JSON.ARRPOP', key, path, index) : this.client.call('JSON.ARRPOP', key, path);
+    }
+    /* ----------------------------------------------------------------------- */
+    /* Dangerous! – flush helpers                                              */
+    /* ----------------------------------------------------------------------- */
+    async flushAll() {
+        console.warn('Flushing all Redis data!');
+        return this.client.flushall();
+    }
+    async flushDb() {
+        console.warn('Flushing current Redis DB!');
+        return this.client.flushdb();
     }
 }
 exports.RedisClient = RedisClient;

package/package.json

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