dt-common-device
Version:
A secure and robust device management library for IoT applications
174 lines (173 loc) • 7.06 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InternalEventSubscription = exports.InternalEventType = void 0;
const dt_pub_sub_1 = require("dt-pub-sub");
const config_1 = require("../config/config");
const dt_audit_library_1 = require("dt-audit-library");
// Event types enum for better type safety
var InternalEventType;
(function (InternalEventType) {
InternalEventType["HEARTBEAT"] = "heartbeat";
InternalEventType["SCHEDULE_CREATE"] = "schedule.create";
InternalEventType["SCHEDULE_UPDATE"] = "schedule.update";
InternalEventType["SCHEDULE_DELETE"] = "schedule.delete";
InternalEventType["SERVICE_DOWN"] = "service.down";
})(InternalEventType || (exports.InternalEventType = InternalEventType = {}));
class InternalEventSubscription {
constructor(internalEventHandler) {
this.internalEventHandler = internalEventHandler;
this.isInitialized = false;
this.isSubscribed = false;
this.sqsQueueUrl = (0, config_1.getSqsQueueUrl)() || "";
this.reservationSqsQueueUrl = (0, config_1.getReservationSqsQueueUrl)() || "";
this.heartbeatSqsQueueUrl = (0, config_1.getHeartbeatSqsQueueUrl)() || "";
this.issueSqsQueueUrl = (0, config_1.getIssueSqsQueueUrl)() || "";
this.logger = (0, config_1.getConfig)().LOGGER;
this.isInitialized = true;
}
async handleMessage(message) {
try {
const eventType = message["detail-type"];
const eventData = message.detail;
const MessageId = message.id;
eventData.MessageId = MessageId;
this.logger.info(`Received internal event: ${eventType} ${eventData}`);
switch (eventType) {
case InternalEventType.HEARTBEAT:
await this.safeCallHandler(() => this.internalEventHandler.onHeartbeat(eventData));
break;
case InternalEventType.SCHEDULE_CREATE:
await this.safeCallHandler(() => this.internalEventHandler.onScheduleCreate(eventData));
break;
case InternalEventType.SCHEDULE_UPDATE:
await this.safeCallHandler(() => this.internalEventHandler.onScheduleUpdate(eventData));
break;
case InternalEventType.SCHEDULE_DELETE:
await this.safeCallHandler(() => this.internalEventHandler.onScheduleDelete(eventData));
break;
case InternalEventType.SERVICE_DOWN:
await this.safeCallHandler(() => this.internalEventHandler.onServiceDown(eventData));
break;
default:
await this.safeCallHandler(() => this.internalEventHandler.onServiceSpecificEvent(eventType, eventData));
break;
}
}
catch (error) {
this.logger.error("Error processing internal event message", {
error,
message,
eventType: message["detail-type"],
});
(0, dt_audit_library_1.publishAudit)({
eventType: "internal_event_subscription_error",
properties: {
error: error instanceof Error
? error.message
: "Error Processing Internal Event",
errorStack: error instanceof Error
? error.stack
: "Error Processing Internal Event",
},
});
}
}
/**
* Safely call handler methods with error handling
*/
async safeCallHandler(handlerCall) {
try {
await handlerCall();
}
catch (error) {
this.logger.error("Handler method execution failed", { error });
(0, dt_audit_library_1.publishAudit)({
eventType: "internal_event_subscription_error",
properties: {
error: error instanceof Error
? error.message
: "Error Processing Internal Event",
errorStack: error instanceof Error
? error.stack
: "Error Processing Internal Event",
},
});
}
}
/**
* Subscribe to SQS events
*/
async subscribe() {
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 {
if (this.reservationSqsQueueUrl) {
await dt_pub_sub_1.eventDispatcher.subscribeToQueue(this.reservationSqsQueueUrl, this.handleMessage.bind(this));
}
if (this.heartbeatSqsQueueUrl) {
await dt_pub_sub_1.eventDispatcher.subscribeToQueue(this.heartbeatSqsQueueUrl, this.handleMessage.bind(this));
}
if (this.issueSqsQueueUrl) {
await dt_pub_sub_1.eventDispatcher.subscribeToQueue(this.issueSqsQueueUrl, this.handleMessage.bind(this));
}
await dt_pub_sub_1.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
*/
async unsubscribe() {
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
*/
getStatus() {
return {
isInitialized: this.isInitialized,
isSubscribed: this.isSubscribed,
sqsUrl: this.sqsQueueUrl,
};
}
/**
* Check if subscription is ready
*/
isReady() {
return this.isInitialized && this.isSubscribed;
}
}
exports.InternalEventSubscription = InternalEventSubscription;