@mulingai-npm/redis 3.17.2 → 3.18.0

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

@@ -0,0 +1,115 @@
+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>;
+}

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

@@ -0,0 +1,282 @@
+"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;
+    }
+}
+exports.DemoStateManager = DemoStateManager;

package/package.json

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