@mulingai-npm/redis 1.2.7 → 1.2.9

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

@@ -1,3 +1,3 @@
-export declare enum RedisDatabase {
-    MULINGSTREAM_LISTENER = 0
-}
+export declare enum RedisDatabase {
+    MULINGSTREAM_LISTENER = 0
+}

package/dist/enums/redis-database.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisDatabase = void 0;
-var RedisDatabase;
-(function (RedisDatabase) {
-    RedisDatabase[RedisDatabase["MULINGSTREAM_LISTENER"] = 0] = "MULINGSTREAM_LISTENER";
-})(RedisDatabase = exports.RedisDatabase || (exports.RedisDatabase = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDatabase = void 0;
+var RedisDatabase;
+(function (RedisDatabase) {
+    RedisDatabase[RedisDatabase["MULINGSTREAM_LISTENER"] = 0] = "MULINGSTREAM_LISTENER";
+})(RedisDatabase = exports.RedisDatabase || (exports.RedisDatabase = {}));

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

@@ -1,22 +1,23 @@
-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;
-    addListener(listenerData: Omit<MulingstreamListenerData, 'listenerId'>): Promise<string>;
-    getAllListeners(): Promise<MulingstreamListenerData[]>;
-    getListenersByRoom(roomId: string): Promise<MulingstreamListenerData[]>;
-    getListener(listenerIdOrToken: string): Promise<MulingstreamListenerData | null>;
-    removeListenerByToken(token: string): Promise<boolean>;
-    updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
-}
+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;
+    addListener(listenerData: Omit<MulingstreamListenerData, 'listenerId'>): Promise<string>;
+    getAllListeners(): Promise<MulingstreamListenerData[]>;
+    getListenersByRoom(roomId: string): Promise<MulingstreamListenerData[]>;
+    getListener(listenerIdOrToken: string): Promise<MulingstreamListenerData | null>;
+    removeListenerByToken(token: string): Promise<boolean>;
+    updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
+    updateSocketId(listenerIdOrToken: string, socketId: string): Promise<boolean>;
+}

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

@@ -1,118 +1,129 @@
-"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.
-    // -Generates a unique listenerId and adds it to the room's set.
-    // -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: 'true'
-        });
-        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;
-    }
-    async getListener(listenerIdOrToken) {
-        // try direct lookup by listenerId:
-        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
-        if (directData && directData.listenerId) {
-            return this.parseHashData(directData);
-        }
-        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
-        const keys = await this.redisClient.keys('listener:*');
-        if (!keys || keys.length === 0) {
-            return null;
-        }
-        for (const key of keys) {
-            const data = await this.redisClient.hgetall(key);
-            if (data && data.token === listenerIdOrToken) {
-                return this.parseHashData(data);
-            }
-        }
-        return null;
-    }
-    async removeListenerByToken(token) {
-        // find the listener by token
-        const listener = await this.getListener(token);
-        if (!listener) {
-            return false;
-        }
-        // remove the listener ID from the room's set
-        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
-        // remove the listener data (the hash)
-        await this.redisClient.del(`listener:${listener.listenerId}`);
-        return true;
-    }
-    async updateNameLanguage(listenerIdOrToken, name, language) {
-        const listener = await this.getListener(listenerIdOrToken);
-        if (!listener) {
-            return false;
-        }
-        // Update the name/language on the listener’s hash key
-        await this.redisClient.hset(`listener:${listener.listenerId}`, {
-            name,
-            language
-        });
-        return true;
-    }
-}
-exports.MulingstreamListenerManager = MulingstreamListenerManager;
+"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.
+    // -Generates a unique listenerId and adds it to the room's set.
+    // -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: 'true'
+        });
+        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;
+    }
+    async getListener(listenerIdOrToken) {
+        // try direct lookup by listenerId:
+        const directData = await this.redisClient.hgetall(`listener:${listenerIdOrToken}`);
+        if (directData && directData.listenerId) {
+            return this.parseHashData(directData);
+        }
+        // if not found by listenerId, treat 'listenerIdOrToken' as a token and scan all listeners
+        const keys = await this.redisClient.keys('listener:*');
+        if (!keys || keys.length === 0) {
+            return null;
+        }
+        for (const key of keys) {
+            const data = await this.redisClient.hgetall(key);
+            if (data && data.token === listenerIdOrToken) {
+                return this.parseHashData(data);
+            }
+        }
+        return null;
+    }
+    async removeListenerByToken(token) {
+        // find the listener by token
+        const listener = await this.getListener(token);
+        if (!listener) {
+            return false;
+        }
+        // remove the listener ID from the room's set
+        await this.redisClient.srem(`room:${listener.roomId}:listeners`, listener.listenerId);
+        // remove the listener data (the hash)
+        await this.redisClient.del(`listener:${listener.listenerId}`);
+        return true;
+    }
+    async updateNameLanguage(listenerIdOrToken, name, language) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            name,
+            language
+        });
+        return true;
+    }
+    async updateSocketId(listenerIdOrToken, socketId) {
+        const listener = await this.getListener(listenerIdOrToken);
+        if (!listener) {
+            return false;
+        }
+        // Update the name/language on the listener’s hash key
+        await this.redisClient.hset(`listener:${listener.listenerId}`, {
+            socketId
+        });
+        return true;
+    }
+}
+exports.MulingstreamListenerManager = MulingstreamListenerManager;

package/dist/redis-client.d.ts

@@ -1,21 +1,21 @@
-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>;
-    del(key: string): 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>;
-}
+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>;
+    del(key: string): 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>;
+}

package/dist/redis-client.js

@@ -1,62 +1,62 @@
-"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);
-    }
-    async del(key) {
-        return this.client.del(key);
-    }
-    // Insert one or more values into a set
-    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.
-    async hset(key, data) {
-        return this.client.hset(key, data);
-    }
-    async hgetall(key) {
-        return this.client.hgetall(key);
-    }
-    // flush methods
-    async flushAll() {
-        console.log('Removing all data!');
-        return this.client.flushall();
-    }
-    async flushDb() {
-        return this.client.flushdb();
-    }
-}
-exports.RedisClient = RedisClient;
+"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);
+    }
+    async del(key) {
+        return this.client.del(key);
+    }
+    // Insert one or more values into a set
+    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.
+    async hset(key, data) {
+        return this.client.hset(key, data);
+    }
+    async hgetall(key) {
+        return this.client.hgetall(key);
+    }
+    // flush methods
+    async flushAll() {
+        console.log('Removing all data!');
+        return this.client.flushall();
+    }
+    async flushDb() {
+        return this.client.flushdb();
+    }
+}
+exports.RedisClient = RedisClient;

package/package.json

@@ -1,33 +1,34 @@
-{
-    "name": "@mulingai-npm/redis",
-    "version": "1.2.7",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/mulingai/mulingai-backend.git"
-    },
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/"
-    },
-    "private": false,
-    "scripts": {
-        "dev": "rm -f tsconfig.tsbuildinfo && tsc --watch",
-        "build": "rm -f tsconfig.tsbuildinfo && tsc",
-        "prepublishOnly": "npm run build"
-    },
-    "dependencies": {
-        "ioredis": "^5.6.0"
-    },
-    "devDependencies": {
-        "concurrently": "^9.1.2",
-        "copyfiles": "^2.4.1",
-        "nodemon": "^3.1.9",
-        "typescript": "^4.9.5"
-    },
-    "files": [
-        "dist",
-        "package.json",
-        "README.md"
-    ]
-}
+{
+    "name": "@mulingai-npm/redis",
+    "version": "1.2.9",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mulingai/mulingai-backend.git"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "private": false,
+    "scripts": {
+        "dev": "rm -f tsconfig.tsbuildinfo && tsc --watch",
+        "build": "rm -f tsconfig.tsbuildinfo && tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "ioredis": "^5.6.0",
+        "uuid": "^11.1.0"
+    },
+    "devDependencies": {
+        "concurrently": "^9.1.2",
+        "copyfiles": "^2.4.1",
+        "nodemon": "^3.1.9",
+        "typescript": "^4.9.5"
+    },
+    "files": [
+        "dist",
+        "package.json",
+        "README.md"
+    ]
+}