dt-common-device 13.1.5 → 13.1.7

package/dist/pms/webhookQueue/examples/pms-integration.js

@@ -1,254 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExamplePmsController = exports.ExamplePmsServiceWithQueue = void 0;
-exports.exampleUsage = exampleUsage;
-const WebhookQueueIntegration_1 = require("../services/WebhookQueueIntegration");
-/**
- * Example: How to integrate webhook queue with existing PMS service
- *
- * This example shows how to modify your existing PMS service to use
- * the webhook queue system without major refactoring.
- */
-// Configuration for the webhook queue
-const webhookQueueConfig = {
-    redisHost: process.env.REDIS_HOST || "localhost",
-    redisPort: parseInt(process.env.REDIS_PORT || "6379"),
-    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
-};
-// Example: Modified PMS Service with webhook queue integration
-class ExamplePmsServiceWithQueue {
-    constructor() {
-        this.webhookQueueIntegration = new WebhookQueueIntegration_1.WebhookQueueIntegration();
-    }
-    /**
-     * Initialize the webhook queue system
-     */
-    async initializeWebhookQueue() {
-        try {
-            // Initialize with your existing webhook processing logic
-            await this.webhookQueueIntegration.initialize(webhookQueueConfig, this.processWebhook.bind(this) // Bind to existing method
-            );
-            console.log("Webhook queue initialized in PMS service");
-        }
-        catch (error) {
-            console.error("Failed to initialize webhook queue:", error);
-            throw error;
-        }
-    }
-    /**
-     * Your existing webhook processing method
-     * This will be called by the queue worker
-     */
-    async processWebhook(webhookData, pmsType) {
-        console.log(`[PMS Service] Processing webhook for PMS: ${pmsType}`);
-        try {
-            // Your existing webhook processing logic here
-            // This could include:
-            // - Calling handleWebhookEvents
-            // - Database operations
-            // - Business logic
-            // - etc.
-            // Simulate processing
-            await this.simulateWebhookProcessing(webhookData, pmsType);
-            console.log(`[PMS Service] Webhook processed successfully for PMS: ${pmsType}`);
-            return { success: true, processedAt: new Date().toISOString() };
-        }
-        catch (error) {
-            console.error(`[PMS Service] Error processing webhook for PMS: ${pmsType}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Modified webhook handler that queues webhooks instead of processing directly
-     */
-    async handleWebhookWithQueue(webhookData, pmsType, propertyId) {
-        try {
-            // Extract propertyId from webhook if not provided
-            const extractedPropertyId = propertyId || this.extractPropertyIdFromWebhook(webhookData);
-            if (!extractedPropertyId) {
-                // Fallback to direct processing if propertyId cannot be extracted
-                console.warn("Could not extract propertyId, processing webhook directly");
-                return await this.processWebhook(webhookData, pmsType);
-            }
-            // Queue the webhook for processing
-            const jobId = await this.webhookQueueIntegration.queueWebhook(extractedPropertyId, pmsType, webhookData);
-            console.log(`Webhook queued successfully with job ID: ${jobId}`);
-            return jobId;
-        }
-        catch (error) {
-            console.error("Failed to queue webhook:", error);
-            // Fallback to direct processing
-            console.log("Falling back to direct webhook processing");
-            return await this.processWebhook(webhookData, pmsType);
-        }
-    }
-    /**
-     * Get webhook queue status for monitoring
-     */
-    async getWebhookQueueStatus(propertyId, pmsType) {
-        if (!this.webhookQueueIntegration.isReady()) {
-            throw new Error("Webhook queue not initialized");
-        }
-        return await this.webhookQueueIntegration.getQueueStatus(propertyId, pmsType);
-    }
-    /**
-     * Get all webhook queue statuses for a property
-     */
-    async getAllWebhookQueueStatuses(propertyId) {
-        if (!this.webhookQueueIntegration.isReady()) {
-            throw new Error("Webhook queue not initialized");
-        }
-        return await this.webhookQueueIntegration.getAllQueueStatuses(propertyId);
-    }
-    /**
-     * Clean up old webhook jobs
-     */
-    async cleanupWebhookQueues(propertyId) {
-        if (!this.webhookQueueIntegration.isReady()) {
-            return;
-        }
-        const pmsTypes = ["CLOUDBEDS", "HOTELKEY", "STAYNTOUCH"];
-        for (const pmsType of pmsTypes) {
-            try {
-                await this.webhookQueueIntegration.cleanupQueue(propertyId, pmsType);
-                console.log(`Cleaned up webhook queue for ${propertyId}_${pmsType}`);
-            }
-            catch (error) {
-                console.error(`Failed to cleanup queue for ${propertyId}_${pmsType}:`, error);
-            }
-        }
-    }
-    /**
-     * Shutdown webhook queue system
-     */
-    async shutdownWebhookQueue() {
-        if (this.webhookQueueIntegration.isReady()) {
-            await this.webhookQueueIntegration.shutdown();
-        }
-    }
-    // Helper methods
-    extractPropertyIdFromWebhook(webhookData) {
-        // Implement your logic to extract propertyId from webhook data
-        // This will depend on how each PMS sends the propertyId
-        return webhookData.propertyId || webhookData.property_id || null;
-    }
-    async simulateWebhookProcessing(webhookData, pmsType) {
-        // Simulate some processing time
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        // Simulate different processing logic based on PMS type
-        switch (pmsType) {
-            case "CLOUDBEDS":
-                console.log("Processing Cloudbeds webhook...");
-                break;
-            case "HOTELKEY":
-                console.log("Processing HotelKey webhook...");
-                break;
-            case "STAYNTOUCH":
-                console.log("Processing StayNTouch webhook...");
-                break;
-            default:
-                console.log("Processing unknown PMS webhook...");
-        }
-    }
-}
-exports.ExamplePmsServiceWithQueue = ExamplePmsServiceWithQueue;
-// Example: How to use in your existing controller
-class ExamplePmsController {
-    constructor() {
-        this.pmsService = new ExamplePmsServiceWithQueue();
-    }
-    /**
-     * Initialize the service (call this when your app starts)
-     */
-    async initialize() {
-        await this.pmsService.initializeWebhookQueue();
-    }
-    /**
-     * Modified webhook endpoint that uses the queue
-     */
-    async handleWebhook(payload, pmsType) {
-        try {
-            // Try to extract propertyId from the webhook payload
-            const propertyId = this.extractPropertyIdFromPayload(payload);
-            if (propertyId) {
-                // Use the queue system
-                const jobId = await this.pmsService.handleWebhookWithQueue(payload, pmsType, propertyId);
-                return {
-                    message: "Webhook queued successfully",
-                    jobId,
-                    propertyId,
-                    pmsType,
-                };
-            }
-            else {
-                // Fallback to direct processing
-                console.warn("PropertyId not found, processing webhook directly");
-                return await this.pmsService.processWebhook(payload, pmsType);
-            }
-        }
-        catch (error) {
-            console.error("Error handling webhook:", error);
-            throw error;
-        }
-    }
-    /**
-     * Get webhook queue status
-     */
-    async getWebhookQueueStatus(propertyId, pmsType) {
-        return await this.pmsService.getWebhookQueueStatus(propertyId, pmsType);
-    }
-    /**
-     * Get all webhook queue statuses for a property
-     */
-    async getAllWebhookQueueStatuses(propertyId) {
-        return await this.pmsService.getAllWebhookQueueStatuses(propertyId);
-    }
-    /**
-     * Cleanup webhook queues
-     */
-    async cleanupWebhookQueues(propertyId) {
-        await this.pmsService.cleanupWebhookQueues(propertyId);
-    }
-    /**
-     * Shutdown the service
-     */
-    async shutdown() {
-        await this.pmsService.shutdownWebhookQueue();
-    }
-    extractPropertyIdFromPayload(payload) {
-        // Implement your logic to extract propertyId
-        return payload.propertyId || payload.property_id || null;
-    }
-}
-exports.ExamplePmsController = ExamplePmsController;
-// Example: Usage in your application
-async function exampleUsage() {
-    try {
-        // 1. Create controller
-        const controller = new ExamplePmsController();
-        // 2. Initialize
-        await controller.initialize();
-        // 3. Handle webhooks (they will be queued)
-        const webhookPayload = {
-            eventType: "reservation.created",
-            propertyId: "hotel123",
-            reservationId: "res_001",
-        };
-        const result = await controller.handleWebhook(webhookPayload, "CLOUDBEDS");
-        console.log("Webhook result:", result);
-        // 4. Check queue status
-        const status = await controller.getWebhookQueueStatus("hotel123", "CLOUDBEDS");
-        console.log("Queue status:", status);
-        // 5. Cleanup when done
-        await controller.cleanupWebhookQueues("hotel123");
-        // 6. Shutdown
-        await controller.shutdown();
-    }
-    catch (error) {
-        console.error("Example usage failed:", error);
-    }
-}

package/dist/pms/webhookQueue/examples/usage.d.ts

@@ -1,7 +0,0 @@
-export declare function initializeWebhookQueue(): Promise<import("..").WebhookQueueService>;
-export declare function addWebhookToQueue(propertyId: string, pmsType: string, webhookData: any): Promise<string>;
-export declare function checkQueueStatus(propertyId: string, pmsType: string): Promise<import("../types/webhook.types").IWebhookQueueStatus>;
-export declare function getAllQueueStatuses(propertyId: string): Promise<Record<string, import("../types/webhook.types").IWebhookQueueStatus>>;
-export declare function cleanupWebhookQueue(): Promise<void>;
-export declare function completeWebhookWorkflow(): Promise<void>;
-export declare function demonstrateErrorHandling(): Promise<string>;

package/dist/pms/webhookQueue/examples/usage.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeWebhookQueue = initializeWebhookQueue;
-exports.addWebhookToQueue = addWebhookToQueue;
-exports.checkQueueStatus = checkQueueStatus;
-exports.getAllQueueStatuses = getAllQueueStatuses;
-exports.cleanupWebhookQueue = cleanupWebhookQueue;
-exports.completeWebhookWorkflow = completeWebhookWorkflow;
-exports.demonstrateErrorHandling = demonstrateErrorHandling;
-const WebhookQueueFactory_1 = require("../services/WebhookQueueFactory");
-/**
- * Example usage of the Webhook Queue System
- */
-// Configuration for the webhook queue
-const webhookQueueConfig = {
-    redisHost: process.env.REDIS_HOST || "localhost",
-    redisPort: parseInt(process.env.REDIS_PORT || "6379"),
-    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
-};
-// Example webhook processor function
-async function processWebhook(webhookData, pmsType) {
-    console.log(`Processing webhook for PMS: ${pmsType}`);
-    console.log("Webhook data:", webhookData);
-    // Your webhook processing logic here
-    // This could include:
-    // - Updating database records
-    // - Sending notifications
-    // - Triggering other services
-    // - etc.
-    // Simulate some processing time
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    console.log(`Webhook processed successfully for PMS: ${pmsType}`);
-    return { success: true, processedAt: new Date().toISOString() };
-}
-// Example: Initialize webhook queue
-async function initializeWebhookQueue() {
-    try {
-        // Create webhook queue service
-        const webhookQueue = WebhookQueueFactory_1.WebhookQueueFactory.createWebhookQueue(webhookQueueConfig);
-        // Set webhook processor for different PMS types
-        await webhookQueue.setWebhookProcessor("property123", "CLOUDBEDS", processWebhook);
-        await webhookQueue.setWebhookProcessor("property123", "HOTELKEY", processWebhook);
-        await webhookQueue.setWebhookProcessor("property123", "STAYNTOUCH", processWebhook);
-        console.log("Webhook queue initialized successfully");
-        return webhookQueue;
-    }
-    catch (error) {
-        console.error("Failed to initialize webhook queue:", error);
-        throw error;
-    }
-}
-// Example: Add webhook to queue
-async function addWebhookToQueue(propertyId, pmsType, webhookData) {
-    try {
-        const webhookQueue = WebhookQueueFactory_1.WebhookQueueFactory.getWebhookQueue();
-        if (!webhookQueue) {
-            throw new Error("Webhook queue not initialized");
-        }
-        const jobId = await webhookQueue.addWebhookToQueue(propertyId, pmsType, webhookData);
-        console.log(`Webhook added to queue with job ID: ${jobId}`);
-        return jobId;
-    }
-    catch (error) {
-        console.error("Failed to add webhook to queue:", error);
-        throw error;
-    }
-}
-// Example: Check queue status
-async function checkQueueStatus(propertyId, pmsType) {
-    try {
-        const webhookQueue = WebhookQueueFactory_1.WebhookQueueFactory.getWebhookQueue();
-        if (!webhookQueue) {
-            throw new Error("Webhook queue not initialized");
-        }
-        const status = await webhookQueue.getQueueStatus(propertyId, pmsType);
-        console.log(`Queue status for ${propertyId}_${pmsType}_webhook:`, status);
-        return status;
-    }
-    catch (error) {
-        console.error("Failed to check queue status:", error);
-        throw error;
-    }
-}
-// Example: Get all queue statuses for a property
-async function getAllQueueStatuses(propertyId) {
-    try {
-        const webhookQueue = WebhookQueueFactory_1.WebhookQueueFactory.getWebhookQueue();
-        if (!webhookQueue) {
-            throw new Error("Webhook queue not initialized");
-        }
-        const statuses = await webhookQueue.getAllPropertyQueueStatuses(propertyId);
-        console.log(`All queue statuses for property ${propertyId}:`, statuses);
-        return statuses;
-    }
-    catch (error) {
-        console.error("Failed to get queue statuses:", error);
-        throw error;
-    }
-}
-// Example: Cleanup and shutdown
-async function cleanupWebhookQueue() {
-    try {
-        await WebhookQueueFactory_1.WebhookQueueFactory.shutdownAll();
-        console.log("Webhook queue shutdown successfully");
-    }
-    catch (error) {
-        console.error("Failed to shutdown webhook queue:", error);
-        throw error;
-    }
-}
-// Example: Complete workflow
-async function completeWebhookWorkflow() {
-    try {
-        // 1. Initialize the queue
-        const webhookQueue = await initializeWebhookQueue();
-        // 2. Add some webhooks
-        const webhookData1 = {
-            eventType: "reservation.created",
-            reservationId: "res_001",
-            guestName: "John Doe",
-            checkIn: "2024-01-15",
-            checkOut: "2024-01-17",
-        };
-        const webhookData2 = {
-            eventType: "reservation.updated",
-            reservationId: "res_002",
-            guestName: "Jane Smith",
-            checkIn: "2024-01-16",
-            checkOut: "2024-01-18",
-        };
-        // Add webhooks to different queues
-        await addWebhookToQueue("property123", "CLOUDBEDS", webhookData1);
-        await addWebhookToQueue("property123", "HOTELKEY", webhookData2);
-        // 3. Check queue statuses
-        await checkQueueStatus("property123", "CLOUDBEDS");
-        await getAllQueueStatuses("property123");
-        // 4. Wait for processing (in real scenario, this would be handled by workers)
-        console.log("Waiting for webhooks to be processed...");
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-        // 5. Check final statuses
-        await checkQueueStatus("property123", "CLOUDBEDS");
-        console.log("Webhook workflow completed successfully");
-    }
-    catch (error) {
-        console.error("Webhook workflow failed:", error);
-        throw error;
-    }
-}
-// Example: Error handling and retries
-async function demonstrateErrorHandling() {
-    try {
-        const webhookQueue = WebhookQueueFactory_1.WebhookQueueFactory.getWebhookQueue();
-        if (!webhookQueue) {
-            throw new Error("Webhook queue not initialized");
-        }
-        // Add webhook with custom retry options
-        const jobId = await webhookQueue.addWebhookToQueue("property123", "CLOUDBEDS", { test: "error-handling" }, {
-            attempts: 5,
-            backoff: {
-                type: "exponential",
-                delay: 1000,
-            },
-        });
-        console.log(`Webhook added with custom retry options, job ID: ${jobId}`);
-        return jobId;
-    }
-    catch (error) {
-        console.error("Failed to demonstrate error handling:", error);
-        throw error;
-    }
-}

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

@@ -1,3 +0,0 @@
-export * from "./interfaces";
-export * from "./services";
-export * from "./types";

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

@@ -1,33 +0,0 @@
-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>;
-    /**
-     * Mark a webhook job as completed (processed successfully)
-     */
-    markWebhookCompleted(propertyId: string, pmsType: string, jobId: string): Promise<void>;
-    /**
-     * Mark a webhook job as failed
-     */
-    markWebhookFailed(propertyId: string, pmsType: string, jobId: string, error?: string): Promise<void>;
-    /**
-     * Poll available webhook from ANY available webhook queue in Redis
-     */
-    pollWebhookFromQueues(): Promise<{
-        jobId: string;
-        data: any;
-        propertyId: string;
-        pmsType: string;
-        queueName: string;
-    } | null>;
-    /**
-     * Get all available webhook queue names from Redis
-     */
-    getAllQueueNames(): Promise<string[]>;
-    /**
-     * Get total waiting count across all webhook queues
-     */
-    getTotalWaitingCount(): Promise<number>;
-}

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

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

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

@@ -1,38 +0,0 @@
-import { IWebhookJobData, IWebhookProcessingResult } from "../types/webhook.types";
-export interface IWebhookWorker {
-    /**
-     * Start processing webhook jobs from the queue
-     */
-    startProcessing(queueName: string): Promise<void>;
-    /**
-     * Stop processing webhook jobs
-     */
-    stopProcessing(): Promise<void>;
-    /**
-     * Process a single webhook job
-     */
-    processWebhookJob(jobData: IWebhookJobData): Promise<IWebhookProcessingResult>;
-    /**
-     * Handle webhook processing errors
-     */
-    handleError(error: Error, jobData: IWebhookJobData): Promise<void>;
-    /**
-     * Get worker status
-     */
-    getWorkerStatus(): Promise<{
-        isRunning: boolean;
-        processedJobs: number;
-        failedJobs: number;
-        lastProcessedAt?: string;
-    }>;
-    /**
-     * Set webhook processor function
-     */
-    setWebhookProcessor(processor: (webhookData: any, pmsType: string) => Promise<any>): void;
-}
-export interface IWebhookProcessor {
-    /**
-     * Process webhook data
-     */
-    process(webhookData: any, pmsType: string): Promise<any>;
-}

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

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

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

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

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

@@ -1,38 +0,0 @@
-import { IWebhookQueueConfig } from "../types/webhook.types";
-import { WebhookQueueService } from "./WebhookQueueService";
-export declare class WebhookQueueFactory {
-    private static instances;
-    /**
-     * Create or get a webhook queue service instance
-     * @param config Configuration for the webhook queue
-     * @param instanceKey Optional key to identify different instances
-     * @returns WebhookQueueService instance
-     */
-    static createWebhookQueue(config: IWebhookQueueConfig, instanceKey?: string): WebhookQueueService;
-    /**
-     * Get an existing webhook queue service instance
-     * @param instanceKey Key to identify the instance
-     * @returns WebhookQueueService instance or null if not found
-     */
-    static getWebhookQueue(instanceKey?: string): WebhookQueueService | null;
-    /**
-     * Get all webhook queue service instances
-     * @returns Array of all WebhookQueueService instances
-     */
-    static getAllWebhookQueues(): WebhookQueueService[];
-    /**
-     * Shutdown all webhook queue service instances
-     */
-    static shutdownAll(): Promise<void>;
-    /**
-     * Check if a webhook queue service instance exists
-     * @param instanceKey Key to identify the instance
-     * @returns True if instance exists, false otherwise
-     */
-    static hasWebhookQueue(instanceKey?: string): boolean;
-    /**
-     * Remove a webhook queue service instance
-     * @param instanceKey Key to identify the instance
-     */
-    static removeWebhookQueue(instanceKey?: string): Promise<void>;
-}