dt-common-device 2.0.7 → 3.0.1

package/src/queue/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./http.types";
+export * from "./queue.types";

package/src/queue/types/queue.types.ts

@@ -0,0 +1,21 @@
+export interface QueueConfig {
+  concurrency: number;
+  removeOnComplete: { age: number; count: number };
+  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/src/queue/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./rateLimit.utils";
+export * from "./jobUtils";
+export * from "./queueUtils";

package/src/queue/utils/jobUtils.ts

@@ -0,0 +1,80 @@
+import { Job } from "bullmq";
+import { IJobResult } from "../interfaces";
+import { getConfig } from "../../config/config";
+
+export class JobUtils {
+  static async waitForJobCompletion(
+    job: Job,
+    queueKey: string,
+    jobResults: Map<string, IJobResult>
+  ): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let timeoutId: NodeJS.Timeout;
+      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: any) {
+          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: any): {
+    connectionId: string;
+    provider: string;
+    microservice: string;
+  } {
+    const {
+      connectionId,
+      connectionProvider: provider,
+      microservice,
+    } = options?.queueOptions ?? {};
+
+    if (!connectionId) throw new Error("Connection ID not found in options");
+    if (!provider) throw new Error("Connection provider not found in options");
+    if (!microservice) throw new Error("Microservice not found in options");
+    return { connectionId, provider, microservice };
+  }
+}

package/src/queue/utils/queueUtils.ts

@@ -0,0 +1,91 @@
+import { getConfig } from "../../config/config";
+import { getRedisClient } from "../../db/redis";
+
+export class QueueUtils {
+  static getQueueKey(
+    microservice: string,
+    connectionId: string,
+    provider: string
+  ): string {
+    return `${microservice}_${provider}_${connectionId}`;
+  }
+
+  static getOrCreateQueue(queueKey: string, queues: Map<string, any>): any {
+    return (
+      queues.get(queueKey) ??
+      queues
+        .set(
+          queueKey,
+          new (require("bullmq").Queue)(queueKey, {
+            connection: getRedisClient(),
+          })
+        )
+        .get(queueKey)!
+    );
+  }
+
+  static getOrCreateWorker(
+    queueKey: string,
+    workers: Map<string, any>,
+    processFunction: (job: any) => Promise<any>,
+    jobResults: Map<string, any>
+  ): void {
+    if (workers.has(queueKey)) return;
+
+    const { Worker } = require("bullmq");
+    const worker = new Worker(queueKey, processFunction, {
+      connection: getRedisClient(),
+      concurrency: 1,
+      removeOnComplete: { age: 300, count: 1 },
+      removeOnFail: { age: 300, count: 1 },
+      lockDuration: 300000,
+      stalledInterval: 60000,
+    });
+
+    // Simplified event handlers
+    worker.on("completed", (job: any) => {
+      getConfig().LOGGER.info(
+        `HTTP request completed: ${job.id} [${queueKey}]`
+      );
+      job.returnvalue
+        .then((result: any) =>
+          jobResults.set(job.id!, {
+            result,
+            resolved: true,
+            timestamp: Date.now(),
+          })
+        )
+        .catch((error: any) =>
+          jobResults.set(job.id!, {
+            error: error.message,
+            resolved: true,
+            timestamp: Date.now(),
+          })
+        );
+    });
+
+    worker.on("failed", (job: any, err: any) => {
+      getConfig().LOGGER.error(
+        `HTTP request failed: ${job?.id} [${queueKey}], Error: ${err.message}`
+      );
+      jobResults.set(job!.id!, {
+        error: err.message,
+        resolved: true,
+        timestamp: Date.now(),
+      });
+    });
+
+    worker.on("error", (err: any) =>
+      getConfig().LOGGER.error(`Worker error for ${queueKey}: ${err.message}`)
+    );
+    worker.on("stalled", (jobId: string) =>
+      getConfig().LOGGER.warn(`Job ${jobId} stalled in worker ${queueKey}`)
+    );
+    worker.on("active", (job: any) =>
+      getConfig().LOGGER.info(`HTTP request started: ${job.id} [${queueKey}]`)
+    );
+
+    workers.set(queueKey, worker);
+    getConfig().LOGGER.info(`Worker initialized for queue: ${queueKey}`);
+  }
+}

package/src/queue/utils/rateLimit.utils.ts

@@ -0,0 +1,131 @@
+import { IRateLimitConfig } from "../interfaces";
+import { getRedisClient } from "../../db/redis";
+import { getConfig } from "../../config/config";
+
+export class RateLimitUtils {
+  private static redisClient = getRedisClient();
+
+  static async checkRateLimit(
+    connectionId: string,
+    provider: string,
+    rateLimitConfigs: Map<string, IRateLimitConfig>
+  ): Promise<boolean> {
+    const config = rateLimitConfigs.get(provider);
+    if (!config) {
+      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: number) => t > windowStart)
+        : [];
+
+      if (requests.length >= config.maxRequests) return false;
+
+      requests.push(now);
+      await this.redisClient.setex(
+        key,
+        Math.ceil(config.windowMs / 1000),
+        JSON.stringify(requests)
+      );
+      return true;
+    } catch (error) {
+      getConfig().LOGGER.error(`Rate limit check error: ${error}`);
+      return true;
+    }
+  }
+
+  static initializeRateLimitConfigs(): Map<string, IRateLimitConfig> {
+    const configs = new Map<string, IRateLimitConfig>();
+
+    // Configure rate limits for different providers
+    configs.set("Sensibo", {
+      maxRequests: 5,
+      windowMs: 60000,
+      provider: "Sensibo",
+    });
+
+    return configs;
+  }
+
+  static async isRateLimitAllowed(
+    connectionId: string,
+    provider: string,
+    rateLimitConfigs: Map<string, IRateLimitConfig>
+  ): Promise<boolean> {
+    const config = rateLimitConfigs.get(provider);
+    if (!config) {
+      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: number) => t > windowStart)
+        : [];
+
+      return requests.length < config.maxRequests;
+    } catch (error) {
+      getConfig().LOGGER.error(`Rate limit check error: ${error}`);
+      return true;
+    }
+  }
+  static async recordRequest(
+    connectionId: string,
+    provider: string
+  ): Promise<void> {
+    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: number) => t > windowStart)
+        : [];
+
+      requests.push(now);
+      await this.redisClient.setex(
+        key,
+        Math.ceil(config.windowMs / 1000),
+        JSON.stringify(requests)
+      );
+    } catch (error) {
+      getConfig().LOGGER.error(`Rate limit record error: ${error}`);
+    }
+  }
+
+  static async getRawRequestTimestamps(key: string): Promise<number[]> {
+    try {
+      const data = await this.redisClient.get(key);
+      return data ? JSON.parse(data) : [];
+    } catch (error) {
+      getConfig().LOGGER.error(
+        `Error fetching raw request timestamps: ${error}`
+      );
+      return [];
+    }
+  }
+
+  static getRateLimitConfig(provider: string): IRateLimitConfig | undefined {
+    return this.initializeRateLimitConfigs().get(provider);
+  }
+}

package/tsconfig.json

@@ -6,6 +6,10 @@
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",
+    "baseUrl": ".",
+    "paths": {
+      "src/*": ["src/*"]
+    },
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,

package/src/device/local/entities/README.md

@@ -1,173 +0,0 @@
-# AlertBuilder - Builder Pattern Implementation
-
-## Overview
-
-The `AlertBuilder` is a TypeScript implementation of the Builder design pattern, specifically designed to help construct `CreateAlertData` objects with a fluent interface. This is a standard and widely-used design pattern in TypeScript for creating complex objects with optional parameters.
-
-## Why Use the Builder Pattern?
-
-The Builder pattern is particularly useful for:
-
-1. **Complex Object Construction**: When creating objects with many optional parameters
-2. **Fluent Interface**: Provides a readable, chainable API
-3. **Validation**: Ensures required fields are provided before object creation
-4. **Default Values**: Automatically sets sensible defaults
-5. **Type Safety**: Provides compile-time type checking
-
-## Usage Examples
-
-### Basic Usage
-
-```typescript
-import { AlertBuilder } from "./AlertBuilder";
-import { AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
-
-const alertData = new AlertBuilder()
-  .setCategory(AlertCategory.OPERATIONS)
-  .setPropertyId("prop123")
-  .setTitle("Device Offline")
-  .setDescription("Device has been offline for more than 5 minutes")
-  .setEntityId("device456")
-  .setEntityType(EntityType.DEVICE)
-  .setSeverity(AlertSeverity.HIGH)
-  .setCreatedBy("user789")
-  .build();
-```
-
-### Using Static Factory Methods
-
-```typescript
-// Create a device-specific alert
-const deviceAlert = AlertBuilder.createDeviceAlert("device123", "prop456")
-  .setCategory(AlertCategory.READINESS)
-  .setTitle("Device Maintenance Required")
-  .setDescription("Device firmware update is available")
-  .setSeverity(AlertSeverity.MEDIUM)
-  .setCreatedBy("system")
-  .build();
-
-// Create a hub-specific alert
-const hubAlert = AlertBuilder.createHubAlert("hub789", "prop202")
-  .setCategory(AlertCategory.OPERATIONS)
-  .setTitle("Hub Connection Lost")
-  .setDescription("Hub has lost connection to the network")
-  .setSeverity(AlertSeverity.CRITICAL)
-  .setCreatedBy("network-monitor")
-  .build();
-```
-
-### Using Predefined Alert Types
-
-```typescript
-// Security alert with CRITICAL severity
-const securityAlert = AlertBuilder.createSecurityAlert()
-  .setPropertyId("prop789")
-  .setTitle("Unauthorized Access Attempt")
-  .setDescription("Multiple failed login attempts detected")
-  .setEntityId("user123")
-  .setEntityType(EntityType.USER)
-  .setCreatedBy("security-system")
-  .build();
-
-// Energy alert with LOW severity
-const energyAlert = AlertBuilder.createEnergyAlert()
-  .setPropertyId("prop101")
-  .setTitle("High Energy Consumption")
-  .setDescription("Energy usage is 20% above normal levels")
-  .setEntityId("zone456")
-  .setEntityType(EntityType.COLLECTION)
-  .setCreatedBy("energy-monitor")
-  .build();
-```
-
-### Reusing Builder Instances
-
-```typescript
-const builder = new AlertBuilder()
-  .setPropertyId("prop404")
-  .setCreatedBy("system");
-
-const alert1 = builder
-  .setCategory(AlertCategory.OPERATIONS)
-  .setTitle("Device Temperature High")
-  .setDescription("Device temperature exceeds normal operating range")
-  .setEntityId("device789")
-  .setEntityType(EntityType.DEVICE)
-  .setSeverity(AlertSeverity.HIGH)
-  .build();
-
-const alert2 = builder
-  .reset()
-  .setPropertyId("prop404")
-  .setCategory(AlertCategory.ENERGY)
-  .setTitle("Low Battery Warning")
-  .setDescription("Device battery level is below 20%")
-  .setEntityId("device789")
-  .setEntityType(EntityType.DEVICE)
-  .setSeverity(AlertSeverity.MEDIUM)
-  .setCreatedBy("system")
-  .build();
-```
-
-## Available Methods
-
-### Instance Methods
-
-- `setCategory(category: AlertCategory)`: Sets the alert category
-- `setPropertyId(propertyId: string)`: Sets the property ID (required)
-- `setTitle(title: string)`: Sets the alert title (required)
-- `setDescription(description: string)`: Sets the alert description (required)
-- `setEntityId(entityId?: string)`: Sets the entity ID (optional)
-- `setEntityType(entityType: EntityType)`: Sets the entity type (required)
-- `setSeverity(severity?: AlertSeverity)`: Sets the alert severity (optional, defaults to MEDIUM)
-- `setCreatedBy(createdBy?: string)`: Sets the user who created the alert (optional)
-- `setSnoozeUntil(snoozeUntil?: Date)`: Sets the snooze until date (optional)
-- `build()`: Builds and returns the CreateAlertData object
-- `reset()`: Resets the builder to its initial state
-
-### Static Factory Methods
-
-- `createReadinessAlert()`: Creates a builder with READINESS category and MEDIUM severity
-- `createOperationsAlert()`: Creates a builder with OPERATIONS category and HIGH severity
-- `createSecurityAlert()`: Creates a builder with SECURITY category and CRITICAL severity
-- `createEnergyAlert()`: Creates a builder with ENERGY category and LOW severity
-- `createDeviceAlert(deviceId: string, propertyId: string)`: Creates a device-specific alert builder
-- `createHubAlert(hubId: string, propertyId: string)`: Creates a hub-specific alert builder
-
-## Validation
-
-The builder automatically validates that all required fields are present when `build()` is called. Required fields are:
-
-- `category`
-- `propertyId`
-- `title`
-- `description`
-- `entityType`
-
-If any required field is missing, an error will be thrown with details about which fields are missing.
-
-## Default Values
-
-- `severity`: Defaults to `AlertSeverity.MEDIUM` if not specified
-
-## Error Handling
-
-The builder includes comprehensive error handling:
-
-- Validates required fields before building
-- Trims whitespace from string inputs
-- Validates that propertyId and title are not empty strings
-- Provides clear error messages for missing or invalid data
-
-## Design Pattern Benefits
-
-This implementation follows the Builder pattern which provides:
-
-1. **Separation of Concerns**: Object construction is separated from object representation
-2. **Fluent Interface**: Method chaining for better readability
-3. **Immutability**: Each method returns a new builder instance
-4. **Validation**: Built-in validation before object creation
-5. **Flexibility**: Easy to add new fields or modify existing ones
-6. **Type Safety**: Full TypeScript support with compile-time checking
-
-This is indeed a standard design pattern in TypeScript and is widely used in enterprise applications for constructing complex objects with many optional parameters. 

package/src/device/local/entities/index.ts

@@ -1,2 +0,0 @@
-export { AlertBuilder } from "./AlertBuilder";
-export { IssueBuilder } from "./IssueBuilder"; 

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export * from "./config.types";
-export * from "./issue.types";
-export * from "./alert.types";