dt-common-device 7.6.9 → 7.6.11

package/dist/index.d.ts

@@ -17,3 +17,4 @@ export * from "./queue";
 export * from "./entities/pms";
 export * from "./audit";
 export { initialize, getConfig, shutdown } from "./config/config";
+export * from "./pms/index";

package/dist/index.js

@@ -59,3 +59,5 @@ var config_1 = require("./config/config");
 Object.defineProperty(exports, "initialize", { enumerable: true, get: function () { return config_1.initialize; } });
 Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
 Object.defineProperty(exports, "shutdown", { enumerable: true, get: function () { return config_1.shutdown; } });
+//Export PMS Webhook Queue
+__exportStar(require("./pms/index"), exports);

package/dist/pms/webhookQueue/interfaces/IWebhookQueue.d.ts

@@ -1,55 +1,7 @@
-import { IWebhookQueueMetrics, IWebhookQueueOptions, IWebhookQueueStatus } from "../types/webhook.types";
+import { IWebhookQueueOptions } from "../types/webhook.types";
 export interface IWebhookQueue {
     /**
      * Add a webhook to the appropriate queue based on propertyId and pmsType
      */
     addWebhookToQueue(propertyId: string, pmsType: string, webhookData: any, options?: IWebhookQueueOptions): Promise<string>;
-    /**
-     * Get the status of a specific webhook queue
-     */
-    getQueueStatus(propertyId: string, pmsType: string): Promise<IWebhookQueueStatus>;
-    /**
-     * Get status of all webhook queues for a property
-     */
-    getAllPropertyQueueStatuses(propertyId: string): Promise<Record<string, IWebhookQueueStatus>>;
-    /**
-     * Get detailed metrics for a specific queue
-     */
-    getQueueMetrics(propertyId: string, pmsType: string): Promise<IWebhookQueueMetrics>;
-    /**
-     * Clean up completed and failed jobs from a specific queue
-     */
-    cleanupQueue(propertyId: string, pmsType: string): Promise<void>;
-    /**
-     * Pause a specific queue
-     */
-    pauseQueue(propertyId: string, pmsType: string): Promise<void>;
-    /**
-     * Resume a paused queue
-     */
-    resumeQueue(propertyId: string, pmsType: string): Promise<void>;
-    /**
-     * Get all active queues
-     */
-    getActiveQueues(): Promise<string[]>;
-    /**
-     * Shutdown all queues and workers
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Check if a queue exists
-     */
-    queueExists(propertyId: string, pmsType: string): Promise<boolean>;
-    /**
-     * Get queue configuration
-     */
-    getQueueConfig(propertyId: string, pmsType: string): Promise<any>;
-    /**
-     * Update queue configuration
-     */
-    updateQueueConfig(propertyId: string, pmsType: string, config: Partial<any>): Promise<void>;
-    /**
-     * Set webhook processor function for a specific queue
-     */
-    setWebhookProcessor(propertyId: string, pmsType: string, processor: (webhookData: any, pmsType: string) => Promise<any>): Promise<void>;
 }

package/dist/pms/webhookQueue/interfaces/index.d.ts

@@ -1,2 +1 @@
 export * from "./IWebhookQueue";
-export * from "./IWebhookWorker";

package/dist/pms/webhookQueue/interfaces/index.js

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

package/dist/pms/webhookQueue/services/WebhookQueueService.d.ts

@@ -1,27 +1,16 @@
-import { IWebhookQueue } from "../interfaces";
-import { IWebhookQueueConfig, IWebhookQueueMetrics, IWebhookQueueOptions, IWebhookQueueStatus } from "../types/webhook.types";
+import { IWebhookQueue } from "../interfaces/IWebhookQueue";
+import { IWebhookQueueOptions } from "../types/webhook.types";
 export declare class WebhookQueueService implements IWebhookQueue {
-    private redisConnection;
-    private webhookQueues;
-    private workers;
-    private config;
-    constructor(config: IWebhookQueueConfig);
-    addWebhookToQueue(propertyId: string, pmsType: string, webhookData: any, options?: IWebhookQueueOptions): Promise<string>;
-    getQueueStatus(propertyId: string, pmsType: string): Promise<IWebhookQueueStatus>;
-    getAllPropertyQueueStatuses(propertyId: string): Promise<Record<string, IWebhookQueueStatus>>;
-    getQueueMetrics(propertyId: string, pmsType: string): Promise<IWebhookQueueMetrics>;
-    cleanupQueue(propertyId: string, pmsType: string): Promise<void>;
-    pauseQueue(propertyId: string, pmsType: string): Promise<void>;
-    resumeQueue(propertyId: string, pmsType: string): Promise<void>;
-    getActiveQueues(): Promise<string[]>;
-    shutdown(): Promise<void>;
-    queueExists(propertyId: string, pmsType: string): Promise<boolean>;
-    getQueueConfig(propertyId: string, pmsType: string): Promise<any>;
-    updateQueueConfig(propertyId: string, pmsType: string, config: Partial<any>): Promise<void>;
+    private readonly webhookQueues;
+    /**
+     * Generate queue name based on propertyId and pmsType
+     * Format: propertyId_pmsType_webhook
+     */
+    private generateQueueName;
     /**
-     * Set webhook processor function for a specific queue
+     * Add a webhook to the appropriate queue based on propertyId and pmsType
+     * Creates queue if it doesn't exist
      */
-    setWebhookProcessor(propertyId: string, pmsType: string, processor: (webhookData: any, pmsType: string) => Promise<any>): Promise<void>;
-    private getQueueName;
-    private getOrCreateQueue;
+    addWebhookToQueue(propertyId: string, pmsType: string, webhookData: any, options?: IWebhookQueueOptions): Promise<string>;
+    static getOrCreateQueue(queueKey: string, queues: Map<string, any>): any;
 }

package/dist/pms/webhookQueue/services/WebhookQueueService.js

@@ -39,226 +39,52 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhookQueueService = void 0;
-const bullmq_1 = require("bullmq");
-const ioredis_1 = require("ioredis");
 const typedi_1 = require("typedi");
-const WebhookWorker_1 = require("./WebhookWorker");
+const redis_1 = require("../../../db/redis");
 let WebhookQueueService = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
     var WebhookQueueService = _classThis = class {
-        constructor(config) {
-            this.webhookQueues = new Map();
-            this.workers = new Map();
-            this.config = {
-                maxRetries: 3,
-                backoffDelay: 2000,
-                jobTimeout: 300000, // 5 minutes
-                removeOnComplete: { age: 3600000, count: 100 }, // 1 hour, max 100
-                removeOnFail: { age: 7200000, count: 50 }, // 2 hours, max 50
-                ...config,
-            };
-            this.redisConnection = new ioredis_1.Redis({
-                host: this.config.redisHost,
-                port: this.config.redisPort,
-                maxRetriesPerRequest: null,
-                enableReadyCheck: false,
-            });
+        constructor() {
+            this.webhookQueues = new Map(); // BullMQ Queue instances
+        }
+        /**
+         * Generate queue name based on propertyId and pmsType
+         * Format: propertyId_pmsType_webhook
+         */
+        generateQueueName(propertyId, pmsType) {
+            return `${propertyId}_${pmsType}_webhook`;
         }
-        async addWebhookToQueue(propertyId, pmsType, webhookData, options = {}) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = await this.getOrCreateQueue(queueName);
-            const jobData = {
+        /**
+         * Add a webhook to the appropriate queue based on propertyId and pmsType
+         * Creates queue if it doesn't exist
+         */
+        async addWebhookToQueue(propertyId, pmsType, webhookData, options) {
+            const queueName = this.generateQueueName(propertyId, pmsType);
+            // Get or create queue using the static method
+            const queue = WebhookQueueService.getOrCreateQueue(queueName, this.webhookQueues);
+            // Add job to queue immediately with 5 minute TTL
+            const job = await queue.add("webhook-job", {
                 propertyId,
                 pmsType,
                 webhookData,
                 timestamp: new Date().toISOString(),
-                retryCount: 0,
-            };
-            const jobOptions = {
-                priority: options.priority || 1,
-                delay: options.delay || 0,
-                attempts: options.attempts || this.config.maxRetries,
-                backoff: options.backoff || {
-                    type: "exponential",
-                    delay: this.config.backoffDelay,
-                },
-                removeOnComplete: this.config.removeOnComplete,
-                removeOnFail: this.config.removeOnFail,
-                timeout: this.config.jobTimeout,
-            };
-            const job = await queue.add("process_webhook", jobData, jobOptions);
+            }, {
+                removeOnComplete: { age: 5 * 60 }, // Remove after 5 minutes
+                removeOnFail: { age: 5 * 60 }, // Remove failed jobs after 5 minutes
+                attempts: 1, // Only try once
+            });
             return job.id;
         }
-        async getQueueStatus(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = this.webhookQueues.get(queueName);
-            if (!queue) {
-                return {
-                    waiting: 0,
-                    active: 0,
-                    completed: 0,
-                    failed: 0,
-                    delayed: 0,
-                };
-            }
-            const [waiting, active, completed, failed, delayed] = await Promise.all([
-                queue.getWaiting(),
-                queue.getActive(),
-                queue.getCompleted(),
-                queue.getFailed(),
-                queue.getDelayed(),
-            ]);
-            return {
-                waiting: waiting.length,
-                active: active.length,
-                completed: completed.length,
-                failed: failed.length,
-                delayed: delayed.length,
-            };
-        }
-        async getAllPropertyQueueStatuses(propertyId) {
-            const pmsTypes = ["CLOUDBEDS", "HOTELKEY", "STAYNTOUCH"];
-            const statuses = {};
-            for (const pmsType of pmsTypes) {
-                statuses[pmsType] = await this.getQueueStatus(propertyId, pmsType);
-            }
-            return statuses;
-        }
-        async getQueueMetrics(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = this.webhookQueues.get(queueName);
-            if (!queue) {
-                return {
-                    totalProcessed: 0,
-                    totalFailed: 0,
-                    averageProcessingTime: 0,
-                    queueName,
-                };
-            }
-            const [completed, failed] = await Promise.all([
-                queue.getCompleted(),
-                queue.getFailed(),
-            ]);
-            const totalProcessed = completed.length;
-            const totalFailed = failed.length;
-            // Calculate average processing time from completed jobs
-            let totalProcessingTime = 0;
-            let processedWithTime = 0;
-            for (const job of completed) {
-                if (job.processedOn && job.timestamp) {
-                    totalProcessingTime += job.processedOn - job.timestamp;
-                    processedWithTime++;
-                }
-            }
-            const averageProcessingTime = processedWithTime > 0 ? totalProcessingTime / processedWithTime : 0;
-            const lastProcessedAt = completed.length > 0
-                ? new Date(completed[0].processedOn || 0).toISOString()
-                : undefined;
-            return {
-                totalProcessed,
-                totalFailed,
-                averageProcessingTime,
-                lastProcessedAt,
-                queueName,
-            };
-        }
-        async cleanupQueue(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = this.webhookQueues.get(queueName);
-            if (queue) {
-                // BullMQ v5: clean(grace, limit, type)
-                await queue.clean(3600000, 1000, "completed"); // Clean completed jobs older than 1 hour
-                await queue.clean(7200000, 1000, "failed"); // Clean failed jobs older than 2 hours
-            }
-        }
-        async pauseQueue(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = this.webhookQueues.get(queueName);
-            if (queue) {
-                await queue.pause();
-            }
-        }
-        async resumeQueue(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = this.webhookQueues.get(queueName);
-            if (queue) {
-                await queue.resume();
-            }
-        }
-        async getActiveQueues() {
-            return Array.from(this.webhookQueues.keys());
-        }
-        async shutdown() {
-            // Stop all workers
-            for (const worker of this.workers.values()) {
-                await worker.stopProcessing();
-            }
-            // Close all queues
-            for (const queue of this.webhookQueues.values()) {
-                await queue.close();
-            }
-            // Close Redis connection
-            await this.redisConnection.quit();
-            this.webhookQueues.clear();
-            this.workers.clear();
-        }
-        async queueExists(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            return this.webhookQueues.has(queueName);
-        }
-        async getQueueConfig(propertyId, pmsType) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            const queue = this.webhookQueues.get(queueName);
-            if (!queue) {
-                return null;
-            }
-            return {
-                name: queue.name,
-                client: queue.client,
-                opts: queue.opts,
-            };
-        }
-        async updateQueueConfig(propertyId, pmsType, config) {
-            // Note: BullMQ doesn't support runtime config updates
-            // This would require recreating the queue
-            throw new Error("Queue configuration updates not supported at runtime");
-        }
-        /**
-         * Set webhook processor function for a specific queue
-         */
-        async setWebhookProcessor(propertyId, pmsType, processor) {
-            const queueName = this.getQueueName(propertyId, pmsType);
-            let worker = this.workers.get(queueName);
-            if (!worker) {
-                worker = new WebhookWorker_1.WebhookWorker(this.redisConnection);
-                this.workers.set(queueName, worker);
-            }
-            worker.setWebhookProcessor(processor);
-            await worker.startProcessing(queueName);
-        }
-        getQueueName(propertyId, pmsType) {
-            return `${propertyId}_${pmsType}_webhook`;
-        }
-        async getOrCreateQueue(queueName) {
-            if (!this.webhookQueues.has(queueName)) {
-                const queue = new bullmq_1.Queue(queueName, {
-                    connection: this.redisConnection,
-                    defaultJobOptions: {
-                        removeOnComplete: this.config.removeOnComplete,
-                        removeOnFail: this.config.removeOnFail,
-                        attempts: this.config.maxRetries,
-                        backoff: {
-                            type: "exponential",
-                            delay: this.config.backoffDelay,
-                        },
-                    },
-                });
-                this.webhookQueues.set(queueName, queue);
-            }
-            return this.webhookQueues.get(queueName);
+        static getOrCreateQueue(queueKey, queues) {
+            return (queues.get(queueKey) ??
+                queues
+                    .set(queueKey, new (require("bullmq").Queue)(queueKey, {
+                    connection: (0, redis_1.getRedisClient)(),
+                }))
+                    .get(queueKey));
         }
     };
     __setFunctionName(_classThis, "WebhookQueueService");

package/dist/pms/webhookQueue/services/index.d.ts

@@ -1,4 +1 @@
-export * from "./WebhookQueueFactory";
-export * from "./WebhookQueueIntegration";
 export * from "./WebhookQueueService";
-export * from "./WebhookWorker";

package/dist/pms/webhookQueue/services/index.js

@@ -14,7 +14,4 @@ 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("./WebhookQueueFactory"), exports);
-__exportStar(require("./WebhookQueueIntegration"), exports);
 __exportStar(require("./WebhookQueueService"), exports);
-__exportStar(require("./WebhookWorker"), exports);

package/dist/pms/webhookQueue/types/webhook.types.d.ts

@@ -36,25 +36,4 @@ export interface IWebhookQueueOptions {
         delay: number;
     };
 }
-export interface IWebhookProcessingResult {
-    success: boolean;
-    propertyId: string;
-    pmsType: string;
-    timestamp: string;
-    error?: string;
-    processingTime?: number;
-}
-export interface IWebhookQueueMetrics {
-    totalProcessed: number;
-    totalFailed: number;
-    averageProcessingTime: number;
-    lastProcessedAt?: string;
-    queueName: string;
-}
 export type PMS_TYPE = "CLOUDBEDS" | "HOTELKEY" | "STAYNTOUCH";
-export interface IWebhookPayload {
-    eventType?: string;
-    propertyId?: string;
-    reservationId?: string;
-    [key: string]: any;
-}

package/package.json

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