@mulingai-npm/redis 1.1.3 → 1.2.0

package/dist/index.d.ts

@@ -2,13 +2,18 @@ export interface RedisConfig {
     host: string;
     port: number;
     password?: string;
-    db?: number;
+    db: number;
 }
 export declare class RedisClient {
     private client;
     constructor(config: RedisConfig);
     set(key: string, value: string): Promise<void>;
     get(key: string): Promise<string | null>;
+    hset(key: string, data: Record<string, string>): Promise<number>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    sadd(key: string, ...values: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    keys(pattern: string): Promise<string[]>;
     flushAll(): Promise<string>;
     flushDb(): Promise<string>;
 }

package/dist/index.js

@@ -4,31 +4,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
+// redis-client.ts
 const ioredis_1 = __importDefault(require("ioredis"));
 class RedisClient {
     constructor(config) {
-        var _a;
         this.client = new ioredis_1.default({
             host: config.host,
             port: config.port,
             password: config.password,
-            db: (_a = config.db) !== null && _a !== void 0 ? _a : 0
+            db: config.db
         });
         this.client.on('error', (err) => {
             console.error('Redis error:', err);
         });
     }
+    // existing set/get
     async set(key, value) {
         await this.client.set(key, value);
     }
     async get(key) {
         return this.client.get(key);
     }
-    // Flush ALL databases
+    // add these methods for hash, sets, keys, etc.
+    async hset(key, data) {
+        return this.client.hset(key, data);
+    }
+    async hgetall(key) {
+        return this.client.hgetall(key);
+    }
+    // Insert one or more values into a set
+    async sadd(key, ...values) {
+        return this.client.sadd(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);
+    }
+    // flush methods
     async flushAll() {
         return this.client.flushall();
     }
-    // Flush ONLY the current database
     async flushDb() {
         return this.client.flushdb();
     }

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

@@ -0,0 +1,24 @@
+import { RedisClient } from '../redis-client';
+export type MulingstreamListenerData = {
+    listenerId: string;
+    roomId: string;
+    socketId?: string;
+    token: string;
+    name?: string;
+    firstJoined: number;
+    language?: string;
+    isActive?: boolean;
+};
+export declare class MulingstreamListenerManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    private parseHashData;
+    /**
+     * Creates a new listener.
+     * 1) Generates a unique listenerId and adds it to the room's set.
+     * 2) Stores the listener data in a Redis hash under `listener:{listenerId}`.
+     */
+    addListener(listenerData: Omit<MulingstreamListenerData, 'listenerId'>): Promise<string>;
+    getAllListeners(): Promise<MulingstreamListenerData[]>;
+    getListenersByRoom(roomId: string): Promise<MulingstreamListenerData[]>;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MulingstreamListenerManager = void 0;
+const uuid_1 = require("uuid");
+class MulingstreamListenerManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    parseHashData(data) {
+        return {
+            listenerId: data.listenerId,
+            roomId: data.roomId,
+            socketId: data.socketId || '',
+            token: data.token,
+            name: data.name || '',
+            firstJoined: parseInt(data.firstJoined, 10),
+            language: data.language || '',
+            isActive: data.isActive === 'true'
+        };
+    }
+    /**
+     * Creates a new listener.
+     * 1) Generates a unique listenerId and adds it to the room's set.
+     * 2) Stores the listener data in a Redis hash under `listener:{listenerId}`.
+     */
+    async addListener(listenerData) {
+        var _a, _b, _c;
+        // You can combine roomId + uuid, or just a uuid, up to you:
+        const listenerId = `${listenerData.roomId}--${(0, uuid_1.v4)()}`;
+        // Add listenerId to the set for that room
+        await this.redisClient.sadd(`room:${listenerData.roomId}:listeners`, listenerId);
+        // Store listener data in a hash
+        await this.redisClient.hset(`listener:${listenerId}`, {
+            listenerId,
+            roomId: listenerData.roomId,
+            socketId: (_a = listenerData.socketId) !== null && _a !== void 0 ? _a : '',
+            token: listenerData.token,
+            name: (_b = listenerData.name) !== null && _b !== void 0 ? _b : '',
+            firstJoined: listenerData.firstJoined.toString(),
+            language: (_c = listenerData.language) !== null && _c !== void 0 ? _c : '',
+            isActive: listenerData.isActive ? 'true' : 'false'
+        });
+        return listenerId;
+    }
+    async getAllListeners() {
+        // 1) Get all keys that match 'listener:*'
+        //    If you have many keys, consider using SCAN instead of KEYS to avoid performance issues.
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        // 2) Fetch each hash with HGETALL
+        const listeners = [];
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            listeners.push(this.parseHashData(data));
+        }
+        return listeners;
+    }
+    async getListenersByRoom(roomId) {
+        // 1) Get the set of listener IDs
+        const listenerIds = await this.redisClient.smembers(`room:${roomId}:listeners`);
+        if (!listenerIds || listenerIds.length === 0) {
+            return [];
+        }
+        // 2) For each ID, fetch the hash from Redis
+        const listeners = [];
+        for (const id of listenerIds) {
+            const data = await this.redisClient.hgetall(`listener:${id}`);
+            if (data) {
+                listeners.push(this.parseHashData(data));
+            }
+        }
+        return listeners;
+    }
+}
+exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/dist/redis-client.d.ts

@@ -0,0 +1,19 @@
+export interface RedisConfig {
+    host: string;
+    port: number;
+    password?: string;
+    db: number;
+}
+export declare class RedisClient {
+    private client;
+    constructor(config: RedisConfig);
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    hset(key: string, data: Record<string, string>): Promise<number>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    sadd(key: string, ...values: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    keys(pattern: string): Promise<string[]>;
+    flushAll(): Promise<string>;
+    flushDb(): Promise<string>;
+}

package/dist/redis-client.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisClient {
+    constructor(config) {
+        this.client = new ioredis_1.default({
+            host: config.host,
+            port: config.port,
+            password: config.password,
+            db: config.db
+        });
+        this.client.on('error', (err) => {
+            console.error('Redis error:', err);
+        });
+    }
+    // existing set/get
+    async set(key, value) {
+        await this.client.set(key, value);
+    }
+    async get(key) {
+        return this.client.get(key);
+    }
+    // add these methods for hash, sets, keys, etc.
+    async hset(key, data) {
+        return this.client.hset(key, data);
+    }
+    async hgetall(key) {
+        return this.client.hgetall(key);
+    }
+    // Insert one or more values into a set
+    async sadd(key, ...values) {
+        return this.client.sadd(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);
+    }
+    // flush methods
+    async flushAll() {
+        return this.client.flushall();
+    }
+    async flushDb() {
+        return this.client.flushdb();
+    }
+}
+exports.RedisClient = RedisClient;

package/package.json

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