dt-common-device 13.0.16 → 13.0.17

package/dist/config/config.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -308,5 +341,13 @@ async function shutdown() {
             getConfig().LOGGER.error("Failed to stop event subscription", { error });
         }
     }
+    // Close notification queue connections
+    try {
+        const { closeNotificationQueue } = await Promise.resolve().then(() => __importStar(require("../notificationQueue/queue.service")));
+        await closeNotificationQueue();
+    }
+    catch (error) {
+        getConfig().LOGGER.error("Failed to close notification queue", { error });
+    }
     getConfig().LOGGER.info("dt-common-device: Shutdown completed");
 }

package/dist/index.js

@@ -65,5 +65,5 @@ __exportStar(require("./webhookQueue"), exports);
 __exportStar(require("./copilotQueue"), exports);
 //Export Service Queue
 __exportStar(require("./serviceQueue"), exports);
-// Export Notification Queue (Redis pub/sub for notifications)
+// Export Notification Queue (BullMQ for guaranteed delivery)
 __exportStar(require("./notificationQueue"), exports);

package/dist/notificationQueue/index.d.ts

@@ -1 +1,2 @@
 export * from "./queue.service";
+export * from "./interfaces";

package/dist/notificationQueue/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./queue.service"), exports);
+__exportStar(require("./interfaces"), exports);

package/dist/notificationQueue/interfaces/INotificationQueue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Payload structure for notification queue events
+ */
+export interface INotificationQueuePayload {
+    userId: string;
+    orgId?: string;
+    propertyId?: string;
+    data?: any;
+    title?: string;
+    message?: string;
+    url?: string;
+}

package/dist/notificationQueue/interfaces/INotificationQueue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/notificationQueue/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from "./INotificationQueue";

package/dist/notificationQueue/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./INotificationQueue"), exports);

package/dist/notificationQueue/queue.service.d.ts

@@ -1,21 +1,18 @@
-export interface NotificationQueuePayload {
-    userId: string;
-    orgId?: string;
-    propertyId?: string;
-    data?: any;
-    title?: string;
-    message?: string;
-    url?: string;
-}
-export interface NotificationQueueOptions {
-    channel?: string;
-}
+import { INotificationQueuePayload } from "./interfaces";
 /**
- * Publish an event payload to Redis so any interested consumer can process it.
+ * Enqueue an event payload to BullMQ queue for guaranteed delivery.
+ * Jobs are processed in parallel across different userIds but maintain FIFO order per userId.
+ * This replaces the previous Redis pub/sub implementation.
  */
-export declare function enqueueEvent(event: NotificationQueuePayload, opts?: NotificationQueueOptions): Promise<void>;
+export declare function enqueueEvent(event: INotificationQueuePayload): Promise<void>;
 /**
- * Start a single pub/sub consumer in this process.
+ * Start a BullMQ worker to process notification events.
+ * Jobs are processed in parallel across different userIds but maintain FIFO order per userId.
  * The `handler` is responsible for business logic (e.g. calling processEvent()).
+ * This replaces the previous Redis pub/sub consumer implementation.
  */
-export declare function startConsumer(handler: (payload: NotificationQueuePayload) => Promise<void>, opts?: NotificationQueueOptions): Promise<void>;
+export declare function startConsumer(handler: (payload: INotificationQueuePayload) => Promise<void>): Promise<void>;
+/**
+ * Gracefully close the worker and queue connections
+ */
+export declare function closeNotificationQueue(): Promise<void>;

package/dist/notificationQueue/queue.service.js

@@ -1,96 +1,192 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enqueueEvent = enqueueEvent;
 exports.startConsumer = startConsumer;
-const redis_1 = require("../db/redis");
-const DEFAULT_CHANNEL = "notification:events";
-let consumerStarted = false;
+exports.closeNotificationQueue = closeNotificationQueue;
+const bullmq_1 = require("bullmq");
+const config_1 = require("../config/config");
+const ioredis_1 = __importDefault(require("ioredis"));
+const QUEUE_NAME = "notification:events";
+// Singleton instances
+let notificationQueue = null;
+let notificationWorker = null;
+let queueEvents = null;
+let redisConnection = null;
+// Track active jobs per userId to maintain FIFO order per user
+// while allowing parallel processing across different users
+const activeJobsPerUser = new Map();
 /**
- * Publish an event payload to Redis so any interested consumer can process it.
+ * Get or create Redis connection for BullMQ
  */
-async function enqueueEvent(event, opts) {
-    const client = (0, redis_1.getRedisClient)();
-    const channel = opts?.channel ?? DEFAULT_CHANNEL;
-    try {
-        await client.publish(channel, JSON.stringify(event));
-    }
-    catch (error) {
-        // eslint-disable-next-line no-console
-        console.error("Failed to publish notification event", {
-            error,
-            channel,
-            event,
+function getRedisConnection() {
+    if (!redisConnection) {
+        const { host, port } = (0, config_1.getRedisDbHostAndPort)();
+        redisConnection = new ioredis_1.default({
+            host,
+            port,
+            maxRetriesPerRequest: null,
+            enableReadyCheck: false,
+        });
+        redisConnection.on("error", (error) => {
+            (0, config_1.getConfig)().LOGGER.error("Redis connection error for BullMQ", { error });
+        });
+        redisConnection.on("connect", () => {
+            (0, config_1.getConfig)().LOGGER.info("Redis connected for BullMQ");
         });
     }
+    return redisConnection;
 }
 /**
- * Start a single pub/sub consumer in this process.
- * The `handler` is responsible for business logic (e.g. calling processEvent()).
+ * Get or create the notification queue instance
  */
-async function startConsumer(handler, opts) {
-    if (consumerStarted) {
-        // eslint-disable-next-line no-console
-        console.warn("NotificationQueue consumer already started; skipping");
-        return;
+function getQueue() {
+    if (!notificationQueue) {
+        const connection = getRedisConnection();
+        notificationQueue = new bullmq_1.Queue(QUEUE_NAME, {
+            connection,
+            defaultJobOptions: {
+                backoff: {
+                    type: "exponential",
+                    delay: 2000,
+                },
+                removeOnComplete: { age: 5 * 60 }, // Keep completed jobs for 5 minutes
+                removeOnFail: { age: 5 * 60 }, // Remove failed jobs after 5 minutes
+                attempts: 1, // Only try once
+            },
+        });
+        // Set up queue event listeners for monitoring
+        queueEvents = new bullmq_1.QueueEvents(QUEUE_NAME, { connection });
+        queueEvents.on("completed", ({ jobId }) => {
+            (0, config_1.getConfig)().LOGGER.info(`Notification job ${jobId} completed`);
+        });
+        queueEvents.on("failed", ({ jobId, failedReason }) => {
+            (0, config_1.getConfig)().LOGGER.error(`Notification job ${jobId} failed`, {
+                failedReason,
+            });
+        });
     }
-    consumerStarted = true;
-    const baseClient = (0, redis_1.getRedisClient)();
-    const subscriber = baseClient.duplicate();
-    const channel = opts?.channel ?? DEFAULT_CHANNEL;
+    return notificationQueue;
+}
+/**
+ * Enqueue an event payload to BullMQ queue for guaranteed delivery.
+ * Jobs are processed in parallel across different userIds but maintain FIFO order per userId.
+ * This replaces the previous Redis pub/sub implementation.
+ */
+async function enqueueEvent(event) {
+    const queue = getQueue();
     try {
-        await subscriber.connect();
+        // Use userId as part of jobId to ensure proper ordering per user
+        await queue.add("notification-event", event, {
+            jobId: `${event.userId}-${Date.now()}-${Math.random()
+                .toString(36)
+                .substr(2, 9)}`,
+        });
+        (0, config_1.getConfig)().LOGGER.info("Notification event enqueued successfully", {
+            userId: event.userId,
+        });
     }
     catch (error) {
-        // eslint-disable-next-line no-console
-        console.error("Failed to connect Redis subscriber for notifications", {
+        (0, config_1.getConfig)().LOGGER.error("Failed to enqueue notification event", {
             error,
+            event,
         });
+        throw error;
+    }
+}
+/**
+ * Start a BullMQ worker to process notification events.
+ * Jobs are processed in parallel across different userIds but maintain FIFO order per userId.
+ * The `handler` is responsible for business logic (e.g. calling processEvent()).
+ * This replaces the previous Redis pub/sub consumer implementation.
+ */
+async function startConsumer(handler) {
+    if (notificationWorker) {
         return;
     }
-    subscriber.on("error", (error) => {
-        // eslint-disable-next-line no-console
-        console.error("Redis notification subscriber error", { error });
-    });
+    const connection = getRedisConnection();
     try {
-        // ioredis `subscribe` expects an (err, count) callback, not a message handler.
-        // We subscribe first, then attach a separate "message" listener.
-        await subscriber.subscribe(channel);
-        subscriber.on("message", async (subscribedChannel, message) => {
-            // Only process messages for the intended channel (defensive in case of multiple subscriptions)
-            if (subscribedChannel !== channel) {
-                return;
-            }
-            let payload;
-            try {
-                payload = JSON.parse(message);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error("Failed to parse pub/sub notification payload", {
-                    error,
-                    message,
-                    channel: subscribedChannel,
-                });
-                return;
-            }
-            try {
-                await handler(payload);
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.error("Failed to process pub/sub notification event", {
-                    error,
-                    payload,
-                    channel: subscribedChannel,
-                });
+        notificationWorker = new bullmq_1.Worker(QUEUE_NAME, async (job) => {
+            const payload = job.data;
+            const userId = payload.userId;
+            // Wait for any existing job for this userId to complete (FIFO per user)
+            const previousJob = activeJobsPerUser.get(userId);
+            if (previousJob) {
+                try {
+                    await previousJob;
+                }
+                catch (error) {
+                    // Previous job failed, but we still want to process this one
+                    (0, config_1.getConfig)().LOGGER.warn(`Previous job for userId ${userId} failed, continuing with next job`, { error });
+                }
             }
+            // Create the promise for this job
+            const jobPromise = (async () => {
+                try {
+                    await handler(payload);
+                }
+                catch (error) {
+                    // Re-throw to let BullMQ handle retries
+                    throw error;
+                }
+                finally {
+                    // Remove from active jobs when done
+                    // Since only one job per userId runs at a time, we can safely delete by userId
+                    activeJobsPerUser.delete(userId);
+                }
+            })();
+            // Store the promise for this userId
+            activeJobsPerUser.set(userId, jobPromise);
+            // Wait for this job to complete
+            await jobPromise;
+        }, {
+            connection,
+            removeOnComplete: { age: 5 * 60 }, // Remove after 5 minutes
+            removeOnFail: { age: 5 * 60 }, // Remove failed jobs after 5 minutes
+        });
+        notificationWorker.on("completed", (job) => {
+            (0, config_1.getConfig)().LOGGER.info(`Notification job ${job.id} completed`);
+        });
+        notificationWorker.on("failed", (job, err) => {
+            (0, config_1.getConfig)().LOGGER.error(`Notification job ${job?.id} failed`, {
+                error: err,
+                attemptsMade: job?.attemptsMade,
+            });
+        });
+        notificationWorker.on("error", (error) => {
+            (0, config_1.getConfig)().LOGGER.error("Notification worker error", { error });
         });
     }
     catch (error) {
-        // eslint-disable-next-line no-console
-        console.error("Error while subscribing to notification channel", {
+        (0, config_1.getConfig)().LOGGER.error("Failed to start notification worker", {
             error,
-            channel,
         });
+        throw error;
+    }
+}
+/**
+ * Gracefully close the worker and queue connections
+ */
+async function closeNotificationQueue() {
+    const promises = [];
+    if (notificationWorker) {
+        promises.push(notificationWorker.close());
+        notificationWorker = null;
+    }
+    if (notificationQueue) {
+        promises.push(notificationQueue.close());
+        notificationQueue = null;
+    }
+    if (queueEvents) {
+        promises.push(queueEvents.close());
+        queueEvents = null;
+    }
+    if (redisConnection) {
+        promises.push(redisConnection.quit().then(() => undefined));
+        redisConnection = null;
     }
+    await Promise.all(promises);
+    (0, config_1.getConfig)().LOGGER.info("Notification queue connections closed");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "13.0.16",
+  "version": "13.0.17",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [