plac-micro-common 1.1.13 → 1.2.0

package/dist/libs/redis/redis.constant.d.ts

@@ -1,4 +1,16 @@
-export declare const REDIS_CLIENT = "REDIS_CLIENT";
+export declare const REDIS_CLIENTS = "REDIS_CLIENTS";
+/**
+ * Named client token helper (if you want to inject a specific client directly)
+ * Example: @Inject(getRedisClientToken('geo')) private geoRedis: Redis
+ */
+export declare const getRedisClientToken: (name: string) => string;
+/**
+ * Backward compatible tokens:
+ * - REDIS_CLIENT is the "main" redis client
+ * - REDIS_GEO_CLIENT is the "geo" redis client
+ */
+export declare const REDIS_CLIENT: string;
+export declare const REDIS_GEO_CLIENT: string;
 export type RedisModuleOptions = {
     url?: string;
     host?: string;

package/dist/libs/redis/redis.constant.js

@@ -1,4 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REDIS_CLIENT = void 0;
-exports.REDIS_CLIENT = "REDIS_CLIENT";
+exports.REDIS_GEO_CLIENT = exports.REDIS_CLIENT = exports.getRedisClientToken = exports.REDIS_CLIENTS = void 0;
+exports.REDIS_CLIENTS = "REDIS_CLIENTS";
+/**
+ * Named client token helper (if you want to inject a specific client directly)
+ * Example: @Inject(getRedisClientToken('geo')) private geoRedis: Redis
+ */
+const getRedisClientToken = (name) => `REDIS_CLIENT:${name}`;
+exports.getRedisClientToken = getRedisClientToken;
+/**
+ * Backward compatible tokens:
+ * - REDIS_CLIENT is the "main" redis client
+ * - REDIS_GEO_CLIENT is the "geo" redis client
+ */
+exports.REDIS_CLIENT = (0, exports.getRedisClientToken)("main");
+exports.REDIS_GEO_CLIENT = (0, exports.getRedisClientToken)("geo");

package/dist/libs/redis/redis.module.js

@@ -16,40 +16,92 @@ const config_1 = require("@nestjs/config");
 const ioredis_1 = __importDefault(require("ioredis"));
 const redis_constant_1 = require("./redis.constant");
 const redis_service_1 = require("./redis.service");
+function parseNames(v) {
+    // default includes geo for backward compatibility with your existing code
+    const raw = (v ?? "main,geo")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    // ensure unique
+    return Array.from(new Set(raw));
+}
+function upper(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+}
 let RedisModule = RedisModule_1 = class RedisModule {
     static forRootAsync() {
         return {
             module: RedisModule_1,
             imports: [config_1.ConfigModule],
             providers: [
+                // 1) Build ALL clients from env and store as a map
                 {
-                    provide: redis_constant_1.REDIS_CLIENT,
+                    provide: redis_constant_1.REDIS_CLIENTS,
                     inject: [config_1.ConfigService],
                     useFactory: (config) => {
-                        const url = config.get("REDIS_URL");
-                        const keyPrefix = config.get("REDIS_KEY_PREFIX") || undefined;
-                        // Prefer REDIS_URL if present
-                        const client = url
-                            ? new ioredis_1.default(url, { keyPrefix })
-                            : new ioredis_1.default({
-                                host: config.get("REDIS_HOST"),
-                                port: config.get("REDIS_PORT"),
-                                password: config.get("REDIS_PASSWORD") || undefined,
-                                db: config.get("REDIS_DB") || 0,
-                                keyPrefix,
+                        const names = parseNames(config.get("REDIS_NAMES"));
+                        const baseUrl = config.get("REDIS_URL");
+                        const baseHost = config.get("REDIS_HOST");
+                        const basePort = config.get("REDIS_PORT");
+                        const basePassword = config.get("REDIS_PASSWORD") || undefined;
+                        const baseDb = config.get("REDIS_DB") ?? 0;
+                        const baseKeyPrefix = config.get("REDIS_KEY_PREFIX") || undefined;
+                        const map = {};
+                        for (const name of names) {
+                            const N = upper(name);
+                            const url = config.get(`REDIS_${N}_URL`) ?? baseUrl;
+                            const host = config.get(`REDIS_${N}_HOST`) ?? baseHost;
+                            const port = config.get(`REDIS_${N}_PORT`) ?? basePort;
+                            const password = config.get(`REDIS_${N}_PASSWORD`) ?? basePassword;
+                            const db = config.get(`REDIS_${N}_DB`) ?? baseDb;
+                            const keyPrefix = config.get(`REDIS_${N}_KEY_PREFIX`) ?? baseKeyPrefix;
+                            const client = url
+                                ? new ioredis_1.default(url, { keyPrefix })
+                                : new ioredis_1.default({
+                                    host,
+                                    port,
+                                    password,
+                                    db,
+                                    keyPrefix,
+                                });
+                            client.on("error", (err) => {
+                                // eslint-disable-next-line no-console
+                                console.error(`[redis:${name}] error:`, err?.message || err);
                             });
-                        // (Optional) basic visibility
-                        client.on("error", (err) => {
-                            // don’t throw here; just log
-                            // eslint-disable-next-line no-console
-                            console.error("[redis] error:", err?.message || err);
-                        });
-                        return client;
+                            map[name] = client;
+                        }
+                        return map;
                     },
                 },
+                // 2) Provide each named token for DI (optional but useful)
+                //    e.g. @Inject(getRedisClientToken('geo')) geoRedis: Redis
+                {
+                    provide: (0, redis_constant_1.getRedisClientToken)("main"),
+                    inject: [redis_constant_1.REDIS_CLIENTS],
+                    useFactory: (clients) => {
+                        if (!clients.main)
+                            throw new Error(`[redis] missing client "main" (check REDIS_NAMES)`);
+                        return clients.main;
+                    },
+                },
+                {
+                    provide: (0, redis_constant_1.getRedisClientToken)("geo"),
+                    inject: [redis_constant_1.REDIS_CLIENTS],
+                    useFactory: (clients) => {
+                        if (!clients.geo)
+                            throw new Error(`[redis] missing client "geo" (check REDIS_NAMES)`);
+                        return clients.geo;
+                    },
+                },
+                // 3) Service uses the map; you can use any client name dynamically
+                redis_service_1.RedisService,
+            ],
+            exports: [
+                redis_constant_1.REDIS_CLIENTS,
                 redis_service_1.RedisService,
+                (0, redis_constant_1.getRedisClientToken)("main"),
+                (0, redis_constant_1.getRedisClientToken)("geo"),
             ],
-            exports: [redis_constant_1.REDIS_CLIENT, redis_service_1.RedisService],
         };
     }
 };

package/dist/libs/redis/redis.service.d.ts

@@ -1,13 +1,18 @@
 import { OnModuleDestroy } from "@nestjs/common";
 import { Redis } from "ioredis";
+type RedisClientMap = Record<string, Redis>;
 export declare class RedisService implements OnModuleDestroy {
-    private readonly redis;
-    constructor(redis: Redis);
-    get(key: string): Promise<string | null>;
-    del(key: string): Promise<number>;
-    exists(key: string): Promise<number>;
-    getJson<T>(key: string): Promise<T | null>;
-    setJson(key: string, value: unknown, ttlSeconds?: number): Promise<"OK">;
-    client(): Redis;
+    private readonly clients;
+    constructor(clients: RedisClientMap);
+    private pick;
+    get(key: string, clientName?: string): Promise<string | null>;
+    del(key: string, clientName?: string): Promise<number>;
+    exists(key: string, clientName?: string): Promise<number>;
+    client(clientName?: string): Redis;
+    getJson<T>(key: string, clientName?: string): Promise<T | null>;
+    setJson(key: string, value: unknown, ttlSeconds?: number, clientName?: string): Promise<"OK">;
+    getGeoJson<T>(key: string): Promise<T | null>;
+    setGeoJson(key: string, value: unknown, ttlSeconds?: number): Promise<"OK">;
     onModuleDestroy(): Promise<void>;
 }
+export {};

package/dist/libs/redis/redis.service.js

@@ -14,25 +14,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisService = void 0;
 const common_1 = require("@nestjs/common");
-const ioredis_1 = require("ioredis");
 const redis_constant_1 = require("./redis.constant");
 let RedisService = class RedisService {
-    constructor(redis) {
-        this.redis = redis;
+    constructor(clients) {
+        this.clients = clients;
     }
-    // Raw helpers
-    get(key) {
-        return this.redis.get(key);
+    pick(name = "main") {
+        const client = this.clients[name];
+        if (!client) {
+            const available = Object.keys(this.clients).join(", ");
+            throw new Error(`[redis] client "${name}" not found. Available: ${available}`);
+        }
+        return client;
+    }
+    // -------------------- RAW --------------------
+    get(key, clientName = "main") {
+        return this.pick(clientName).get(key);
     }
-    del(key) {
-        return this.redis.del(key);
+    del(key, clientName = "main") {
+        return this.pick(clientName).del(key);
     }
-    exists(key) {
-        return this.redis.exists(key);
+    exists(key, clientName = "main") {
+        return this.pick(clientName).exists(key);
     }
-    // JSON helpers (most common use)
-    async getJson(key) {
-        const val = await this.redis.get(key);
+    client(clientName = "main") {
+        return this.pick(clientName);
+    }
+    // -------------------- JSON --------------------
+    async getJson(key, clientName = "main") {
+        const val = await this.pick(clientName).get(key);
         if (!val)
             return null;
         try {
@@ -42,31 +52,36 @@ let RedisService = class RedisService {
             return null;
         }
     }
-    async setJson(key, value, ttlSeconds) {
+    async setJson(key, value, ttlSeconds, clientName = "main") {
         const payload = JSON.stringify(value);
-        if (ttlSeconds && ttlSeconds > 0) {
-            return this.redis.set(key, payload, "EX", ttlSeconds);
-        }
-        return this.redis.set(key, payload);
+        const c = this.pick(clientName);
+        if (ttlSeconds && ttlSeconds > 0)
+            return c.set(key, payload, "EX", ttlSeconds);
+        return c.set(key, payload);
     }
-    // Optional: if you need access to ioredis commands directly
-    client() {
-        return this.redis;
+    // Backward-compat convenience (optional)
+    async getGeoJson(key) {
+        return this.getJson(key, "geo");
+    }
+    async setGeoJson(key, value, ttlSeconds) {
+        return this.setJson(key, value, ttlSeconds, "geo");
     }
     async onModuleDestroy() {
-        // Graceful shutdown
-        try {
-            await this.redis.quit();
-        }
-        catch {
-            // fallback
-            this.redis.disconnect();
+        // Graceful shutdown for ALL clients
+        const list = Object.values(this.clients);
+        for (const c of list) {
+            try {
+                await c.quit();
+            }
+            catch {
+                c.disconnect();
+            }
         }
     }
 };
 exports.RedisService = RedisService;
 exports.RedisService = RedisService = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(redis_constant_1.REDIS_CLIENT)),
-    __metadata("design:paramtypes", [ioredis_1.Redis])
+    __param(0, (0, common_1.Inject)(redis_constant_1.REDIS_CLIENTS)),
+    __metadata("design:paramtypes", [Object])
 ], RedisService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plac-micro-common",
-  "version": "1.1.13",
+  "version": "1.2.0",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "scripts": {