dt-common-device 3.0.9 → 3.0.11

package/src/events/EventHandlerOrchestrator.ts

@@ -1,119 +0,0 @@
-import { Service } from "typedi";
-import { IEventHandler } from "./interfaces/IEventHandler";
-import { DeviceEvent } from "./interfaces/DeviceEvent";
-import { ILogger } from "../config/config.types";
-import { getConfig } from "../config/config";
-
-@Service()
-export class EventHandlerOrchestrator {
-  private handlers: IEventHandler[] = [];
-  private readonly logger: ILogger;
-  constructor() {
-    this.logger = getConfig().LOGGER;
-  }
-  /**
-   * Register a handler with the orchestrator
-   */
-  registerHandler(handler: IEventHandler): void {
-    this.handlers.push(handler);
-    // Sort handlers by priority (lower numbers = higher priority)
-    this.handlers.sort((a, b) => a.getPriority() - b.getPriority());
-    this.logger.info(
-      `Registered handler: ${
-        handler.constructor.name
-      } with priority ${handler.getPriority()}`
-    );
-  }
-
-  /**
-   * Register multiple handlers
-   */
-  registerHandlers(handlers: IEventHandler[]): void {
-    handlers.forEach((handler) => this.registerHandler(handler));
-  }
-
-  /**
-   * Process a single event through the handler hierarchy
-   */
-  async processEvent(event: DeviceEvent): Promise<void> {
-    try {
-      this.logger.info(
-        `Processing event: ${event.eventName} for device: ${event.deviceId}`
-      );
-
-      const applicableHandlers = this.handlers.filter((handler) =>
-        handler.canHandle(event.eventName)
-      );
-
-      if (applicableHandlers.length === 0) {
-        this.logger.warn(
-          `No handlers found for event type: ${event.eventName}`
-        );
-        return;
-      }
-
-      this.logger.info(
-        `Found ${applicableHandlers.length} handlers for event: ${event.eventName}`
-      );
-
-      // Process with each applicable handler in priority order
-      for (const handler of applicableHandlers) {
-        try {
-          await handler.handleEvent(event);
-          this.logger.info(`Event processed by: ${handler.constructor.name}`);
-        } catch (error) {
-          this.logger.error(
-            `Error in handler ${handler.constructor.name}:`,
-            error
-          );
-          // Continue with other handlers even if one fails
-        }
-      }
-    } catch (error) {
-      this.logger.error(
-        "Error in EventHandlerOrchestrator.processEvent:",
-        error
-      );
-    }
-  }
-
-  /**
-   * Process multiple events
-   */
-  async processEvents(events: DeviceEvent[]): Promise<void> {
-    try {
-      this.logger.info(`Processing ${events.length} events`);
-
-      for (const event of events) {
-        await this.processEvent(event);
-      }
-    } catch (error) {
-      this.logger.error(
-        "Error in EventHandlerOrchestrator.processEvents:",
-        error
-      );
-    }
-  }
-
-  /**
-   * Get all registered handlers
-   */
-  getHandlers(): IEventHandler[] {
-    return [...this.handlers];
-  }
-
-  /**
-   * Get handlers that can handle a specific event type
-   */
-  getHandlersForEventType(eventType: string): IEventHandler[] {
-    return this.handlers.filter((handler) => handler.canHandle(eventType));
-  }
-
-  /**
-   * Clear all registered handlers
-   */
-  clearHandlers(): void {
-    this.handlers = [];
-    this.logger.info("All handlers cleared");
-  }
-}

package/src/events/EventProcessingService.ts

@@ -1,248 +0,0 @@
-import { Service } from "typedi";
-import { DeviceEventHandler } from "./DeviceEventHandler";
-import { ILogger } from "../config/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

@@ -1,194 +0,0 @@
-import { eventDispatcher } from "dt-pub-sub";
-import { getConfig } from "../config/config";
-import {
-  IInternalEvent,
-  HeartbeatEventData,
-  ScheduleEventData,
-  ServiceEventData,
-} from "./interfaces/IInternalEvent";
-import { ILogger } from "../config/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.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

@@ -1,9 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,33 +0,0 @@
-// 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 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>;
-}

package/src/events/interfaces/index.ts

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