dt-common-device 3.0.10 → 3.0.11

package/dist/queue/utils/queueUtils.js

@@ -1,12 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueUtils = void 0;
+const rateLimit_utils_1 = require("./rateLimit.utils");
+const axios_1 = __importDefault(require("axios"));
+const dt_audit_library_1 = require("dt-audit-library");
 const config_1 = require("../../config/config");
 const redis_1 = require("../../db/redis");
 class QueueUtils {
     static getQueueKey(microservice, connectionId, provider) {
         return `${microservice}_${provider}_${connectionId}`;
     }
+    static getRequestQueueKey(connectionId, provider) {
+        return `${connectionId}_${provider}`;
+    }
     static getOrCreateQueue(queueKey, queues) {
         return (queues.get(queueKey) ??
             queues
@@ -27,10 +36,9 @@ class QueueUtils {
             lockDuration: 300000,
             stalledInterval: 60000,
         });
-        // Simplified event handlers
+        // Event handlers for job tracking
         worker.on("completed", (job) => {
             (0, config_1.getConfig)().LOGGER.info(`HTTP request completed: ${job.id} [${queueKey}]`);
-            // job.returnvalue is the actual result, not a Promise
             const result = job.returnvalue;
             jobResults.set(job.id, {
                 result,
@@ -47,10 +55,111 @@ class QueueUtils {
             });
         });
         worker.on("error", (err) => (0, config_1.getConfig)().LOGGER.error(`Worker error for ${queueKey}: ${err.message}`));
-        worker.on("stalled", (jobId) => (0, config_1.getConfig)().LOGGER.warn(`Job ${jobId} stalled in worker ${queueKey}`));
-        worker.on("active", (job) => (0, config_1.getConfig)().LOGGER.info(`HTTP request started: ${job.id} [${queueKey}]`));
         workers.set(queueKey, worker);
         (0, config_1.getConfig)().LOGGER.info(`Worker initialized for queue: ${queueKey}`);
     }
+    static async waitForRateLimitExpiry(connectionId, provider, rateLimitConfigs) {
+        const key = `rate_limit:${provider}:${connectionId}`;
+        const config = rateLimitConfigs.get(provider);
+        if (!config)
+            return;
+        while (true) {
+            const timestamps = await rateLimit_utils_1.RateLimitUtils.getRawRequestTimestamps(key);
+            const now = Date.now();
+            const windowStart = now - config.windowMs;
+            const recentRequests = timestamps.filter((t) => t > windowStart);
+            if (recentRequests.length < config.maxRequests) {
+                // Rate limit not exceeded, we can proceed
+                break;
+            }
+            // Calculate when the earliest request will expire
+            const earliestRequest = recentRequests[0];
+            const nextAvailableTime = earliestRequest + config.windowMs;
+            const delay = Math.max(nextAvailableTime - now, 1000); // At least 1 second
+            (0, config_1.getConfig)().LOGGER.info(`Rate limit exceeded for ${provider} [${connectionId}]. Waiting ${delay}ms until next allowed request. Current requests in window: ${recentRequests.length}/${config.maxRequests}`);
+            // Wait for the calculated delay
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    static async executeHttpRequest(url, method, options, connectionId, provider) {
+        (0, config_1.getConfig)().LOGGER.info(`Executing: ${method} ${url} -> ${provider} [${connectionId}]`);
+        try {
+            // Record the request first
+            await rateLimit_utils_1.RateLimitUtils.recordRequest(connectionId, provider);
+            // Execute the HTTP request
+            const response = await (0, axios_1.default)({
+                method: method.toLowerCase(),
+                url: url,
+                headers: options.headers || {},
+                timeout: 30000,
+                ...(options.body && { data: options.body }),
+                ...(options.params && { params: options.params }),
+            });
+            (0, config_1.getConfig)().LOGGER.info(`HTTP request successful: ${method} ${url} for ${provider} [${connectionId}]`);
+            // Return only the response data
+            return response.data;
+        }
+        catch (error) {
+            (0, config_1.getConfig)().LOGGER.error(`HTTP request failed: ${error.message}`);
+            await (0, dt_audit_library_1.publishAudit)({
+                eventType: "http.request.error",
+                properties: {
+                    connectionId,
+                    provider,
+                    endpoint: url,
+                    method,
+                    timestamp: Date.now(),
+                    reason: "execution_error",
+                    errorMessage: error.message,
+                },
+            });
+            // Throw the error instead of returning it
+            throw new Error(`HTTP request failed: ${error.message}`);
+        }
+    }
+    static async addJobToQueue(queueKey, jobData, delay, queues) {
+        const queue = this.getOrCreateQueue(queueKey, queues);
+        const job = await queue.add("http-request", jobData, {
+            delay,
+            attempts: 1,
+            removeOnComplete: { age: 300, count: 1 },
+            removeOnFail: { age: 300, count: 1 },
+        });
+        return job.id;
+    }
+    static async waitForJobCompletion(jobId, queueKey, jobResults) {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            let checkCount = 0;
+            const maxChecks = 600;
+            const checkJob = async () => {
+                if (++checkCount >= maxChecks) {
+                    clearTimeout(timeoutId);
+                    return reject(new Error("Job timeout: Request took too long"));
+                }
+                try {
+                    const memoryResult = jobResults.get(jobId);
+                    if (memoryResult?.resolved) {
+                        clearTimeout(timeoutId);
+                        return memoryResult.result !== undefined
+                            ? resolve(memoryResult.result)
+                            : reject(new Error(memoryResult.error || "Unknown error"));
+                    }
+                    // Continue checking
+                    timeoutId = setTimeout(checkJob, checkCount < 10 ? 50 : 100);
+                }
+                catch (error) {
+                    clearTimeout(timeoutId);
+                    reject(new Error(`Error checking job: ${error.message}`));
+                }
+            };
+            checkJob();
+            // Backup timeout
+            setTimeout(() => {
+                clearTimeout(timeoutId);
+                reject(new Error("Request timeout: Maximum wait time exceeded"));
+            }, 60000);
+        });
+    }
 }
 exports.QueueUtils = QueueUtils;

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "dt-common-device",
-  "version": "3.0.10",
+  "version": "3.0.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "patch": "npm version patch && npm run build && npm publish",

package/.eslintrc.js

@@ -1,44 +0,0 @@
-module.exports = {
-  parser: "@typescript-eslint/parser",
-  extends: ["eslint:recommended", "@typescript-eslint/recommended"],
-  plugins: ["@typescript-eslint"],
-  env: {
-    node: true,
-    es2020: true,
-  },
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: "module",
-  },
-  rules: {
-    // Security rules
-    "no-eval": "error",
-    "no-implied-eval": "error",
-    "no-new-func": "error",
-    "no-script-url": "error",
-    "no-unsafe-finally": "error",
-
-    // TypeScript security
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/no-unsafe-assignment": "warn",
-    "@typescript-eslint/no-unsafe-call": "warn",
-    "@typescript-eslint/no-unsafe-member-access": "warn",
-    "@typescript-eslint/no-unsafe-return": "warn",
-
-    // Code quality
-    "@typescript-eslint/explicit-function-return-type": "warn",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/prefer-const": "error",
-    "@typescript-eslint/no-var-requires": "error",
-
-    // Error handling
-    "no-console": "warn",
-    "no-throw-literal": "error",
-
-    // Best practices
-    "prefer-const": "error",
-    "no-var": "error",
-    "object-shorthand": "error",
-  },
-  ignorePatterns: ["dist/", "node_modules/", "*.js"],
-};

package/src/alerts/Alert.model.ts

@@ -1,289 +0,0 @@
-import mongoose, { Schema, Model } from "mongoose";
-import {
-  AlertCategory,
-  AlertSeverity,
-  EntityType,
-  AlertDocument as IAlertDocument,
-  CreateAlertData,
-  UpdateAlertData,
-} from "./alert.types";
-
-// Interface for instance methods
-interface IAlertMethods {
-  markAsRead(updatedBy: string): void;
-  markAsUnread(updatedBy: string): void;
-  activate(updatedBy: string): void;
-  deactivate(updatedBy: string): void;
-  snooze(until: Date, updatedBy: string): void;
-  unsnooze(updatedBy: string): void;
-}
-
-// Interface for static methods
-interface IAlertModel extends Model<IAlertDocument, {}, IAlertMethods> {
-  findByProperty(
-    propertyId: string,
-    includeDeleted?: boolean
-  ): Promise<IAlertDocument[]>;
-  findByEntity(
-    entityId: string,
-    entityType: EntityType,
-    includeDeleted?: boolean
-  ): Promise<IAlertDocument[]>;
-  findByCategory(
-    category: AlertCategory,
-    includeDeleted?: boolean
-  ): Promise<IAlertDocument[]>;
-  findBySeverity(
-    severity: AlertSeverity,
-    includeDeleted?: boolean
-  ): Promise<IAlertDocument[]>;
-  findActive(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-  findUnread(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-  findSnoozed(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-  findExpiredSnooze(includeDeleted?: boolean): Promise<IAlertDocument[]>;
-}
-
-// Main Alert schema
-const AlertSchema = new Schema<IAlertDocument, IAlertModel, IAlertMethods>(
-  {
-    category: {
-      type: [String],
-      enum: Object.values(AlertCategory),
-      required: true,
-      validate: {
-        validator: function (categories: string[]) {
-          return categories && categories.length > 0;
-        },
-        message: "At least one category is required",
-      },
-    },
-    propertyId: {
-      type: String,
-      required: true,
-      index: true,
-    },
-    title: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    description: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    entityId: {
-      type: String,
-      index: true,
-    },
-    entityType: {
-      type: String,
-      enum: Object.values(EntityType),
-      required: true,
-      index: true,
-    },
-    severity: {
-      type: String,
-      enum: Object.values(AlertSeverity),
-      default: AlertSeverity.MEDIUM,
-    },
-    isRead: {
-      type: Boolean,
-      default: false,
-      index: true,
-    },
-    isActive: {
-      type: Boolean,
-      default: true,
-      index: true,
-    },
-    isDeleted: {
-      type: Boolean,
-      default: false,
-    },
-    snoozeUntil: {
-      type: Date,
-    },
-    createdBy: {
-      type: String,
-    },
-    updatedBy: {
-      type: String,
-    },
-    createdAt: {
-      type: Date,
-      default: Date.now,
-    },
-    updatedAt: {
-      type: Date,
-      default: Date.now,
-    },
-  },
-  {
-    timestamps: true,
-    collection: "dt_alerts",
-  }
-);
-
-// Compound indexes to match Prisma schema
-AlertSchema.index({ propertyId: 1, isActive: 1, isRead: 1 });
-AlertSchema.index({ entityId: 1, entityType: 1 });
-AlertSchema.index({ createdAt: 1 });
-
-// Pre-save middleware to update the updatedAt field
-AlertSchema.pre("save", function (next) {
-  this.updatedAt = new Date();
-  next();
-});
-
-// Pre-update middleware to update the updatedAt field
-AlertSchema.pre(
-  ["updateOne", "findOneAndUpdate", "updateMany"],
-  function (next) {
-    this.set({ updatedAt: new Date() });
-    next();
-  }
-);
-
-// Instance methods
-AlertSchema.methods.markAsRead = function (updatedBy: string): void {
-  this.isRead = true;
-  this.updatedBy = updatedBy;
-};
-
-AlertSchema.methods.markAsUnread = function (updatedBy: string): void {
-  this.isRead = false;
-  this.updatedBy = updatedBy;
-};
-
-AlertSchema.methods.activate = function (updatedBy: string): void {
-  this.isActive = true;
-  this.updatedBy = updatedBy;
-};
-
-AlertSchema.methods.deactivate = function (updatedBy: string): void {
-  this.isActive = false;
-  this.updatedBy = updatedBy;
-};
-
-AlertSchema.methods.snooze = function (until: Date, updatedBy: string): void {
-  this.snoozeUntil = until;
-  this.updatedBy = updatedBy;
-};
-
-AlertSchema.methods.unsnooze = function (updatedBy: string): void {
-  this.snoozeUntil = undefined;
-  this.updatedBy = updatedBy;
-};
-
-// Static methods
-AlertSchema.statics.findByProperty = function (
-  propertyId: string,
-  includeDeleted = false
-) {
-  const query: any = { propertyId };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ createdAt: -1 });
-};
-
-AlertSchema.statics.findByEntity = function (
-  entityId: string,
-  entityType: EntityType,
-  includeDeleted = false
-) {
-  const query: any = { entityId, entityType };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ createdAt: -1 });
-};
-
-AlertSchema.statics.findByCategory = function (
-  category: AlertCategory,
-  includeDeleted = false
-) {
-  const query: any = { category: { $in: [category] } };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ createdAt: -1 });
-};
-
-AlertSchema.statics.findBySeverity = function (
-  severity: AlertSeverity,
-  includeDeleted = false
-) {
-  const query: any = { severity };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ severity: -1, createdAt: -1 });
-};
-
-AlertSchema.statics.findActive = function (includeDeleted = false) {
-  const query: any = { isActive: true };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ severity: -1, createdAt: -1 });
-};
-
-AlertSchema.statics.findUnread = function (includeDeleted = false) {
-  const query: any = { isRead: false };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ severity: -1, createdAt: -1 });
-};
-
-AlertSchema.statics.findSnoozed = function (includeDeleted = false) {
-  const query: any = { snoozeUntil: { $exists: true, $ne: null } };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ snoozeUntil: 1 });
-};
-
-AlertSchema.statics.findExpiredSnooze = function (includeDeleted = false) {
-  const query: any = {
-    snoozeUntil: { $lt: new Date() },
-    isActive: true,
-  };
-  if (!includeDeleted) {
-    query.isDeleted = false;
-  }
-  return this.find(query).sort({ snoozeUntil: 1 });
-};
-
-// Virtual for snooze status
-AlertSchema.virtual("isSnoozed").get(function () {
-  return this.snoozeUntil && this.snoozeUntil > new Date();
-});
-
-AlertSchema.virtual("isSnoozeExpired").get(function () {
-  return this.snoozeUntil && this.snoozeUntil <= new Date();
-});
-
-// Ensure virtuals are serialized
-AlertSchema.set("toJSON", { virtuals: true });
-AlertSchema.set("toObject", { virtuals: true });
-
-// Create and export the model
-export const AlertModel = mongoose.model<IAlertDocument, IAlertModel>(
-  "Alert",
-  AlertSchema
-);
-
-// Export the schema for potential reuse
-export { AlertSchema };
-
-// Export types for external use
-export type {
-  IAlertDocument,
-  CreateAlertData,
-  UpdateAlertData,
-  IAlertMethods,
-  IAlertModel,
-};