dt-common-device 14.0.1 → 14.0.2

package/dist/entities/pms/IPms.d.ts

@@ -5,7 +5,8 @@ export declare enum PmsProvider {
     Yanolja = "Yanolja",
     SMOOBU = "Smoobu",
     WEBREZPRO = "Webrezpro",
-    MEWS = "Mews"
+    MEWS = "Mews",
+    Infor = "Infor"
 }
 export interface IPmsSchedule {
     id: string;

package/dist/entities/pms/IPms.js

@@ -10,4 +10,5 @@ var PmsProvider;
     PmsProvider["SMOOBU"] = "Smoobu";
     PmsProvider["WEBREZPRO"] = "Webrezpro";
     PmsProvider["MEWS"] = "Mews";
+    PmsProvider["Infor"] = "Infor";
 })(PmsProvider || (exports.PmsProvider = PmsProvider = {}));

package/dist/entities/pms/pms.service.js

@@ -148,19 +148,30 @@ let PmsService = (() => {
             if (!scheduleAccessGroups || scheduleAccessGroups.length === 0) {
                 return false;
             }
-            const orderedAccessGroups = [...scheduleAccessGroups].sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime());
-            // First entry new code should be assigned
-            if (orderedAccessGroups.length < 2) {
+            // Split reservations often have multiple rows per schedule with the *same* startTime
+            // across different access groups. Sorting *all* rows globally made the last two entries
+            // always different access groups. Here we only consider rows for this accessGroupId,
+            // ordered by startTime, and require the latest segment to follow the previous one in time.
+            const rowsForThisAccessGroup = scheduleAccessGroups
+                .filter((row) => row.accessGroupId === accessGroupId)
+                .sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime());
+            if (rowsForThisAccessGroup.length < 2) {
                 return false;
             }
-            const last = orderedAccessGroups?.at(-1);
-            const secondLast = orderedAccessGroups?.at(-2);
-            // True only if last and second last entries are same and equal to accessGroupId
-            return (
-            // This 1st condition doesnt seems to be required so verify with use case
-            last.accessGroupId === accessGroupId &&
-                secondLast.accessGroupId === accessGroupId //A(secondLast) A(last)
-            );
+            const previousSegment = rowsForThisAccessGroup.at(-2);
+            const currentSegment = rowsForThisAccessGroup.at(-1);
+            if (!previousSegment.endTime || !currentSegment.startTime) {
+                return false;
+            }
+            const previousStart = new Date(previousSegment.startTime).getTime();
+            const previousEnd = new Date(previousSegment.endTime).getTime();
+            const currentStart = new Date(currentSegment.startTime).getTime();
+            // Same startTime as previous row (duplicate import, extra map row, etc.) — still reuse one code.
+            if (currentStart === previousStart) {
+                return true;
+            }
+            // Consecutive nights: current segment starts at or after previous segment ends.
+            return currentStart >= previousEnd;
         }
     };
     __setFunctionName(_classThis, "PmsService");

package/dist/entities/property/Property.repository.d.ts

@@ -4,5 +4,6 @@ export declare class PropertyRepository {
     constructor();
     getPropertyPreferences(propertyId: string, keys?: string[]): Promise<IPropertySettings | null>;
     getProperty(propertyId: string): Promise<IProperty | null>;
+    getOrganizationByPropertyId(propertyId: string): Promise<any | null>;
     getAllProperties(): Promise<any[]>;
 }

package/dist/entities/property/Property.repository.js

@@ -41,6 +41,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropertyRepository = void 0;
 const db_1 = require("../../db");
 const typedi_1 = require("typedi");
+const utils_1 = require("../../utils");
 let PropertyRepository = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -84,6 +85,10 @@ let PropertyRepository = (() => {
             }
             return null;
         }
+        async getOrganizationByPropertyId(propertyId) {
+            const organization = await (0, utils_1.getAdminServiceAxiosInstance)().get(`/properties/${propertyId}/organizations`);
+            return organization.data.data;
+        }
         async getAllProperties() {
             try {
                 //Retrieve all the properties ids from the database where isDeleted is false

package/dist/entities/property/Property.service.d.ts

@@ -5,4 +5,5 @@ export declare class LocalPropertyService {
     getProperty(propertyId: string): Promise<import("./IProperty").IProperty | null>;
     getPropertyTimeZone(propertyId: string): Promise<string>;
     getAllProperties(): Promise<any[]>;
+    getOrganizationByPropertyId(propertyId: string): Promise<any>;
 }

package/dist/entities/property/Property.service.js

@@ -110,6 +110,12 @@ let LocalPropertyService = (() => {
             const properties = await this.propertyRepository.getAllProperties();
             return properties;
         }
+        async getOrganizationByPropertyId(propertyId) {
+            if (!propertyId) {
+                throw new Error("Property ID is required");
+            }
+            return await this.propertyRepository.getOrganizationByPropertyId(propertyId);
+        }
     };
     __setFunctionName(_classThis, "LocalPropertyService");
     (() => {

package/dist/index.d.ts

@@ -25,3 +25,4 @@ export * from "./webhooks";
 export * from "./Integrations";
 export * from "./Integrations/twilio";
 export * from "./emails/emailService";
+export * from "./entities/notification";

package/dist/index.js

@@ -75,3 +75,5 @@ __exportStar(require("./Integrations"), exports);
 __exportStar(require("./Integrations/twilio"), exports);
 // Export Email Service
 __exportStar(require("./emails/emailService"), exports);
+// Export Notification Service
+__exportStar(require("./entities/notification"), exports);

package/dist/issues/issue.types.d.ts

@@ -31,6 +31,7 @@ export declare enum EntitySubType {
     ON_PREM_SERVER = "ON_PREM_SERVER",
     CLOUDBEDS = "CLOUDBEDS",
     STAYNTOUCH = "STAYNTOUCH",
+    INFOR = "INFOR",
     HOTELKEY = "HOTELKEY",
     YANOLJA = "YANOLJA",
     SKYTOUCH = "SKYTOUCH",
@@ -49,7 +50,9 @@ export declare enum EntitySubType {
     SALTOSPACE = "SALTOSPACE",
     SCHLAGE = "SCHLAGE",
     LOCKLY = "LOCKLY",
-    SIFELY = "SIFELY"
+    SIFELY = "SIFELY",
+    GEOCODING = "GEOCODING",
+    ULTRALOCK = "ULTRALOCK"
 }
 export declare enum IssueStatus {
     PENDING = "PENDING",
@@ -85,7 +88,9 @@ export declare enum IssueType {
     LOW_GUEST_CODES = "LOW_GUEST_CODES",
     PMS_CODE_NOT_DELIVERED = "PMS_CODE_NOT_DELIVERED",
     SCHEDULE_CODE_NOT_ASSIGNED = "SCHEDULE_CODE_NOT_ASSIGNED",
-    MISSING_ACCESS_GROUP = "MISSING_ACCESS_GROUP"
+    MISSING_ACCESS_GROUP = "MISSING_ACCESS_GROUP",
+    GEOCODING_FAILED = "GEOCODING_FAILED",
+    CLOUD_PROVIDER_EVENTS_ISSUE = "CLOUD_PROVIDER_EVENTS_ISSUE"
 }
 export declare const IssueDescriptions: {
     BATTERY_LOW: string;
@@ -101,6 +106,8 @@ export declare const IssueDescriptions: {
     PMS_CODE_NOT_DELIVERED: string;
     SCHEDULE_CODE_NOT_ASSIGNED: string;
     MISSING_ACCESS_GROUP: string;
+    GEOCODING_FAILED: string;
+    CLOUD_PROVIDER_EVENTS_ISSUE: string;
 };
 export interface IssueDocument {
     id: string;

package/dist/issues/issue.types.js

@@ -40,6 +40,7 @@ var EntitySubType;
     // PMS PROVIDERS
     EntitySubType["CLOUDBEDS"] = "CLOUDBEDS";
     EntitySubType["STAYNTOUCH"] = "STAYNTOUCH";
+    EntitySubType["INFOR"] = "INFOR";
     EntitySubType["HOTELKEY"] = "HOTELKEY";
     EntitySubType["YANOLJA"] = "YANOLJA";
     EntitySubType["SKYTOUCH"] = "SKYTOUCH";
@@ -60,6 +61,9 @@ var EntitySubType;
     EntitySubType["SCHLAGE"] = "SCHLAGE";
     EntitySubType["LOCKLY"] = "LOCKLY";
     EntitySubType["SIFELY"] = "SIFELY";
+    // OTHER
+    EntitySubType["GEOCODING"] = "GEOCODING";
+    EntitySubType["ULTRALOCK"] = "ULTRALOCK";
 })(EntitySubType || (exports.EntitySubType = EntitySubType = {}));
 var IssueStatus;
 (function (IssueStatus) {
@@ -92,6 +96,8 @@ var IssueType;
     IssueType["PMS_CODE_NOT_DELIVERED"] = "PMS_CODE_NOT_DELIVERED";
     IssueType["SCHEDULE_CODE_NOT_ASSIGNED"] = "SCHEDULE_CODE_NOT_ASSIGNED";
     IssueType["MISSING_ACCESS_GROUP"] = "MISSING_ACCESS_GROUP";
+    IssueType["GEOCODING_FAILED"] = "GEOCODING_FAILED";
+    IssueType["CLOUD_PROVIDER_EVENTS_ISSUE"] = "CLOUD_PROVIDER_EVENTS_ISSUE";
 })(IssueType || (exports.IssueType = IssueType = {}));
 exports.IssueDescriptions = {
     [IssueType.BATTERY_LOW]: "The issue is raised when the battery level is lower than the threshold.",
@@ -107,4 +113,6 @@ exports.IssueDescriptions = {
     [IssueType.PMS_CODE_NOT_DELIVERED]: "The issue is raised when the code is not delivered to the PMS system.",
     [IssueType.SCHEDULE_CODE_NOT_ASSIGNED]: "The issue is raised when the code is not assigned to a schedule.",
     [IssueType.MISSING_ACCESS_GROUP]: "The issue is raised when the access group is missing from devicethread but present in PMS system.",
+    [IssueType.GEOCODING_FAILED]: "The issue is raised when the system fails to retrieve latitude and longitude from the provided property address.",
+    [IssueType.CLOUD_PROVIDER_EVENTS_ISSUE]: "The issue is raised when the system fails to automatically resolve the event subscription for the cloud provider (Lock or PMS)",
 };

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...`);
@@ -35,6 +35,8 @@ class QueueUtils {
                 console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Existing worker running status: ${isRunning}`);
                 if (!isRunning) {
                     console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker not running, closing and recreating...`);
+                    // Stale worker detected — surface at WARN level with count context
+                    (0, config_1.getConfig)().LOGGER.warn(`Stale worker for queue ${queueKey} (not running), recreating. Active workers before recreate: ${workers.size}`);
                     try {
                         existingWorker.close();
                     }
@@ -95,24 +97,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}`);
@@ -129,7 +118,8 @@ class QueueUtils {
         });
         workers.set(queueKey, worker);
         console.log(`[${new Date().toISOString()}] [getOrCreateWorker] Worker initialized and stored for queue: ${queueKey}`);
-        (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey}`);
+        // Log total active workers — a growing count here signals a connection-proliferation leak
+        (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey} (total active workers: ${workers.size})`);
     }
     static async waitForRateLimitExpiry(connectionId, provider, rateLimitConfigs) {
         const key = `rate_limit:${provider}:${connectionId}`;
@@ -215,22 +205,25 @@ class QueueUtils {
                 queue.getActiveCount(),
             ]);
             console.log(`[${new Date().toISOString()}] [addJobToQueue] Queue state - QueueKey: ${queueKey}, Waiting: ${waiting}, Delayed: ${delayed}, Active: ${active}`);
+            // Warn via structured logger when backlog is building — correlates with heap stats
+            if (waiting + delayed > 1) {
+                (0, config_1.getConfig)().LOGGER.warn(`Queue backlog [${queueKey}]: waiting=${waiting} delayed=${delayed} active=${active}`);
+            }
         }
         catch (e) {
             // Ignore errors getting queue state
         }
         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 +232,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 +241,25 @@ 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();
+                // Log via structured logger before rejecting so the timeout is visible in
+                // CloudWatch alongside the periodic heap stats — correlates queue stalls with memory pressure.
+                (0, config_1.getConfig)().LOGGER.error(`Job ${jobId} timed out after ${totalTimeout}ms [${queueKey}] (jobDelay=${jobDelay}ms)`);
                 reject(new Error(`Request timeout: Maximum wait time exceeded (${totalTimeout}ms). Job delay was ${jobDelay}ms.`));
             }, totalTimeout);
         });

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

@@ -51,6 +51,12 @@ class RateLimitUtils {
             provider: constants_1.CONNECTION_PROVIDERS.STAYNTOUCH,
             maxTimeoutWindowMs: 120000,
         });
+        configs.set(constants_1.CONNECTION_PROVIDERS.INFOR, {
+            maxRequests: 10,
+            windowMs: 10000, // 10 seconds
+            provider: constants_1.CONNECTION_PROVIDERS.INFOR,
+            maxTimeoutWindowMs: 120000,
+        });
         configs.set(constants_1.CONNECTION_PROVIDERS.HOTELKEY, {
             maxRequests: 10,
             windowMs: 10000, // 10 seconds
@@ -76,7 +82,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,
@@ -141,6 +147,18 @@ class RateLimitUtils {
             provider: constants_1.CONNECTION_PROVIDERS.SIFELY,
             maxTimeoutWindowMs: 120000,
         });
+        configs.set(constants_1.CONNECTION_PROVIDERS.DUSAW, {
+            maxRequests: 10,
+            windowMs: 60000, // 1 minute
+            provider: constants_1.CONNECTION_PROVIDERS.DUSAW,
+            maxTimeoutWindowMs: 120000,
+        });
+        configs.set(constants_1.CONNECTION_PROVIDERS.ULTRALOCK, {
+            maxRequests: 60,
+            windowMs: 60000, // 1 minute — adjust once UltraLock API docs confirm their limit
+            provider: constants_1.CONNECTION_PROVIDERS.ULTRALOCK,
+            maxTimeoutWindowMs: 120000,
+        });
         return configs;
     }
     static async isRateLimitAllowed(connectionId, provider, rateLimitConfigs) {

package/dist/utils/http.utils.d.ts

@@ -1,3 +1,4 @@
+import axios from "axios";
 /**
  * Validates if a URL is properly formatted and accessible
  */
@@ -5,10 +6,11 @@ export declare function validateServiceUrl(url: string): boolean;
 /**
  * Creates a properly configured axios instance with error handling
  */
-export declare function createAxiosInstance(baseURL?: string): import("axios").AxiosInstance;
+export declare function createAxiosInstance(baseURL?: string): axios.AxiosInstance;
 export declare function getDeviceServiceAxiosInstance(): any;
 export declare function getAdminServiceAxiosInstance(): any;
 export declare function getMonitoringServiceAxiosInstance(): any;
+export declare function getNotificationServiceAxiosInstance(): any;
 /**
  * Retry function for failed HTTP requests
  */

package/dist/utils/http.utils.js

@@ -8,6 +8,7 @@ exports.createAxiosInstance = createAxiosInstance;
 exports.getDeviceServiceAxiosInstance = getDeviceServiceAxiosInstance;
 exports.getAdminServiceAxiosInstance = getAdminServiceAxiosInstance;
 exports.getMonitoringServiceAxiosInstance = getMonitoringServiceAxiosInstance;
+exports.getNotificationServiceAxiosInstance = getNotificationServiceAxiosInstance;
 exports.retryRequest = retryRequest;
 const config_1 = require("../config/config");
 const axios_1 = __importDefault(require("axios"));
@@ -105,6 +106,13 @@ function getMonitoringServiceAxiosInstance() {
     }
     return deviceMonitoringServiceAxiosInstance;
 }
+let notificationServiceAxiosInstance = null;
+function getNotificationServiceAxiosInstance() {
+    if (!notificationServiceAxiosInstance) {
+        notificationServiceAxiosInstance = createAxiosInstance((0, config_1.getNotificationServiceUrl)());
+    }
+    return notificationServiceAxiosInstance;
+}
 /**
  * Retry function for failed HTTP requests
  */

package/dist/webhookQueue/services/WebhookQueueService.js

@@ -1,20 +1,4 @@
 "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 __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
     function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
     var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
@@ -49,23 +33,6 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-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 __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
@@ -144,7 +111,7 @@ let WebhookQueueService = (() => {
                     try {
                         // Create queue instance if not exists locally
                         if (!this.webhookQueues.has(queueName)) {
-                            const { Queue } = await Promise.resolve().then(() => __importStar(require("bullmq")));
+                            const { Queue } = await import("bullmq");
                             const queue = new Queue(queueName, {
                                 connection: (0, redis_1.getRedisClient)(),
                             });
@@ -219,7 +186,7 @@ let WebhookQueueService = (() => {
                         try {
                             // Create queue instance if not exists locally
                             if (!this.webhookQueues.has(queueName)) {
-                                const { Queue } = await Promise.resolve().then(() => __importStar(require("bullmq")));
+                                const { Queue } = await import("bullmq");
                                 const queue = new Queue(queueName, {
                                     connection: (0, redis_1.getRedisClient)(),
                                 });
@@ -245,7 +212,7 @@ let WebhookQueueService = (() => {
             if (queues.has(queueKey)) {
                 return queues.get(queueKey);
             }
-            const { Queue } = await Promise.resolve().then(() => __importStar(require("bullmq")));
+            const { Queue } = await import("bullmq");
             const queue = new Queue(queueKey, {
                 connection: (0, redis_1.getRedisClient)(),
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "14.0.1",
+  "version": "14.0.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -43,10 +43,11 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.835.0",
+    "@aws-sdk/client-s3": "3.1015.0",
     "@aws-sdk/client-ses": "3.1003.0",
     "axios": "1.10.0",
     "bullmq": "5.56.4",
+    "class-validator": "0.15.1",
     "dt-audit-library": "1.7.1",
     "dt-pub-sub": "^1.0.0",
     "ioredis": "5.6.1",