@mulingai-npm/redis 3.7.0 → 3.8.0

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

@@ -5,6 +5,9 @@ export interface CachedPageContent {
     locale: string;
     slug: string;
     payload: string;
+    createdAt: number;
+    lastUsedAt: number | null;
+    totalUsage: number;
 }
 export declare class PageContentManager {
     private redis;
@@ -12,7 +15,7 @@ export declare class PageContentManager {
     constructor(redis: RedisClient);
     private key;
     private build;
-    private scanAll;
+    private scan;
     addPageContent(locale: string, slug: string, payload: unknown, ttl?: number): Promise<void>;
     getPageContent(locale: string, slug: string): Promise<CachedPageContent | null>;
     getAllPageContents(): Promise<CachedPageContent[]>;
@@ -20,4 +23,5 @@ export declare class PageContentManager {
     clearPageContent(locale: string, slug: string): Promise<void>;
     clearAllPageContents(): Promise<void>;
     clearAllPageContentsByLocale(locale: string): Promise<void>;
+    incrementUsage(locale: string, slug: string): Promise<void>;
 }

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

@@ -10,17 +10,27 @@ class PageContentManager {
     }
     build(locale, slug, payload) {
         const id = this.key(locale, slug);
-        return { id, path: `/${locale}/${slug}`, locale, slug, payload: JSON.stringify(payload) };
+        const now = Date.now();
+        return {
+            id,
+            path: `/${locale}/${slug}`,
+            locale,
+            slug,
+            payload: JSON.stringify(payload),
+            createdAt: now,
+            lastUsedAt: null,
+            totalUsage: 0
+        };
     }
-    async scanAll() {
-        let cursor = '0';
-        const out = [];
+    async scan(pattern) {
+        let cursor = 0;
+        const keys = [];
         do {
-            const [next, keys] = await this.redis.scan(Number(cursor), 'page-content--[*');
-            cursor = next;
-            out.push(...keys);
-        } while (cursor !== '0');
-        return out;
+            const [next, batch] = await this.redis.scan(cursor, pattern);
+            cursor = Number(next);
+            keys.push(...batch);
+        } while (cursor !== 0);
+        return keys;
     }
     async addPageContent(locale, slug, payload, ttl = PageContentManager.DEFAULT_TTL) {
         const obj = this.build(locale, slug, payload);
@@ -32,31 +42,53 @@ class PageContentManager {
         return raw ? JSON.parse(raw) : null;
     }
     async getAllPageContents() {
-        const keys = await this.scanAll();
+        const keys = await this.scan('page-content--[*');
         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)] : []));
+        const res = await p.exec();
+        return res.flatMap(([_, v]) => (v ? [JSON.parse(v)] : []));
     }
     async getAllPageContentsByLocale(locale) {
-        const all = await this.getAllPageContents();
-        return all.filter((c) => c.locale.toLowerCase() === locale.toLowerCase());
+        const keys = await this.scan(`page-content--[${locale.toLowerCase()}]-[*`);
+        if (!keys.length)
+            return [];
+        const p = this.redis.pipeline();
+        keys.forEach((k) => p.get(k));
+        const res = await p.exec();
+        return res.flatMap(([_, v]) => (v ? [JSON.parse(v)] : []));
     }
     async clearPageContent(locale, slug) {
         await this.redis.unlink(this.key(locale, slug));
     }
     async clearAllPageContents() {
-        const keys = await this.scanAll();
+        const keys = await this.scan('page-content--[*');
         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);
+        const keys = await this.scan(`page-content--[${locale.toLowerCase()}]-[*`);
+        if (keys.length)
+            await this.redis.unlink(...keys);
+    }
+    async incrementUsage(locale, slug) {
+        var _a;
+        const k = this.key(locale, slug);
+        const pipe = this.redis.pipeline();
+        pipe.get(k);
+        pipe.ttl(k);
+        const [getRes, ttlRes] = (await pipe.exec());
+        const raw = getRes === null || getRes === void 0 ? void 0 : getRes[1];
+        if (!raw)
+            return;
+        const ttl = Number((_a = ttlRes === null || ttlRes === void 0 ? void 0 : ttlRes[1]) !== null && _a !== void 0 ? _a : -1);
+        const obj = JSON.parse(raw);
+        obj.totalUsage += 1;
+        obj.lastUsedAt = Date.now();
+        await this.redis.set(k, JSON.stringify(obj));
+        if (ttl > 0)
+            await this.redis.expire(k, ttl);
     }
 }
 exports.PageContentManager = PageContentManager;

package/dist/redis-client.d.ts

@@ -5,18 +5,10 @@ export interface RedisConfig {
     password?: string;
     db: number;
 }
-/**
- * Thin wrapper around ioredis that exposes exactly the helpers used by the two
- * managers. All helpers are 1-to-1 pass-through so there is no behavioural
- * change – this merely centralises typing and keeps the rest of the codebase
- * clean.
- */
 export declare class RedisClient {
     private client;
     constructor(config: RedisConfig);
     set(key: string, value: string): Promise<void>;
-    /** Atomic SET with NX + EX.
-     *  @returns true if the key was set, false when it already existed            */
     setNxEx(key: string, value: string, expireSeconds: number): Promise<boolean>;
     get(key: string): Promise<string | null>;
     del(key: string): Promise<number>;

package/dist/redis-client.js

@@ -5,12 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
-/**
- * Thin wrapper around ioredis that exposes exactly the helpers used by the two
- * managers. All helpers are 1-to-1 pass-through so there is no behavioural
- * change – this merely centralises typing and keeps the rest of the codebase
- * clean.
- */
 class RedisClient {
     constructor(config) {
         this.client = new ioredis_1.default({
@@ -23,14 +17,9 @@ class RedisClient {
             console.error('Redis error:', err);
         });
     }
-    /* ----------------------------------------------------------------------- */
-    /* Primitive string helpers                                                */
-    /* ----------------------------------------------------------------------- */
     async set(key, value) {
         await this.client.set(key, value);
     }
-    /** Atomic SET with NX + EX.
-     *  @returns true if the key was set, false when it already existed            */
     async setNxEx(key, value, expireSeconds) {
         // correct order: 'EX', ttl, 'NX'
         const res = (await this.client.set(key, value, 'EX', expireSeconds, 'NX'));
@@ -48,9 +37,6 @@ class RedisClient {
     async expire(key, seconds) {
         return this.client.expire(key, seconds);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Set helpers                                                             */
-    /* ----------------------------------------------------------------------- */
     async sadd(key, ...values) {
         return this.client.sadd(key, values);
     }
@@ -60,18 +46,12 @@ class RedisClient {
     async smembers(key) {
         return this.client.smembers(key);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Hash helpers                                                            */
-    /* ----------------------------------------------------------------------- */
     async hset(key, data) {
         return this.client.hset(key, data);
     }
     async hgetall(key) {
         return this.client.hgetall(key);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Sorted-set helpers                                                      */
-    /* ----------------------------------------------------------------------- */
     async zadd(key, score, member) {
         return this.client.zadd(key, score, member);
     }
@@ -87,24 +67,15 @@ class RedisClient {
     async zrem(key, ...members) {
         return this.client.zrem(key, members);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Scan (pattern search)                                                   */
-    /* ----------------------------------------------------------------------- */
     async scan(cursor, pattern, count = 1000) {
         return this.client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
     }
     async keys(pattern) {
         return this.client.keys(pattern);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Pipeline                                                                */
-    /* ----------------------------------------------------------------------- */
     pipeline() {
         return this.client.pipeline();
     }
-    /* ----------------------------------------------------------------------- */
-    /* Misc                                                                    */
-    /* ----------------------------------------------------------------------- */
     async unlink(...keys) {
         // unlink exists on Redis ≥4 and is supported by ioredis but not typed in
         // older versions – we cast to any.
@@ -112,7 +83,6 @@ class RedisClient {
         // @ts-ignore – runtime command exists even if typings lag behind.
         return this.client.unlink(...keys);
     }
-    /* JSON commands (RedisJSON module) -------------------------------------- */
     async jsonSet(key, path, value) {
         const result = await this.client.call('JSON.SET', key, path, JSON.stringify(value));
         return result;
@@ -135,9 +105,6 @@ class RedisClient {
     async jsonArrPop(key, path, index) {
         return index !== undefined ? this.client.call('JSON.ARRPOP', key, path, index) : this.client.call('JSON.ARRPOP', key, path);
     }
-    /* ----------------------------------------------------------------------- */
-    /* Dangerous! – flush helpers                                              */
-    /* ----------------------------------------------------------------------- */
     async flushAll() {
         console.warn('Flushing all Redis data!');
         return this.client.flushall();

package/package.json

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