dt-common-device 2.0.7 → 3.0.1

package/src/events/BaseEventHandler.ts

@@ -1,8 +1,8 @@
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventHandler } from "./interfaces/IEventHandler";
-import { getConfig } from "../config/config";
-import { ILogger } from "../types/config.types";
-import { LocalDeviceService } from "../device/local/services/Device.service";
+import { getConfig } from "src/config/config";
+import { ILogger } from "src/config/config.types";
+import { LocalDeviceService } from "src/device/local/services/Device.service";
 
 export abstract class BaseEventHandler implements IEventHandler {
   protected readonly supportedEventTypes: string[];

package/src/events/BaseEventTransformer.ts

@@ -1,5 +1,5 @@
-import { getConfig } from "../config/config";
-import { ILogger } from "../types/config.types";
+import { getConfig } from "src/config/config";
+import { ILogger } from "src/config/config.types";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventTransformer } from "./interfaces/IEventTransformer";
 

package/src/events/DeviceEventHandler.ts

@@ -1,6 +1,6 @@
-import { DT_EVENT_TYPES } from "../constants/Event";
-import { IDevice } from "../device/local/interfaces";
-import { LocalHubService } from "../device/local/services";
+import { DT_EVENT_TYPES } from "src/constants/Event";
+import { IDevice } from "src/device/local/interfaces";
+import { LocalHubService } from "src/device/local/services";
 import { BaseEventHandler } from "./BaseEventHandler";
 import {
   DeviceEvent,

package/src/events/EventHandler.ts

@@ -1,6 +1,6 @@
 import { eventDispatcher } from "dt-pub-sub";
 import { publishAudit } from "dt-audit-library";
-import { DT_EVENT_TYPES } from "../constants/Event";
+import { DT_EVENT_TYPES } from "src/constants/Event";
 
 export class EventHandler {
   private readonly source: string;

package/src/events/EventHandlerOrchestrator.ts

@@ -1,8 +1,8 @@
 import { Service } from "typedi";
 import { IEventHandler } from "./interfaces/IEventHandler";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
-import { ILogger } from "../types/config.types";
-import { getConfig } from "../config/config";
+import { ILogger } from "src/config/config.types";
+import { getConfig } from "src/config/config";
 
 @Service()
 export class EventHandlerOrchestrator {

package/src/events/EventProcessingService.ts

@@ -1,7 +1,7 @@
 import { Service } from "typedi";
 import { DeviceEventHandler } from "./DeviceEventHandler";
-import { ILogger } from "../types/config.types";
-import { getConfig } from "../config/config";
+import { ILogger } from "src/config/config.types";
+import { getConfig } from "src/config/config";
 import { DeviceEvent } from "./interfaces/DeviceEvent";
 import { IEventTransformer } from "./interfaces/IEventTransformer";
 import { EventHandlerOrchestrator } from "./EventHandlerOrchestrator";

package/src/events/InternalEventSubscription.ts

@@ -1,5 +1,5 @@
 import { eventDispatcher } from "dt-pub-sub";
-import { getConfig } from "../config/config";
+import { getConfig } from "src/config/config";
 import {
   IInternalEvent,
   HeartbeatEventData,
@@ -7,7 +7,7 @@ import {
   ReservationEventData,
   ServiceEventData,
 } from "./interfaces/IInternalEvent";
-import { ILogger } from "../types/config.types";
+import { ILogger } from "src/config/config.types";
 
 // Event types enum for better type safety
 export enum InternalEventType {

package/src/index.ts

@@ -1,6 +1,6 @@
 // Main entry point for dt-common-device
 
-// Cloud exports
+// DEVICE EXPORTS
 export {
   CloudDevice,
   CloudDeviceService,
@@ -9,26 +9,32 @@ export {
 export {
   LocalDeviceService,
   LocalHubService,
-  LocalConnectionService,
-  LocalPropertyService,
   LocalScheduleService,
 } from "./device/local/services";
+export * from "./device/local/interfaces";
+export * from "./device/cloud/interfaces";
 
-// Events exports
-export * from "./events";
-export * from "./events/interfaces";
+// CONNECTION EXPORTS
+export * from "./connection";
 
-export * from "./device/cloud/interfaces";
+// PROPERTY EXPORTS
+export * from "./property";
 
-// Local exports
-export * from "./device/local/interfaces";
+// EVENTS EXPORTS
 export * from "./events";
 export * from "./events/interfaces";
-// Types exports
-export * from "./types";
 
-// Redis utils
+// ALERTS EXPORTS
+export * from "./alerts";
+
+// ISSUES EXPORTS
+export * from "./issues";
+
+// REDIS EXPORTS
 export * from "./utils";
 
-//initialize export
+// QUEUE EXPORTS
+export * from "./queue";
+
+// CONFIG EXPORTS
 export { initialize, getConfig, shutdown } from "./config/config";

package/src/{device/local/models → issues}/Issue.model.ts

@@ -9,7 +9,7 @@ import {
   CreateIssueData,
   UpdateIssueData,
   AddCommentData,
-} from "../../../types/issue.types";
+} from "./issue.types";
 
 // Comment sub-schema
 const CommentSchema = new Schema<IssueComment>(

package/src/{device/local/repository → issues}/Issue.repository.ts

@@ -1,5 +1,5 @@
 import { Service } from "typedi";
-import { IssueModel, IIssueDocument } from "../models/Issue.model";
+import { IssueModel, IIssueDocument } from "./Issue.model";
 import {
   CreateIssueData,
   UpdateIssueData,
@@ -7,7 +7,7 @@ import {
   IssuePriority,
   IssuesCategory,
   EntityType,
-} from "../../../types/issue.types";
+} from "./issue.types";
 
 @Service()
 export class IssueRepository {

package/src/{device/local/services → issues}/Issue.service.ts

@@ -1,6 +1,6 @@
 import { Service } from "typedi";
-import { IssueRepository } from "../repository/Issue.repository";
-import { IssueModel, IIssueDocument } from "../models/Issue.model";
+import { IssueRepository } from "./Issue.repository";
+import { IssueModel, IIssueDocument } from "./Issue.model";
 import {
   CreateIssueData,
   UpdateIssueData,
@@ -9,8 +9,8 @@ import {
   IssuePriority,
   IssuesCategory,
   EntityType,
-} from "../../../types/issue.types";
-import { IssueBuilder } from "../entities/IssueBuilder";
+} from "./issue.types";
+import { IssueBuilder } from "./IssueBuilder";
 
 @Service()
 export class IssueService {

package/src/{device/local/entities → issues}/IssueBuilder.example.ts

@@ -1,5 +1,5 @@
 import { IssueBuilder } from "./IssueBuilder";
-import { IssuesCategory, IssuePriority, EntityType } from "../../../types/issue.types";
+import { IssuesCategory, IssuePriority, EntityType } from "./issue.types";
 
 /**
  * Example usage of IssueBuilder

package/src/{device/local/entities → issues}/IssueBuilder.ts

@@ -3,7 +3,7 @@ import {
   IssuesCategory,
   IssuePriority,
   EntityType,
-} from "../../../types/issue.types";
+} from "./issue.types";
 
 /**
  * IssueBuilder - A builder pattern implementation for constructing CreateIssueData objects

package/src/{device/local/services → issues}/IssueService.example.ts

@@ -1,6 +1,6 @@
 import { IssueService } from "./Issue.service";
-import { IssueBuilder } from "../entities/IssueBuilder";
-import { IssuesCategory, IssuePriority, EntityType } from "../../../types/issue.types";
+import { IssueBuilder } from "./IssueBuilder";
+import { IssuesCategory, IssuePriority, EntityType } from "./issue.types";
 
 /**
  * Example usage of the updated IssueService with IssueBuilder integration
@@ -291,17 +291,18 @@ export class IssueServiceExample {
       category: IssuesCategory.OPERATIONS,
       propertyId: "prop123",
       title: "Legacy Issue",
-      description: "This issue was created using the old CreateIssueData format",
+      description:
+        "This issue was created using the old CreateIssueData format",
       entityId: "device456",
       entityType: EntityType.DEVICE,
       priority: IssuePriority.MEDIUM,
       assignedTo: "tech-support",
       createdBy: "legacy-system",
-      dueDate: new Date("2024-01-20")
+      dueDate: new Date("2024-01-20"),
     };
 
     // This still works with the updated createIssue method
     const issue = await this.issueService.createIssue(issueData);
     return issue;
   }
-} 
+}

package/src/issues/index.ts

@@ -0,0 +1,2 @@
+export * from "./Issue.service";
+export * from "./issue.types";

package/src/{device/local/repository → property}/Property.repository.ts

@@ -1,6 +1,6 @@
-import { getPostgresClient } from "../../../db";
+import { getPostgresClient } from "../db";
 import { Service } from "typedi";
-import { IProperty, IPropertySettings } from "../interfaces/IProperty";
+import { IProperty, IPropertySettings } from "./IProperty";
 
 @Service()
 export class PropertyRepository {

package/src/{device/local/services → property}/Property.service.ts

@@ -1,4 +1,4 @@
-import { PropertyRepository } from "../repository/Property.repository";
+import { PropertyRepository } from "./Property.repository";
 
 export class LocalPropertyService {
   private readonly propertyRepository: PropertyRepository;

package/src/property/index.ts

@@ -0,0 +1,2 @@
+export * from "./IProperty";
+export * from "./Property.service";

package/src/queue/entities/HybridHttpQueue.ts

@@ -0,0 +1,272 @@
+import { HttpCallOption } from "../types/http.types";
+import { getConfig } from "../../config/config";
+import axios from "axios";
+import { publishAudit } from "dt-audit-library";
+import { Service } from "typedi";
+import { RateLimitUtils } from "../utils/rateLimit.utils";
+import { JobUtils } from "../utils/jobUtils";
+import { QueueUtils } from "../utils/queueUtils";
+import {
+  IRateLimitConfig,
+  IJobResult,
+  IHttpRequestJob,
+  IQueueResponse,
+} from "../interfaces";
+import { Queue } from "bullmq";
+
+@Service()
+export class HybridHttpQueue {
+  private readonly queues = new Map<string, any>();
+  private readonly workers = new Map<string, any>();
+  private readonly rateLimitConfigs: Map<string, IRateLimitConfig>;
+  private readonly jobResults = new Map<string, IJobResult>();
+
+  constructor() {
+    this.rateLimitConfigs = RateLimitUtils.initializeRateLimitConfigs();
+  }
+
+  private async handleRateLimitAndQueue(
+    url: string,
+    method: string,
+    options: HttpCallOption
+  ): Promise<IQueueResponse> {
+    const { connectionId, provider, microservice } =
+      JobUtils.extractConnectionDetails(options);
+    const key = `rate_limit:${provider}:${connectionId}`;
+    const config = this.rateLimitConfigs.get(provider);
+    const windowMs = config?.windowMs ?? 60000;
+
+    const timestamps = await RateLimitUtils.getRawRequestTimestamps(key);
+    const now = Date.now();
+    const windowStart = now - windowMs;
+    const recentRequests = timestamps.filter((t) => t > windowStart);
+    const nextAvailableTime =
+      recentRequests.length > 0 ? recentRequests[0] + windowMs : now + 1000;
+    const delay = Math.max(nextAvailableTime - now, 1000); // at least 1s delay
+
+    // Create job data
+    const jobData = {
+      microservice,
+      connectionId,
+      provider,
+      url,
+      method,
+      options,
+      timestamp: Date.now(),
+    };
+
+    // Add job to queue with delay (background processing)
+    const queueKey = QueueUtils.getQueueKey(
+      microservice,
+      connectionId,
+      provider
+    );
+    const queue = QueueUtils.getOrCreateQueue(queueKey, this.queues);
+
+    QueueUtils.getOrCreateWorker(
+      queueKey,
+      this.workers,
+      this.processHttpRequest.bind(this),
+      this.jobResults
+    );
+
+    const job = await queue.add("http-request", jobData, {
+      delay,
+      attempts: 1,
+      removeOnComplete: { age: 300, count: 1 },
+      removeOnFail: { age: 300, count: 1 },
+    });
+
+    await publishAudit({
+      eventType: "http.request.rateLimitQueued",
+      properties: {
+        resource: microservice,
+        connectionId,
+        provider,
+        endpoint: url,
+        method,
+        timestamp: Date.now(),
+        queueId: job.id,
+        reason: "rate_limit_exceeded_queued",
+        delay,
+        estimatedProcessingTime: now + delay,
+      },
+    });
+
+    // Return immediate response to controller
+    return {
+      success: true,
+      queued: true,
+      estimatedProcessingTime: now + delay,
+      jobId: job.id,
+    };
+  }
+
+  private async processHttpRequest(job: any): Promise<any> {
+    const { connectionId, provider, url, method, options } = job.data;
+
+    const allowed = await RateLimitUtils.isRateLimitAllowed(
+      connectionId,
+      provider,
+      this.rateLimitConfigs
+    );
+
+    if (!allowed) {
+      // This shouldn't happen since we check before queuing, but handle it gracefully
+      getConfig().LOGGER.warn(
+        `Job ${job.id} still rate limited after delay, skipping`
+      );
+      return;
+    }
+
+    await RateLimitUtils.recordRequest(connectionId, provider);
+
+    try {
+      getConfig().LOGGER.info(
+        `Executing HTTP request: ${method} ${url} for ${provider}`
+      );
+
+      const response = await axios({
+        method: method.toLowerCase(),
+        url: url,
+        headers: options.headers || {},
+        timeout: 30000,
+        ...(options.body && { data: options.body }),
+        ...(options.params && { params: options.params }),
+      });
+
+      getConfig().LOGGER.info(
+        `HTTP request successful: ${method} ${url} for ${provider}`
+      );
+      return response.data;
+    } catch (error: any) {
+      getConfig().LOGGER.error(
+        `HTTP request failed ${job.id}: ${error.message}`
+      );
+
+      await publishAudit({
+        eventType: "http.request.error",
+        properties: {
+          connectionId,
+          provider,
+          endpoint: url,
+          method,
+          timestamp: Date.now(),
+          queueId: job.id,
+          reason: "execution_error",
+          errorMessage: error.message,
+        },
+      });
+
+      throw new Error(`HTTP request failed: ${error.message}`);
+    }
+  }
+
+  async request(options: {
+    method: string;
+    url: string;
+    body?: any;
+    headers?: Record<string, string>;
+    queueOptions?: {
+      connectionId: string;
+      connectionProvider: string;
+      microservice: string;
+    };
+  }): Promise<IQueueResponse> {
+    const { method, url, body, headers, queueOptions } = options;
+    // Create HttpCallOption object
+    const httpCallOption: HttpCallOption = {
+      headers,
+      body,
+      queueOptions,
+    };
+    // Call handleRequest with the constructed parameters
+    return this.handleRequest(url, method, httpCallOption);
+  }
+
+  async handleRequest(
+    url: string,
+    method: string,
+    options: HttpCallOption
+  ): Promise<IQueueResponse> {
+    const { connectionId, provider, microservice } =
+      JobUtils.extractConnectionDetails(options);
+
+    // Check rate limit first
+    const allowed = await RateLimitUtils.isRateLimitAllowed(
+      connectionId,
+      provider,
+      this.rateLimitConfigs
+    );
+
+    if (!allowed) {
+      // Rate limited - queue the request and return immediate response
+      return this.handleRateLimitAndQueue(url, method, options);
+    }
+
+    // Not rate limited - process immediately
+    getConfig().LOGGER.info(
+      `Processing immediately: ${method} ${url} -> ${provider} [${connectionId}]`
+    );
+
+    try {
+      // Record the request first
+      await RateLimitUtils.recordRequest(connectionId, provider);
+
+      // Execute the HTTP request
+      const response = await axios({
+        method: method.toLowerCase(),
+        url: url,
+        headers: options.headers || {},
+        timeout: 30000,
+        ...(options.body && { data: options.body }),
+        ...(options.params && { params: options.params }),
+      });
+
+      getConfig().LOGGER.info(
+        `HTTP request successful: ${method} ${url} for ${provider}`
+      );
+
+      return {
+        success: true,
+        data: response.data,
+        queued: false,
+      };
+    } catch (error: any) {
+      getConfig().LOGGER.error(`HTTP request failed: ${error.message}`);
+
+      await publishAudit({
+        eventType: "http.request.error",
+        properties: {
+          connectionId,
+          provider,
+          endpoint: url,
+          method,
+          timestamp: Date.now(),
+          reason: "execution_error",
+          errorMessage: error.message,
+        },
+      });
+
+      return {
+        success: false,
+        error: `HTTP request failed: ${error.message}`,
+        queued: false,
+      };
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    getConfig().LOGGER.info("Shutting down HTTP queues...");
+
+    await Promise.all([
+      ...Array.from(this.workers.values()).map((worker: any) => worker.close()),
+      ...Array.from(this.queues.values()).map((queue: any) => queue.close()),
+    ]);
+
+    this.workers.clear();
+    this.queues.clear();
+    this.jobResults.clear();
+    getConfig().LOGGER.info("HTTP queues shutdown complete");
+  }
+}

package/src/queue/entities/index.ts

@@ -0,0 +1 @@
+export * from "./HybridHttpQueue";

package/src/queue/index.ts

@@ -0,0 +1,6 @@
+// Main queue exports
+export * from "./entities";
+export * from "./interfaces";
+export * from "./services";
+export * from "./types";
+export * from "./utils";

package/src/queue/interfaces/IHttpRequestJob.ts

@@ -0,0 +1,10 @@
+import { HttpCallOption } from "../types/http.types";
+
+export interface IHttpRequestJob {
+  connectionId: string;
+  provider: string;
+  url: string;
+  method: string;
+  options: HttpCallOption;
+  timestamp: number;
+}

package/src/queue/interfaces/IHybridHttpQueue.ts

@@ -0,0 +1,24 @@
+import { HttpCallOption } from "../types/http.types";
+import { IQueueResponse } from "./IJobResult";
+
+export interface IHybridHttpQueue {
+  request(options: {
+    method: string;
+    url: string;
+    body?: any;
+    headers?: Record<string, string>;
+    queueOptions?: {
+      connectionId: string;
+      connectionProvider: string;
+      microservice: string;
+    };
+  }): Promise<IQueueResponse>;
+
+  handleRequest(
+    url: string,
+    method: string,
+    options: HttpCallOption
+  ): Promise<IQueueResponse>;
+
+  shutdown(): Promise<void>;
+}

package/src/queue/interfaces/IJobResult.ts

@@ -0,0 +1,15 @@
+export interface IJobResult {
+  result?: any;
+  error?: string;
+  resolved: boolean;
+  timestamp: number;
+}
+
+export interface IQueueResponse {
+  success: boolean;
+  data?: any;
+  error?: string;
+  queued?: boolean;
+  estimatedProcessingTime?: number;
+  jobId?: string;
+}

package/src/queue/interfaces/IRateLimitConfig.ts

@@ -0,0 +1,5 @@
+export interface IRateLimitConfig {
+  maxRequests: number;
+  windowMs: number;
+  provider: string;
+}

package/src/queue/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from "./IHybridHttpQueue";
+export * from "./IHttpRequestJob";
+export * from "./IJobResult";
+export * from "./IRateLimitConfig";

package/src/queue/services/QueueService.ts

@@ -0,0 +1,39 @@
+import { Service } from "typedi";
+import { HybridHttpQueue } from "../entities/HybridHttpQueue";
+import { IHybridHttpQueue, IQueueResponse } from "../interfaces";
+import { HttpCallOption } from "../types/http.types";
+
+@Service()
+export class QueueService implements IHybridHttpQueue {
+  private readonly hybridQueue: HybridHttpQueue;
+
+  constructor() {
+    this.hybridQueue = new HybridHttpQueue();
+  }
+
+  async request(options: {
+    method: string;
+    url: string;
+    body?: any;
+    headers?: Record<string, string>;
+    queueOptions?: {
+      connectionId: string;
+      connectionProvider: string;
+      microservice: string;
+    };
+  }): Promise<IQueueResponse> {
+    return this.hybridQueue.request(options);
+  }
+
+  async handleRequest(
+    url: string,
+    method: string,
+    options: HttpCallOption
+  ): Promise<IQueueResponse> {
+    return this.hybridQueue.handleRequest(url, method, options);
+  }
+
+  async shutdown(): Promise<void> {
+    return this.hybridQueue.shutdown();
+  }
+}

package/src/queue/services/index.ts

@@ -0,0 +1 @@
+export * from "./QueueService";

package/src/queue/types/http.types.ts

@@ -0,0 +1,22 @@
+export interface HttpCallOption {
+  headers?: Record<string, string>;
+  body?: any;
+  params?: Record<string, any>;
+  queueOptions?: {
+    connectionId: string;
+    connectionProvider: string;
+    microservice: string;
+  };
+}
+
+export interface HttpRequestOptions {
+  method: string;
+  url: string;
+  body?: any;
+  headers?: Record<string, string>;
+  queueOptions?: {
+    connectionId: string;
+    connectionProvider: string;
+    microservice: string;
+  };
+}