@ecashlib/shared-message 1.0.1 → 1.0.3

package/dist/redis.repository.js

@@ -0,0 +1,619 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisHashMap = exports.RedisRepository = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const bigIntSerializer = (key, value) => {
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    return value;
+};
+const bigIntDeserializer = (key, value) => {
+    if (typeof value === "string" && /^\d+$/.test(value) && value.length > 15) {
+        try {
+            return BigInt(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+};
+class RedisRepository {
+    constructor(fastify) {
+        this.redis = fastify.redis;
+        this.logger = fastify.log;
+    }
+    /**
+     * Set a string value with TTL (Time To Live)
+     * @param key Redis key
+     * @param value String value to store
+     * @param ttlSeconds TTL in seconds
+     */
+    async setString(key, value, ttlSeconds) {
+        try {
+            if (ttlSeconds !== undefined) {
+                await this.redis.setex(key, ttlSeconds, value);
+                this.logger.debug(`Set key: ${key}, value: ${value}, ttl: ${ttlSeconds}s`);
+            }
+            else {
+                await this.redis.set(key, value);
+                this.logger.debug(`Set key: ${key}, value: ${value}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error setting string key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get a string value by key
+     * @param key Redis key
+     * @returns Promise<string | null> The stored value or null if not found
+     */
+    async getString(key) {
+        try {
+            const value = await this.redis.get(key);
+            this.logger.debug(`Get key: ${key}, value: ${value}`);
+            return value;
+        }
+        catch (error) {
+            this.logger.error(`Error getting string key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Set an object as JSON string with optional TTL
+     * @param key Redis key
+     * @param object Object to store
+     * @param ttlSeconds Optional TTL in seconds
+     */
+    async setObject(key, object, ttlSeconds) {
+        try {
+            const jsonValue = JSON.stringify(object, bigIntSerializer);
+            if (ttlSeconds !== undefined) {
+                await this.redis.setex(key, ttlSeconds, jsonValue);
+                this.logger.debug(`Set object key: ${key}, ttl: ${ttlSeconds}s`);
+            }
+            else {
+                await this.redis.set(key, jsonValue);
+                this.logger.debug(`Set object key: ${key}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error setting object key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get an object by key and parse as JSON
+     * @param key Redis key
+     * @returns Promise<T | null> The parsed object or null if not found
+     */
+    async getObject(key) {
+        try {
+            const jsonValue = await this.redis.get(key);
+            if (jsonValue === null) {
+                this.logger.debug(`Get object key: ${key}, found: false`);
+                return null;
+            }
+            const object = JSON.parse(jsonValue, bigIntDeserializer);
+            this.logger.debug(`Get object key: ${key}, found: true`);
+            return object;
+        }
+        catch (error) {
+            this.logger.error(`Error getting object key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get a Redis hash map operations
+     * @param mapName Hash map name
+     * @returns RedisHashMap instance for operations
+     */
+    getMap(mapName) {
+        return new RedisHashMap(mapName, this.redis, this.logger);
+    }
+    /**
+     * Delete a key from Redis
+     * @param key Redis key to delete
+     * @returns Promise<boolean> true if key was deleted, false if key didn't exist
+     */
+    async delete(key) {
+        try {
+            const result = await this.redis.del(key);
+            const deleted = result > 0;
+            this.logger.debug(`Delete key: ${key}, success: ${deleted}`);
+            return deleted;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Check if a key exists in Redis
+     * @param key Redis key to check
+     * @returns Promise<boolean> true if key exists, false otherwise
+     */
+    async exists(key) {
+        try {
+            const result = await this.redis.exists(key);
+            const exists = result === 1;
+            this.logger.debug(`Key exists: ${key}, result: ${exists}`);
+            return exists;
+        }
+        catch (error) {
+            this.logger.error(`Error checking key existence: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Set expiry time for an existing key
+     * @param key Redis key
+     * @param ttlSeconds TTL in seconds
+     * @returns Promise<boolean> true if expiry was set, false if key doesn't exist
+     */
+    async expire(key, ttlSeconds) {
+        try {
+            const result = await this.redis.expire(key, ttlSeconds);
+            this.logger.debug(`Set expiry for key: ${key}, ttl: ${ttlSeconds}s, success: ${result === 1}`);
+            return result === 1;
+        }
+        catch (error) {
+            this.logger.error(`Error setting expiry for key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get TTL (time to live) for a key
+     * @param key Redis key
+     * @returns Promise<number> TTL in seconds, -1 if no expiry, -2 if key doesn't exist
+     */
+    async getTTL(key) {
+        try {
+            const ttl = await this.redis.ttl(key);
+            this.logger.debug(`Get TTL for key: ${key}, ttl: ${ttl}s`);
+            return ttl;
+        }
+        catch (error) {
+            this.logger.error(`Error getting TTL for key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Increment a numeric value stored at key
+     * @param key Redis key
+     * @param increment Amount to increment by (default: 1)
+     * @returns Promise<number> The new value after increment
+     */
+    async increment(key, increment = 1) {
+        try {
+            const result = await this.redis.incrby(key, increment);
+            this.logger.debug(`Increment key: ${key}, by: ${increment}, new value: ${result}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error incrementing key: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get multiple keys at once
+     * @param keys Array of Redis keys
+     * @returns Promise<(string | null)[]> Array of values corresponding to keys
+     */
+    async getMultiple(keys) {
+        try {
+            if (keys.length === 0)
+                return [];
+            const values = await this.redis.mget(...keys);
+            this.logger.debug(`Get multiple keys: ${keys.length} keys`);
+            return values;
+        }
+        catch (error) {
+            this.logger.error(`Error getting multiple keys`, error);
+            throw error;
+        }
+    }
+    /**
+     * Set multiple key-value pairs at once
+     * @param keyValues Object containing key-value pairs
+     * @returns Promise<void>
+     */
+    async setMultiple(keyValues) {
+        try {
+            const pairs = [];
+            Object.entries(keyValues).forEach(([key, value]) => {
+                pairs.push(key, value);
+            });
+            if (pairs.length > 0) {
+                await this.redis.mset(...pairs);
+                this.logger.debug(`Set multiple keys: ${Object.keys(keyValues).length} keys`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error setting multiple keys`, error);
+            throw error;
+        }
+    }
+    /**
+     * Find keys matching a pattern using KEYS command
+     * WARNING: This command can be slow on large datasets. Consider using SCAN for production.
+     * @param pattern Pattern to match keys (supports wildcards: *, ?, [])
+     * @returns Promise<string[]> Array of matching key names
+     *
+     * Pattern examples:
+     * - "user:*" - matches all keys starting with "user:"
+     * - "session:*:data" - matches keys like "session:123:data"
+     * - "cache:user:[0-9]*" - matches keys like "cache:user:123"
+     */
+    async keys(pattern) {
+        try {
+            const keys = await this.redis.keys(pattern);
+            this.logger.debug(`Keys pattern: ${pattern}, found: ${keys.length} keys`);
+            return keys;
+        }
+        catch (error) {
+            this.logger.error(`Error finding keys with pattern: ${pattern}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Scan keys matching a pattern using SCAN command (recommended for production)
+     * This is more efficient than KEYS for large datasets as it doesn't block Redis
+     * @param pattern Pattern to match keys
+     * @param count Number of keys to return per iteration (default: 10)
+     * @returns Promise<string[]> Array of matching key names
+     */
+    async scanKeys(pattern, count = 10) {
+        try {
+            const keys = [];
+            let cursor = "0";
+            do {
+                const result = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", count);
+                cursor = result[0];
+                keys.push(...result[1]);
+            } while (cursor !== "0");
+            this.logger.debug(`Scan keys pattern: ${pattern}, found: ${keys.length} keys`);
+            return keys;
+        }
+        catch (error) {
+            this.logger.error(`Error scanning keys with pattern: ${pattern}`, error);
+            throw error;
+        }
+    }
+    // ==================== REDIS SET OPERATIONS ====================
+    /**
+     * Add one or more members to a Redis set
+     * @param key Redis set key
+     * @param members Members to add to the set
+     * @returns Promise<number> Number of members that were added (excluding already existing members)
+     */
+    async setAdd(key, ...members) {
+        try {
+            const result = await this.redis.sadd(key, ...members);
+            this.logger.debug(`Set add - key: ${key}, members: ${members.length}, added: ${result}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error adding to set: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Remove one or more members from a Redis set
+     * @param key Redis set key
+     * @param members Members to remove from the set
+     * @returns Promise<number> Number of members that were removed
+     */
+    async setRemove(key, ...members) {
+        try {
+            const result = await this.redis.srem(key, ...members);
+            this.logger.debug(`Set remove - key: ${key}, members: ${members.length}, removed: ${result}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error removing from set: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get the number of members in a Redis set
+     * @param key Redis set key
+     * @returns Promise<number> Number of members in the set
+     */
+    async setSize(key) {
+        try {
+            const size = await this.redis.scard(key);
+            this.logger.debug(`Set size - key: ${key}, size: ${size}`);
+            return size;
+        }
+        catch (error) {
+            this.logger.error(`Error getting set size: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Check if a member exists in a Redis set
+     * @param key Redis set key
+     * @param member Member to check
+     * @returns Promise<boolean> true if member exists in the set
+     */
+    async setContains(key, member) {
+        try {
+            const result = await this.redis.sismember(key, member);
+            const exists = result === 1;
+            this.logger.debug(`Set contains - key: ${key}, member: ${member}, exists: ${exists}`);
+            return exists;
+        }
+        catch (error) {
+            this.logger.error(`Error checking set membership: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get all members of a Redis set
+     * @param key Redis set key
+     * @returns Promise<string[]> Array of all members in the set
+     */
+    async setMembers(key) {
+        try {
+            const members = await this.redis.smembers(key);
+            this.logger.debug(`Set members - key: ${key}, count: ${members.length}`);
+            return members;
+        }
+        catch (error) {
+            this.logger.error(`Error getting set members: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get a random member from a Redis set
+     * @param key Redis set key
+     * @param count Number of random members to return (default: 1)
+     * @returns Promise<string[]> Array of random members
+     */
+    async setRandomMembers(key, count = 1) {
+        try {
+            const members = await this.redis.srandmember(key, count);
+            const result = Array.isArray(members)
+                ? members
+                : [members].filter(Boolean);
+            this.logger.debug(`Set random members - key: ${key}, count: ${count}, returned: ${result.length}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error getting random set members: ${key}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Pop (remove and return) a random member from a Redis set
+     * @param key Redis set key
+     * @param count Number of members to pop (default: 1)
+     * @returns Promise<string[]> Array of popped members
+     */
+    async setPop(key, count = 1) {
+        try {
+            const members = await this.redis.spop(key, count);
+            const result = Array.isArray(members)
+                ? members
+                : [members].filter(Boolean);
+            this.logger.debug(`Set pop - key: ${key}, count: ${count}, popped: ${result.length}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error popping from set: ${key}`, error);
+            throw error;
+        }
+    }
+    async hSet(key, field, value) {
+        try {
+            const jsonValue = typeof value === "string"
+                ? value
+                : JSON.stringify(value, bigIntSerializer);
+            await this.redis.hset(key, field, jsonValue);
+            this.logger.debug(`Hset - key: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Error hset: ${key}`, error);
+            throw error;
+        }
+    }
+    async hSetMultiple(key, values) {
+        const serializedValues = Object.entries(values).reduce((acc, [key, value]) => {
+            acc[key] = JSON.stringify(value, bigIntSerializer);
+            return acc;
+        }, {});
+        await this.redis.hset(key, serializedValues);
+    }
+    async hGet(key, field) {
+        try {
+            const value = await this.redis.hget(key, field);
+            if (value === null) {
+                return null;
+            }
+            return JSON.parse(value, bigIntDeserializer);
+        }
+        catch (error) {
+            this.logger.error(`Error hgetall: ${key}`, error);
+            throw error;
+        }
+    }
+    async hGetAll(key) {
+        try {
+            const value = await this.redis.hgetall(key);
+            Object.keys(value).forEach((key) => {
+                value[key] = JSON.parse(value[key]);
+            });
+            return value;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async hDel(key) {
+        try {
+            await this.redis.hdel(key);
+            this.logger.debug(`Hdel - key: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Error hdel: ${key}`, error);
+            throw error;
+        }
+    }
+    async hDelItem(key, field) {
+        try {
+            await this.redis.hdel(key, field);
+            this.logger.debug(`Hdel - key: ${key}, field: ${field}`);
+        }
+        catch (error) {
+            this.logger.error(`Error hdel: ${key}`, error);
+            throw error;
+        }
+    }
+}
+exports.RedisRepository = RedisRepository;
+/**
+ * Helper class for Redis Hash Map operations
+ */
+class RedisHashMap {
+    constructor(mapName, redis, logger) {
+        this.mapName = mapName;
+        this.redis = redis;
+        this.logger = logger;
+    }
+    /**
+     * Set a field in the hash map
+     * @param field Hash field name
+     * @param value Value to set
+     */
+    async set(field, value) {
+        try {
+            const jsonValue = typeof value === "string"
+                ? value
+                : JSON.stringify(value, bigIntSerializer);
+            await this.redis.hset(this.mapName, field, jsonValue);
+            this.logger.debug(`Hash set - map: ${this.mapName}, field: ${field}`);
+        }
+        catch (error) {
+            this.logger.error(`Error setting hash field: ${this.mapName}.${field}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get a field from the hash map
+     * @param field Hash field name
+     * @returns Promise<T | null> The field value or null if not found
+     */
+    async get(field) {
+        try {
+            const value = await this.redis.hget(this.mapName, field);
+            if (value === null) {
+                this.logger.debug(`Hash get - map: ${this.mapName}, field: ${field}, found: false`);
+                return null;
+            }
+            try {
+                const parsed = JSON.parse(value, bigIntDeserializer);
+                this.logger.debug(`Hash get - map: ${this.mapName}, field: ${field}, found: true`);
+                return parsed;
+            }
+            catch {
+                // If JSON parsing fails, return as string
+                this.logger.debug(`Hash get - map: ${this.mapName}, field: ${field}, found: true (string)`);
+                return value;
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error getting hash field: ${this.mapName}.${field}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get all fields and values from the hash map
+     * @returns Promise<Record<string, string>> All field-value pairs
+     */
+    async getAll() {
+        try {
+            const result = await this.redis.hgetall(this.mapName);
+            this.logger.debug(`Hash get all - map: ${this.mapName}, fields: ${Object.keys(result).length}`);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error getting all hash fields: ${this.mapName}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Delete a field from the hash map
+     * @param field Hash field name
+     * @returns Promise<boolean> true if field was deleted
+     */
+    async delete(field) {
+        try {
+            const result = await this.redis.hdel(this.mapName, field);
+            const deleted = result > 0;
+            this.logger.debug(`Hash delete - map: ${this.mapName}, field: ${field}, success: ${deleted}`);
+            return deleted;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting hash field: ${this.mapName}.${field}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Check if a field exists in the hash map
+     * @param field Hash field name
+     * @returns Promise<boolean> true if field exists
+     */
+    async exists(field) {
+        try {
+            const result = await this.redis.hexists(this.mapName, field);
+            this.logger.debug(`Hash exists - map: ${this.mapName}, field: ${field}, exists: ${result === 1}`);
+            return result === 1;
+        }
+        catch (error) {
+            this.logger.error(`Error checking hash field existence: ${this.mapName}.${field}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get all field names in the hash map
+     * @returns Promise<string[]> Array of field names
+     */
+    async getKeys() {
+        try {
+            const keys = await this.redis.hkeys(this.mapName);
+            this.logger.debug(`Hash keys - map: ${this.mapName}, count: ${keys.length}`);
+            return keys;
+        }
+        catch (error) {
+            this.logger.error(`Error getting hash keys: ${this.mapName}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Get the number of fields in the hash map
+     * @returns Promise<number> Number of fields
+     */
+    async size() {
+        try {
+            const size = await this.redis.hlen(this.mapName);
+            this.logger.debug(`Hash size - map: ${this.mapName}, size: ${size}`);
+            return size;
+        }
+        catch (error) {
+            this.logger.error(`Error getting hash size: ${this.mapName}`, error);
+            throw error;
+        }
+    }
+}
+exports.RedisHashMap = RedisHashMap;
+exports.default = (0, fastify_plugin_1.default)(async (fastify) => {
+    const repo = new RedisRepository(fastify);
+    fastify.decorate("redisRepository", repo);
+}, { name: "redis-repository", dependencies: ["redis"] });

package/package.json

@@ -1,38 +1,41 @@
-{
-  "name": "@ecashlib/shared-message",
-  "version": "1.0.1",
-  "description": "Shared utilities for Ecash microservices - Message handling, i18n, error helpers",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
-    "prepublishOnly": "npm run build",
-    "clean": "rimraf dist"
-  },
-  "keywords": [
-    "ecash",
-    "ecashlib",
-    "shared",
-    "i18n",
-    "message",
-    "error-handling"
-  ],
-  "author": "Ecash Team",
-  "license": "PRIVATE",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "fastify": "^4.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "rimraf": "^5.0.0"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ]
+{
+  "name": "@ecashlib/shared-message",
+  "version": "1.0.3",
+  "description": "Shared utilities for Ecash microservices - Message handling, i18n, error helpers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "clean": "rimraf dist"
+  },
+  "keywords": [
+    "ecash",
+    "ecashlib",
+    "shared",
+    "i18n",
+    "message",
+    "error-handling"
+  ],
+  "author": "Ecash Team",
+  "license": "PRIVATE",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@fastify/redis": "^7.0.0",
+    "fastify": "^4.0.0",
+    "fastify-plugin": "^4.0.0",
+    "ioredis": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "rimraf": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
 }