@mulingai-npm/redis 3.17.2 → 3.18.3

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

@@ -0,0 +1,90 @@
+import { RedisClient } from '../redis-client';
+/**
+ * Chunk waiting room entry
+ */
+export interface WaitingChunk {
+    chunkNumber: number;
+    arrivedAt: number;
+    language: string;
+}
+/**
+ * Sequencer configuration (passed from settings)
+ */
+export interface SequencerConfig {
+    timeoutMs: number;
+    maxWaitingRoom: number;
+    maxGapSize: number;
+}
+/**
+ * Chunk Sequencer Manager
+ * Maintains strict chunk ordering per room per language
+ * Holds out-of-order chunks in a waiting room with timeout
+ */
+export declare class ChunkSequencerManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    /**
+     * Redis key for expected chunk number
+     * Format: sequencer:{roomId}:{language}:expectedChunk
+     */
+    private expectedChunkKey;
+    /**
+     * Redis key for waiting room (ZSET)
+     * Format: sequencer:{roomId}:{language}:waiting
+     * Score: arrivalTimestamp
+     * Member: chunkNumber
+     */
+    private waitingRoomKey;
+    /**
+     * Get the next expected chunk number for a room/language
+     * Returns 1 if not initialized yet (first chunk)
+     */
+    getExpectedChunk(roomId: string, language: string): Promise<number>;
+    /**
+     * Set the expected chunk number
+     */
+    setExpectedChunk(roomId: string, language: string, chunkNumber: number): Promise<void>;
+    /**
+     * Increment the expected chunk number
+     */
+    incrementExpectedChunk(roomId: string, language: string): Promise<number>;
+    /**
+     * Add a chunk to the waiting room
+     * Uses ZSET with timestamp as score for timeout checking
+     */
+    addToWaitingRoom(roomId: string, chunkNumber: number, language: string): Promise<void>;
+    /**
+     * Get all chunks in waiting room sorted by arrival time (oldest first)
+     */
+    getWaitingChunks(roomId: string, language: string): Promise<WaitingChunk[]>;
+    /**
+     * Remove a chunk from the waiting room
+     */
+    removeFromWaitingRoom(roomId: string, chunkNumber: number, language: string): Promise<void>;
+    /**
+     * Clear the entire waiting room for a room/language
+     * Used when skipping ahead (Option C)
+     */
+    clearWaitingRoom(roomId: string, language: string): Promise<number>;
+    /**
+     * Get the size of the waiting room
+     */
+    getWaitingRoomSize(roomId: string, language: string): Promise<number>;
+    /**
+     * Check if a specific chunk is in the waiting room
+     */
+    isChunkInWaitingRoom(roomId: string, chunkNumber: number, language: string): Promise<boolean>;
+    /**
+     * Get chunks that have exceeded the timeout
+     */
+    getTimedOutChunks(roomId: string, language: string, timeoutMs: number): Promise<WaitingChunk[]>;
+    /**
+     * Clean up all sequencer state for a room/language
+     * Called when room ends
+     */
+    cleanupSequencerState(roomId: string, language: string): Promise<void>;
+    /**
+     * Clean up all sequencer state for an entire room (all languages)
+     */
+    cleanupRoomSequencerState(roomId: string): Promise<void>;
+}

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkSequencerManager = void 0;
+/**
+ * Chunk Sequencer Manager
+ * Maintains strict chunk ordering per room per language
+ * Holds out-of-order chunks in a waiting room with timeout
+ */
+class ChunkSequencerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    /**
+     * Redis key for expected chunk number
+     * Format: sequencer:{roomId}:{language}:expectedChunk
+     */
+    expectedChunkKey(roomId, language) {
+        return `sequencer:${roomId}:${language}:expectedChunk`;
+    }
+    /**
+     * Redis key for waiting room (ZSET)
+     * Format: sequencer:{roomId}:{language}:waiting
+     * Score: arrivalTimestamp
+     * Member: chunkNumber
+     */
+    waitingRoomKey(roomId, language) {
+        return `sequencer:${roomId}:${language}:waiting`;
+    }
+    /**
+     * Get the next expected chunk number for a room/language
+     * Returns 1 if not initialized yet (first chunk)
+     */
+    async getExpectedChunk(roomId, language) {
+        const key = this.expectedChunkKey(roomId, language);
+        const value = await this.redisClient.get(key);
+        if (!value) {
+            // Initialize to 1 for first chunk
+            await this.redisClient.set(key, '1');
+            await this.redisClient.expire(key, 3600); // 1 hour TTL
+            return 1;
+        }
+        return parseInt(value, 10);
+    }
+    /**
+     * Set the expected chunk number
+     */
+    async setExpectedChunk(roomId, language, chunkNumber) {
+        const key = this.expectedChunkKey(roomId, language);
+        await this.redisClient.set(key, chunkNumber.toString());
+        await this.redisClient.expire(key, 3600); // 1 hour TTL
+    }
+    /**
+     * Increment the expected chunk number
+     */
+    async incrementExpectedChunk(roomId, language) {
+        const key = this.expectedChunkKey(roomId, language);
+        const newValue = await this.redisClient.incr(key);
+        await this.redisClient.expire(key, 3600); // 1 hour TTL
+        return newValue;
+    }
+    /**
+     * Add a chunk to the waiting room
+     * Uses ZSET with timestamp as score for timeout checking
+     */
+    async addToWaitingRoom(roomId, chunkNumber, language) {
+        const key = this.waitingRoomKey(roomId, language);
+        const now = Date.now();
+        await this.redisClient.zadd(key, now, chunkNumber.toString());
+        await this.redisClient.expire(key, 3600); // 1 hour TTL
+    }
+    /**
+     * Get all chunks in waiting room sorted by arrival time (oldest first)
+     */
+    async getWaitingChunks(roomId, language) {
+        const key = this.waitingRoomKey(roomId, language);
+        // Get all members with scores (ZRANGE with WITHSCORES)
+        const results = await this.redisClient.zrangeWithScores(key, 0, -1);
+        if (!results || results.length === 0) {
+            return [];
+        }
+        const chunks = [];
+        for (const { value, score } of results) {
+            chunks.push({
+                chunkNumber: parseInt(value, 10),
+                arrivedAt: score,
+                language
+            });
+        }
+        return chunks;
+    }
+    /**
+     * Remove a chunk from the waiting room
+     */
+    async removeFromWaitingRoom(roomId, chunkNumber, language) {
+        const key = this.waitingRoomKey(roomId, language);
+        await this.redisClient.zrem(key, chunkNumber.toString());
+    }
+    /**
+     * Clear the entire waiting room for a room/language
+     * Used when skipping ahead (Option C)
+     */
+    async clearWaitingRoom(roomId, language) {
+        const key = this.waitingRoomKey(roomId, language);
+        const count = await this.redisClient.zcard(key);
+        await this.redisClient.del(key);
+        return count;
+    }
+    /**
+     * Get the size of the waiting room
+     */
+    async getWaitingRoomSize(roomId, language) {
+        const key = this.waitingRoomKey(roomId, language);
+        return await this.redisClient.zcard(key);
+    }
+    /**
+     * Check if a specific chunk is in the waiting room
+     */
+    async isChunkInWaitingRoom(roomId, chunkNumber, language) {
+        const key = this.waitingRoomKey(roomId, language);
+        const score = await this.redisClient.zscore(key, chunkNumber.toString());
+        return score !== null;
+    }
+    /**
+     * Get chunks that have exceeded the timeout
+     */
+    async getTimedOutChunks(roomId, language, timeoutMs) {
+        const allWaiting = await this.getWaitingChunks(roomId, language);
+        const now = Date.now();
+        return allWaiting.filter(chunk => {
+            const age = now - chunk.arrivedAt;
+            return age > timeoutMs;
+        });
+    }
+    /**
+     * Clean up all sequencer state for a room/language
+     * Called when room ends
+     */
+    async cleanupSequencerState(roomId, language) {
+        const expectedKey = this.expectedChunkKey(roomId, language);
+        const waitingKey = this.waitingRoomKey(roomId, language);
+        await this.redisClient.del(expectedKey);
+        await this.redisClient.del(waitingKey);
+    }
+    /**
+     * Clean up all sequencer state for an entire room (all languages)
+     */
+    async cleanupRoomSequencerState(roomId) {
+        // Find all sequencer keys for this room
+        const pattern = `sequencer:${roomId}:*`;
+        const keys = await this.redisClient.keys(pattern);
+        if (keys && keys.length > 0) {
+            await Promise.all(keys.map(key => this.redisClient.del(key)));
+        }
+    }
+}
+exports.ChunkSequencerManager = ChunkSequencerManager;

package/dist/managers/demo-state-manager.d.ts

@@ -0,0 +1,121 @@
+import { RedisClient } from '../redis-client';
+/**
+ * Demo Room State
+ * Tracks the runtime state of an active demo room
+ */
+export interface DemoRoomState {
+    roomId: string;
+    userId: string;
+    demoType: 'preTranscribed' | 'alwaysLive';
+    sourceLanguage: string;
+    targetLanguages: string[];
+    currentChunkIndex: number;
+    totalChunks: number;
+    loopCount: number;
+    startedAt: number;
+    demoStartAt: number | null;
+    demoDurationMinutes: number;
+    isActive: boolean;
+    isPaused: boolean;
+    lastChunkEmittedAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Demo State Manager
+ * Manages Redis-backed state for active demo rooms
+ */
+export declare class DemoStateManager {
+    private redisClient;
+    private readonly EXPIRATION;
+    private readonly KEY_PREFIX;
+    private readonly ACTIVE_DEMOS_SET;
+    constructor(redisClient: RedisClient);
+    /**
+     * Generate Redis key for demo room state
+     */
+    private getStateKey;
+    /**
+     * Serialize state to Redis format
+     */
+    private serializeState;
+    /**
+     * Deserialize state from Redis format
+     */
+    private deserializeState;
+    /**
+     * Initialize a new demo room state
+     */
+    createDemoState(params: {
+        roomId: string;
+        userId: string;
+        demoType: 'preTranscribed' | 'alwaysLive';
+        sourceLanguage: string;
+        targetLanguages: string[];
+        totalChunks: number;
+        demoStartAt: number | null;
+        demoDurationMinutes: number;
+    }): Promise<DemoRoomState>;
+    /**
+     * Get demo room state
+     */
+    getDemoState(roomId: string): Promise<DemoRoomState | null>;
+    /**
+     * Update demo state (incremental update)
+     */
+    updateDemoState(roomId: string, updates: Partial<Omit<DemoRoomState, 'roomId' | 'userId' | 'createdAt'>>): Promise<DemoRoomState | null>;
+    /**
+     * Advance to next chunk
+     * Handles looping when reaching end of transcriptions
+     */
+    advanceToNextChunk(roomId: string): Promise<DemoRoomState | null>;
+    /**
+     * Check if demo should still be running
+     * Returns true if demo should continue, false if it should stop
+     */
+    isDemoStillActive(state: DemoRoomState): boolean;
+    /**
+     * Stop a demo room
+     */
+    stopDemo(roomId: string): Promise<boolean>;
+    /**
+     * Pause a demo room
+     */
+    pauseDemo(roomId: string): Promise<boolean>;
+    /**
+     * Resume a paused demo room
+     */
+    resumeDemo(roomId: string): Promise<boolean>;
+    /**
+     * Get all active demo room IDs
+     */
+    getActiveDemoRooms(): Promise<string[]>;
+    /**
+     * Delete demo state completely
+     */
+    deleteDemoState(roomId: string): Promise<void>;
+    /**
+     * Get statistics about a demo
+     */
+    getDemoStats(roomId: string): Promise<{
+        totalChunksProcessed: number;
+        loopCount: number;
+        uptimeMinutes: number;
+        isActive: boolean;
+    } | null>;
+    /**
+     * Check if a demo room is currently active
+     */
+    isDemoActive(roomId: string): Promise<boolean>;
+    /**
+     * Cleanup stale demos (safety mechanism)
+     * Call this periodically to remove demos that should have ended
+     */
+    cleanupStaleDemos(): Promise<number>;
+    /**
+     * Cleanup ALL demo states on startup
+     * This prevents stale states from service restarts
+     * Call this when the service initializes
+     */
+    cleanupAllDemosOnStartup(): Promise<number>;
+}

package/dist/managers/demo-state-manager.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DemoStateManager = void 0;
+/**
+ * Demo State Manager
+ * Manages Redis-backed state for active demo rooms
+ */
+class DemoStateManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+        this.EXPIRATION = 24 * 60 * 60; // 24 hours
+        this.KEY_PREFIX = 'demo:room:';
+        this.ACTIVE_DEMOS_SET = 'demo:active';
+    }
+    /**
+     * Generate Redis key for demo room state
+     */
+    getStateKey(roomId) {
+        return `${this.KEY_PREFIX}${roomId}`;
+    }
+    /**
+     * Serialize state to Redis format
+     */
+    serializeState(state) {
+        return {
+            roomId: state.roomId,
+            userId: state.userId,
+            demoType: state.demoType,
+            sourceLanguage: state.sourceLanguage,
+            targetLanguages: JSON.stringify(state.targetLanguages),
+            currentChunkIndex: String(state.currentChunkIndex),
+            totalChunks: String(state.totalChunks),
+            loopCount: String(state.loopCount),
+            startedAt: String(state.startedAt),
+            demoStartAt: state.demoStartAt ? String(state.demoStartAt) : '',
+            demoDurationMinutes: String(state.demoDurationMinutes),
+            isActive: String(state.isActive),
+            isPaused: String(state.isPaused),
+            lastChunkEmittedAt: state.lastChunkEmittedAt ? String(state.lastChunkEmittedAt) : '',
+            createdAt: String(state.createdAt),
+            updatedAt: String(state.updatedAt),
+        };
+    }
+    /**
+     * Deserialize state from Redis format
+     */
+    deserializeState(data) {
+        return {
+            roomId: data.roomId,
+            userId: data.userId,
+            demoType: data.demoType,
+            sourceLanguage: data.sourceLanguage,
+            targetLanguages: JSON.parse(data.targetLanguages),
+            currentChunkIndex: parseInt(data.currentChunkIndex, 10),
+            totalChunks: parseInt(data.totalChunks, 10),
+            loopCount: parseInt(data.loopCount, 10),
+            startedAt: parseInt(data.startedAt, 10),
+            demoStartAt: data.demoStartAt ? parseInt(data.demoStartAt, 10) : null,
+            demoDurationMinutes: parseInt(data.demoDurationMinutes, 10),
+            isActive: data.isActive === 'true',
+            isPaused: data.isPaused === 'true',
+            lastChunkEmittedAt: data.lastChunkEmittedAt ? parseInt(data.lastChunkEmittedAt, 10) : null,
+            createdAt: parseInt(data.createdAt, 10),
+            updatedAt: parseInt(data.updatedAt, 10),
+        };
+    }
+    /**
+     * Initialize a new demo room state
+     */
+    async createDemoState(params) {
+        const now = Date.now();
+        const state = {
+            roomId: params.roomId,
+            userId: params.userId,
+            demoType: params.demoType,
+            sourceLanguage: params.sourceLanguage,
+            targetLanguages: params.targetLanguages,
+            currentChunkIndex: 0,
+            totalChunks: params.totalChunks,
+            loopCount: 0,
+            startedAt: now,
+            demoStartAt: params.demoStartAt,
+            demoDurationMinutes: params.demoDurationMinutes,
+            isActive: true,
+            isPaused: false,
+            lastChunkEmittedAt: null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const key = this.getStateKey(params.roomId);
+        const serialized = this.serializeState(state);
+        // Store state and add to active demos set
+        const pipeline = this.redisClient.pipeline();
+        pipeline.hset(key, serialized);
+        pipeline.expire(key, this.EXPIRATION);
+        pipeline.sadd(this.ACTIVE_DEMOS_SET, params.roomId);
+        await pipeline.exec();
+        return state;
+    }
+    /**
+     * Get demo room state
+     */
+    async getDemoState(roomId) {
+        const key = this.getStateKey(roomId);
+        const data = await this.redisClient.hgetall(key);
+        if (!data || Object.keys(data).length === 0) {
+            return null;
+        }
+        return this.deserializeState(data);
+    }
+    /**
+     * Update demo state (incremental update)
+     */
+    async updateDemoState(roomId, updates) {
+        const current = await this.getDemoState(roomId);
+        if (!current) {
+            return null;
+        }
+        const updated = {
+            ...current,
+            ...updates,
+            updatedAt: Date.now(),
+        };
+        const key = this.getStateKey(roomId);
+        const serialized = this.serializeState(updated);
+        const pipeline = this.redisClient.pipeline();
+        pipeline.hset(key, serialized);
+        pipeline.expire(key, this.EXPIRATION);
+        await pipeline.exec();
+        return updated;
+    }
+    /**
+     * Advance to next chunk
+     * Handles looping when reaching end of transcriptions
+     */
+    async advanceToNextChunk(roomId) {
+        const state = await this.getDemoState(roomId);
+        if (!state) {
+            return null;
+        }
+        const nextIndex = state.currentChunkIndex + 1;
+        let newLoopCount = state.loopCount;
+        // Check if we've reached the end
+        if (nextIndex >= state.totalChunks) {
+            // Loop back to beginning
+            return await this.updateDemoState(roomId, {
+                currentChunkIndex: 0,
+                loopCount: state.loopCount + 1,
+                lastChunkEmittedAt: Date.now(),
+            });
+        }
+        // Normal advancement
+        return await this.updateDemoState(roomId, {
+            currentChunkIndex: nextIndex,
+            lastChunkEmittedAt: Date.now(),
+        });
+    }
+    /**
+     * Check if demo should still be running
+     * Returns true if demo should continue, false if it should stop
+     */
+    isDemoStillActive(state) {
+        // Always-live demos run forever
+        if (state.demoType === 'alwaysLive') {
+            return true;
+        }
+        // Check if scheduled demo duration has expired
+        if (state.demoDurationMinutes === 0) {
+            return true; // Duration 0 = infinite
+        }
+        const now = Date.now();
+        const elapsedMs = now - state.startedAt;
+        const durationMs = state.demoDurationMinutes * 60 * 1000;
+        return elapsedMs < durationMs;
+    }
+    /**
+     * Stop a demo room
+     */
+    async stopDemo(roomId) {
+        const state = await this.getDemoState(roomId);
+        if (!state) {
+            return false;
+        }
+        await this.updateDemoState(roomId, {
+            isActive: false,
+            isPaused: false,
+        });
+        // Remove from active demos set
+        await this.redisClient.srem(this.ACTIVE_DEMOS_SET, roomId);
+        return true;
+    }
+    /**
+     * Pause a demo room
+     */
+    async pauseDemo(roomId) {
+        const state = await this.getDemoState(roomId);
+        if (!state) {
+            return false;
+        }
+        await this.updateDemoState(roomId, {
+            isPaused: true,
+        });
+        return true;
+    }
+    /**
+     * Resume a paused demo room
+     */
+    async resumeDemo(roomId) {
+        const state = await this.getDemoState(roomId);
+        if (!state) {
+            return false;
+        }
+        await this.updateDemoState(roomId, {
+            isPaused: false,
+        });
+        return true;
+    }
+    /**
+     * Get all active demo room IDs
+     */
+    async getActiveDemoRooms() {
+        return await this.redisClient.smembers(this.ACTIVE_DEMOS_SET);
+    }
+    /**
+     * Delete demo state completely
+     */
+    async deleteDemoState(roomId) {
+        const key = this.getStateKey(roomId);
+        const pipeline = this.redisClient.pipeline();
+        pipeline.del(key);
+        pipeline.srem(this.ACTIVE_DEMOS_SET, roomId);
+        await pipeline.exec();
+    }
+    /**
+     * Get statistics about a demo
+     */
+    async getDemoStats(roomId) {
+        const state = await this.getDemoState(roomId);
+        if (!state) {
+            return null;
+        }
+        const now = Date.now();
+        const uptimeMs = now - state.startedAt;
+        return {
+            totalChunksProcessed: state.loopCount * state.totalChunks + state.currentChunkIndex,
+            loopCount: state.loopCount,
+            uptimeMinutes: Math.floor(uptimeMs / 1000 / 60),
+            isActive: state.isActive,
+        };
+    }
+    /**
+     * Check if a demo room is currently active
+     */
+    async isDemoActive(roomId) {
+        const state = await this.getDemoState(roomId);
+        return state !== null && state.isActive;
+    }
+    /**
+     * Cleanup stale demos (safety mechanism)
+     * Call this periodically to remove demos that should have ended
+     */
+    async cleanupStaleDemos() {
+        const activeDemoIds = await this.getActiveDemoRooms();
+        let cleaned = 0;
+        for (const roomId of activeDemoIds) {
+            const state = await this.getDemoState(roomId);
+            if (!state) {
+                // State missing but in active set - cleanup
+                await this.redisClient.srem(this.ACTIVE_DEMOS_SET, roomId);
+                cleaned++;
+                continue;
+            }
+            // Check if demo should still be running
+            if (!this.isDemoStillActive(state)) {
+                await this.stopDemo(roomId);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Cleanup ALL demo states on startup
+     * This prevents stale states from service restarts
+     * Call this when the service initializes
+     */
+    async cleanupAllDemosOnStartup() {
+        console.log('[Demo State Manager] Cleaning up all demo states from previous run...');
+        const activeDemoIds = await this.getActiveDemoRooms();
+        if (activeDemoIds.length === 0) {
+            console.log('[Demo State Manager] No stale demo states found');
+            return 0;
+        }
+        console.log(`[Demo State Manager] Found ${activeDemoIds.length} stale demo state(s): ${activeDemoIds.join(', ')}`);
+        // Delete all demo states
+        const pipeline = this.redisClient.pipeline();
+        for (const roomId of activeDemoIds) {
+            const key = this.getStateKey(roomId);
+            pipeline.del(key);
+        }
+        // Clear the active set
+        pipeline.del(this.ACTIVE_DEMOS_SET);
+        await pipeline.exec();
+        console.log(`[Demo State Manager] ✅ Cleaned up ${activeDemoIds.length} stale demo state(s)`);
+        return activeDemoIds.length;
+    }
+}
+exports.DemoStateManager = DemoStateManager;

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

@@ -108,5 +108,17 @@ export declare class MulingstreamChunkManager {
         isEmitted?: boolean;
     }): Promise<MulingstreamChunkData | null>;
     areTranslationsProcessed(roomId: string, n: number): Promise<boolean>;
+    /**
+     * @deprecated This function is replaced by ChunkSequencer (5-sequencer-handler.ts)
+     *
+     * This function tried to sort and emit chunks, but it discarded late-arriving chunks
+     * instead of waiting for them with a timeout. The new ChunkSequencer provides:
+     * - Waiting room for out-of-order chunks
+     * - Configurable timeout (20 seconds)
+     * - Option C overflow handling (gap skip)
+     * - Per-room-per-language isolation
+     *
+     * DO NOT USE THIS FUNCTION - use sequenceAndPublish() from 5-sequencer-handler.ts instead
+     */
     getAllReadyTts(roomId: string, lang: string): Promise<MulingstreamChunkData[]>;
 }

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

@@ -298,6 +298,18 @@ class MulingstreamChunkManager {
         const c = await this.getMulingstreamChunkById(roomId, n);
         return !!c && Object.values(c.translation).every((t) => t.status !== 'INIT');
     }
+    /**
+     * @deprecated This function is replaced by ChunkSequencer (5-sequencer-handler.ts)
+     *
+     * This function tried to sort and emit chunks, but it discarded late-arriving chunks
+     * instead of waiting for them with a timeout. The new ChunkSequencer provides:
+     * - Waiting room for out-of-order chunks
+     * - Configurable timeout (20 seconds)
+     * - Option C overflow handling (gap skip)
+     * - Per-room-per-language isolation
+     *
+     * DO NOT USE THIS FUNCTION - use sequenceAndPublish() from 5-sequencer-handler.ts instead
+     */
     async getAllReadyTts(roomId, lang) {
         var _a;
         const chunks = (_a = (await this.getMulingstreamChunksByRoom(roomId))) !== null && _a !== void 0 ? _a : [];

package/dist/redis-client.d.ts

@@ -24,6 +24,13 @@ export declare class RedisClient {
     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>;
+    zrangeWithScores(key: string, start: number, stop: number): Promise<Array<{
+        value: string;
+        score: number;
+    }>>;
+    zcard(key: string): Promise<number>;
+    zscore(key: string, member: string): Promise<number | null>;
+    incr(key: string): Promise<number>;
     scan(cursor: number, pattern: string, count?: number): Promise<[string, string[]]>;
     keys(pattern: string): Promise<string[]>;
     pipeline(): ReturnType<IORedis['pipeline']>;

package/dist/redis-client.js

@@ -67,6 +67,27 @@ class RedisClient {
     async zrem(key, ...members) {
         return this.client.zrem(key, members);
     }
+    async zrangeWithScores(key, start, stop) {
+        const results = await this.client.zrange(key, start, stop, 'WITHSCORES');
+        const parsed = [];
+        for (let i = 0; i < results.length; i += 2) {
+            parsed.push({
+                value: results[i],
+                score: parseFloat(results[i + 1])
+            });
+        }
+        return parsed;
+    }
+    async zcard(key) {
+        return this.client.zcard(key);
+    }
+    async zscore(key, member) {
+        const score = await this.client.zscore(key, member);
+        return score !== null ? parseFloat(score) : null;
+    }
+    async incr(key) {
+        return this.client.incr(key);
+    }
     async scan(cursor, pattern, count = 1000) {
         return this.client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
     }

package/package.json

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