@mulingai-npm/redis 3.29.4 → 3.29.7

package/dist/enums/redis-database.d.ts

@@ -3,5 +3,6 @@ export declare enum RedisDatabase {
     MULINGSTREAM_CHUNK = 1,
     MULINGSTREAM_SPEAKER = 2,
     CONTENT_DATA = 3,
-    ACCOUNT_DATA = 4
+    ACCOUNT_DATA = 4,
+    USAGE_DATA = 5
 }

package/dist/enums/redis-database.js

@@ -8,4 +8,5 @@ var RedisDatabase;
     RedisDatabase[RedisDatabase["MULINGSTREAM_SPEAKER"] = 2] = "MULINGSTREAM_SPEAKER";
     RedisDatabase[RedisDatabase["CONTENT_DATA"] = 3] = "CONTENT_DATA";
     RedisDatabase[RedisDatabase["ACCOUNT_DATA"] = 4] = "ACCOUNT_DATA";
+    RedisDatabase[RedisDatabase["USAGE_DATA"] = 5] = "USAGE_DATA";
 })(RedisDatabase = exports.RedisDatabase || (exports.RedisDatabase = {}));

package/dist/managers/usage-data-manager.d.ts

@@ -0,0 +1,65 @@
+import { RedisClient } from '../redis-client';
+/**
+ * Pending usage data for a user
+ */
+export interface PendingUsageData {
+    userId: string;
+    billingMs: number;
+    roomDurations: Record<string, number>;
+    lastUpdated: number;
+}
+/**
+ * Usage Data Manager
+ *
+ * Stores pending streaming usage in Redis for batch DB writes.
+ * Pipeline service writes here every 5 seconds during streaming.
+ * Job service flushes to DB every 30-60 seconds.
+ *
+ * Key structure:
+ * - usage:pending:{userId} - Hash with billing and room usage
+ * - usage:pending:users - Set of all user IDs with pending usage
+ */
+export declare class UsageDataManager {
+    private redisClient;
+    private readonly EXPIRATION;
+    constructor(redisClient: RedisClient);
+    /**
+     * Key for a user's pending usage data
+     */
+    private userKey;
+    /**
+     * Key for the set of users with pending usage
+     */
+    private usersSetKey;
+    /**
+     * Add streaming usage for a user
+     * Called by pipeline-service every 5 seconds during streaming
+     */
+    addUsage(userId: string, roomId: string, durationMs: number): Promise<void>;
+    /**
+     * Get all users with pending usage
+     */
+    getUsersWithPendingUsage(): Promise<string[]>;
+    /**
+     * Get pending usage for a specific user
+     */
+    getPendingUsage(userId: string): Promise<PendingUsageData | null>;
+    /**
+     * Get all pending usage data (for batch flush)
+     */
+    getAllPendingUsage(): Promise<PendingUsageData[]>;
+    /**
+     * Clear pending usage for a specific user (after successful DB write)
+     */
+    clearUserUsage(userId: string): Promise<void>;
+    /**
+     * Clear all pending usage (after successful batch flush)
+     */
+    clearAllUsage(): Promise<void>;
+    /**
+     * Flush a single user's usage to DB immediately
+     * Called when session closes to ensure no data is lost
+     * Returns the usage data that was flushed (for logging)
+     */
+    getAndClearUserUsage(userId: string): Promise<PendingUsageData | null>;
+}

package/dist/managers/usage-data-manager.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageDataManager = void 0;
+/**
+ * Usage Data Manager
+ *
+ * Stores pending streaming usage in Redis for batch DB writes.
+ * Pipeline service writes here every 5 seconds during streaming.
+ * Job service flushes to DB every 30-60 seconds.
+ *
+ * Key structure:
+ * - usage:pending:{userId} - Hash with billing and room usage
+ * - usage:pending:users - Set of all user IDs with pending usage
+ */
+class UsageDataManager {
+    constructor(redisClient) {
+        this.EXPIRATION = 24 * 60 * 60; // 24 hours TTL
+        this.redisClient = redisClient;
+    }
+    /**
+     * Key for a user's pending usage data
+     */
+    userKey(userId) {
+        return `usage:pending:${userId}`;
+    }
+    /**
+     * Key for the set of users with pending usage
+     */
+    usersSetKey() {
+        return 'usage:pending:users';
+    }
+    /**
+     * Add streaming usage for a user
+     * Called by pipeline-service every 5 seconds during streaming
+     */
+    async addUsage(userId, roomId, durationMs) {
+        const key = this.userKey(userId);
+        // Increment billing total
+        await this.redisClient.hincrby(key, 'billingMs', durationMs);
+        // Increment room-specific duration
+        await this.redisClient.hincrby(key, `room:${roomId}`, durationMs);
+        // Update timestamp
+        await this.redisClient.hset(key, { lastUpdated: Date.now().toString() });
+        // Set expiration
+        await this.redisClient.expire(key, this.EXPIRATION);
+        // Add user to the set of users with pending usage
+        await this.redisClient.sadd(this.usersSetKey(), userId);
+        await this.redisClient.expire(this.usersSetKey(), this.EXPIRATION);
+    }
+    /**
+     * Get all users with pending usage
+     */
+    async getUsersWithPendingUsage() {
+        const members = await this.redisClient.smembers(this.usersSetKey());
+        return members || [];
+    }
+    /**
+     * Get pending usage for a specific user
+     */
+    async getPendingUsage(userId) {
+        const key = this.userKey(userId);
+        const data = await this.redisClient.hgetall(key);
+        if (!data || Object.keys(data).length === 0) {
+            return null;
+        }
+        const billingMs = parseInt(data.billingMs || '0', 10);
+        const lastUpdated = parseInt(data.lastUpdated || '0', 10);
+        // Extract room durations (keys starting with "room:")
+        const roomDurations = {};
+        for (const [field, value] of Object.entries(data)) {
+            if (field.startsWith('room:')) {
+                const roomId = field.substring(5); // Remove "room:" prefix
+                roomDurations[roomId] = parseInt(value, 10);
+            }
+        }
+        return {
+            userId,
+            billingMs,
+            roomDurations,
+            lastUpdated
+        };
+    }
+    /**
+     * Get all pending usage data (for batch flush)
+     */
+    async getAllPendingUsage() {
+        const userIds = await this.getUsersWithPendingUsage();
+        const results = [];
+        for (const userId of userIds) {
+            const usage = await this.getPendingUsage(userId);
+            if (usage && usage.billingMs > 0) {
+                results.push(usage);
+            }
+        }
+        return results;
+    }
+    /**
+     * Clear pending usage for a specific user (after successful DB write)
+     */
+    async clearUserUsage(userId) {
+        const key = this.userKey(userId);
+        await this.redisClient.del(key);
+        await this.redisClient.srem(this.usersSetKey(), userId);
+    }
+    /**
+     * Clear all pending usage (after successful batch flush)
+     */
+    async clearAllUsage() {
+        const userIds = await this.getUsersWithPendingUsage();
+        for (const userId of userIds) {
+            await this.redisClient.del(this.userKey(userId));
+        }
+        await this.redisClient.del(this.usersSetKey());
+    }
+    /**
+     * Flush a single user's usage to DB immediately
+     * Called when session closes to ensure no data is lost
+     * Returns the usage data that was flushed (for logging)
+     */
+    async getAndClearUserUsage(userId) {
+        const usage = await this.getPendingUsage(userId);
+        if (usage) {
+            await this.clearUserUsage(userId);
+        }
+        return usage;
+    }
+}
+exports.UsageDataManager = UsageDataManager;

package/dist/redis-client.d.ts

@@ -19,6 +19,7 @@ export declare class RedisClient {
     smembers(key: string): Promise<string[]>;
     hset(key: string, data: Record<string, string>): Promise<number>;
     hgetall(key: string): Promise<Record<string, string>>;
+    hincrby(key: string, field: string, increment: 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>;

package/dist/redis-client.js

@@ -52,6 +52,9 @@ class RedisClient {
     async hgetall(key) {
         return this.client.hgetall(key);
     }
+    async hincrby(key, field, increment) {
+        return this.client.hincrby(key, field, increment);
+    }
     async zadd(key, score, member) {
         return this.client.zadd(key, score, member);
     }

package/package.json

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