dt-common-device 13.10.3 → 13.10.5

package/dist/audit/IAuditProperties.d.ts

@@ -20,7 +20,8 @@ export declare enum Resource {
     ACCESS_BLE = "accessBle",
     EMERGENCY_CODE = "emergencyCode",
     EMERGENCY_RFID = "emergencyRfid",
-    EMERGENCY_BLE = "emergencyBle"
+    EMERGENCY_BLE = "emergencyBle",
+    SERVER = "server"
 }
 export interface IAuditProperties {
     resource: Resource;

package/dist/audit/IAuditProperties.js

@@ -24,4 +24,5 @@ var Resource;
     Resource["EMERGENCY_CODE"] = "emergencyCode";
     Resource["EMERGENCY_RFID"] = "emergencyRfid";
     Resource["EMERGENCY_BLE"] = "emergencyBle";
+    Resource["SERVER"] = "server";
 })(Resource || (exports.Resource = Resource = {}));

package/dist/queue/entities/HybridHttpQueue.d.ts

@@ -5,7 +5,6 @@ export declare class HybridHttpQueue {
     private readonly rateLimitConfigs;
     private readonly queues;
     private readonly workers;
-    private readonly jobResults;
     constructor();
     private addToQueue;
     private processHttpRequest;

package/dist/queue/entities/HybridHttpQueue.js

@@ -54,7 +54,6 @@ let HybridHttpQueue = (() => {
             // BullMQ queues and workers for persistent storage
             this.queues = new Map();
             this.workers = new Map();
-            this.jobResults = new Map();
             this.rateLimitConfigs = rateLimit_utils_1.RateLimitUtils.initializeRateLimitConfigs();
         }
         async addToQueue(connectionId, provider, url, method, options) {
@@ -89,7 +88,7 @@ let HybridHttpQueue = (() => {
             console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Job added to queue - JobId: ${jobId}, QueueKey: ${queueKey}`);
             // Initialize worker if not exists
             console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Initializing worker for queue: ${queueKey}`);
-            queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
+            queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this));
             // Verify worker was created
             if (this.workers.has(queueKey)) {
                 console.log(`[${new Date().toISOString()}] [HybridHttpQueue] Worker confirmed for queue: ${queueKey}`);
@@ -100,7 +99,7 @@ let HybridHttpQueue = (() => {
             (0, config_1.getConfig)().LOGGER.info(`Request queued: ${method} ${url} -> ${provider} [${connectionId}]. Job ID: ${jobId}, Delay: ${delay}ms`);
             // Wait for job completion and return result
             // Simple: delay + windowMs + HTTP buffer timeout
-            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, delay, windowMs);
+            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, delay, windowMs, this.queues);
         }
         async processHttpRequest(job) {
             // Log immediately when worker picks up the job
@@ -148,7 +147,7 @@ let HybridHttpQueue = (() => {
             return this.handleRequest(url, method, httpCallOption);
         }
         async handleRequest(url, method, options) {
-            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+            const { connectionId, provider } = jobUtils_1.JobUtils.extractConnectionDetails(options);
             // Check rate limit first
             const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
             if (allowed) {
@@ -170,7 +169,6 @@ let HybridHttpQueue = (() => {
             ]);
             this.workers.clear();
             this.queues.clear();
-            this.jobResults.clear();
             (0, config_1.getConfig)().LOGGER.info("HTTP queues shutdown complete");
         }
     };

package/dist/queue/utils/queueUtils.d.ts

@@ -4,9 +4,9 @@ export declare class QueueUtils {
     static getQueueKey(microservice: string, connectionId: string, provider: string): string;
     static getRequestQueueKey(connectionId: string, provider: string): string;
     static getOrCreateQueue(queueKey: string, queues: Map<string, any>): any;
-    static getOrCreateWorker(queueKey: string, workers: Map<string, any>, processFunction: (job: any) => Promise<any>, jobResults: Map<string, any>): void;
+    static getOrCreateWorker(queueKey: string, workers: Map<string, any>, processFunction: (job: any) => Promise<any>): void;
     static waitForRateLimitExpiry(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<void>;
     static executeHttpRequest(url: string, method: string, options: HttpCallOption, connectionId: string, provider: string): Promise<any>;
     static addJobToQueue(queueKey: string, jobData: any, delay: number, queues: Map<string, any>): Promise<string>;
-    static waitForJobCompletion(jobId: string, queueKey: string, jobDelay?: number, windowMs?: number): Promise<any>;
+    static waitForJobCompletion(jobId: string, queueKey: string, jobDelay: number | undefined, windowMs: number | undefined, queues: Map<string, any>): Promise<any>;
 }

package/dist/queue/utils/queueUtils.js

@@ -24,7 +24,7 @@ class QueueUtils {
             }))
                 .get(queueKey));
     }
-    static getOrCreateWorker(queueKey, workers, processFunction, jobResults) {
+    static getOrCreateWorker(queueKey, workers, processFunction) {
         if (workers.has(queueKey)) {
             const existingWorker = workers.get(queueKey);
             console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker already exists for queue: ${queueKey}, checking if it's running...`);
@@ -95,24 +95,11 @@ class QueueUtils {
             console.log(`[${new Date().toISOString()}] [Worker Event] Job completed - JobId: ${job.id}, QueueKey: ${queueKey}, ReturnValueType: ${typeof job.returnvalue}, HasReturnValue: ${job.returnvalue !== undefined}`);
             (0, config_1.getConfig)().LOGGER.info(`HTTP request completed: ${job.id} [${queueKey}]`);
             const result = job.returnvalue;
-            const jobResult = {
-                result,
-                resolved: true,
-                timestamp: Date.now(),
-            };
             console.log(`[${new Date().toISOString()}] [Worker Event] Storing job result - JobId: ${job.id}, ResultType: ${typeof result}, Resolved: true`);
-            jobResults.set(job.id, jobResult);
-            console.log(`[${new Date().toISOString()}] [Worker Event] Job result stored in jobResults - JobId: ${job.id}, StoredResult: ${JSON.stringify(jobResult)}`);
         });
         worker.on("failed", (job, err) => {
             console.log(`[${new Date().toISOString()}] [Worker Event] Job failed - JobId: ${job?.id}, QueueKey: ${queueKey}, Error: ${err.message}`);
             (0, config_1.getConfig)().LOGGER.error(`HTTP request failed: ${job?.id} [${queueKey}], Error: ${err.message}`);
-            jobResults.set(job.id, {
-                error: err.message,
-                resolved: true,
-                timestamp: Date.now(),
-            });
-            console.log(`[${new Date().toISOString()}] [Worker Event] Job error stored in jobResults - JobId: ${job?.id}`);
         });
         worker.on("error", (err) => {
             console.log(`[${new Date().toISOString()}] [Worker Event] Worker error - QueueKey: ${queueKey}, Error: ${err.message}, Stack: ${err.stack}`);
@@ -221,16 +208,15 @@ class QueueUtils {
         }
         return job.id;
     }
-    static async waitForJobCompletion(jobId, queueKey, jobDelay = 0, windowMs = 60000) {
+    static async waitForJobCompletion(jobId, queueKey, jobDelay = 0, windowMs = 60000, queues) {
         // Simple: delay (wait) + windowMs (execute) + HTTP timeout buffer
         const httpTimeout = 60000;
         const totalTimeout = jobDelay + windowMs + httpTimeout;
         console.log(`[${new Date().toISOString()}] [waitForJobCompletion] Waiting for job ${jobId} - delay: ${jobDelay}ms, timeout: ${totalTimeout}ms`);
         const startTime = Date.now();
-        const { Queue } = require("bullmq");
-        const queue = new Queue(queueKey, {
-            connection: (0, redis_1.getRedisClient)(),
-        });
+        // Reuse the existing queue instance — never create a new Queue per call
+        // (each new Queue duplicates the Redis connection, causing a connection leak)
+        const queue = this.getOrCreateQueue(queueKey, queues);
         return new Promise(async (resolve, reject) => {
             const checkInterval = setInterval(async () => {
                 try {
@@ -239,7 +225,6 @@ class QueueUtils {
                         const elapsed = Date.now() - startTime;
                         if (elapsed > totalTimeout) {
                             clearInterval(checkInterval);
-                            await queue.close();
                             return reject(new Error(`Job ${jobId} not found and timeout exceeded`));
                         }
                         return; // Job not found yet, keep checking
@@ -249,26 +234,22 @@ class QueueUtils {
                         console.log(`[${new Date().toISOString()}] [waitForJobCompletion] Job ${jobId} completed`);
                         clearInterval(checkInterval);
                         const result = job.returnvalue;
-                        await queue.close();
                         return resolve(result);
                     }
                     if (state === "failed") {
                         console.log(`[${new Date().toISOString()}] [waitForJobCompletion] Job ${jobId} failed: ${job.failedReason}`);
                         clearInterval(checkInterval);
-                        await queue.close();
                         return reject(new Error(job.failedReason || "Job failed"));
                     }
                 }
                 catch (error) {
                     clearInterval(checkInterval);
-                    await queue.close();
                     reject(error);
                 }
             }, 500); // Check every 500ms
             // Timeout
             setTimeout(() => {
                 clearInterval(checkInterval);
-                queue.close();
                 reject(new Error(`Request timeout: Maximum wait time exceeded (${totalTimeout}ms). Job delay was ${jobDelay}ms.`));
             }, totalTimeout);
         });

package/dist/queue/utils/rateLimit.utils.js

@@ -76,7 +76,7 @@ class RateLimitUtils {
             maxTimeoutWindowMs: 120000,
         });
         configs.set(constants_1.CONNECTION_PROVIDERS.SMARTTHINGS, {
-            maxRequests: 30,
+            maxRequests: 25,
             windowMs: 60000, // 1 minute
             provider: constants_1.CONNECTION_PROVIDERS.SMARTTHINGS,
             maxTimeoutWindowMs: 120000,

package/package.json

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