dt-common-device 1.3.0 → 2.0.0

package/dist/events/DeviceEventHandler.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceEventHandler = void 0;
+const Event_1 = require("../constants/Event");
+const services_1 = require("../device/local/services");
+const BaseEventHandler_1 = require("./BaseEventHandler");
+class DeviceEventHandler extends BaseEventHandler_1.BaseEventHandler {
+    constructor() {
+        super([
+            Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
+            Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE,
+            Event_1.DT_EVENT_TYPES.DEVICE.STATUS.CHANGED,
+            Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CRITICAL,
+            Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LOW,
+            Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED,
+        ], 100);
+        this.localHubService = new services_1.LocalHubService();
+    }
+    async onEvent(event) {
+        this.logger.info("[DT | CDL]:[DeviceEventHandler]: Processing event", {
+            eventName: event.eventName,
+        });
+        try {
+            const device = await this.localDeviceService.getDevice(event.deviceId);
+            if (!device?.deviceId) {
+                throw new Error("[DT | CDL]:[DeviceEventHandler]: deviceId does not exist");
+            }
+            await this.updateDeviceEventData(device, event);
+            // Update relevant tables based on event type
+            await this.updateTablesBasedOnEventType(event, device);
+            // Save event logs
+            await this.dumpToEventOperation(event, device);
+        }
+        catch (error) {
+            this.logger.error("[DT | CDL]:[DeviceEventHandler]: Error processing event", error);
+            throw error;
+        }
+    }
+    async updateDeviceEventData(deviceData, event) {
+        switch (event.eventName) {
+            case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE:
+            case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE:
+                await this.localDeviceService.setState(deviceData.deviceId, {
+                    status: {
+                        online: event.eventName === Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE,
+                        lastUpdated: new Date().toISOString(),
+                        error: {
+                            type: event.eventName === Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE
+                                ? "offline"
+                                : "",
+                            message: event.eventName === Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE
+                                ? "Device is offline"
+                                : "",
+                            default: {},
+                        },
+                    },
+                });
+                break;
+            case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
+                await this.localDeviceService.setBatteryLevel(deviceData.deviceId, event?.data?.batteryLevel ?? 0);
+                break;
+        }
+    }
+    async extractHubDetails(device) {
+        const hubIds = device?.hubId;
+        const hubDetails = [];
+        if (hubIds) {
+            for (const hubId of hubIds) {
+                const hubDetail = await this.localHubService.getHub(hubId);
+                hubDetails.push({
+                    id: hubDetail?.deviceId,
+                    name: hubDetail?.name,
+                    type: hubDetail?.deviceType?.type,
+                    brand: hubDetail?.specifications?.manufacturer,
+                    model: hubDetail?.specifications?.model,
+                    status: hubDetail?.status?.online ? "ONLINE" : "OFFLINE",
+                });
+            }
+        }
+        return hubDetails;
+    }
+    constructDeviceEventEntity(eventData, device, hubDetails, options = {}) {
+        return {
+            event: {
+                eventId: options.eventId || eventData?.eventId || "",
+                eventName: options.eventName || eventData?.eventName || "",
+                status: options.status || eventData?.status || "",
+                mode: options.mode || eventData?.data?.mode,
+                userName: options.userName || eventData?.userName || "",
+                userId: options.userId || eventData?.userId || "",
+                userType: options.userType || eventData?.userType || "",
+                raw_event: options.rawEvent || eventData?.rawData || {},
+                batteryLevel: options.batteryLevel || eventData?.data?.batteryLevel || "",
+                reason: options.reason || eventData?.data?.reason || "",
+                eventDescription: options.eventDescription || eventData?.event || "",
+            },
+            device: {
+                id: eventData?.deviceId || "",
+                name: device?.name || "",
+                type: device?.deviceType?.type || "",
+                brand: device?.specifications?.manufacturer || "",
+                model: device?.specifications?.model || "",
+            },
+            hub: hubDetails,
+            property: {
+                id: eventData?.property?.id || "",
+                name: eventData?.property?.name || "",
+                location: eventData?.property?.apartment || "",
+            },
+        };
+    }
+    async dumpToEventOperation(data, device) {
+        try {
+            const hubDetails = await this.extractHubDetails(device);
+            const eventData = this.constructDeviceEventEntity(data, device, hubDetails, {
+                status: data.eventName === "lock.unlock" ? "UNLOCKED" : "LOCKED",
+                rawEvent: data.rawData,
+            });
+            this.logger.info("[DT | CDL]:[DeviceEventHandler]: Event data dumped to event operation", { eventData });
+        }
+        catch (error) {
+            this.logger.error("[DT | CDL]:[DeviceEventHandler]: Error dumping to event operation", error);
+        }
+    }
+    async updateTablesBasedOnEventType(eventData, device) {
+        switch (eventData.eventName) {
+            case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.ONLINE:
+            case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.OFFLINE:
+            case Event_1.DT_EVENT_TYPES.DEVICE.STATUS.CHANGED:
+                this.updateDeviceStatus(eventData, device);
+                break;
+            case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CHANGED:
+            case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.CRITICAL:
+            case Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.LOW:
+                this.updateDeviceBattery(eventData, device);
+                break;
+        }
+    }
+    async updateDeviceStatus(data, device) {
+        this.logger.info("[DT | CDL]:[DeviceEventHandler]: Updating device status", {
+            data,
+            device,
+        });
+    }
+    async updateDeviceBattery(data, device) {
+        this.logger.info("[DT | CDL]:[DeviceEventHandler]: Updating device battery", {
+            data,
+            device,
+        });
+    }
+}
+exports.DeviceEventHandler = DeviceEventHandler;

package/dist/events/DeviceEventTransformerFactory.d.ts

@@ -0,0 +1,27 @@
+import { IEventTransformer } from './interfaces/IEventTransformer';
+/**
+ * Abstract base factory for creating device event transformers
+ * This class can be moved to dt-common-device and extended by specific device type factories
+ */
+export declare abstract class DeviceEventTransformerFactory {
+    /**
+     * Create the appropriate event transformer based on device type
+     * This method should be implemented by subclasses to handle specific device types
+     */
+    abstract createTransformer(deviceType: string, rawData: any): IEventTransformer | null;
+    /**
+     * Create a default transformer for unsupported or generic device types
+     * This method can be overridden by subclasses to provide device-specific default behavior
+     */
+    protected createDefaultTransformer(deviceType: string, rawData: any): IEventTransformer;
+    /**
+     * Handle unsupported device types
+     * This method can be overridden by subclasses to provide custom handling
+     */
+    protected handleUnsupportedDeviceType(deviceType: string): IEventTransformer | null;
+    /**
+     * Handle errors during transformer creation
+     * This method can be overridden by subclasses to provide custom error handling
+     */
+    protected handleTransformerCreationError(deviceType: string, error: any): IEventTransformer | null;
+}

package/dist/events/DeviceEventTransformerFactory.js

@@ -0,0 +1,116 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceEventTransformerFactory = void 0;
+const typedi_1 = require("typedi");
+/**
+ * Abstract base factory for creating device event transformers
+ * This class can be moved to dt-common-device and extended by specific device type factories
+ */
+let DeviceEventTransformerFactory = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var DeviceEventTransformerFactory = _classThis = class {
+        /**
+         * Create a default transformer for unsupported or generic device types
+         * This method can be overridden by subclasses to provide device-specific default behavior
+         */
+        createDefaultTransformer(deviceType, rawData) {
+            return new (class {
+                constructor(deviceType, rawData) {
+                    this.deviceType = deviceType;
+                    this.rawData = rawData;
+                }
+                parseData(rawData) {
+                    // Default parsing - return as-is
+                    return rawData;
+                }
+                transform(parsedData) {
+                    // Default transformation - return as-is
+                    return parsedData;
+                }
+                validate(transformedEvent) {
+                    // Default validation - always return true
+                    return true;
+                }
+                executeTransformation() {
+                    try {
+                        const parsedData = this.parseData(this.rawData);
+                        const transformedResult = this.transform(parsedData);
+                        const events = Array.isArray(transformedResult) ? transformedResult : [transformedResult];
+                        return events.filter((event) => this.validate(event));
+                    }
+                    catch (error) {
+                        console.error(`Error in default transformer for device type ${this.deviceType}:`, error);
+                        return [];
+                    }
+                }
+            })(deviceType, rawData);
+        }
+        /**
+         * Handle unsupported device types
+         * This method can be overridden by subclasses to provide custom handling
+         */
+        handleUnsupportedDeviceType(deviceType) {
+            console.warn(`Unsupported device type: ${deviceType}`);
+            return null;
+        }
+        /**
+         * Handle errors during transformer creation
+         * This method can be overridden by subclasses to provide custom error handling
+         */
+        handleTransformerCreationError(deviceType, error) {
+            console.error(`Error creating transformer for device type ${deviceType}:`, error);
+            return null;
+        }
+    };
+    __setFunctionName(_classThis, "DeviceEventTransformerFactory");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        DeviceEventTransformerFactory = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return DeviceEventTransformerFactory = _classThis;
+})();
+exports.DeviceEventTransformerFactory = DeviceEventTransformerFactory;

package/dist/events/EventHandler.d.ts

@@ -0,0 +1,11 @@
+export declare class EventHandler {
+    private readonly source;
+    constructor();
+    onDeviceCreate(body: any): Promise<void>;
+    onDeviceUpdate(deviceId: string, body: any): Promise<void>;
+    onDeviceDelete(deviceId: string): Promise<void>;
+    onStateChange(deviceId: string, state: any): Promise<void>;
+    onStatusChange(deviceId: string, status: any): Promise<void>;
+    onBatteryLevelChange(deviceId: string, batteryLevel: number): Promise<void>;
+    onDeviceMetaChange(deviceId: string, metaData: Record<string, any>): Promise<void>;
+}

package/dist/events/EventHandler.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const dt_pub_sub_1 = require("dt-pub-sub");
+const dt_audit_library_1 = require("dt-audit-library");
+const Event_1 = require("../constants/Event");
+class EventHandler {
+    constructor() {
+        this.source = "dt-common-device";
+    }
+    async onDeviceCreate(body) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Event_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS, body, this.source);
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.CREATE.SUCCESS,
+            properties: {
+                ...body,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onDeviceUpdate(deviceId, body) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Event_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS, { deviceId, body }, this.source);
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.UPDATE.SUCCESS,
+            properties: {
+                ...body,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onDeviceDelete(deviceId) {
+        await dt_pub_sub_1.eventDispatcher.publishEvent(Event_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS, { deviceId }, this.source);
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.DELETE.SUCCESS,
+            properties: {
+                deviceId,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onStateChange(deviceId, state) {
+        // TODO: For Future Consumption
+        /* await eventDispatcher.publishEvent(
+          DT_EVENT_TYPES.DEVICE.STATE.SET,
+          { deviceId, state },
+          this.source
+        ); */
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATE.SET,
+            properties: {
+                deviceId,
+                state,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onStatusChange(deviceId, status) {
+        // TODO: For Future Consumption
+        /* await eventDispatcher.publishEvent(
+          DT_EVENT_TYPES.DEVICE.STATUS.SET,
+          { deviceId, status },
+          this.source
+        ); */
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.STATUS.SET,
+            properties: {
+                deviceId,
+                status,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onBatteryLevelChange(deviceId, batteryLevel) {
+        // TODO: For Future Consumption
+        /* await eventDispatcher.publishEvent(
+          DT_EVENT_TYPES.DEVICE.BATTERY.SET,
+          { deviceId, batteryLevel },
+          this.source
+        ); */
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.BATTERY.SET,
+            properties: {
+                deviceId,
+                batteryLevel,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+    async onDeviceMetaChange(deviceId, metaData) {
+        // TODO: For Future Consumption
+        /*  await eventDispatcher.publishEvent(
+          DT_EVENT_TYPES.DEVICE.META_DATA.SET,
+          { deviceId, metaData },
+          this.source
+        ); */
+        const payload = {
+            eventType: Event_1.DT_EVENT_TYPES.DEVICE.META_DATA.SET,
+            properties: {
+                deviceId,
+                metaData,
+            },
+        };
+        await (0, dt_audit_library_1.publishAudit)(payload);
+    }
+}
+exports.EventHandler = EventHandler;

package/dist/events/EventHandlerOrchestrator.d.ts

@@ -0,0 +1,35 @@
+import { IEventHandler } from "./interfaces/IEventHandler";
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+export declare class EventHandlerOrchestrator {
+    private handlers;
+    private readonly logger;
+    constructor();
+    /**
+     * Register a handler with the orchestrator
+     */
+    registerHandler(handler: IEventHandler): void;
+    /**
+     * Register multiple handlers
+     */
+    registerHandlers(handlers: IEventHandler[]): void;
+    /**
+     * Process a single event through the handler hierarchy
+     */
+    processEvent(event: DeviceEvent): Promise<void>;
+    /**
+     * Process multiple events
+     */
+    processEvents(events: DeviceEvent[]): Promise<void>;
+    /**
+     * Get all registered handlers
+     */
+    getHandlers(): IEventHandler[];
+    /**
+     * Get handlers that can handle a specific event type
+     */
+    getHandlersForEventType(eventType: string): IEventHandler[];
+    /**
+     * Clear all registered handlers
+     */
+    clearHandlers(): void;
+}

package/dist/events/EventHandlerOrchestrator.js

@@ -0,0 +1,141 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandlerOrchestrator = void 0;
+const typedi_1 = require("typedi");
+const config_1 = require("../config/config");
+let EventHandlerOrchestrator = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var EventHandlerOrchestrator = _classThis = class {
+        constructor() {
+            this.handlers = [];
+            this.logger = (0, config_1.getConfig)().LOGGER;
+        }
+        /**
+         * Register a handler with the orchestrator
+         */
+        registerHandler(handler) {
+            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) {
+            handlers.forEach((handler) => this.registerHandler(handler));
+        }
+        /**
+         * Process a single event through the handler hierarchy
+         */
+        async processEvent(event) {
+            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) {
+            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() {
+            return [...this.handlers];
+        }
+        /**
+         * Get handlers that can handle a specific event type
+         */
+        getHandlersForEventType(eventType) {
+            return this.handlers.filter((handler) => handler.canHandle(eventType));
+        }
+        /**
+         * Clear all registered handlers
+         */
+        clearHandlers() {
+            this.handlers = [];
+            this.logger.info("All handlers cleared");
+        }
+    };
+    __setFunctionName(_classThis, "EventHandlerOrchestrator");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        EventHandlerOrchestrator = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return EventHandlerOrchestrator = _classThis;
+})();
+exports.EventHandlerOrchestrator = EventHandlerOrchestrator;

package/dist/events/EventProcessingService.d.ts

@@ -0,0 +1,43 @@
+import { DeviceEventHandler } from "./DeviceEventHandler";
+import { DeviceEvent } from "./interfaces/DeviceEvent";
+import { DeviceEventTransformerFactory } from "./DeviceEventTransformerFactory";
+export declare class EventProcessingService {
+    private readonly deviceEventTransformerFactory;
+    private readonly handlerOrchestrator;
+    readonly deviceEventHandler: DeviceEventHandler;
+    private readonly logger;
+    private deviceHandlers;
+    constructor(deviceEventTransformerFactory: DeviceEventTransformerFactory);
+    /**
+     * Initialize device-specific handlers - to be implemented by subclasses
+     */
+    protected initializeDeviceHandlers(): void;
+    /**
+     * Initialize the handler hierarchy - to be implemented by subclasses
+     */
+    protected initializeHandlers(): void;
+    /**
+     * Get device-specific handler based on connection provider
+     */
+    private getDeviceHandler;
+    /**
+     * Transform device event using EventTransformerFactory
+     */
+    transformDeviceEventWithTransformer(connectionProvider: string, rawData: any): DeviceEvent | null;
+    /**
+     * Transform raw event data to DeviceEvent format using EventTransformer
+     */
+    private transformToDeviceEvent;
+    /**
+     * Process a single event from device.event.controller
+     */
+    processEvent(connectionProvider: string, rawData: any): Promise<void>;
+    /**
+     * Process a single event (legacy method for DeviceEvent objects)
+     */
+    processEventLegacy(event: DeviceEvent): Promise<void>;
+    /**
+     * Process multiple events
+     */
+    processEvents(events: DeviceEvent[]): Promise<void>;
+}