dt-common-device 1.3.0 → 2.0.1

package/src/events/EventProcessingService.ts

@@ -0,0 +1,248 @@
+import { Service } from "typedi";
+import { DeviceEventHandler } from "./DeviceEventHandler";
+import { ILogger } from "../types/config.types";
+import { getConfig } from "../config/config";
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+import { IEventTransformer } from "./interfaces/IEventTransformer";
+import { EventHandlerOrchestrator } from "./EventHandlerOrchestrator";
+import { DeviceEventTransformerFactory } from "./DeviceEventTransformerFactory";
+import { BaseEventHandler } from "./BaseEventHandler";
+
+@Service()
+export class EventProcessingService {
+  private readonly handlerOrchestrator: EventHandlerOrchestrator;
+  public readonly deviceEventHandler: DeviceEventHandler;
+  private readonly logger: ILogger;
+  private deviceHandlers: Map<string, any> = new Map();
+
+  constructor(
+    private readonly deviceEventTransformerFactory: DeviceEventTransformerFactory
+  ) {
+    this.handlerOrchestrator = new EventHandlerOrchestrator();
+    this.deviceEventHandler = new DeviceEventHandler();
+    this.logger = getConfig().LOGGER;
+    this.initializeDeviceHandlers();
+    this.initializeHandlers();
+  }
+
+  /**
+   * Initialize device-specific handlers - to be implemented by subclasses
+   */
+  protected initializeDeviceHandlers(): void {
+    this.deviceHandlers = new Map();
+    // Subclasses should override this method to add their specific handlers
+  }
+
+  /**
+   * Initialize the handler hierarchy - to be implemented by subclasses
+   */
+  protected initializeHandlers(): void {
+    try {
+      // Register generic handler for common events
+      this.handlerOrchestrator.registerHandlers([
+        new DeviceEventHandler(), // Priority 100 - handles common events first
+      ]);
+
+      this.logger.info("Base event handlers initialized successfully");
+    } catch (error) {
+      this.logger.error(
+        "EventProcessingService: initializeHandlers Error",
+        error
+      );
+    }
+  }
+
+  /**
+   * Get device-specific handler based on connection provider
+   */
+  private getDeviceHandler(connectionProvider: string): any {
+    const normalizedProvider = connectionProvider.toLowerCase();
+    return this.deviceHandlers.get(normalizedProvider) || null;
+  }
+
+  /**
+   * Transform device event using EventTransformerFactory
+   */
+  transformDeviceEventWithTransformer(
+    connectionProvider: string,
+    rawData: any
+  ): DeviceEvent | null {
+    try {
+      // Create transformer for the connection provider
+      const transformer: IEventTransformer | null =
+        this.deviceEventTransformerFactory.createTransformer(
+          connectionProvider,
+          rawData
+        );
+
+      if (!transformer) {
+        this.logger.warn(
+          `No transformer found for connection provider: ${connectionProvider}`
+        );
+        return null;
+      }
+
+      // Execute the transformation pipeline
+      const transformedEvents = transformer.executeTransformation();
+
+      if (transformedEvents.length === 0) {
+        this.logger.warn(
+          `No events transformed for connection provider: ${connectionProvider}`
+        );
+        return null;
+      }
+
+      // Return the first transformed event (or handle multiple events as needed)
+      return transformedEvents[0];
+    } catch (error) {
+      this.logger.error(
+        `Error transforming event for ${connectionProvider}:`,
+        error
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Transform raw event data to DeviceEvent format using EventTransformer
+   */
+  private transformToDeviceEvent(
+    connectionProvider: string,
+    rawData: any
+  ): DeviceEvent | null {
+    try {
+      // Use the transformer-based approach
+      const deviceEvent = this.transformDeviceEventWithTransformer(
+        connectionProvider,
+        rawData
+      );
+
+      if (!deviceEvent) {
+        this.logger.warn("Failed to transform event data using transformer", {
+          connectionProvider,
+          rawData,
+        });
+        return null;
+      }
+
+      this.logger.info("Transformed event using EventTransformer", {
+        connectionProvider,
+        originalEventName: deviceEvent.originalEventName,
+        transformedEventName: deviceEvent.eventName,
+        deviceId: deviceEvent.deviceId,
+      });
+
+      return deviceEvent;
+    } catch (error) {
+      this.logger.error(
+        "EventProcessingService: transformToDeviceEvent Error",
+        error
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Process a single event from device.event.controller
+   */
+  async processEvent(connectionProvider: string, rawData: any): Promise<void> {
+    try {
+      this.logger.info("EventProcessingService: Processing event", {
+        connectionProvider,
+        eventName: rawData.eventName ?? rawData.type,
+      });
+
+      // Transform raw data to DeviceEvent using EventTransformer
+      const deviceEvent = this.transformToDeviceEvent(
+        connectionProvider,
+        rawData
+      );
+      if (!deviceEvent) {
+        this.logger.warn("Failed to transform event data", {
+          connectionProvider,
+          rawData,
+        });
+        return;
+      }
+
+      // Get device-specific handler
+      const deviceHandler: BaseEventHandler =
+        this.getDeviceHandler(connectionProvider);
+      if (!deviceHandler) {
+        this.logger.warn("No device handler found for provider", {
+          connectionProvider,
+        });
+        return;
+      }
+
+      // Process with GenericEventHandler first (common logic)
+      if (this.deviceEventHandler.canHandle(deviceEvent.eventName)) {
+        try {
+          await this.deviceEventHandler.handleEvent(deviceEvent);
+          this.logger.info("Event processed by GenericEventHandler");
+        } catch (error) {
+          this.logger.error(
+            "EventProcessingService: GenericEventHandler Error",
+            error
+          );
+        }
+      }
+
+      // Process with device-specific handler
+      if (deviceHandler.canHandle(deviceEvent.eventName)) {
+        try {
+          await deviceHandler.onEvent(deviceEvent);
+          this.logger.info("Event processed by device-specific handler", {
+            handler: deviceHandler.constructor.name,
+          });
+        } catch (error) {
+          this.logger.error(
+            "EventProcessingService: Device-specific handler Error",
+            error
+          );
+        }
+      } else {
+        this.logger.warn("Device handler cannot handle event", {
+          handler: deviceHandler.constructor.name,
+          eventName: deviceEvent.eventName,
+        });
+      }
+    } catch (error) {
+      this.logger.error("EventProcessingService: processEvent Error", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Process a single event (legacy method for DeviceEvent objects)
+   */
+  async processEventLegacy(event: DeviceEvent): Promise<void> {
+    try {
+      this.logger.info("EventProcessingService: Processing legacy event", {
+        eventName: event.eventName,
+      });
+      await this.handlerOrchestrator.processEvent(event);
+    } catch (error) {
+      this.logger.error(
+        "EventProcessingService: processEventLegacy Error",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Process multiple events
+   */
+  async processEvents(events: DeviceEvent[]): Promise<void> {
+    try {
+      this.logger.info("EventProcessingService: Processing multiple events", {
+        count: events.length,
+      });
+      await this.handlerOrchestrator.processEvents(events);
+    } catch (error) {
+      this.logger.error("EventProcessingService: processEvents Error", error);
+      throw error;
+    }
+  }
+}

package/src/events/InternalEventSubscription.ts

@@ -0,0 +1,219 @@
+import { eventDispatcher } from "dt-pub-sub";
+import { getConfig } from "../config/config";
+import {
+  IInternalEvent,
+  HeartbeatEventData,
+  ScheduleEventData,
+  ReservationEventData,
+  ServiceEventData,
+} from "./interfaces/IInternalEvent";
+import { ILogger } from "../types/config.types";
+
+// Event types enum for better type safety
+export enum InternalEventType {
+  HEARTBEAT = "heartbeat",
+  SCHEDULE_CREATE = "schedule.create",
+  SCHEDULE_UPDATE = "schedule.update",
+  SCHEDULE_DELETE = "schedule.delete",
+  RESERVATION_CREATE = "reservation.create",
+  RESERVATION_UPDATE = "reservation.update",
+  RESERVATION_CANCEL = "reservation.cancel",
+  SERVICE_DOWN = "service.down",
+}
+
+export class InternalEventSubscription {
+  private readonly sqsQueueUrl: string;
+  private readonly logger: ILogger;
+  private readonly isInitialized: boolean = false;
+  private isSubscribed: boolean = false;
+
+  constructor(private readonly internalEventHandler: IInternalEvent) {
+    this.sqsQueueUrl = getConfig().SQS_QUEUE_URL;
+    this.logger = getConfig().LOGGER;
+    this.isInitialized = true;
+  }
+
+  private async handleMessage(message: any): Promise<void> {
+    try {
+      const eventType = message["detail-type"];
+      const eventData = message.detail;
+
+      this.logger.info("Received internal event", { eventType, eventData });
+
+      switch (eventType) {
+        case InternalEventType.HEARTBEAT:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onHeartbeat(
+              eventData as HeartbeatEventData
+            )
+          );
+          break;
+
+        case InternalEventType.SCHEDULE_CREATE:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onScheduleCreate(
+              eventData as ScheduleEventData
+            )
+          );
+          break;
+
+        case InternalEventType.SCHEDULE_UPDATE:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onScheduleUpdate(
+              eventData as ScheduleEventData
+            )
+          );
+          break;
+
+        case InternalEventType.SCHEDULE_DELETE:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onScheduleDelete(
+              eventData as ScheduleEventData
+            )
+          );
+          break;
+
+        case InternalEventType.RESERVATION_CREATE:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onReservationCreate(
+              eventData as ReservationEventData
+            )
+          );
+          break;
+
+        case InternalEventType.RESERVATION_UPDATE:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onReservationUpdate(
+              eventData as ReservationEventData
+            )
+          );
+          break;
+
+        case InternalEventType.RESERVATION_CANCEL:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onReservationCancel(
+              eventData as ReservationEventData
+            )
+          );
+          break;
+
+        case InternalEventType.SERVICE_DOWN:
+          await this.safeCallHandler(() =>
+            this.internalEventHandler.onServiceDown(
+              eventData as ServiceEventData
+            )
+          );
+          break;
+
+        default:
+          this.logger.warn("Unknown event type", { eventType, eventData });
+          break;
+      }
+    } catch (error) {
+      this.logger.error("Error processing internal event message", {
+        error,
+        message,
+        eventType: message["detail-type"],
+      });
+      // Re-throw to let SQS handle retry logic
+      throw error;
+    }
+  }
+
+  /**
+   * Safely call handler methods with error handling
+   */
+  private async safeCallHandler(
+    handlerCall: () => Promise<void>
+  ): Promise<void> {
+    try {
+      await handlerCall();
+    } catch (error) {
+      this.logger.error("Handler method execution failed", { error });
+      // Re-throw to let the main error handler deal with it
+      throw error;
+    }
+  }
+
+  /**
+   * Subscribe to SQS events
+   */
+  public async subscribe(): Promise<void> {
+    if (!this.isInitialized) {
+      throw new Error(
+        "InternalEventSubscription must be initialized before subscribing"
+      );
+    }
+
+    if (!this.sqsQueueUrl) {
+      throw new Error("AWS SQS URL not found in environment variables");
+    }
+
+    if (this.isSubscribed) {
+      this.logger.warn("InternalEventSubscription is already subscribed");
+      return;
+    }
+
+    try {
+      await eventDispatcher.subscribeToQueue(
+        this.sqsQueueUrl,
+        this.handleMessage.bind(this)
+      );
+      this.isSubscribed = true;
+      this.logger.info("Successfully subscribed to internal events", {
+        sqsUrl: this.sqsQueueUrl,
+      });
+    } catch (error) {
+      this.logger.error("Failed to subscribe to internal events", {
+        error,
+        sqsUrl: this.sqsQueueUrl,
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Unsubscribe from SQS events
+   */
+  public async unsubscribe(): Promise<void> {
+    if (!this.isSubscribed) {
+      this.logger.warn("InternalEventSubscription is not currently subscribed");
+      return;
+    }
+
+    try {
+      // Note: You might need to implement unsubscribe method in dt-pub-sub
+      // await eventDispatcher.unsubscribeFromQueue(this.sqsQueueUrl);
+
+      this.isSubscribed = false;
+      this.logger.info("Successfully unsubscribed from internal events");
+    } catch (error) {
+      this.logger.error("Failed to unsubscribe from internal events", {
+        error,
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Get subscription status
+   */
+  public getStatus(): {
+    isInitialized: boolean;
+    isSubscribed: boolean;
+    sqsUrl: string;
+  } {
+    return {
+      isInitialized: this.isInitialized,
+      isSubscribed: this.isSubscribed,
+      sqsUrl: this.sqsQueueUrl,
+    };
+  }
+
+  /**
+   * Check if subscription is ready
+   */
+  public isReady(): boolean {
+    return this.isInitialized && this.isSubscribed;
+  }
+}

package/src/events/index.ts

@@ -0,0 +1,9 @@
+export { DT_EVENT_TYPES } from "../constants/Event";
+export { EventHandler } from "./EventHandler";
+export { InternalEventSubscription } from "./InternalEventSubscription";
+export { EventProcessingService } from "./EventProcessingService";
+export { DeviceEventHandler } from "./DeviceEventHandler";
+export { EventHandlerOrchestrator } from "./EventHandlerOrchestrator";
+export { DeviceEventTransformerFactory } from "./DeviceEventTransformerFactory";
+export { BaseEventHandler } from "./BaseEventHandler";
+export { BaseEventTransformer } from "./BaseEventTransformer";

package/src/events/interfaces/DeviceEvent.ts

@@ -0,0 +1,56 @@
+export interface DeviceEvent {
+  eventId: string;
+  deviceId: string;
+  eventName: string;
+  data: DeviceEventData;
+  timestamp?: string;
+  connectionProvider?: string;
+  originalEventName?: string;
+  rawEvent?: any; // Store the original raw event data
+}
+
+export interface EventConstructionOptions {
+  eventId?: string;
+  eventName?: string;
+  status?: string;
+  mode?: string;
+  userName?: string;
+  userId?: string;
+  userType?: string;
+  rawEvent?: any;
+  batteryLevel?: string;
+  reason?: string;
+  eventDescription?: string;
+}
+
+export interface DeviceEventEntity {
+  event: any;
+  device: any;
+  hub: any[];
+  property: any;
+}
+
+export interface DeviceEventData {
+  mode?: string;
+  batteryLevel?: number;
+}
+
+export interface TTLockEventData extends DeviceEventData {
+  label: string;
+}
+
+export interface SaltoKSLockEventData extends DeviceEventData {
+  userId: string;
+  deviceName: string;
+  username: string;
+  accessBy: string;
+  accessDetails: string;
+}
+
+export interface TuyaLockEventData extends DeviceEventData {
+  // Inherits mode from DeviceEventData
+}
+
+export interface SchlageLockEventData extends DeviceEventData {
+  event: any;
+}

package/src/events/interfaces/IEventHandler.ts

@@ -0,0 +1,28 @@
+import { DeviceEvent } from "./DeviceEvent";
+
+export interface IEventHandler {
+  /**
+   * Handle a single transformed event
+   */
+  handleEvent(event: DeviceEvent): Promise<void>;
+
+  /**
+   * Handle multiple events
+   */
+  handleEvents(events: DeviceEvent[]): Promise<void>;
+
+  /**
+   * Check if this handler can process the given event type
+   */
+  canHandle(eventType: string): boolean;
+
+  /**
+   * Get the priority of this handler (lower numbers = higher priority)
+   */
+  getPriority(): number;
+
+  /**
+   * Get the event types this handler can process
+   */
+  getSupportedEventTypes(): string[];
+}

package/src/events/interfaces/IEventTransformer.ts

@@ -0,0 +1,8 @@
+import { DeviceEvent } from "./DeviceEvent";
+
+export interface IEventTransformer {
+  parseData(rawData: any): any;
+  transform(parsedData: any): DeviceEvent | DeviceEvent[];
+  validate(transformedEvent: DeviceEvent): boolean;
+  executeTransformation(): DeviceEvent[];
+}

package/src/events/interfaces/IInternalEvent.ts

@@ -0,0 +1,47 @@
+// Event data interfaces for better type safety
+export interface HeartbeatEventData {
+  duration?: number;
+  propertyId?: string;
+  timestamp?: string;
+  [key: string]: any;
+}
+
+export interface ScheduleEventData {
+  scheduleId: string;
+  propertyId: string;
+  deviceId?: string;
+  startTime: string;
+  endTime: string;
+  action: string;
+  [key: string]: any;
+}
+
+export interface ReservationEventData {
+  reservationId: string;
+  propertyId: string;
+  deviceId?: string;
+  userId?: string;
+  startTime: string;
+  endTime: string;
+  status: string;
+  [key: string]: any;
+}
+
+export interface ServiceEventData {
+  serviceId: string;
+  serviceName: string;
+  status: string;
+  timestamp: string;
+  [key: string]: any;
+}
+
+export interface IInternalEvent {
+  onHeartbeat(data: HeartbeatEventData): Promise<void>;
+  onScheduleCreate(data: ScheduleEventData): Promise<void>;
+  onScheduleUpdate(data: ScheduleEventData): Promise<void>;
+  onScheduleDelete(data: ScheduleEventData): Promise<void>;
+  onServiceDown(data: ServiceEventData): Promise<void>;
+  onReservationCreate(data: ReservationEventData): Promise<void>;
+  onReservationUpdate(data: ReservationEventData): Promise<void>;
+  onReservationCancel(data: ReservationEventData): Promise<void>;
+}

package/src/events/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from "./IInternalEvent";
+export * from "./IEventHandler";
+export * from "./IEventTransformer";
+export * from "./DeviceEvent";

package/src/index.ts

@@ -14,11 +14,18 @@ export {
   LocalScheduleService,
 } from "./device/local/services";
 
+// Events exports
+export * from "./events";
+export * from "./events/interfaces";
+
 export * from "./device/cloud/interfaces";
 
 // Local exports
 export * from "./device/local/interfaces";
-export * from "./device/local/events";
+export * from "./events";
+export * from "./events/interfaces";
+// Types exports
+export * from "./types";
 
 //initialize export
-export { initialize, getConfig } from "./config/config";
+export { initialize, getConfig, shutdown } from "./config/config";