dt-common-device 1.2.13 → 2.0.0

package/TROUBLESHOOTING.md

@@ -0,0 +1,184 @@
+# Troubleshooting Guide
+
+## HTTP Request Issues
+
+### Error: `TypeError: Cannot read properties of undefined (reading 'emit')`
+
+This error typically occurs when HTTP requests fail due to network connectivity issues, invalid service URLs, or request timeouts.
+
+#### Common Causes:
+
+1. **Invalid or unreachable DEVICE_SERVICE URL**
+2. **Network connectivity issues**
+3. **Service is down or not responding**
+4. **Request timeout (default: 30 seconds)**
+5. **DNS resolution failures**
+
+#### Solutions:
+
+1. **Check Service URL Configuration**
+
+   ```typescript
+   // Ensure DEVICE_SERVICE URL is properly configured
+   const config: DeviceConfig = {
+     DEVICE_SERVICE: "http://localhost:3000", // or your actual service URL
+     // ... other config
+   };
+   ```
+
+2. **Verify Network Connectivity**
+
+   ```bash
+   # Test if the service is reachable
+   curl -v http://your-device-service-url/health
+   ```
+
+3. **Check Service Status**
+
+   - Ensure the device service is running
+   - Check if the service is listening on the correct port
+   - Verify firewall settings
+
+4. **Enable Debug Logging**
+   ```typescript
+   const config: DeviceConfig = {
+     LOGGER: {
+       info: (msg, ...args) => console.log(msg, ...args),
+       warn: (msg, ...args) => console.warn(msg, ...args),
+       error: (msg, ...args) => console.error(msg, ...args),
+     },
+     // ... other config
+   };
+   ```
+
+#### Recent Fixes Applied:
+
+1. **Centralized Axios Instance**: All HTTP requests now use a single, properly configured axios instance
+2. **Added Request Timeouts**: All HTTP requests have a 30-second timeout
+3. **Improved Error Handling**: Better error messages with context
+4. **Request/Response Interceptors**: Added logging for debugging
+5. **URL Validation**: Service URLs are validated during initialization
+6. **Retry Logic**: Failed requests can be retried with exponential backoff
+
+#### Architecture Changes:
+
+**Before**: Each repository created its own axios instance
+
+```typescript
+// Old approach - each repository had its own axios setup
+export class DeviceRepository {
+  private readonly axiosInstance;
+
+  constructor() {
+    this.axiosInstance = axios.create({
+      timeout: 30000,
+      // ... other config
+    });
+    // ... interceptors setup
+  }
+}
+```
+
+**After**: Centralized axios instance shared across all repositories
+
+```typescript
+// New approach - centralized axios instance
+import { getDeviceServiceAxiosInstance } from "../../../utils/http-utils";
+
+export class DeviceRepository {
+  private readonly axiosInstance;
+
+  constructor() {
+    this.axiosInstance = getDeviceServiceAxiosInstance();
+  }
+}
+```
+
+#### Benefits of Centralized Approach:
+
+1. **Consistency**: All HTTP requests use the same configuration
+2. **Maintainability**: Configuration changes only need to be made in one place
+3. **Performance**: Single instance reduces memory usage
+4. **Error Handling**: Centralized error handling and logging
+5. **Testing**: Easier to mock and test HTTP requests
+
+#### Debugging Steps:
+
+1. **Check Logs**: Look for detailed error messages in the logs
+2. **Verify Configuration**: Ensure all required environment variables are set
+3. **Test Connectivity**: Use curl or similar tools to test service endpoints
+4. **Check Network**: Verify network connectivity and DNS resolution
+
+#### Environment Variables Required:
+
+```bash
+# Required for HTTP requests
+DEVICE_SERVICE=http://your-device-service-url
+
+# Required for database connections
+ADMIN_DB_URI=postgresql://...
+MONGODB_URI=mongodb://...
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+# Required for AWS services
+AWS_ACCESS_KEY_ID=your-access-key
+AWS_SECRET_ACCESS_KEY=your-secret-key
+AWS_REGION=your-region
+EVENT_BUS_NAME=your-event-bus
+
+# Required for analytics
+POSTHOG_API_KEY=your-api-key
+POSTHOG_HOST=your-posthog-host
+```
+
+#### Example Error Handling:
+
+```typescript
+import { initialize } from "dt-common-device";
+
+try {
+  await initialize({
+    DEVICE_SERVICE: "http://localhost:3000",
+    LOGGER: console,
+    // ... other config
+  });
+} catch (error) {
+  console.error("Initialization failed:", error.message);
+  // Handle initialization error
+}
+```
+
+#### Repository Error Handling:
+
+All repository classes now include:
+
+- Proper try-catch blocks
+- Detailed error logging
+- Request timeouts
+- Response validation
+- Network error detection
+- Centralized axios instance usage
+
+#### Affected Files:
+
+The following repository files now use the centralized axios instance:
+
+- `src/device/local/repository/Device.repository.ts`
+- `src/device/local/repository/Hub.repository.ts`
+- `src/device/local/repository/Schedule.repository.ts`
+
+Other repository files (Alert, Issue, Property, Connection) use database operations and don't require HTTP requests.
+
+#### HTTP Utilities:
+
+The centralized axios instance is managed in:
+
+- `src/utils/http-utils.ts` - Contains the axios instance creation and configuration
+
+If you continue to experience issues, please:
+
+1. Check the service logs for detailed error messages
+2. Verify all environment variables are correctly set
+3. Test network connectivity to the service endpoints
+4. Ensure the target services are running and accessible

package/dist/config/config.d.ts

@@ -1,13 +1,16 @@
 import { DeviceConfig } from "../types";
-export declare function initialize(cfg: DeviceConfig): void;
+import { InternalEventSubscription } from "../events";
+export declare function initialize(cfg: DeviceConfig): Promise<void>;
 export declare function getConfig(): DeviceConfig;
-export declare function checkAwsEnv(): void;
+export declare function getEventSubscription(): InternalEventSubscription | null;
+export declare function checkRequiredEnv(): void;
 export declare function ensureAuditInitialized(): void;
 /**
  * Returns the PostgreSQL DB URI from environment variables.
  * Throws an error if not set.
  */
 export declare function getPostgresDbUri(): string;
+export declare function getMongoUri(): string;
 /**
  * Returns the Redis DB Host and port from environment variables.
  * Throws an error if not set.
@@ -16,3 +19,7 @@ export declare function getRedisDbHostAndPort(): {
     host: string;
     port: number;
 };
+/**
+ * Graceful shutdown function
+ */
+export declare function shutdown(): Promise<void>;

package/dist/config/config.js

@@ -5,28 +5,76 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initialize = initialize;
 exports.getConfig = getConfig;
-exports.checkAwsEnv = checkAwsEnv;
+exports.getEventSubscription = getEventSubscription;
+exports.checkRequiredEnv = checkRequiredEnv;
 exports.ensureAuditInitialized = ensureAuditInitialized;
 exports.getPostgresDbUri = getPostgresDbUri;
+exports.getMongoUri = getMongoUri;
 exports.getRedisDbHostAndPort = getRedisDbHostAndPort;
+exports.shutdown = shutdown;
 const dt_audit_library_1 = require("dt-audit-library");
+const db_1 = require("../db/db");
 const dotenv_1 = __importDefault(require("dotenv"));
+const events_1 = require("../events");
+const http_utils_1 = require("../utils/http-utils");
 dotenv_1.default.config();
 let config = null;
 let auditInitialized = false;
-function initialize(cfg) {
-    // Check if at least one service is provided
-    const hasAtLeastOneService = [
-        "ADMIN_SERVICE",
-        "OPERATIONAL_SERVICE",
-        "DEVICE_SERVICE",
-        "MONITORING_SERVICE",
-        "ENERGY_SERVICE",
-    ].some((key) => Boolean(cfg[key]));
-    if (!hasAtLeastOneService) {
-        throw new Error("At least one http service must be initialized");
-    }
+let eventSubscription = null;
+async function initialize(cfg) {
+    // Initialize config
     config = { ...cfg };
+    // Validate service URLs if provided
+    if (cfg.DEVICE_SERVICE && !(0, http_utils_1.validateServiceUrl)(cfg.DEVICE_SERVICE)) {
+        throw new Error(`Invalid DEVICE_SERVICE URL: ${cfg.DEVICE_SERVICE}`);
+    }
+    if (cfg.ADMIN_SERVICE && !(0, http_utils_1.validateServiceUrl)(cfg.ADMIN_SERVICE)) {
+        throw new Error(`Invalid ADMIN_SERVICE URL: ${cfg.ADMIN_SERVICE}`);
+    }
+    if (cfg.ACCESS_SERVICE && !(0, http_utils_1.validateServiceUrl)(cfg.ACCESS_SERVICE)) {
+        throw new Error(`Invalid ACCESS_SERVICE URL: ${cfg.ACCESS_SERVICE}`);
+    }
+    if (cfg.ENERGY_SERVICE && !(0, http_utils_1.validateServiceUrl)(cfg.ENERGY_SERVICE)) {
+        throw new Error(`Invalid ENERGY_SERVICE URL: ${cfg.ENERGY_SERVICE}`);
+    }
+    // Initialize internal event subscription if handler is provided
+    if (cfg.INTERNAL_EVENT_HANDLER) {
+        try {
+            eventSubscription = new events_1.InternalEventSubscription(cfg.INTERNAL_EVENT_HANDLER);
+            cfg.LOGGER.info("InternalEventSubscription initialized successfully");
+        }
+        catch (error) {
+            cfg.LOGGER.error("Failed to initialize InternalEventSubscription", {
+                error,
+            });
+            throw error;
+        }
+    }
+    // Connect to databases
+    try {
+        await (0, db_1.connectDatabase)();
+        cfg.LOGGER.info("Database connections established successfully");
+    }
+    catch (error) {
+        cfg.LOGGER.error("Failed to connect to databases", { error });
+        throw error;
+    }
+    // Subscribe to events if event subscription is available
+    if (eventSubscription) {
+        try {
+            await eventSubscription.subscribe();
+            cfg.LOGGER.info("Event subscription started successfully");
+        }
+        catch (error) {
+            cfg.LOGGER.error(`Failed to start event subscription: ${error.message || error.toString()}`);
+            // Don't throw here as the main setup should continue
+        }
+    }
+    // Check if required env variables are set
+    checkRequiredEnv();
+    // Initialize audit
+    ensureAuditInitialized();
+    console.log("dt-common-device: Initialization completed successfully");
 }
 function getConfig() {
     if (!config) {
@@ -34,12 +82,21 @@ function getConfig() {
     }
     return config;
 }
-function checkAwsEnv() {
+function getEventSubscription() {
+    return eventSubscription;
+}
+function checkRequiredEnv() {
     const requiredEnv = [
         "AWS_SECRET_ACCESS_KEY",
         "AWS_REGION",
         "AWS_ACCESS_KEY_ID",
         "EVENT_BUS_NAME",
+        "ADMIN_DB_URI",
+        "MONGODB_URI",
+        "REDIS_HOST",
+        "REDIS_PORT",
+        "POSTHOG_API_KEY",
+        "POSTHOG_HOST",
     ];
     const missing = requiredEnv.filter((key) => !process.env[key]);
     if (missing.length > 0) {
@@ -52,6 +109,7 @@ function ensureAuditInitialized() {
     const apiKey = process.env.POSTHOG_API_KEY;
     const host = process.env.POSTHOG_HOST;
     if (!apiKey || !host) {
+        getConfig().LOGGER.error("POSTHOG_API_KEY and POSTHOG_HOST must be set in environment variables");
         throw new Error("dt-common-device: POSTHOG_API_KEY and POSTHOG_HOST must be set in environment variables");
     }
     (0, dt_audit_library_1.initializeAudit)(apiKey, host);
@@ -64,10 +122,19 @@ function ensureAuditInitialized() {
 function getPostgresDbUri() {
     const fullUri = process.env.ADMIN_DB_URI;
     if (!fullUri) {
+        getConfig().LOGGER.error("ADMIN_DB_URI must be set in environment variables or .env file");
         throw new Error("dt-common-device: ADMIN_DB_URI must be set in environment variables or .env file");
     }
     return fullUri;
 }
+function getMongoUri() {
+    const fullUri = process.env.MONGODB_URI;
+    if (!fullUri) {
+        getConfig().LOGGER.error("MONGODB_URI must be set in environment variables or .env file");
+        throw new Error("dt-common-device: MONGODB_URI must be set in environment variables or .env file");
+    }
+    return fullUri;
+}
 /**
  * Returns the Redis DB Host and port from environment variables.
  * Throws an error if not set.
@@ -76,7 +143,23 @@ function getRedisDbHostAndPort() {
     const host = process.env.REDIS_HOST;
     const port = process.env.REDIS_PORT;
     if (!host || !port) {
+        getConfig().LOGGER.error("REDIS_HOST and REDIS_PORT must be set in environment variables");
         throw new Error("dt-common-device: REDIS_HOST and REDIS_PORT must be set in environment variables");
     }
     return { host, port: Number(port) };
 }
+/**
+ * Graceful shutdown function
+ */
+async function shutdown() {
+    if (eventSubscription) {
+        try {
+            await eventSubscription.unsubscribe();
+            getConfig().LOGGER.info("Event subscription stopped successfully");
+        }
+        catch (error) {
+            getConfig().LOGGER.error("Failed to stop event subscription", { error });
+        }
+    }
+    getConfig().LOGGER.info("dt-common-device: Shutdown completed");
+}

package/dist/constants/Event.d.ts

@@ -0,0 +1,75 @@
+export declare const DT_EVENT_TYPES: {
+    DEVICE: {
+        CREATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        STATE: {
+            SET: string;
+            UNKNOWN: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+        STATUS: {
+            SET: string;
+            ONLINE: string;
+            OFFLINE: string;
+            UNKNOWN: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+        BATTERY: {
+            SET: string;
+            UNKNOWN: string;
+            LOW: string;
+            CRITICAL: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+        META_DATA: {
+            SET: string;
+            UPDATED: string;
+            CHANGED: string;
+        };
+    };
+    CONNECTION: {
+        CREATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+    };
+    PROPERTY: {
+        CREATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        UPDATE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        DELETE: {
+            SUCCESS: string;
+            FAILED: string;
+        };
+        PREFERENCES: {
+            UPDATED: string;
+            CREATED: string;
+        };
+    };
+};

package/dist/constants/Event.js

@@ -0,0 +1,78 @@
+"use strict";
+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",
+        },
+        STATE: {
+            SET: "device.state.set",
+            UNKNOWN: "device.state.unknown",
+            UPDATED: "device.state.updated",
+            CHANGED: "device.state.changed",
+        },
+        STATUS: {
+            SET: "device.status.set",
+            ONLINE: "device.status.online",
+            OFFLINE: "device.status.offline",
+            UNKNOWN: "device.status.unknown",
+            UPDATED: "device.status.updated",
+            CHANGED: "device.status.changed",
+        },
+        BATTERY: {
+            SET: "device.battery.set",
+            UNKNOWN: "device.battery.unknown",
+            LOW: "device.battery.low",
+            CRITICAL: "device.battery.critical",
+            UPDATED: "device.battery.updated",
+            CHANGED: "device.battery.changed",
+        },
+        META_DATA: {
+            SET: "device.metaData.set",
+            UPDATED: "device.metaData.updated",
+            CHANGED: "device.metaData.changed",
+        },
+    },
+    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",
+        },
+    },
+    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",
+        },
+        PREFERENCES: {
+            UPDATED: "property.preferences.updated",
+            CREATED: "property.preferences.created",
+        },
+    },
+};

package/dist/db/db.d.ts

@@ -1,2 +1,3 @@
 import { Pool } from "pg";
 export declare function getPostgresClient(): Pool;
+export declare const connectDatabase: () => Promise<void>;

package/dist/db/db.js

@@ -1,11 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectDatabase = void 0;
 exports.getPostgresClient = getPostgresClient;
 const pg_1 = require("pg");
 const config_1 = require("../config/config");
-const URI = (0, config_1.getPostgresDbUri)();
-let pool = null;
+const mongoose_1 = __importDefault(require("mongoose"));
 function getPostgresClient() {
+    const URI = (0, config_1.getPostgresDbUri)();
+    let pool = null;
     if (!pool) {
         pool = new pg_1.Pool({
             connectionString: URI,
@@ -13,3 +18,14 @@ function getPostgresClient() {
     }
     return pool;
 }
+const connectDatabase = async () => {
+    try {
+        const URI = (0, config_1.getMongoUri)();
+        await mongoose_1.default.connect(URI);
+        console.log(`Connected to MongoDB at ${URI.split("/").at(-1)}`);
+    }
+    catch (error) {
+        console.error("Error connecting to MongoDB:", error);
+    }
+};
+exports.connectDatabase = connectDatabase;

package/dist/device/local/entities/AlertBuilder.d.ts

@@ -0,0 +1,87 @@
+import { CreateAlertData, AlertCategory, AlertSeverity, EntityType } from "../../../types/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)
+ *   .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();
+ */
+export declare class AlertBuilder {
+    private data;
+    /**
+     * Sets the alert category
+     */
+    setCategory(category: AlertCategory): AlertBuilder;
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId: string): AlertBuilder;
+    /**
+     * Sets the alert title
+     */
+    setTitle(title: string): AlertBuilder;
+    /**
+     * Sets the alert description
+     */
+    setDescription(description: string): AlertBuilder;
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId?: string): AlertBuilder;
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType: EntityType): AlertBuilder;
+    /**
+     * Sets the alert severity (optional, defaults to MEDIUM)
+     */
+    setSeverity(severity?: AlertSeverity): AlertBuilder;
+    /**
+     * Sets the user who created the alert (optional)
+     */
+    setCreatedBy(createdBy?: string): AlertBuilder;
+    /**
+     * Sets the snooze until date (optional)
+     */
+    setSnoozeUntil(snoozeUntil?: Date): AlertBuilder;
+    /**
+     * Validates that all required fields are present
+     */
+    private validate;
+    /**
+     * Builds and returns the CreateAlertData object
+     * @throws Error if required fields are missing
+     */
+    build(): CreateAlertData;
+    /**
+     * Resets the builder to its initial state
+     */
+    reset(): AlertBuilder;
+    /**
+     * Creates a new builder instance with predefined values for common alert types
+     */
+    static createReadinessAlert(): AlertBuilder;
+    static createOperationsAlert(): AlertBuilder;
+    static createSecurityAlert(): AlertBuilder;
+    static createEnergyAlert(): AlertBuilder;
+    /**
+     * Creates a device-specific alert builder
+     */
+    static createDeviceAlert(deviceId: string, propertyId: string): AlertBuilder;
+    /**
+     * Creates a hub-specific alert builder
+     */
+    static createHubAlert(hubId: string, propertyId: string): AlertBuilder;
+}

package/dist/device/local/entities/AlertBuilder.example.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Example usage of AlertBuilder
+ * This file demonstrates various ways to use the AlertBuilder pattern
+ */
+export declare function createBasicAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createDeviceAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createSecurityAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createEnergyAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createHubAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createSnoozedAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createMultipleAlerts(): import("../../../types/alert.types").CreateAlertData[];