dt-common-device 2.0.7 → 3.0.1

package/dist/queue/utils/jobUtils.js

@@ -0,0 +1,64 @@
+"use strict";
+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)
+            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 };
+    }
+}
+exports.JobUtils = JobUtils;

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

@@ -0,0 +1,5 @@
+export declare class QueueUtils {
+    static getQueueKey(microservice: string, 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;
+}

package/dist/queue/utils/queueUtils.js

@@ -0,0 +1,60 @@
+"use strict";
+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}`;
+    }
+    static getOrCreateQueue(queueKey, queues) {
+        return (queues.get(queueKey) ??
+            queues
+                .set(queueKey, new (require("bullmq").Queue)(queueKey, {
+                connection: (0, redis_1.getRedisClient)(),
+            }))
+                .get(queueKey));
+    }
+    static getOrCreateWorker(queueKey, workers, processFunction, jobResults) {
+        if (workers.has(queueKey))
+            return;
+        const { Worker } = require("bullmq");
+        const worker = new Worker(queueKey, processFunction, {
+            connection: (0, redis_1.getRedisClient)(),
+            concurrency: 1,
+            removeOnComplete: { age: 300, count: 1 },
+            removeOnFail: { age: 300, count: 1 },
+            lockDuration: 300000,
+            stalledInterval: 60000,
+        });
+        // Simplified event handlers
+        worker.on("completed", (job) => {
+            (0, config_1.getConfig)().LOGGER.info(`HTTP request completed: ${job.id} [${queueKey}]`);
+            job.returnvalue
+                .then((result) => jobResults.set(job.id, {
+                result,
+                resolved: true,
+                timestamp: Date.now(),
+            }))
+                .catch((error) => jobResults.set(job.id, {
+                error: error.message,
+                resolved: true,
+                timestamp: Date.now(),
+            }));
+        });
+        worker.on("failed", (job, err) => {
+            (0, config_1.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) => (0, config_1.getConfig)().LOGGER.error(`Worker error for ${queueKey}: ${err.message}`));
+        worker.on("stalled", (jobId) => (0, config_1.getConfig)().LOGGER.warn(`Job ${jobId} stalled in worker ${queueKey}`));
+        worker.on("active", (job) => (0, config_1.getConfig)().LOGGER.info(`HTTP request started: ${job.id} [${queueKey}]`));
+        workers.set(queueKey, worker);
+        (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey}`);
+    }
+}
+exports.QueueUtils = QueueUtils;

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

@@ -0,0 +1,10 @@
+import { IRateLimitConfig } from "../interfaces";
+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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitUtils = void 0;
+const redis_1 = require("../../db/redis");
+const config_1 = require("../../config/config");
+class RateLimitUtils {
+    static async checkRateLimit(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)
+                : [];
+            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) {
+            (0, config_1.getConfig)().LOGGER.error(`Rate limit check error: ${error}`);
+            return true;
+        }
+    }
+    static initializeRateLimitConfigs() {
+        const configs = new Map();
+        // Configure rate limits for different providers
+        configs.set("Sensibo", {
+            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": "2.0.7",
+  "version": "3.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "axios": "1.10.0",
+    "bullmq": "5.56.4",
     "dt-audit-library": "^1.0.3",
     "dt-pub-sub": "^1.0.0",
     "ioredis": "5.6.1",

package/src/{device/local/models → alerts}/Alert.model.ts

@@ -6,7 +6,7 @@ import {
   AlertDocument as IAlertDocument,
   CreateAlertData,
   UpdateAlertData,
-} from "../../../types/alert.types";
+} from "./alert.types";
 
 // Interface for instance methods
 interface IAlertMethods {

package/src/{device/local/repository → alerts}/Alert.repository.ts

@@ -1,12 +1,12 @@
 import { Service } from "typedi";
-import { AlertModel, IAlertDocument } from "../models/Alert.model";
+import { AlertModel, IAlertDocument } from "./Alert.model";
 import {
   CreateAlertData,
   UpdateAlertData,
   AlertCategory,
   AlertSeverity,
   EntityType,
-} from "../../../types/alert.types";
+} from "./alert.types";
 
 @Service()
 export class AlertRepository {

package/src/{device/local/services → alerts}/Alert.service.ts

@@ -1,14 +1,14 @@
 import { Service } from "typedi";
-import { AlertRepository } from "../repository/Alert.repository";
-import { AlertModel, IAlertDocument } from "../models/Alert.model";
+import { AlertRepository } from "./Alert.repository";
+import { AlertModel, IAlertDocument } from "./Alert.model";
 import {
   CreateAlertData,
   UpdateAlertData,
   AlertCategory,
   AlertSeverity,
   EntityType,
-} from "../../../types/alert.types";
-import { AlertBuilder } from "../entities/AlertBuilder";
+} from "./alert.types";
+import { AlertBuilder } from "./AlertBuilder";
 
 @Service()
 export class AlertService {
@@ -156,7 +156,9 @@ export class AlertService {
    * Create a new alert with business logic validation
    * Accepts either a CreateAlertData object or an AlertBuilder instance
    */
-  async createAlert(alertData: CreateAlertData | AlertBuilder): Promise<IAlertDocument> {
+  async createAlert(
+    alertData: CreateAlertData | AlertBuilder
+  ): Promise<IAlertDocument> {
     let processedAlertData: CreateAlertData;
 
     // Handle AlertBuilder instance
@@ -171,11 +173,16 @@ export class AlertService {
 
     // Business logic: Set default severity if not provided
     if (!processedAlertData.severity) {
-      processedAlertData.severity = this.determineDefaultSeverity(processedAlertData.category);
+      processedAlertData.severity = this.determineDefaultSeverity(
+        processedAlertData.category
+      );
     }
 
     // Business logic: Validate snooze date is in the future
-    if (processedAlertData.snoozeUntil && processedAlertData.snoozeUntil <= new Date()) {
+    if (
+      processedAlertData.snoozeUntil &&
+      processedAlertData.snoozeUntil <= new Date()
+    ) {
       throw new Error("Snooze date must be in the future");
     }
 

package/src/{device/local/entities → alerts}/AlertBuilder.example.ts

@@ -1,5 +1,5 @@
 import { AlertBuilder } from "./AlertBuilder";
-import { AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+import { AlertCategory, AlertSeverity, EntityType } from "./alert.types";
 
 /**
  * Example usage of AlertBuilder
@@ -123,4 +123,4 @@ export function createMultipleAlerts() {
     .build();
 
   return [alert1, alert2];
-} 
+}

package/src/{device/local/entities → alerts}/AlertBuilder.ts

@@ -3,15 +3,15 @@ import {
   AlertCategory,
   AlertSeverity,
   EntityType,
-} from "../../../types/alert.types";
+} from "./alert.types";
 
 /**
  * AlertBuilder - A builder pattern implementation for constructing CreateAlertData objects
- * 
+ *
  * This builder provides a fluent interface for creating alert data with proper validation
  * and default values. It follows the Builder pattern which is a standard design pattern
  * in TypeScript for constructing complex objects.
- * 
+ *
  * Usage example:
  * const alertData = new AlertBuilder()
  *   .setCategory(AlertCategory.OPERATIONS)
@@ -120,8 +120,16 @@ export class AlertBuilder {
    * Validates that all required fields are present
    */
   private validate(): void {
-    const requiredFields = ["category", "propertyId", "title", "description", "entityType"];
-    const missingFields = requiredFields.filter(field => !this.data[field as keyof CreateAlertData]);
+    const requiredFields = [
+      "category",
+      "propertyId",
+      "title",
+      "description",
+      "entityType",
+    ];
+    const missingFields = requiredFields.filter(
+      (field) => !this.data[field as keyof CreateAlertData]
+    );
 
     if (missingFields.length > 0) {
       throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
@@ -197,6 +205,4 @@ export class AlertBuilder {
       .setEntityId(hubId)
       .setPropertyId(propertyId);
   }
-
-
-} 
+}

package/src/{device/local/services → alerts}/AlertService.example.ts

@@ -1,6 +1,6 @@
 import { AlertService } from "./Alert.service";
-import { AlertBuilder } from "../entities/AlertBuilder";
-import { AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+import { AlertBuilder } from "./AlertBuilder";
+import { AlertCategory, AlertSeverity, EntityType } from "./alert.types";
 
 /**
  * Example usage of the updated AlertService with AlertBuilder integration
@@ -215,15 +215,16 @@ export class AlertServiceExample {
       category: AlertCategory.OPERATIONS,
       propertyId: "prop123",
       title: "Legacy Alert",
-      description: "This alert was created using the old CreateAlertData format",
+      description:
+        "This alert was created using the old CreateAlertData format",
       entityId: "device456",
       entityType: EntityType.DEVICE,
       severity: AlertSeverity.MEDIUM,
-      createdBy: "legacy-system"
+      createdBy: "legacy-system",
     };
 
     // This still works with the updated createAlert method
     const alert = await this.alertService.createAlert(alertData);
     return alert;
   }
-} 
+}

package/src/{types → alerts}/alert.types.ts

@@ -1,4 +1,4 @@
-import { EntityType } from "./issue.types";
+import { EntityType } from "../issues/issue.types";
 
 export enum AlertCategory {
   READINESS = "READINESS",
@@ -61,4 +61,4 @@ export interface UpdateAlertData {
 }
 
 // Re-export EntityType from issue.types.ts to avoid duplication
-export { EntityType } from "./issue.types";
+export { EntityType } from "../issues/issue.types";

package/src/alerts/index.ts

@@ -0,0 +1,3 @@
+export * from "./Alert.service";
+export * from "./AlertBuilder";
+export * from "./alert.types";

package/src/config/config.ts

@@ -1,17 +1,17 @@
-import { DeviceConfig } from "../types";
 import { initializeAudit } from "dt-audit-library";
-import { connectDatabase } from "../db/db";
+import { connectDatabase } from "src/db/db";
 import dotenv from "dotenv";
-import { InternalEventSubscription } from "../events";
-import { validateServiceUrl } from "../utils/http.utils";
+import { InternalEventSubscription } from "src/events";
+import { validateServiceUrl } from "src/utils/http.utils";
+import { IConfig } from "./config.types";
 
 dotenv.config();
 
-let config: DeviceConfig | null = null;
+let config: IConfig | null = null;
 let auditInitialized = false;
 let eventSubscription: InternalEventSubscription | null = null;
 
-export async function initialize(cfg: DeviceConfig): Promise<void> {
+export async function initialize(cfg: IConfig): Promise<void> {
   // Initialize config
   config = { ...cfg };
 
@@ -77,7 +77,7 @@ export async function initialize(cfg: DeviceConfig): Promise<void> {
   console.log("dt-common-device: Initialization completed successfully");
 }
 
-export function getConfig(): DeviceConfig {
+export function getConfig(): IConfig {
   if (!config) {
     throw new Error(
       "dt-common-device: Library not initialized. Call initialize() first."

package/src/{types → config}/config.types.ts

@@ -8,7 +8,7 @@ export interface ILogger {
 
 type AllowedSource = "ACCESS_SERVICE" | "ADMIN_SERVICE" | "ENERGY_SERVICE";
 
-export type DeviceConfig = {
+export type IConfig = {
   SOURCE: AllowedSource;
   SQS_QUEUE_URL: string;
   DEVICE_SERVICE?: string;

package/src/{device/local/repository → connection}/Connection.repository.ts

@@ -1,5 +1,5 @@
-import { getPostgresClient } from "../../../db";
-import { IConnection } from "../interfaces/IConnection";
+import { getPostgresClient } from "src/db";
+import { IConnection } from "./IConnection";
 import { Service } from "typedi";
 
 @Service()

package/src/{device/local/services → connection}/Connection.service.ts

@@ -1,6 +1,6 @@
 import { Container } from "typedi";
-import { ConnectionRepository } from "../repository/Connection.repository";
-import { IConnection } from "../interfaces/IConnection";
+import { ConnectionRepository } from "./Connection.repository";
+import { IConnection } from "./IConnection";
 
 export class LocalConnectionService {
   private readonly connectionRepository: ConnectionRepository;

package/src/connection/index.ts

@@ -0,0 +1,3 @@
+export * from "./IConnection";
+export * from "./Connection.service";
+

package/src/device/cloud/entities/CloudDevice.ts

@@ -1,7 +1,7 @@
-import { IDevice } from "../../local/interfaces";
+import { IDevice } from "src/device/local/interfaces";
 import { ICloudDevice } from "../interfaces/ICloudDevice";
 import { ICloudDeviceService } from "../interfaces/ICloudDeviceService";
-import { IConnection } from "../../local/interfaces/IConnection";
+import { IConnection } from "src/connection";
 
 export abstract class CloudDevice implements ICloudDevice {
   deviceId: string;

package/src/device/cloud/entities/CloudDeviceService.ts

@@ -1,5 +1,5 @@
 import { ICloudDeviceService } from "../interfaces/ICloudDeviceService";
-import { IConnection } from "../../local/interfaces/IConnection";
+import { IConnection } from "src/connection";
 
 export class CloudDeviceService implements ICloudDeviceService {
   async getConnection(deviceId: string): Promise<IConnection> {

package/src/device/cloud/entities/DeviceFactory.ts

@@ -1,5 +1,5 @@
-import { IDevice } from "../../local/interfaces";
-import { LocalDeviceService } from "../../local/services/Device.service";
+import { IDevice } from "src/device/local/interfaces";
+import { LocalDeviceService } from "src/device/local/services/Device.service";
 import { IDeviceFactory } from "../interfaces/IDeviceFactory";
 
 export class DeviceFactory implements IDeviceFactory {

package/src/device/cloud/interfaces/ICloudDeviceService.ts

@@ -1,5 +1,5 @@
 // Interface for CloudDeviceService
-import { IConnection } from "../../local/interfaces/IConnection";
+import { IConnection } from "../../../connection";
 
 export interface ICloudDeviceService {
   getConnection(deviceId: string): Promise<IConnection>;

package/src/device/cloud/interfaces/IRawDevice.ts

@@ -1,4 +1,4 @@
-import { IConnection } from "../../local/interfaces";
+import { IConnection } from "../../../connection";
 
 export enum DeviceType {
   HUB = "HUB",

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

@@ -1,4 +1,3 @@
 export * from "./IDevice";
-export * from "./IProperty";
-export * from "./IConnection";
-export * from "./IProperty";
+export * from "./IDtDevice";
+export * from "./ISchedule";

package/src/device/local/repository/Device.repository.ts

@@ -1,9 +1,9 @@
 import { IDevice, IStatus } from "../interfaces/IDevice";
-import { getConfig } from "../../../config/config";
-import { getPostgresClient } from "../../../db";
+import { getConfig } from "src/config/config";
+import { getPostgresClient } from "src/db";
 import { Service } from "typedi";
 import { IDtDevice } from "../interfaces/IDtDevice";
-import { getDeviceServiceAxiosInstance } from "../../../utils/http.utils";
+import { getDeviceServiceAxiosInstance } from "src/utils/http.utils";
 
 @Service()
 export class DeviceRepository {

package/src/device/local/repository/Hub.repository.ts

@@ -1,8 +1,8 @@
-import { getConfig } from "../../../config/config";
-import { getPostgresClient } from "../../../db";
+import { getConfig } from "src/config/config";
+import { getPostgresClient } from "src/db";
 import { Service } from "typedi";
 import { IDevice } from "../interfaces";
-import { getDeviceServiceAxiosInstance } from "../../../utils/http.utils";
+import { getDeviceServiceAxiosInstance } from "src/utils/http.utils";
 
 @Service()
 export class HubRepository {
@@ -26,7 +26,7 @@ export class HubRepository {
 
   async getHubs(hubIds: string[]): Promise<IDevice[]> {
     try {
-      const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
+      const query = hubIds?.length ? `?ids=${hubIds.join(",")}` : "";
       const response = await this.axiosInstance.get(`/devices/hubs${query}`);
       return response.data;
     } catch (error: any) {

package/src/device/local/repository/Schedule.repository.ts

@@ -1,7 +1,7 @@
 import { Service } from "typedi";
-import { getConfig } from "../../../config/config";
+import { getConfig } from "src/config/config";
 import { ISchedule } from "../interfaces/ISchedule";
-import { getDeviceServiceAxiosInstance } from "../../../utils/http.utils";
+import { getDeviceServiceAxiosInstance } from "src/utils/http.utils";
 
 @Service()
 export class ScheduleRepository {

package/src/device/local/services/Device.service.ts

@@ -1,5 +1,5 @@
 import { IDevice, IStatus } from "../interfaces";
-import { EventHandler } from "../../../events/EventHandler";
+import { EventHandler } from "src/events/EventHandler";
 import { isEqual } from "lodash";
 import { DeviceRepository } from "../repository/Device.repository";
 import Container from "typedi";

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

@@ -1,7 +1,3 @@
-export * from "./Alert.service";
-export * from "./Connection.service";
 export * from "./Device.service";
 export * from "./Hub.service";
-export * from "./Issue.service";
-export * from "./Property.service";
 export * from "./Schedule.service";

package/{TROUBLESHOOTING.md → src/docs/TROUBLESHOOTING.md}

@@ -20,7 +20,7 @@ This error typically occurs when HTTP requests fail due to network connectivity
 
    ```typescript
    // Ensure DEVICE_SERVICE URL is properly configured
-   const config: DeviceConfig = {
+   const config: IConfig = {
      DEVICE_SERVICE: "http://localhost:3000", // or your actual service URL
      // ... other config
    };
@@ -41,7 +41,7 @@ This error typically occurs when HTTP requests fail due to network connectivity
 
 4. **Enable Debug Logging**
    ```typescript
-   const config: DeviceConfig = {
+   const config: IConfig = {
      LOGGER: {
        info: (msg, ...args) => console.log(msg, ...args),
        warn: (msg, ...args) => console.warn(msg, ...args),