@bikdotai/bik-shared-backend 20.3.1 → 20.3.2-beta.1

package/lib/redis/redisPubSubService.js

@@ -15,10 +15,99 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisPubSubService = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
 const auth_1 = require("../auth");
+// One publisher + one subscriber shared across ALL RedisPubSubService instances.
+// This ensures the entire process uses exactly 2 pub/sub connections regardless
+// of how many channels are subscribed to.
+let sharedPublisher = null;
+let sharedSubscriber = null;
+let shutdownRegistered = false;
+// Stored so closeAll() can remove the handlers and avoid accumulation across
+// closeAll() + reinit cycles (e.g. in tests).
+let signalHandler = null;
+// Registry mapping channel name → message callback for all active subscriptions.
+// A single 'message' listener on sharedSubscriber dispatches via this map,
+// avoiding MaxListenersExceededWarning when many channels are subscribed.
+const channelCallbacks = new Map();
+// Guards registration of the shared 'ready' and 'message' listeners so they
+// are added to sharedSubscriber exactly once regardless of how many instances
+// call subscribe().
+let sharedListenersRegistered = false;
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 200;
+// Single authoritative predicate for transient Redis errors, used by both the
+// client error handler and retryWithBackoff — no duplicate classification logic.
+function isTransientError(err) {
+    const code = err === null || err === void 0 ? void 0 : err.code;
+    const name = err === null || err === void 0 ? void 0 : err.name;
+    const message = err === null || err === void 0 ? void 0 : err.message;
+    const transientCodes = new Set([
+        'ECONNRESET',
+        'ETIMEDOUT',
+        'EHOSTUNREACH',
+        'ENETUNREACH',
+        'ECONNREFUSED',
+        'NR_CLOSED',
+        'EPIPE',
+    ]);
+    if (name === 'TimeoutError')
+        return true;
+    if (code && transientCodes.has(code))
+        return true;
+    if (message) {
+        return [
+            /connection is closed/i,
+            /socket closed/i,
+            /not yet established/i,
+            /still connecting/i,
+            /Ready check failed/i,
+        ].some((r) => r.test(message));
+    }
+    return false;
+}
+function createRedisClient(opts) {
+    var _a, _b, _c;
+    const client = new ioredis_1.default({
+        host: opts.host,
+        password: opts.password,
+        port: opts.port,
+        keepAlive: 30000,
+        lazyConnect: (_a = opts.lazyConnect) !== null && _a !== void 0 ? _a : false,
+        autoResubscribe: (_b = opts.autoResubscribe) !== null && _b !== void 0 ? _b : true,
+        enableReadyCheck: (_c = opts.enableReadyCheck) !== null && _c !== void 0 ? _c : true,
+    });
+    client.on('error', (err) => {
+        if (isTransientError(err))
+            return;
+        console.error('RedisPubSubService client error:', err);
+    });
+    return client;
+}
+// Module-level so the shared 'ready' listener (registered once) can call it
+// without requiring a class instance reference.
+function retryWithBackoff(fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let attempt = 0;
+        let lastError;
+        while (attempt <= MAX_RETRIES) {
+            try {
+                return yield fn();
+            }
+            catch (err) {
+                lastError = err;
+                if (!isTransientError(err) || attempt === MAX_RETRIES) {
+                    throw err;
+                }
+                const delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt), 2000);
+                yield new Promise((res) => setTimeout(res, delay));
+                attempt++;
+            }
+        }
+        throw lastError;
+    });
+}
 class RedisPubSubService {
     constructor(config) {
-        this.maxRetries = 3;
-        this.baseDelayMs = 200;
+        this.subscribed = false;
         const host = auth_1.EnvVariableHelper.access(auth_1.ServiceName.REDIS, auth_1.RedisKeys.HOST, 'REDIS_HOST') || 'localhost';
         const portStr = auth_1.EnvVariableHelper.access(auth_1.ServiceName.REDIS, auth_1.RedisKeys.PORT, 'REDIS_PORT');
         const port = portStr ? parseInt(portStr) : 6379;
@@ -27,114 +116,60 @@ class RedisPubSubService {
         if (!host || !password) {
             throw new Error('Missing environment variables for Redis Cloud from bik-shared-backend');
         }
-        this.publisher = new ioredis_1.default({ host, password, port });
-        // autoResubscribe: false — we re-subscribe manually in the 'ready' handler,
-        // so ioredis's built-in re-subscribe doesn't double-up and cause the
-        // "Connection in subscriber mode" error on reconnect.
-        // enableReadyCheck: false — avoids the INFO ready-check command racing with
-        // our SUBSCRIBE and producing the same "subscriber mode" error.
-        this.subscriber = new ioredis_1.default({
-            host,
-            password,
-            port,
-            autoResubscribe: false,
-            enableReadyCheck: false,
-        });
-        const isTransient = (err) => {
-            const code = err === null || err === void 0 ? void 0 : err.code;
-            const name = err === null || err === void 0 ? void 0 : err.name;
-            const message = err === null || err === void 0 ? void 0 : err.message;
-            const transientCodes = new Set([
-                'ECONNRESET',
-                'ETIMEDOUT',
-                'EHOSTUNREACH',
-                'ENETUNREACH',
-                'ECONNREFUSED',
-                'NR_CLOSED',
-                'EPIPE',
-            ]);
-            if (name === 'TimeoutError')
-                return true;
-            if (code && transientCodes.has(code))
-                return true;
-            if (message) {
-                return [
-                    /connection is closed/i,
-                    /socket closed/i,
-                    /not yet established/i,
-                    /still connecting/i,
-                    /Ready check failed/i,
-                ].some((r) => r.test(message));
-            }
-            return false;
-        };
-        this.publisher.on('error', (err) => {
-            if (isTransient(err))
-                return; // suppress transient errors
-            console.error('Redis publisher error:', err);
-        });
-        this.subscriber.on('error', (err) => {
-            if (isTransient(err))
-                return; // suppress transient errors
-            console.error('Redis subscriber error:', err);
-        });
-    }
-    isRetriableRedisError(error) {
-        const code = error === null || error === void 0 ? void 0 : error.code;
-        const name = error === null || error === void 0 ? void 0 : error.name;
-        const message = error === null || error === void 0 ? void 0 : error.message;
-        const transientCodes = new Set([
-            'ECONNRESET',
-            'ETIMEDOUT',
-            'EHOSTUNREACH',
-            'ENETUNREACH',
-            'ECONNREFUSED',
-            'NR_CLOSED',
-            'EPIPE',
-        ]);
-        if (name === 'TimeoutError')
-            return true;
-        if (code && transientCodes.has(code))
-            return true;
-        if (message) {
-            const patterns = [
-                /connection is closed/i,
-                /socket closed/i,
-                /The connection is not yet established/i,
-                /ioredis is still connecting/i,
-                /Ready check failed/i,
-            ];
-            if (patterns.some((re) => re.test(message)))
-                return true;
+        // Initialise shared clients once per process.
+        if (!sharedPublisher) {
+            // lazyConnect: true — publisher only opens a connection when publish() is
+            // first called, saving a connection on pods that only subscribe.
+            sharedPublisher = createRedisClient({ host, password, port, lazyConnect: true });
         }
-        return false;
-    }
-    retryWithBackoff(fn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let attempt = 0;
-            let lastError;
-            while (attempt <= this.maxRetries) {
+        if (!sharedSubscriber) {
+            // autoResubscribe: false — we re-subscribe manually in the 'ready' handler
+            // so ioredis's built-in re-subscribe doesn't double-up and cause the
+            // "Connection in subscriber mode" error on reconnect.
+            // enableReadyCheck: false — avoids the INFO ready-check command racing with
+            // SUBSCRIBE on reconnect.
+            sharedSubscriber = createRedisClient({
+                host,
+                password,
+                port,
+                autoResubscribe: false,
+                enableReadyCheck: false,
+            });
+        }
+        // Register SIGTERM/SIGINT cleanup once per process. This handler closes the
+        // shared Redis connections gracefully. process.exit() is intentionally NOT
+        // called here — that responsibility belongs to the host service (e.g. via
+        // Fastify server.close() in main.ts) so it can drain HTTP and perform its
+        // own cleanup before exiting.
+        // signalHandler is stored so closeAll() can remove it via process.off(),
+        // preventing handler accumulation across closeAll() + reinit cycles.
+        if (!shutdownRegistered) {
+            shutdownRegistered = true;
+            signalHandler = () => __awaiter(this, void 0, void 0, function* () {
+                console.log('[RedisPubSubService] Signal received — closing shared Redis pub/sub connections');
                 try {
-                    return yield fn();
+                    yield Promise.all([sharedPublisher === null || sharedPublisher === void 0 ? void 0 : sharedPublisher.quit(), sharedSubscriber === null || sharedSubscriber === void 0 ? void 0 : sharedSubscriber.quit()]);
+                    console.log('[RedisPubSubService] Redis pub/sub connections closed successfully');
                 }
                 catch (err) {
-                    lastError = err;
-                    if (!this.isRetriableRedisError(err) || attempt === this.maxRetries) {
-                        throw err;
-                    }
-                    const delay = Math.min(this.baseDelayMs * Math.pow(2, attempt), 2000);
-                    yield new Promise((res) => setTimeout(res, delay));
-                    attempt++;
+                    console.warn('[RedisPubSubService] Error closing pub/sub connections:', err);
                 }
-            }
-            throw lastError;
-        });
+            });
+            process.on('SIGTERM', signalHandler);
+            process.on('SIGINT', signalHandler);
+        }
+    }
+    get publisher() {
+        return sharedPublisher;
+    }
+    get subscriber() {
+        return sharedSubscriber;
     }
     publish(data) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const payload = JSON.stringify(data);
-                yield this.retryWithBackoff(() => this.publisher.publish(this.channel, payload));
+                yield retryWithBackoff(() => this.publisher.publish(this.channel, payload));
                 console.log(`Published to ${this.channel}:`, data);
             }
             catch (error) {
@@ -143,39 +178,92 @@ class RedisPubSubService {
         });
     }
     subscribe(callback) {
-        const doSubscribe = () => {
-            this.retryWithBackoff(() => this.subscriber.subscribe(this.channel))
-                .then(() => console.log(`Subscribed to channel: ${this.channel}`))
-                .catch((err) => console.error('Redis subscription failed:', err));
-        };
-        // 'ready' fires after AUTH + SELECT (and INFO if enableReadyCheck is on),
-        // so it's safe to send SUBSCRIBE here without conflicting with ioredis internals.
-        // It also fires on every reconnect, handling re-subscription since
-        // autoResubscribe is disabled.
-        this.subscriber.on('ready', () => {
-            console.log(`Redis Subscriber ready on channel "${this.channel}"`);
-            doSubscribe();
-        });
+        if (this.subscribed) {
+            console.warn(`RedisPubSubService: already subscribed to channel "${this.channel}", ignoring duplicate call.`);
+            return;
+        }
+        this.subscribed = true;
+        // Register the callback before attaching listeners so the 'ready' handler
+        // sees this channel immediately on the first connect.
+        channelCallbacks.set(this.channel, callback);
+        if (!sharedListenersRegistered) {
+            sharedListenersRegistered = true;
+            // Single 'ready' listener re-subscribes ALL registered channels on every
+            // connect/reconnect. autoResubscribe is disabled so we own this entirely.
+            // 'ready' fires after AUTH + SELECT, safe to send SUBSCRIBE here.
+            sharedSubscriber.on('ready', () => {
+                const channels = Array.from(channelCallbacks.keys());
+                if (channels.length === 0)
+                    return;
+                console.log(`[RedisPubSubService] Subscriber ready — resubscribing to: ${channels.join(', ')}`);
+                retryWithBackoff(() => sharedSubscriber.subscribe(...channels))
+                    .then(() => console.log(`[RedisPubSubService] Subscribed to: ${channels.join(', ')}`))
+                    .catch((err) => console.error('[RedisPubSubService] Subscription failed:', err));
+            });
+            // Single 'message' listener dispatches to the correct per-channel callback
+            // via the registry. This replaces per-instance listeners and prevents
+            // MaxListenersExceededWarning regardless of how many channels are active.
+            sharedSubscriber.on('message', (incomingChannel, message) => {
+                const cb = channelCallbacks.get(incomingChannel);
+                if (!cb)
+                    return;
+                try {
+                    const parsed = JSON.parse(message);
+                    console.log(`Message received on ${incomingChannel}:`, parsed);
+                    cb(parsed);
+                }
+                catch (e) {
+                    console.error(`[RedisPubSubService] Error parsing message on ${incomingChannel}:`, e);
+                }
+            });
+        }
         // Handle the case where the connection is already established before
         // subscribe() is called (e.g. delayed initialization).
         if (this.subscriber.status === 'ready') {
-            doSubscribe();
+            retryWithBackoff(() => this.subscriber.subscribe(this.channel))
+                .then(() => console.log(`[RedisPubSubService] Subscribed to channel: ${this.channel}`))
+                .catch((err) => console.error('[RedisPubSubService] Subscription failed:', err));
         }
-        this.subscriber.on('message', (_channel, message) => {
+    }
+    // Unsubscribes this instance's channel and removes its callback from the
+    // shared registry. The shared publisher/subscriber remain open for other
+    // active channels and are closed on SIGTERM or via closeAll().
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.subscribed)
+                return;
+            this.subscribed = false;
+            channelCallbacks.delete(this.channel);
             try {
-                const parsed = JSON.parse(message);
-                console.log(`Message received on ${this.channel}:`, parsed);
-                callback(parsed);
+                yield (sharedSubscriber === null || sharedSubscriber === void 0 ? void 0 : sharedSubscriber.unsubscribe(this.channel));
             }
-            catch (e) {
-                console.error('Error parsing message:', e);
+            catch (err) {
+                console.warn(`[RedisPubSubService] Error unsubscribing from ${this.channel}:`, err);
             }
         });
     }
-    close() {
+    // Closes both shared connections and resets all module-level state including
+    // signal handler registration. Intended for tests and explicit full teardown;
+    // in production the SIGTERM handler handles shutdown automatically.
+    static closeAll() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([this.publisher.quit(), this.subscriber.quit()]);
-            console.log('Redis connections closed.');
+            try {
+                yield Promise.all([sharedPublisher === null || sharedPublisher === void 0 ? void 0 : sharedPublisher.quit(), sharedSubscriber === null || sharedSubscriber === void 0 ? void 0 : sharedSubscriber.quit()]);
+                sharedPublisher = null;
+                sharedSubscriber = null;
+                channelCallbacks.clear();
+                sharedListenersRegistered = false;
+                if (signalHandler) {
+                    process.off('SIGTERM', signalHandler);
+                    process.off('SIGINT', signalHandler);
+                    signalHandler = null;
+                }
+                shutdownRegistered = false;
+                console.log('[RedisPubSubService] All Redis pub/sub connections closed.');
+            }
+            catch (err) {
+                console.warn('[RedisPubSubService] Error closing Redis pub/sub connections:', err);
+            }
         });
     }
 }

package/lib/redis/redisService.js

@@ -46,12 +46,13 @@ class RedisAppService {
                 host: redisHost,
                 password: redisKey,
                 port: redisPort ? Number(redisPort) : 6379,
-                keepAlive: 1,
+                keepAlive: 30000,
                 maxRetriesPerRequest: null,
                 enableReadyCheck: false,
                 connectionName: logger_1.LOGGING_CONFIGURATION.serviceName,
                 connectTimeout: 5000,
                 commandTimeout: 5000,
+                disconnectTimeout: 10000,
                 reconnectOnError: (err) => {
                     if (err.code === 'ECONNREFUSED') {
                         console.error('REDIS QUOTA LIKELY EXCEEDED - Check Redis Labs dashboard', err);
@@ -138,7 +139,7 @@ class RedisAppService {
         return __awaiter(this, void 0, void 0, function* () {
             let attempt = 0;
             let lastError;
-            while (attempt < this.maxRetries) {
+            while (attempt <= this.maxRetries) {
                 try {
                     return yield fn();
                 }
@@ -565,15 +566,20 @@ class RedisAppService {
 exports.RedisAppService = RedisAppService;
 // Dangerous - this will impact any service that bik shared is injected with.
 const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log('[RedisAppService] SIGTERM received — closing Redis connection');
     if (!RedisAppService.getInstance().getClient()) {
+        console.log('[RedisAppService] No client found, skipping');
         return;
     }
-    // console.log(
-    //   '@bik-shared (redisService.ts) Received SIGTERM - closing Redis connection and shutting down gracefully.'
-    // );
-    // Close the Redis connection
-    yield RedisAppService.getInstance().gracefulShutdown();
+    try {
+        yield RedisAppService.getInstance().gracefulShutdown();
+        console.log('[RedisAppService] Redis connection closed successfully');
+    }
+    catch (err) {
+        console.warn('[RedisAppService] Error closing Redis connection:', err);
+    }
 });
 // Register the cleanup function for SIGTERM signal
 process.on('SIGTERM', cleanup);
-process.on('exit', cleanup);
+// Also handle SIGINT (Ctrl+C / local dev)
+process.on('SIGINT', cleanup);

package/lib/swagger/SwaggerSchemaHelper.js

@@ -52,7 +52,11 @@ class SwaggerSchemaHelper {
             }
         });
         // Convert camelCase or kebab-case to human-readable format
-        return prefix.charAt(0).toUpperCase() + prefix.slice(1).replace(/([A-Z])/g, ' $1').trim();
+        return (prefix.charAt(0).toUpperCase() +
+            prefix
+                .slice(1)
+                .replace(/([A-Z])/g, ' $1')
+                .trim());
     }
     static loadSwaggerConfig(apiPath) {
         try {
@@ -90,10 +94,10 @@ class SwaggerSchemaHelper {
             security: [
                 {
                     Authorization: [],
-                    bikReferer: []
-                }
+                    bikReferer: [],
+                },
             ],
-            'x-timeout': existingSchema === null || existingSchema === void 0 ? void 0 : existingSchema['x-timeout']
+            'x-timeout': existingSchema === null || existingSchema === void 0 ? void 0 : existingSchema['x-timeout'],
         };
         if (swaggerConfig['x-timeout']) {
             swaggerConfig.description += `\n\n**Timeout:** ${swaggerConfig['x-timeout']} seconds`;
@@ -103,23 +107,23 @@ class SwaggerSchemaHelper {
             acc[example.summary] = { value: example.value };
             return acc;
         }, {});
-        swaggerConfig["responses"] = {
-            "200": {
-                "description": "Default Response"
+        swaggerConfig['responses'] = {
+            '200': {
+                description: 'Default Response',
             },
-            "503": {
-                "description": `Request Timeout - Operation exceeded ${swaggerConfig['x-timeout'] || 'configured'} seconds`
+            '408': {
+                description: `Request Timeout - Operation exceeded ${swaggerConfig['x-timeout'] || 'configured'} seconds`,
             },
         };
-        swaggerConfig["requestBody"] = {
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "type": "object"
+        swaggerConfig['requestBody'] = {
+            content: {
+                'application/json': {
+                    schema: {
+                        type: 'object',
                     },
-                    "examples": flattenedExamples
-                }
-            }
+                    examples: flattenedExamples,
+                },
+            },
         };
         return swaggerConfig;
     }

package/lib/user-properties/userProperties.service.js

@@ -111,6 +111,7 @@ class BikUserPropertiesService {
                     return;
                 }
                 const userPropertiesPayload = userPropertiesHelper.constructUserProperties(currObj, (customerTagsMap === null || customerTagsMap === void 0 ? void 0 : customerTagsMap[currObj.customerId.toString()]) || [], undefined, currObj.tagsToRemove);
+                console.log('Final userPropertiesPayload:', JSON.stringify(userPropertiesPayload === null || userPropertiesPayload === void 0 ? void 0 : userPropertiesPayload.data, null, 2));
                 const isUatStore = (0, events_1.getUatStoreIds)().includes(currObj.storeId || storeId || '');
                 const upTopic = isUatStore ? 'trackUserProperty-uat' : 'trackUserProperty';
                 return (0, pubsub_listener_1.publishMessageToTopic)(upTopic, userPropertiesPayload === null || userPropertiesPayload === void 0 ? void 0 : userPropertiesPayload.data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bikdotai/bik-shared-backend",
-  "version": "20.3.1",
+  "version": "20.3.2-beta.1",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@amplitude/identify": "^1.10.0",
     "@amplitude/node": "^1.10.0",
-    "@bikdotai/bik-models": "^11.6.1",
+    "@bikdotai/bik-models": "11.6.2-beta.0",
     "@elastic/elasticsearch": "^8.7.0",
     "@fastify/cookie": "^9.4.0",
     "@fastify/cors": "^9.0.1",