joye-backend-utility 7.3.6-beta.1 → 7.3.6-beta.2

package/dist/redisClient.d.ts

@@ -1,8 +1,15 @@
 import { createClient, createCluster } from 'redis';
-/** Connected standalone client or cluster client (commands used by callers are supported on both). */
+/**
+ * Standalone or `node-redis` cluster client. Cluster mode uses `createCluster` + `nodeAddressMap` so slot
+ * topology (internal IPs from MOVED / CLUSTER SLOTS) maps to the Azure TLS hostname — avoids ioredis
+ * MOVED + `natMap` slot-key mismatch that caused “Too many Cluster redirections”.
+ */
 export declare type RedisConnection = Awaited<ReturnType<ReturnType<typeof createClient>['connect']>> | ReturnType<typeof createCluster>;
 declare class RedisClient {
     private static instance;
+    /** Ensures concurrent `getInstance()` share one in-flight connect (avoids duplicate clients / flaky MOVED). */
+    private static initPromise;
+    private static createConnection;
     static getInstance(): Promise<RedisConnection>;
 }
 export { RedisClient };

package/dist/redisClient.js

@@ -2,49 +2,107 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = void 0;
 const redis_1 = require("redis");
+function trimEnv(value) {
+    if (value === undefined)
+        return undefined;
+    let t = value.trim();
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        t = t.slice(1, -1).trim();
+    }
+    return t;
+}
+function envBool(value, defaultValue) {
+    var _a;
+    const v = (_a = trimEnv(value)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (v === undefined || v === '')
+        return defaultValue;
+    if (v === 'true' || v === '1' || v === 'yes')
+        return true;
+    if (v === 'false' || v === '0' || v === 'no')
+        return false;
+    return defaultValue;
+}
+/**
+ * Azure Managed Redis (ACL): default user is `default`.
+ * Set `REDIS_CACHE_USERNAME=none` (or empty after trim) to omit username for legacy password-only caches.
+ */
+function redisUsername() {
+    const raw = process.env.REDIS_CACHE_USERNAME;
+    if (raw === undefined)
+        return 'default';
+    const t = trimEnv(raw);
+    if (t === '' || t.toLowerCase() === 'none')
+        return undefined;
+    return t;
+}
+function mapClusterAddressToPublicEndpoint(address, publicHost, fallbackPort) {
+    const idx = address.lastIndexOf(':');
+    if (idx === -1)
+        return { host: publicHost, port: fallbackPort };
+    const p = Number.parseInt(address.slice(idx + 1), 10);
+    return Number.isNaN(p) ? { host: publicHost, port: fallbackPort } : { host: publicHost, port: p };
+}
 class RedisClient {
+    static async createConnection() {
+        const cachePortRaw = trimEnv(process.env.REDIS_CACHE_PORT);
+        const cacheHostName = trimEnv(process.env.REDIS_CACHE_HOST);
+        const cachePassword = trimEnv(process.env.REDIS_CACHE_PASSWORD);
+        const cachePort = cachePortRaw ? Number.parseInt(cachePortRaw, 10) : Number.NaN;
+        const username = redisUsername();
+        const useCluster = envBool(process.env.REDIS_CACHE_CLUSTER, false);
+        const unifiedClusterEndpoint = useCluster && envBool(process.env.REDIS_CACHE_CLUSTER_UNIFIED_ENDPOINT, true);
+        if (!cacheHostName || Number.isNaN(cachePort)) {
+            throw new Error('RedisClient: REDIS_CACHE_HOST and a numeric REDIS_CACHE_PORT are required');
+        }
+        const tlsSocket = {
+            tls: true,
+            servername: cacheHostName,
+        };
+        const standaloneSocket = Object.assign({ host: cacheHostName, port: cachePort }, tlsSocket);
+        const authOptions = Object.assign(Object.assign({}, (username !== undefined ? { username } : {})), (cachePassword !== undefined ? { password: cachePassword } : {}));
+        if (useCluster) {
+            console.log('RedisClient: CLUSTER mode (node-redis createCluster), unifiedEndpoint=%s, maxCommandRedirections=64', String(unifiedClusterEndpoint));
+            const clusterRoot = Object.assign({ socket: standaloneSocket }, authOptions);
+            const cluster = (0, redis_1.createCluster)(Object.assign({ rootNodes: [clusterRoot], defaults: Object.assign(Object.assign({}, authOptions), { socket: tlsSocket }), maxCommandRedirections: 64 }, (unifiedClusterEndpoint
+                ? {
+                    nodeAddressMap: (address) => mapClusterAddressToPublicEndpoint(address, cacheHostName, cachePort),
+                }
+                : {})))
+                .on('error', err => {
+                console.log('Redis Client Error', err);
+            })
+                .on('connect', () => {
+                console.log('Connected to Redis');
+            })
+                .on('end', () => {
+                console.log('Connection to Redis end');
+            });
+            await cluster.connect();
+            return cluster;
+        }
+        console.log('RedisClient: STANDALONE mode (node-redis createClient) — not for OSS cluster endpoints (MOVED).');
+        const client = (0, redis_1.createClient)(Object.assign({ socket: standaloneSocket }, authOptions))
+            .on('error', err => {
+            console.log('Redis Client Error', err);
+        })
+            .on('connect', () => {
+            console.log('Connected to Redis');
+        })
+            .on('end', () => {
+            console.log('Connection to Redis end');
+        });
+        return await client.connect();
+    }
     static async getInstance() {
         if (!RedisClient.instance) {
-            const cachePort = process.env.REDIS_CACHE_PORT;
-            const cacheHostName = process.env.REDIS_CACHE_HOST;
-            const cachePassword = process.env.REDIS_CACHE_PASSWORD;
-            const url = `rediss://${cacheHostName}:${cachePort}`;
-            const useCluster = process.env.REDIS_CACHE_CLUSTER === 'true';
-            const clientOptions = {
-                url,
-                password: cachePassword,
-            };
-            if (useCluster) {
-                const cluster = (0, redis_1.createCluster)({
-                    rootNodes: [clientOptions],
-                    defaults: {
-                        password: cachePassword,
-                    },
-                })
-                    .on('error', err => {
-                    console.log('Redis Client Error', err);
-                })
-                    .on('connect', () => {
-                    console.log('Connected to Redis');
-                })
-                    .on('end', () => {
-                    console.log('Connection to Redis end');
-                });
-                await cluster.connect();
-                RedisClient.instance = cluster;
+            if (!RedisClient.initPromise) {
+                RedisClient.initPromise = RedisClient.createConnection();
+            }
+            try {
+                RedisClient.instance = await RedisClient.initPromise;
             }
-            else {
-                const client = (0, redis_1.createClient)(clientOptions)
-                    .on('error', err => {
-                    console.log('Redis Client Error', err);
-                })
-                    .on('connect', () => {
-                    console.log('Connected to Redis');
-                })
-                    .on('end', () => {
-                    console.log('Connection to Redis end');
-                });
-                RedisClient.instance = await client.connect();
+            finally {
+                RedisClient.initPromise = null;
             }
         }
         if (!RedisClient.instance.isOpen) {
@@ -55,3 +113,5 @@ class RedisClient {
 }
 exports.RedisClient = RedisClient;
 RedisClient.instance = null;
+/** Ensures concurrent `getInstance()` share one in-flight connect (avoids duplicate clients / flaky MOVED). */
+RedisClient.initPromise = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joye-backend-utility",
-  "version": "7.3.6-beta.1",
+  "version": "7.3.6-beta.2",
   "description": "Joye backend utility for db functions and common functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",