@mulingai-npm/redis 3.5.2 → 3.7.0

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

@@ -1,5 +1,6 @@
 export declare enum RedisDatabase {
     MULINGSTREAM_LISTENER = 0,
     MULINGSTREAM_CHUNK = 1,
-    MULINGSTREAM_SPEAKER = 2
+    MULINGSTREAM_SPEAKER = 2,
+    CONTENT_DATA = 3
 }

package/dist/enums/redis-database.js

@@ -6,4 +6,5 @@ var RedisDatabase;
     RedisDatabase[RedisDatabase["MULINGSTREAM_LISTENER"] = 0] = "MULINGSTREAM_LISTENER";
     RedisDatabase[RedisDatabase["MULINGSTREAM_CHUNK"] = 1] = "MULINGSTREAM_CHUNK";
     RedisDatabase[RedisDatabase["MULINGSTREAM_SPEAKER"] = 2] = "MULINGSTREAM_SPEAKER";
+    RedisDatabase[RedisDatabase["CONTENT_DATA"] = 3] = "CONTENT_DATA";
 })(RedisDatabase = exports.RedisDatabase || (exports.RedisDatabase = {}));

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

@@ -21,9 +21,5 @@ export declare class MulingstreamListenerManager {
     updateNameLanguage(listenerIdOrToken: string, name: string, language: string): Promise<boolean>;
     updateSocketId(listenerIdOrToken: string, socketId: string): Promise<boolean>;
     getTargetSocketIdsByRoomLanguage(roomId: string, language: string): Promise<string[]>;
-    /**
-     * Returns an array of unique languages for the given room, from highest frequency to lowest.
-     * If a listener has no language (empty string / undefined), it is ignored.
-     */
     getUniqueLanguagesByRoom(roomId: string): Promise<string[]>;
 }

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

@@ -139,10 +139,6 @@ class MulingstreamListenerManager {
         });
         return filteredListeners.map((listener) => listener.socketId);
     }
-    /**
-     * Returns an array of unique languages for the given room, from highest frequency to lowest.
-     * If a listener has no language (empty string / undefined), it is ignored.
-     */
     async getUniqueLanguagesByRoom(roomId) {
         // 1) Fetch all listeners for the room.
         //    (This includes inactive ones, but feel free to filter out isActive === false if you only want active ones.)

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

@@ -15,11 +15,7 @@ export declare class MulingstreamSpeakerManager {
     private redisClient;
     constructor(redisClient: RedisClient);
     private buildLockKey;
-    /** Try to claim the speaker slot for this room.
-     *  @returns true when the lock was acquired, false if someone else holds it.
-     */
     acquireRoomLock(roomId: string, socketId: string, ttl?: number): Promise<boolean>;
-    /** Release the lock if we still own it. */
     releaseRoomLock(roomId: string, socketId: string): Promise<void>;
     private parseHash;
     private serialize;

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

@@ -7,19 +7,12 @@ class MulingstreamSpeakerManager {
     constructor(redisClient) {
         this.redisClient = redisClient;
     }
-    /* ------------------------------------------------------------------ */
-    /* One-speaker-per-room locking helpers                                */
-    /* ------------------------------------------------------------------ */
     buildLockKey(roomId) {
         return `room:${roomId}:speaker_lock`;
     }
-    /** Try to claim the speaker slot for this room.
-     *  @returns true when the lock was acquired, false if someone else holds it.
-     */
     async acquireRoomLock(roomId, socketId, ttl = LOCK_TTL) {
         return this.redisClient.setNxEx(this.buildLockKey(roomId), socketId, ttl);
     }
-    /** Release the lock if we still own it. */
     async releaseRoomLock(roomId, socketId) {
         const lockKey = this.buildLockKey(roomId);
         const current = await this.redisClient.get(lockKey);
@@ -27,9 +20,6 @@ class MulingstreamSpeakerManager {
             await this.redisClient.del(lockKey);
         }
     }
-    /* ------------------------------------------------------------------ */
-    /* Speaker CRUD + queries                                             */
-    /* ------------------------------------------------------------------ */
     parseHash(hash) {
         return {
             speakerId: hash.speakerId,
@@ -210,7 +200,7 @@ class MulingstreamSpeakerManager {
             this.redisClient.srem(`room:${roomId}:speakers`, speakerId),
             this.redisClient.srem(`user:${userId}:speakers`, speakerId),
             this.redisClient.del(`socket:${socketId}:speaker`),
-            this.redisClient.del(this.buildLockKey(roomId)) // ensure lock clears
+            this.redisClient.del(this.buildLockKey(roomId))
         ]);
     }
 }

package/dist/managers/page-content-manager.d.ts

@@ -0,0 +1,23 @@
+import { RedisClient } from '../redis-client';
+export interface CachedPageContent {
+    id: string;
+    path: string;
+    locale: string;
+    slug: string;
+    payload: string;
+}
+export declare class PageContentManager {
+    private redis;
+    private static DEFAULT_TTL;
+    constructor(redis: RedisClient);
+    private key;
+    private build;
+    private scanAll;
+    addPageContent(locale: string, slug: string, payload: unknown, ttl?: number): Promise<void>;
+    getPageContent(locale: string, slug: string): Promise<CachedPageContent | null>;
+    getAllPageContents(): Promise<CachedPageContent[]>;
+    getAllPageContentsByLocale(locale: string): Promise<CachedPageContent[]>;
+    clearPageContent(locale: string, slug: string): Promise<void>;
+    clearAllPageContents(): Promise<void>;
+    clearAllPageContentsByLocale(locale: string): Promise<void>;
+}

package/dist/managers/page-content-manager.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageContentManager = void 0;
+class PageContentManager {
+    constructor(redis) {
+        this.redis = redis;
+    }
+    key(locale, slug) {
+        return `page-content--[${locale.toLowerCase()}]-[${slug.toLowerCase()}]`;
+    }
+    build(locale, slug, payload) {
+        const id = this.key(locale, slug);
+        return { id, path: `/${locale}/${slug}`, locale, slug, payload: JSON.stringify(payload) };
+    }
+    async scanAll() {
+        let cursor = '0';
+        const out = [];
+        do {
+            const [next, keys] = await this.redis.scan(Number(cursor), 'page-content--[*');
+            cursor = next;
+            out.push(...keys);
+        } while (cursor !== '0');
+        return out;
+    }
+    async addPageContent(locale, slug, payload, ttl = PageContentManager.DEFAULT_TTL) {
+        const obj = this.build(locale, slug, payload);
+        await this.redis.set(obj.id, JSON.stringify(obj));
+        await this.redis.expire(obj.id, ttl);
+    }
+    async getPageContent(locale, slug) {
+        const raw = await this.redis.get(this.key(locale, slug));
+        return raw ? JSON.parse(raw) : null;
+    }
+    async getAllPageContents() {
+        const keys = await this.scanAll();
+        if (!keys.length)
+            return [];
+        const p = this.redis.pipeline();
+        keys.forEach((k) => p.get(k));
+        const r = await p.exec();
+        return r.flatMap(([_, v]) => (v ? [JSON.parse(v)] : []));
+    }
+    async getAllPageContentsByLocale(locale) {
+        const all = await this.getAllPageContents();
+        return all.filter((c) => c.locale.toLowerCase() === locale.toLowerCase());
+    }
+    async clearPageContent(locale, slug) {
+        await this.redis.unlink(this.key(locale, slug));
+    }
+    async clearAllPageContents() {
+        const keys = await this.scanAll();
+        if (keys.length)
+            await this.redis.unlink(...keys);
+    }
+    async clearAllPageContentsByLocale(locale) {
+        const keys = await this.scanAll();
+        const toDel = keys.filter((k) => k.startsWith(`page-content--[${locale.toLowerCase()}]-[`));
+        if (toDel.length)
+            await this.redis.unlink(...toDel);
+    }
+}
+exports.PageContentManager = PageContentManager;
+PageContentManager.DEFAULT_TTL = 24 * 60 * 60;

package/package.json

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