dt-common-device 1.3.0 → 2.0.0

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/src/device/local/events/index.ts

@@ -1,2 +0,0 @@
-export { DT_EVENT_TYPES } from "./Events";
-export { EventHandler } from "./EventHandler";