dt-common-device 13.10.4 → 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.js

@@ -99,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
@@ -147,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) {

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

@@ -8,5 +8,5 @@ export declare class QueueUtils {
     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

@@ -208,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 {
@@ -226,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
@@ -236,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/package.json

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