dt-common-device 3.0.0 → 3.0.2

package/dist/device/local/events/Events.js

@@ -3,17 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DT_EVENT_TYPES = void 0;
 exports.DT_EVENT_TYPES = {
     DEVICE: {
-        CREATE: {
-            SUCCESS: "device.create.success",
-            FAILED: "device.create.failed",
-        },
-        UPDATE: {
-            SUCCESS: "device.update.success",
-            FAILED: "device.update.failed",
-        },
-        DELETE: {
-            SUCCESS: "device.delete.success",
-            FAILED: "device.delete.failed",
+        DEVICE: {
+            CREATED: "device.device.created",
+            UPDATED: "device.device.updated",
+            DELETED: "device.device.deleted",
         },
         STATE: {
             SET: "device.state.set",
@@ -44,31 +37,17 @@ exports.DT_EVENT_TYPES = {
         },
     },
     CONNECTION: {
-        CREATE: {
-            SUCCESS: "connection.create.success",
-            FAILED: "connection.create.failed",
-        },
-        UPDATE: {
-            SUCCESS: "connection.update.success",
-            FAILED: "connection.update.failed",
-        },
-        DELETE: {
-            SUCCESS: "connection.delete.success",
-            FAILED: "connection.delete.failed",
+        CONNECTION: {
+            CREATED: "connection.connection.created",
+            UPDATED: "connection.connection.updated",
+            DELETED: "connection.connection.deleted",
         },
     },
     PROPERTY: {
-        CREATE: {
-            SUCCESS: "property.create.success",
-            FAILED: "property.create.failed",
-        },
-        UPDATE: {
-            SUCCESS: "property.update.success",
-            FAILED: "property.update.failed",
-        },
-        DELETE: {
-            SUCCESS: "property.delete.success",
-            FAILED: "property.delete.failed",
+        PROPERTY: {
+            CREATED: "property.property.created",
+            UPDATED: "property.property.updated",
+            DELETED: "property.property.deleted",
         },
         PREFERENCES: {
             UPDATED: "property.preferences.updated",

package/dist/device/local/interface.js

@@ -0,0 +1 @@
+"use strict";

package/dist/device/local/services/DeviceHub.service.d.ts

@@ -0,0 +1,11 @@
+import { IHubCreateParams } from "../interfaces";
+export declare class DeviceHubService {
+    private readonly baseUrl;
+    constructor();
+    addHub(body: IHubCreateParams): Promise<any>;
+    getHubs(hubIds: string[]): Promise<any>;
+    getHub(hubId: string): Promise<any>;
+    updateHub(hubId: string, body: any): Promise<any>;
+    deleteHub(hubId: string): Promise<any>;
+    deleteAllHubs(hubIds: string[]): Promise<any>;
+}

package/dist/device/local/services/DeviceHub.service.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceHubService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../../../config/config");
+class DeviceHubService {
+    constructor() {
+        const { DEVICE_SERVICE } = (0, config_1.getConfig)();
+        if (!DEVICE_SERVICE) {
+            throw new Error("DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE.");
+        }
+        this.baseUrl = DEVICE_SERVICE;
+    }
+    async addHub(body) {
+        return await axios_1.default.post(`${this.baseUrl}/devices/hubs`, body);
+    }
+    //get hubs takes an array of hub ids as query params
+    async getHubs(hubIds) {
+        const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+        return await axios_1.default.get(`${this.baseUrl}/devices/hubs${query}`);
+    }
+    //get hub takes a hub id in params
+    async getHub(hubId) {
+        return await axios_1.default.get(`${this.baseUrl}/devices/hubs/${hubId}`);
+    }
+    async updateHub(hubId, body) {
+        return await axios_1.default.put(`${this.baseUrl}/devices/hubs/${hubId}`, body);
+    }
+    async deleteHub(hubId) {
+        return await axios_1.default.delete(`${this.baseUrl}/devices/hubs/${hubId}`);
+    }
+    async deleteAllHubs(hubIds) {
+        const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+        return await axios_1.default.delete(`${this.baseUrl}/devices/hubs${query}`);
+    }
+}
+exports.DeviceHubService = DeviceHubService;

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

@@ -1,23 +1,25 @@
 import { HttpCallOption } from "../types/http.types";
+import { IQueueResponse } from "../interfaces";
 export declare class HybridHttpQueue {
     private readonly queues;
     private readonly workers;
     private readonly rateLimitConfigs;
     private readonly jobResults;
     constructor();
-    private handleRateLimit;
+    private handleRateLimitAndQueue;
     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<any>;
-    handleRequest(url: string, method: string, options: HttpCallOption): Promise<any>;
+    }): Promise<IQueueResponse>;
+    handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

package/dist/queue/entities/HybridHttpQueue.js

@@ -61,44 +61,69 @@ let HybridHttpQueue = (() => {
             this.jobResults = new Map();
             this.rateLimitConfigs = rateLimit_utils_1.RateLimitUtils.initializeRateLimitConfigs();
         }
-        async handleRateLimit(job) {
-            const { connectionId, provider, url, method, options } = job.data;
-            const microservice = options.queueOptions?.microservice || "default";
-            const isMaxRetries = job.attemptsMade >= 2;
+        async handleRateLimitAndQueue(url, method, options) {
+            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+            const key = `rate_limit:${provider}:${connectionId}`;
+            const config = this.rateLimitConfigs.get(provider);
+            const windowMs = config?.windowMs ?? 60000;
+            const timestamps = await rateLimit_utils_1.RateLimitUtils.getRawRequestTimestamps(key);
+            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
+            // Create job data
+            const jobData = {
+                microservice,
+                connectionId,
+                provider,
+                url,
+                method,
+                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);
+            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: isMaxRetries
-                    ? "http.request.failed"
-                    : "http.request.rateLimitExceeded",
+                eventType: "http.request.rateLimitQueued",
                 properties: {
+                    resource: microservice,
                     connectionId,
                     provider,
                     endpoint: url,
                     method,
                     timestamp: Date.now(),
                     queueId: job.id,
-                    reason: isMaxRetries ? "max_retries_exceeded" : "rate_limit_exceeded",
-                    ...(!isMaxRetries && {
-                        retryCount: job.attemptsMade + 1,
-                        maxRetries: 3,
-                    }),
+                    reason: "rate_limit_exceeded_queued",
+                    delay,
+                    estimatedProcessingTime: now + delay,
                 },
             });
-            if (isMaxRetries) {
-                await this.queues
-                    .get(queueUtils_1.QueueUtils.getQueueKey(microservice, connectionId, provider))
-                    ?.obliterate({ force: true });
-                // Don't throw error for max retries - just return
-                return;
-            }
-            throw new Error("Rate limit exceeded");
+            // Return immediate response to controller
+            return {
+                success: true,
+                queued: true,
+                estimatedProcessingTime: now + delay,
+                jobId: job.id,
+            };
         }
         async processHttpRequest(job) {
             const { connectionId, provider, url, method, options } = job.data;
-            // Check rate limit
-            if (!(await rateLimit_utils_1.RateLimitUtils.checkRateLimit(connectionId, provider, this.rateLimitConfigs))) {
-                await this.handleRateLimit(job);
+            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)({
@@ -131,11 +156,12 @@ let HybridHttpQueue = (() => {
             }
         }
         async request(options) {
-            const { method, url, body, headers, queueOptions } = options;
+            const { method, url, body, params, headers, queueOptions } = options;
             // Create HttpCallOption object
             const httpCallOption = {
                 headers,
                 body,
+                params,
                 queueOptions,
             };
             // Call handleRequest with the constructed parameters
@@ -143,26 +169,53 @@ let HybridHttpQueue = (() => {
         }
         async handleRequest(url, method, options) {
             const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
-            const queueKey = queueUtils_1.QueueUtils.getQueueKey(microservice, connectionId, provider);
-            (0, config_1.getConfig)().LOGGER.info(`Queueing: ${method} ${url} -> ${provider} [${connectionId}]`);
-            queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
-            const queue = queueUtils_1.QueueUtils.getOrCreateQueue(queueKey, this.queues);
-            const job = await queue.add("http-request", {
-                microservice,
-                connectionId,
-                provider,
-                url,
-                method,
-                options,
-                timestamp: Date.now(),
-            }, {
-                attempts: 3,
-                backoff: { type: "exponential", delay: 5000 },
-                removeOnComplete: { age: 300, count: 1 },
-                removeOnFail: { age: 300, count: 1 },
-            });
-            (0, config_1.getConfig)().LOGGER.info(`Job ${job.id} queued, waiting for completion...`);
-            return jobUtils_1.JobUtils.waitForJobCompletion(job, queueKey, this.jobResults);
+            // 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,
+                };
+            }
+            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,
+                };
+            }
         }
         async shutdown() {
             (0, config_1.getConfig)().LOGGER.info("Shutting down HTTP queues...");

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

@@ -1,16 +1,18 @@
 import { HttpCallOption } from "../types/http.types";
+import { IQueueResponse } from "./IJobResult";
 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<any>;
-    handleRequest(url: string, method: string, options: HttpCallOption): Promise<any>;
+    }): Promise<IQueueResponse>;
+    handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
     shutdown(): Promise<void>;
 }

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

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

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

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

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

@@ -12,6 +12,7 @@ export interface HttpRequestOptions {
     method: string;
     url: string;
     body?: any;
+    params?: Record<string, any>;
     headers?: Record<string, string>;
     queueOptions?: {
         connectionId: string;

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

@@ -13,10 +13,6 @@ export interface QueueConfig {
 }
 export interface JobOptions {
     attempts: number;
-    backoff: {
-        type: string;
-        delay: number;
-    };
     removeOnComplete: {
         age: number;
         count: number;

package/dist/queue/utils/queueUtils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueUtils = void 0;
 const config_1 = require("../../config/config");
+const redis_1 = require("../../db/redis");
 class QueueUtils {
     static getQueueKey(microservice, connectionId, provider) {
         return `${microservice}_${provider}_${connectionId}`;
@@ -10,7 +11,7 @@ class QueueUtils {
         return (queues.get(queueKey) ??
             queues
                 .set(queueKey, new (require("bullmq").Queue)(queueKey, {
-                connection: require("../../db/redis").getRedisClient(),
+                connection: (0, redis_1.getRedisClient)(),
             }))
                 .get(queueKey));
     }
@@ -19,7 +20,7 @@ class QueueUtils {
             return;
         const { Worker } = require("bullmq");
         const worker = new Worker(queueKey, processFunction, {
-            connection: require("../../db/redis").getRedisClient(),
+            connection: (0, redis_1.getRedisClient)(),
             concurrency: 1,
             removeOnComplete: { age: 300, count: 1 },
             removeOnFail: { age: 300, count: 1 },

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

@@ -3,4 +3,8 @@ export declare class RateLimitUtils {
     private static redisClient;
     static checkRateLimit(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<boolean>;
     static initializeRateLimitConfigs(): Map<string, IRateLimitConfig>;
+    static isRateLimitAllowed(connectionId: string, provider: string, rateLimitConfigs: Map<string, IRateLimitConfig>): Promise<boolean>;
+    static recordRequest(connectionId: string, provider: string): Promise<void>;
+    static getRawRequestTimestamps(key: string): Promise<number[]>;
+    static getRateLimitConfig(provider: string): IRateLimitConfig | undefined;
 }

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

@@ -33,12 +33,65 @@ class RateLimitUtils {
         const configs = new Map();
         // Configure rate limits for different providers
         configs.set("Sensibo", {
-            maxRequests: 40,
+            maxRequests: 5,
             windowMs: 60000,
             provider: "Sensibo",
         });
         return configs;
     }
+    static async isRateLimitAllowed(connectionId, provider, rateLimitConfigs) {
+        const config = rateLimitConfigs.get(provider);
+        if (!config) {
+            (0, config_1.getConfig)().LOGGER.warn(`No rate limit config found for provider: ${provider}`);
+            return true;
+        }
+        const key = `rate_limit:${provider}:${connectionId}`;
+        const now = Date.now();
+        const windowStart = now - config.windowMs;
+        try {
+            const data = await this.redisClient.get(key);
+            const requests = data
+                ? JSON.parse(data).filter((t) => t > windowStart)
+                : [];
+            return requests.length < config.maxRequests;
+        }
+        catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`Rate limit check error: ${error}`);
+            return true;
+        }
+    }
+    static async recordRequest(connectionId, provider) {
+        const config = this.getRateLimitConfig(provider);
+        if (!config)
+            return;
+        const key = `rate_limit:${provider}:${connectionId}`;
+        const now = Date.now();
+        const windowStart = now - config.windowMs;
+        try {
+            const data = await this.redisClient.get(key);
+            const requests = data
+                ? JSON.parse(data).filter((t) => t > windowStart)
+                : [];
+            requests.push(now);
+            await this.redisClient.setex(key, Math.ceil(config.windowMs / 1000), JSON.stringify(requests));
+        }
+        catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`Rate limit record error: ${error}`);
+        }
+    }
+    static async getRawRequestTimestamps(key) {
+        try {
+            const data = await this.redisClient.get(key);
+            return data ? JSON.parse(data) : [];
+        }
+        catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`Error fetching raw request timestamps: ${error}`);
+            return [];
+        }
+    }
+    static getRateLimitConfig(provider) {
+        return this.initializeRateLimitConfigs().get(provider);
+    }
 }
 exports.RateLimitUtils = RateLimitUtils;
 RateLimitUtils.redisClient = (0, redis_1.getRedisClient)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-common-device",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {