dt-common-device 1.3.0 → 2.0.1

package/src/types/alert.types.ts

@@ -0,0 +1,64 @@
+import { EntityType } from "./issue.types";
+
+export enum AlertCategory {
+  READINESS = "READINESS",
+  OPERATIONS = "OPERATIONS",
+  SECURITY = "SECURITY",
+  ENERGY = "ENERGY",
+  OTHER = "OTHER",
+}
+
+export enum AlertSeverity {
+  INFO = "INFO",
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+  HIGH = "HIGH",
+  CRITICAL = "CRITICAL",
+}
+
+export interface AlertDocument {
+  _id: string;
+  category: AlertCategory;
+  propertyId: string;
+  title: string;
+  description: string;
+  entityId?: string;
+  entityType: EntityType;
+  severity: AlertSeverity;
+  isRead: boolean;
+  isActive: boolean;
+  isDeleted: boolean;
+  snoozeUntil?: Date;
+  createdBy?: string;
+  updatedBy?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateAlertData {
+  category: AlertCategory;
+  propertyId: string;
+  title: string;
+  description: string;
+  entityId?: string;
+  entityType: EntityType;
+  severity?: AlertSeverity;
+  createdBy?: string;
+  snoozeUntil?: Date;
+}
+
+export interface UpdateAlertData {
+  category?: AlertCategory;
+  title?: string;
+  description?: string;
+  entityId?: string;
+  entityType?: EntityType;
+  severity?: AlertSeverity;
+  isRead?: boolean;
+  isActive?: boolean;
+  snoozeUntil?: Date;
+  updatedBy?: string;
+}
+
+// Re-export EntityType from issue.types.ts to avoid duplication
+export { EntityType } from "./issue.types";

package/src/types/config.types.ts

@@ -1,8 +1,21 @@
+import { IInternalEvent } from "../events/interfaces/IInternalEvent";
+
+export interface ILogger {
+  info(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+}
+
+type AllowedSource = "ACCESS_SERVICE" | "ADMIN_SERVICE" | "ENERGY_SERVICE";
+
 export type DeviceConfig = {
-  ADMIN_SERVICE?: string;
-  OPERATIONAL_SERVICE?: string;
+  SOURCE: AllowedSource;
+  SQS_QUEUE_URL: string;
   DEVICE_SERVICE?: string;
-  MONITORING_SERVICE?: string;
+  ADMIN_SERVICE?: string;
+  ACCESS_SERVICE?: string;
   ENERGY_SERVICE?: string;
-  [key: string]: string | undefined;
+  INTERNAL_EVENT_HANDLER: IInternalEvent;
+  LOGGER: ILogger;
+  [key: string]: any;
 };

package/src/types/index.ts

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

package/src/types/issue.types.ts

@@ -0,0 +1,98 @@
+export enum IssuesCategory {
+  READINESS = "READINESS",
+  OPERATIONS = "OPERATIONS",
+  SECURITY = "SECURITY",
+  ENERGY = "ENERGY",
+  OTHER = "OTHER",
+}
+
+export enum EntityType {
+  DEVICE = "DEVICE",
+  COLLECTION = "COLLECTION",
+  USER = "USER",
+  INTEGRATION = "INTEGRATION",
+  PROPERTY = "PROPERTY",
+  HUB = "HUB",
+  SCHEDULE = "SCHEDULE",
+  ALERT = "ALERT",
+  OTHER = "OTHER",
+}
+
+export enum IssueStatus {
+  PENDING = "PENDING",
+  IN_PROGRESS = "IN_PROGRESS",
+  RESOLVED = "RESOLVED",
+  CLOSED = "CLOSED",
+  CANCELLED = "CANCELLED",
+  ON_HOLD = "ON_HOLD",
+}
+
+export enum IssuePriority {
+  LOW = "LOW",
+  MEDIUM = "MEDIUM",
+  HIGH = "HIGH",
+  CRITICAL = "CRITICAL",
+  URGENT = "URGENT",
+}
+
+export interface IssueComment {
+  id: string;
+  userId: string;
+  content: string;
+  createdAt: Date;
+  updatedAt?: Date;
+}
+
+export interface IssueDocument {
+  _id: string;
+  category: IssuesCategory;
+  propertyId: string;
+  title: string;
+  description: string;
+  entityId?: string;
+  entityType: EntityType;
+  status: IssueStatus;
+  priority: IssuePriority;
+  assignedTo?: string;
+  createdBy: string;
+  updatedBy?: string;
+  isDeleted: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  resolvedAt?: Date;
+  dueDate?: Date;
+  comments?: IssueComment[];
+}
+
+export interface CreateIssueData {
+  category: IssuesCategory;
+  propertyId: string;
+  title: string;
+  description: string;
+  entityId?: string;
+  entityType: EntityType;
+  priority?: IssuePriority;
+  assignedTo?: string;
+  createdBy: string;
+  dueDate?: Date;
+}
+
+export interface UpdateIssueData {
+  category?: IssuesCategory;
+  title?: string;
+  description?: string;
+  entityId?: string;
+  entityType?: EntityType;
+  status?: IssueStatus;
+  priority?: IssuePriority;
+  assignedTo?: string;
+  updatedBy: string;
+  resolvedAt?: Date;
+  dueDate?: Date;
+  isDeleted?: boolean;
+}
+
+export interface AddCommentData {
+  userId: string;
+  content: string;
+}

package/src/utils/http-utils.ts

@@ -0,0 +1,143 @@
+import { getConfig } from "../config/config";
+import axios from "axios";
+
+/**
+ * Validates if a URL is properly formatted and accessible
+ */
+export function validateServiceUrl(url: string): boolean {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  } catch (error) {
+    getConfig().LOGGER.error(`Invalid service URL: ${url}`, error);
+    return false;
+  }
+}
+
+/**
+ * Creates a properly configured axios instance with error handling
+ */
+export function createAxiosInstance(baseURL?: string) {
+  const instance = axios.create({
+    baseURL,
+    timeout: 30000, // 30 seconds timeout
+    maxRedirects: 5,
+    validateStatus: (status: number) => status < 500, // Don't throw on 4xx errors
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": "dt-common-device/1.3.0",
+    },
+  });
+
+  // Add request interceptor for logging
+  instance.interceptors.request.use(
+    (config: any) => {
+      const logger = getConfig().LOGGER;
+      logger.info(
+        `Making request to: ${config.method?.toUpperCase()} ${config.url}`,
+        {
+          baseURL: config.baseURL,
+          timeout: config.timeout,
+        }
+      );
+      return config;
+    },
+    (error: any) => {
+      getConfig().LOGGER.error("Request interceptor error:", error);
+      return Promise.reject(error);
+    }
+  );
+
+  // Add response interceptor for error handling
+  instance.interceptors.response.use(
+    (response: any) => {
+      return response;
+    },
+    (error: any) => {
+      const logger = getConfig().LOGGER;
+      const errorInfo = {
+        url: error.config?.url,
+        method: error.config?.method,
+        status: error.response?.status,
+        statusText: error.response?.statusText,
+        message: error.message,
+        code: error.code,
+        baseURL: error.config?.baseURL,
+      };
+
+      logger.error("HTTP request failed:", errorInfo);
+
+      // Log additional details for network errors
+      if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+        logger.error("Network connectivity issue detected. Please check:", {
+          serviceUrl: error.config?.baseURL,
+          errorCode: error.code,
+          errorMessage: error.message,
+        });
+      }
+
+      return Promise.reject(error);
+    }
+  );
+
+  return instance;
+}
+
+/**
+ * Centralized axios instance for device service
+ */
+let deviceServiceAxiosInstance: any = null;
+
+export function getDeviceServiceAxiosInstance(): any {
+  if (!deviceServiceAxiosInstance) {
+    const { DEVICE_SERVICE } = getConfig();
+    if (!DEVICE_SERVICE) {
+      throw new Error(
+        "DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE."
+      );
+    }
+    deviceServiceAxiosInstance = createAxiosInstance(DEVICE_SERVICE);
+  }
+  return deviceServiceAxiosInstance;
+}
+
+/**
+ * Retry function for failed HTTP requests
+ */
+export async function retryRequest<T>(
+  requestFn: () => Promise<T>,
+  maxRetries: number = 3,
+  delay: number = 1000
+): Promise<T> {
+  let lastError: any;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await requestFn();
+    } catch (error: any) {
+      lastError = error;
+
+      if (attempt === maxRetries) {
+        getConfig().LOGGER.error(
+          `Request failed after ${maxRetries} attempts:`,
+          error
+        );
+        throw error;
+      }
+
+      getConfig().LOGGER.warn(
+        `Request attempt ${attempt} failed, retrying in ${delay}ms:`,
+        {
+          error: error.message,
+          attempt,
+          maxRetries,
+        }
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay *= 2; // Exponential backoff
+    }
+  }
+
+  throw lastError;
+}

package/dist/device/cloud/interface.d.ts

@@ -1,101 +0,0 @@
-import { IConnection, IConnectionConnectParams, IDevice, IDeviceAccountResponse, IDeviceCommand, ISmartthingsDeviceCommand, ICommandResponse } from "./types";
-/**
- * Class interface for device cloud operations and connection management
- */
-export interface IDeviceCloudService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
-    getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    getDevices(connection: IConnection): Promise<IDevice[]>;
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    filterDevices(connection: IConnection, devices: any[]): Promise<IDevice[]>;
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
-}
-/**
- * Interface for device command operations
- */
-export interface IDeviceCommandManager {
-    /**
-     * Invokes a command on a device
-     * @param command - Device command to execute
-     * @param deviceId - Device identifier
-     * @returns Promise with command response
-     */
-    invokeCommand(command: IDeviceCommand, deviceId: string): Promise<ICommandResponse>;
-}
-/**
- * Interface for SmartThings specific device command operations
- */
-export interface ISmartthingsDeviceCommandManager extends IDeviceCommandManager {
-    /**
-     * Performs device action for SmartThings
-     * @param commands - Array of SmartThings device commands
-     * @param deviceId - Device identifier
-     * @param accessToken - Access token for authentication
-     * @returns Promise with action result
-     */
-    performDeviceAction(commands: ISmartthingsDeviceCommand[], deviceId: string, accessToken: string): Promise<any>;
-    /**
-     * Gets device status for SmartThings
-     * @param deviceId - Device identifier
-     * @param accessToken - Access token for authentication
-     * @returns Promise with device status
-     */
-    getDeviceStatus(deviceId: string, accessToken: string): Promise<any>;
-    /**
-     * Gets device lock status for SmartThings
-     * @param deviceId - Device identifier
-     * @param accessToken - Access token for authentication
-     * @returns Promise with lock status
-     */
-    getDeviceLockStatus(deviceId: string, accessToken: string): Promise<any>;
-}
-/**
- * Interface for device command factory
- */
-export interface IDeviceCommandManagerFactory {
-    /**
-     * Creates a device command manager for a specific connection provider
-     * @param connectionProvider - Connection provider type
-     * @param connection - Connection object
-     * @returns Device command manager instance
-     */
-    createDeviceCommandManager(connectionProvider: string, connection: IConnection): IDeviceCommandManager;
-}
-/**
- * Interface for device command classes
- */
-export interface IDeviceCommandClass {
-    /**
-     * Creates a SmartThings device command from a generic device command
-     * @param deviceCommand - Generic device command
-     * @returns SmartThings device command
-     */
-    fromDeviceCommand(deviceCommand: IDeviceCommand): ISmartthingsDeviceCommand;
-}

package/dist/device/cloud/interfaces/IDeviceConnectionService.d.ts

@@ -1,7 +0,0 @@
-import { IConnection, IConnectionConnectParams, IDeviceAccountResponse } from "../types";
-export interface IDeviceConnectionService {
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    getDevices(connection: IConnection): Promise<any>;
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
-}

package/dist/device/cloud/interfaces/IDevicesService.d.ts

@@ -1,9 +0,0 @@
-import { IConnection } from "../types";
-export interface IDeviceService {
-    getDevices(connection: IConnection): Promise<Record<string, any>[]>;
-    getDevice(connectionId: string, deviceId: string): Promise<Record<string, any>>;
-    getStatus(connectionId: string, deviceId: string): Promise<string | null>;
-    getState(deviceId: string): Promise<Record<string, any>>;
-    getGateways(connectionId: string): Promise<any[] | null>;
-    getGatewayDetails(connectionId: string, gatewayId: string): Promise<any>;
-}

package/dist/device/cloud/services/Device.service.d.ts

@@ -1,39 +0,0 @@
-import { IDeviceService } from "../interfaces";
-import { IConnection, IDevice } from "../types";
-export declare abstract class DeviceService implements IDeviceService {
-    deviceId: string;
-    propertyId: string;
-    name: string;
-    hubId: string[];
-    deviceType: {
-        id: string;
-        type: string;
-    };
-    status: {
-        online: boolean;
-        error?: {
-            type?: string;
-            message?: string;
-        };
-        lastUpdated?: string;
-    };
-    state?: Record<string, any>;
-    metaData?: Record<string, any>;
-    zone?: {
-        id: string;
-        name: string;
-        zoneType: string;
-        parentZone?: {
-            id: string;
-            name: string;
-            zoneType: string;
-        };
-    };
-    connection: IConnection;
-    constructor(device: IDevice);
-    abstract getDevices(connection: IConnection): Promise<Record<string, any>[]>;
-    abstract getDevice(connectionId: string, deviceId: string): Promise<any>;
-    abstract getBattery(deviceId: string): Promise<number | string>;
-    abstract getStatus(connectionId: string, deviceId: string): Promise<string>;
-    abstract getState(deviceId: string): Promise<string>;
-}

package/dist/device/cloud/services/Device.service.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceService = void 0;
-class DeviceService {
-    constructor(device) {
-        Object.assign(this, device);
-    }
-}
-exports.DeviceService = DeviceService;

package/dist/device/cloud/services/DeviceCloudService.d.ts

@@ -1,42 +0,0 @@
-import { IDeviceCloudService } from "../interface";
-import { IConnection, IDevice, IDeviceAccountResponse, IConnectionConnectParams } from "../types";
-/**
- * Device Cloud Service Class
- * Implements IDeviceCloudService interface with empty implementations
- * Implementation will be provided by the consuming project
- */
-export declare class DeviceCloudService implements IDeviceCloudService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
-    getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    getDevices(connection: IConnection): Promise<IDevice[]>;
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    filterDevices(connection: IConnection, devices: any[]): Promise<IDevice[]>;
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
-}

package/dist/device/cloud/services/DeviceCloudService.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceCloudService = void 0;
-/**
- * Device Cloud Service Class
- * Implements IDeviceCloudService interface with empty implementations
- * Implementation will be provided by the consuming project
- */
-class DeviceCloudService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
-    async createConnection(data, userId) {
-        // Implementation will be provided by the consuming project
-        throw new Error("createConnection method not implemented");
-    }
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
-    async getDeviceAccount(connection) {
-        // Implementation will be provided by the consuming project
-        throw new Error("getDeviceAccount method not implemented");
-    }
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    async getDevices(connection) {
-        // Implementation will be provided by the consuming project
-        throw new Error("getDevices method not implemented");
-    }
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    async filterDevices(connection, devices) {
-        // Implementation will be provided by the consuming project
-        throw new Error("filterDevices method not implemented");
-    }
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    async connect(connection, connectionConnect) {
-        // Implementation will be provided by the consuming project
-        throw new Error("connect method not implemented");
-    }
-}
-exports.DeviceCloudService = DeviceCloudService;

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

@@ -1,3 +0,0 @@
-export declare abstract class DeviceHubService {
-    abstract getHubs(): Promise<any>;
-}

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

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceHubService = void 0;
-class DeviceHubService {
-}
-exports.DeviceHubService = DeviceHubService;

package/dist/device/cloud/services/Hub.service.d.ts

@@ -1,25 +0,0 @@
-import { IHubService } from "../interfaces";
-import { IConnection, IDevice } from "../types";
-export declare abstract class HubService implements IHubService {
-    deviceId: string;
-    propertyId: string;
-    name: string;
-    deviceType: {
-        id: string;
-        type: string;
-    };
-    status: {
-        online: boolean;
-        error?: {
-            type?: string;
-            message?: string;
-        };
-        lastUpdated?: string;
-    };
-    metaData?: Record<string, any>;
-    connection: IConnection;
-    constructor(hub: IDevice);
-    abstract getHubs(connectionId: string): Promise<any[] | null>;
-    abstract getHub(connectionId: string, hubId: string): Promise<Record<string, any>>;
-    abstract getStatus(connectionId: string, hubId: string): Promise<string>;
-}

package/dist/device/cloud/services/Hub.service.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HubService = void 0;
-class HubService {
-    constructor(hub) {
-        Object.assign(this, hub);
-    }
-}
-exports.HubService = HubService;