dt-common-device 3.0.10 → 3.0.11

package/dist/config/config.d.ts

@@ -1,8 +1,7 @@
 import { InternalEventSubscription } from "../events";
-import { IConfig, ILogger } from "./config.types";
+import { IConfig } from "./config.types";
 export declare function initialize(cfg: IConfig): Promise<void>;
 export declare function getConfig(): IConfig;
-export declare function getLogger(): ILogger;
 export declare function getEventSubscription(): InternalEventSubscription | null;
 export declare function checkRequiredEnv(): void;
 export declare function ensureAuditInitialized(): void;

package/dist/config/config.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initialize = initialize;
 exports.getConfig = getConfig;
-exports.getLogger = getLogger;
 exports.getEventSubscription = getEventSubscription;
 exports.checkRequiredEnv = checkRequiredEnv;
 exports.ensureAuditInitialized = ensureAuditInitialized;
@@ -83,10 +82,6 @@ function getConfig() {
     }
     return config;
 }
-// Direct logger export for easier usage
-function getLogger() {
-    return getConfig().LOGGER;
-}
 function getEventSubscription() {
     return eventSubscription;
 }
@@ -120,6 +115,10 @@ function ensureAuditInitialized() {
     (0, dt_audit_library_1.initializeAudit)(apiKey, host);
     auditInitialized = true;
 }
+// // Direct logger export for easier usage
+// export function getLogger(): ILogger {
+//   return getConfig().LOGGER;
+// }
 /**
  * Returns the PostgreSQL DB URI from environment variables.
  * Throws an error if not set.

package/dist/device/local/repository/Schedule.repository.d.ts

@@ -1,7 +1,6 @@
 import { ISchedule } from "../interfaces/ISchedule";
 export declare class ScheduleRepository {
     private readonly axiosInstance;
-    private readonly logger;
     constructor();
     getSchedule(scheduleId: string): Promise<any>;
     getScheduleByZone(zoneId: string): Promise<any>;

package/dist/device/local/repository/Schedule.repository.js

@@ -40,16 +40,16 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduleRepository = void 0;
 const typedi_1 = require("typedi");
-const config_1 = require("../../../config/config");
 const http_utils_1 = require("../../../utils/http.utils");
+const config_1 = require("../../../config/config");
 let ScheduleRepository = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
     var ScheduleRepository = _classThis = class {
+        // private readonly logger = getLogger();
         constructor() {
-            this.logger = (0, config_1.getLogger)();
             this.axiosInstance = (0, http_utils_1.getDeviceServiceAxiosInstance)();
         }
         async getSchedule(scheduleId) {
@@ -58,7 +58,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to get schedule ${scheduleId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to get schedule ${scheduleId}:`, error);
                 const errorMessage = error.response?.data?.message || error.message || "Unknown error";
                 throw new Error(`Failed to get schedule: ${errorMessage}`);
             }
@@ -69,7 +69,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to get schedule by zone ${zoneId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to get schedule by zone ${zoneId}:`, error);
                 const errorMessage = error.response?.data?.message || error.message || "Unknown error";
                 throw new Error(`Failed to get schedule: ${errorMessage}`);
             }
@@ -80,7 +80,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to update schedule ${scheduleId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to update schedule ${scheduleId}:`, error);
                 const errorMessage = error.response?.data?.message || error.message || "Unknown error";
                 throw new Error(`Failed to update schedule: ${errorMessage}`);
             }
@@ -91,7 +91,7 @@ let ScheduleRepository = (() => {
                 return response.data;
             }
             catch (error) {
-                this.logger.error(`Failed to delete schedule from DB ${scheduleId}:`, error);
+                (0, config_1.getConfig)().LOGGER.error(`Failed to delete schedule from DB ${scheduleId}:`, error);
                 throw new Error(`Failed to delete schedule from DB: ${error.message}`);
             }
         }

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

@@ -1,25 +1,15 @@
 import { HttpCallOption } from "../types/http.types";
 import { IQueueResponse } from "../interfaces";
+import { RequestQueueOptions } from "../types/queue.types";
 export declare class HybridHttpQueue {
+    private readonly rateLimitConfigs;
     private readonly queues;
     private readonly workers;
-    private readonly rateLimitConfigs;
     private readonly jobResults;
     constructor();
-    private handleRateLimitAndQueue;
+    private addToQueue;
     private processHttpRequest;
-    request(options: {
-        method: string;
-        url: string;
-        body?: any;
-        params?: Record<string, any>;
-        headers?: Record<string, string>;
-        queueOptions?: {
-            connectionId: string;
-            connectionProvider: string;
-            microservice: string;
-        };
-    }): Promise<IQueueResponse>;
+    request(options: RequestQueueOptions): Promise<any>;
     handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

package/dist/queue/entities/HybridHttpQueue.js

@@ -37,18 +37,13 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HybridHttpQueue = void 0;
-const config_1 = require("../../config/config");
-const axios_1 = __importDefault(require("axios"));
-const dt_audit_library_1 = require("dt-audit-library");
 const typedi_1 = require("typedi");
 const rateLimit_utils_1 = require("../utils/rateLimit.utils");
 const jobUtils_1 = require("../utils/jobUtils");
 const queueUtils_1 = require("../utils/queueUtils");
+const config_1 = require("../../config/config");
 let HybridHttpQueue = (() => {
     let _classDecorators = [(0, typedi_1.Service)()];
     let _classDescriptor;
@@ -56,13 +51,15 @@ let HybridHttpQueue = (() => {
     let _classThis;
     var HybridHttpQueue = _classThis = class {
         constructor() {
+            // 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 handleRateLimitAndQueue(url, method, options) {
-            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+        async addToQueue(connectionId, provider, url, method, options) {
+            const queueKey = queueUtils_1.QueueUtils.getRequestQueueKey(connectionId, provider);
+            // Calculate delay based on rate limit window
             const key = `rate_limit:${provider}:${connectionId}`;
             const config = this.rateLimitConfigs.get(provider);
             const windowMs = config?.windowMs ?? 60000;
@@ -70,11 +67,14 @@ let HybridHttpQueue = (() => {
             const now = Date.now();
             const windowStart = now - windowMs;
             const recentRequests = timestamps.filter((t) => t > windowStart);
-            const nextAvailableTime = recentRequests.length > 0 ? recentRequests[0] + windowMs : now + 1000;
-            const delay = Math.max(nextAvailableTime - now, 1000); // at least 1s delay
+            let delay = 0;
+            if (recentRequests.length >= (config?.maxRequests ?? 5)) {
+                const earliestRequest = recentRequests[0];
+                const nextAvailableTime = earliestRequest + windowMs;
+                delay = Math.max(nextAvailableTime - now, 1000); // At least 1s delay
+            }
             // Create job data
             const jobData = {
-                microservice,
                 connectionId,
                 provider,
                 url,
@@ -82,78 +82,25 @@ let HybridHttpQueue = (() => {
                 options,
                 timestamp: Date.now(),
             };
-            // Add job to queue with delay (background processing)
-            const queueKey = queueUtils_1.QueueUtils.getQueueKey(microservice, connectionId, provider);
-            const queue = queueUtils_1.QueueUtils.getOrCreateQueue(queueKey, this.queues);
+            // Add job to BullMQ queue with delay
+            const jobId = await queueUtils_1.QueueUtils.addJobToQueue(queueKey, jobData, delay, this.queues);
+            // Initialize worker if not exists
             queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
-            const job = await queue.add("http-request", jobData, {
-                delay,
-                attempts: 1,
-                removeOnComplete: { age: 300, count: 1 },
-                removeOnFail: { age: 300, count: 1 },
-            });
-            await (0, dt_audit_library_1.publishAudit)({
-                eventType: "http.request.rateLimitQueued",
-                properties: {
-                    resource: microservice,
-                    connectionId,
-                    provider,
-                    endpoint: url,
-                    method,
-                    timestamp: Date.now(),
-                    queueId: job.id,
-                    reason: "rate_limit_exceeded_queued",
-                    delay,
-                    estimatedProcessingTime: now + delay,
-                },
-            });
-            // Return immediate response to controller
-            return {
-                success: true,
-                queued: true,
-                estimatedProcessingTime: now + delay,
-                jobId: job.id,
-            };
+            (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
+            return queueUtils_1.QueueUtils.waitForJobCompletion(jobId, queueKey, this.jobResults);
         }
         async processHttpRequest(job) {
             const { connectionId, provider, url, method, options } = job.data;
+            // Check rate limit before processing
             const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
             if (!allowed) {
-                // This shouldn't happen since we check before queuing, but handle it gracefully
-                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, skipping`);
-                return;
-            }
-            await rateLimit_utils_1.RateLimitUtils.recordRequest(connectionId, provider);
-            try {
-                (0, config_1.getConfig)().LOGGER.info(`Executing HTTP request: ${method} ${url} for ${provider}`);
-                const response = await (0, axios_1.default)({
-                    method: method.toLowerCase(),
-                    url: url,
-                    headers: options.headers || {},
-                    timeout: 30000,
-                    ...(options.body && { data: options.body }),
-                    ...(options.params && { params: options.params }),
-                });
-                (0, config_1.getConfig)().LOGGER.info(`HTTP request successful: ${method} ${url} for ${provider}`);
-                return response.data;
-            }
-            catch (error) {
-                (0, config_1.getConfig)().LOGGER.error(`HTTP request failed ${job.id}: ${error.message}`);
-                await (0, dt_audit_library_1.publishAudit)({
-                    eventType: "http.request.error",
-                    properties: {
-                        connectionId,
-                        provider,
-                        endpoint: url,
-                        method,
-                        timestamp: Date.now(),
-                        queueId: job.id,
-                        reason: "execution_error",
-                        errorMessage: error.message,
-                    },
-                });
-                throw new Error(`HTTP request failed: ${error.message}`);
+                // This shouldn't happen since we calculate delay, but handle it gracefully
+                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, waiting for window to expire...`);
+                await queueUtils_1.QueueUtils.waitForRateLimitExpiry(connectionId, provider, this.rateLimitConfigs);
             }
+            // Execute the HTTP request
+            return queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
         }
         async request(options) {
             const { method, url, body, params, headers, queueOptions } = options;
@@ -171,50 +118,15 @@ let HybridHttpQueue = (() => {
             const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
             // Check rate limit first
             const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
-            if (!allowed) {
-                // Rate limited - queue the request and return immediate response
-                return this.handleRateLimitAndQueue(url, method, options);
-            }
-            // Not rate limited - process immediately
-            (0, config_1.getConfig)().LOGGER.info(`Processing immediately: ${method} ${url} -> ${provider} [${connectionId}]`);
-            try {
-                // Record the request first
-                await rateLimit_utils_1.RateLimitUtils.recordRequest(connectionId, provider);
-                // Execute the HTTP request
-                const response = await (0, axios_1.default)({
-                    method: method.toLowerCase(),
-                    url: url,
-                    headers: options.headers || {},
-                    timeout: 30000,
-                    ...(options.body && { data: options.body }),
-                    ...(options.params && { params: options.params }),
-                });
-                (0, config_1.getConfig)().LOGGER.info(`HTTP request successful: ${method} ${url} for ${provider}`);
-                return {
-                    success: true,
-                    data: response.data,
-                    queued: false,
-                };
+            if (allowed) {
+                // Rate limit not exceeded - execute immediately
+                (0, config_1.getConfig)().LOGGER.info(`Rate limit not exceeded: ${method} ${url} -> ${provider} [${connectionId}], executing immediately`);
+                return queueUtils_1.QueueUtils.executeHttpRequest(url, method, options, connectionId, provider);
             }
-            catch (error) {
-                (0, config_1.getConfig)().LOGGER.error(`HTTP request failed: ${error.message}`);
-                await (0, dt_audit_library_1.publishAudit)({
-                    eventType: "http.request.error",
-                    properties: {
-                        connectionId,
-                        provider,
-                        endpoint: url,
-                        method,
-                        timestamp: Date.now(),
-                        reason: "execution_error",
-                        errorMessage: error.message,
-                    },
-                });
-                return {
-                    success: false,
-                    error: `HTTP request failed: ${error.message}`,
-                    queued: false,
-                };
+            else {
+                // Rate limit exceeded - add to BullMQ queue
+                (0, config_1.getConfig)().LOGGER.info(`Rate limit exceeded: ${method} ${url} -> ${provider} [${connectionId}], adding to BullMQ queue`);
+                return this.addToQueue(connectionId, provider, url, method, options);
             }
         }
         async shutdown() {

package/dist/queue/interfaces/IHybridHttpQueue.d.ts

@@ -1,18 +1,8 @@
 import { HttpCallOption } from "../types/http.types";
 import { IQueueResponse } from "./IJobResult";
+import { RequestQueueOptions } from "../types/queue.types";
 export interface IHybridHttpQueue {
-    request(options: {
-        method: string;
-        url: string;
-        body?: any;
-        params?: Record<string, any>;
-        headers?: Record<string, string>;
-        queueOptions?: {
-            connectionId: string;
-            connectionProvider: string;
-            microservice: string;
-        };
-    }): Promise<IQueueResponse>;
+    request(options: RequestQueueOptions): Promise<IQueueResponse>;
     handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

package/dist/queue/interfaces/IJobResult.d.ts

@@ -4,11 +4,4 @@ export interface IJobResult {
     resolved: boolean;
     timestamp: number;
 }
-export interface IQueueResponse {
-    success: boolean;
-    data?: any;
-    error?: string;
-    queued?: boolean;
-    estimatedProcessingTime?: number;
-    jobId?: string;
-}
+export type IQueueResponse = any;

package/dist/queue/interfaces/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./IHybridHttpQueue";
-export * from "./IHttpRequestJob";
 export * from "./IJobResult";
 export * from "./IRateLimitConfig";

package/dist/queue/interfaces/index.js

@@ -15,6 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./IHybridHttpQueue"), exports);
-__exportStar(require("./IHttpRequestJob"), exports);
 __exportStar(require("./IJobResult"), exports);
 __exportStar(require("./IRateLimitConfig"), exports);

package/dist/queue/services/QueueService.d.ts

@@ -1,20 +1,10 @@
 import { IHybridHttpQueue, IQueueResponse } from "../interfaces";
 import { HttpCallOption } from "../types/http.types";
+import { RequestQueueOptions } from "../types/queue.types";
 export declare class QueueService implements IHybridHttpQueue {
     private readonly hybridQueue;
     constructor();
-    request(options: {
-        method: string;
-        url: string;
-        body?: any;
-        params?: Record<string, any>;
-        headers?: Record<string, string>;
-        queueOptions?: {
-            connectionId: string;
-            connectionProvider: string;
-            microservice: string;
-        };
-    }): Promise<IQueueResponse>;
+    request(options: RequestQueueOptions): Promise<IQueueResponse>;
     handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

package/dist/queue/types/queue.types.d.ts

@@ -1,31 +1,12 @@
-export interface QueueConfig {
-    concurrency: number;
-    removeOnComplete: {
-        age: number;
-        count: number;
+export interface RequestQueueOptions {
+    method: string;
+    url: string;
+    body?: any;
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+    queueOptions?: {
+        connectionId: string;
+        connectionProvider: string;
+        microservice: string;
     };
-    removeOnFail: {
-        age: number;
-        count: number;
-    };
-    lockDuration: number;
-    stalledInterval: number;
-}
-export interface JobOptions {
-    attempts: number;
-    removeOnComplete: {
-        age: number;
-        count: number;
-    };
-    removeOnFail: {
-        age: number;
-        count: number;
-    };
-}
-export interface QueueMetrics {
-    totalJobs: number;
-    completedJobs: number;
-    failedJobs: number;
-    pendingJobs: number;
-    activeJobs: number;
 }

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

@@ -1,7 +1,4 @@
-import { Job } from "bullmq";
-import { IJobResult } from "../interfaces";
 export declare class JobUtils {
-    static waitForJobCompletion(job: Job, queueKey: string, jobResults: Map<string, IJobResult>): Promise<any>;
     static extractConnectionDetails(options: any): {
         connectionId: string;
         provider: string;

package/dist/queue/utils/jobUtils.js

@@ -2,54 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JobUtils = void 0;
 class JobUtils {
-    static async waitForJobCompletion(job, queueKey, jobResults) {
-        return new Promise((resolve, reject) => {
-            let timeoutId;
-            let checkCount = 0;
-            const maxChecks = 600;
-            const checkJob = async () => {
-                if (++checkCount >= maxChecks) {
-                    clearTimeout(timeoutId);
-                    return reject(new Error("Job timeout: Request took too long"));
-                }
-                try {
-                    const state = await job.getState();
-                    if (state === "completed") {
-                        clearTimeout(timeoutId);
-                        const memoryResult = jobResults.get(job.id);
-                        if (memoryResult?.resolved) {
-                            return memoryResult.result !== undefined
-                                ? resolve(memoryResult.result)
-                                : reject(new Error(memoryResult.error || "Unknown error"));
-                        }
-                        // Fallback to job result
-                        resolve(await job.returnvalue);
-                    }
-                    else if (state === "failed") {
-                        clearTimeout(timeoutId);
-                        const memoryResult = jobResults.get(job.id);
-                        const errorMsg = memoryResult?.error ||
-                            (await job.failedReason) ||
-                            "Unknown error";
-                        reject(new Error(`Job failed: ${errorMsg}`));
-                    }
-                    else {
-                        timeoutId = setTimeout(checkJob, checkCount < 10 ? 50 : 100);
-                    }
-                }
-                catch (error) {
-                    clearTimeout(timeoutId);
-                    reject(new Error(`Error checking job: ${error.message}`));
-                }
-            };
-            checkJob();
-            // Backup timeout
-            setTimeout(() => {
-                clearTimeout(timeoutId);
-                reject(new Error("Request timeout: Maximum wait time exceeded"));
-            }, 60000);
-        });
-    }
     static extractConnectionDetails(options) {
         const { connectionId, connectionProvider: provider, microservice, } = options?.queueOptions ?? {};
         if (!connectionId)

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

@@ -1,5 +1,12 @@
+import { HttpCallOption } from "../types/http.types";
+import { IRateLimitConfig } from "../interfaces";
 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 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, jobResults: Map<string, any>): Promise<any>;
 }