dt-common-device 2.0.6 → 3.0.0

package/dist/queue/entities/HybridHttpQueue.js

@@ -0,0 +1,189 @@
+"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 });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridHttpQueue = void 0;
+const config_1 = require("../../config/config");
+const axios_1 = __importDefault(require("axios"));
+const dt_audit_library_1 = require("dt-audit-library");
+const typedi_1 = require("typedi");
+const rateLimit_utils_1 = require("../utils/rateLimit.utils");
+const jobUtils_1 = require("../utils/jobUtils");
+const queueUtils_1 = require("../utils/queueUtils");
+let HybridHttpQueue = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var HybridHttpQueue = _classThis = class {
+        constructor() {
+            this.queues = new Map();
+            this.workers = new Map();
+            this.jobResults = new Map();
+            this.rateLimitConfigs = rateLimit_utils_1.RateLimitUtils.initializeRateLimitConfigs();
+        }
+        async handleRateLimit(job) {
+            const { connectionId, provider, url, method, options } = job.data;
+            const microservice = options.queueOptions?.microservice || "default";
+            const isMaxRetries = job.attemptsMade >= 2;
+            await (0, dt_audit_library_1.publishAudit)({
+                eventType: isMaxRetries
+                    ? "http.request.failed"
+                    : "http.request.rateLimitExceeded",
+                properties: {
+                    connectionId,
+                    provider,
+                    endpoint: url,
+                    method,
+                    timestamp: Date.now(),
+                    queueId: job.id,
+                    reason: isMaxRetries ? "max_retries_exceeded" : "rate_limit_exceeded",
+                    ...(!isMaxRetries && {
+                        retryCount: job.attemptsMade + 1,
+                        maxRetries: 3,
+                    }),
+                },
+            });
+            if (isMaxRetries) {
+                await this.queues
+                    .get(queueUtils_1.QueueUtils.getQueueKey(microservice, connectionId, provider))
+                    ?.obliterate({ force: true });
+                // Don't throw error for max retries - just return
+                return;
+            }
+            throw new Error("Rate limit exceeded");
+        }
+        async processHttpRequest(job) {
+            const { connectionId, provider, url, method, options } = job.data;
+            // Check rate limit
+            if (!(await rateLimit_utils_1.RateLimitUtils.checkRateLimit(connectionId, provider, this.rateLimitConfigs))) {
+                await this.handleRateLimit(job);
+                return;
+            }
+            try {
+                (0, config_1.getConfig)().LOGGER.info(`Executing HTTP request: ${method} ${url} for ${provider}`);
+                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}`);
+                return response.data;
+            }
+            catch (error) {
+                (0, config_1.getConfig)().LOGGER.error(`HTTP request failed ${job.id}: ${error.message}`);
+                await (0, dt_audit_library_1.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) {
+            const { method, url, body, headers, queueOptions } = options;
+            // Create HttpCallOption object
+            const httpCallOption = {
+                headers,
+                body,
+                queueOptions,
+            };
+            // Call handleRequest with the constructed parameters
+            return this.handleRequest(url, method, httpCallOption);
+        }
+        async handleRequest(url, method, options) {
+            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+            const queueKey = queueUtils_1.QueueUtils.getQueueKey(microservice, connectionId, provider);
+            (0, config_1.getConfig)().LOGGER.info(`Queueing: ${method} ${url} -> ${provider} [${connectionId}]`);
+            queueUtils_1.QueueUtils.getOrCreateWorker(queueKey, this.workers, this.processHttpRequest.bind(this), this.jobResults);
+            const queue = queueUtils_1.QueueUtils.getOrCreateQueue(queueKey, this.queues);
+            const job = await queue.add("http-request", {
+                microservice,
+                connectionId,
+                provider,
+                url,
+                method,
+                options,
+                timestamp: Date.now(),
+            }, {
+                attempts: 3,
+                backoff: { type: "exponential", delay: 5000 },
+                removeOnComplete: { age: 300, count: 1 },
+                removeOnFail: { age: 300, count: 1 },
+            });
+            (0, config_1.getConfig)().LOGGER.info(`Job ${job.id} queued, waiting for completion...`);
+            return jobUtils_1.JobUtils.waitForJobCompletion(job, queueKey, this.jobResults);
+        }
+        async shutdown() {
+            (0, config_1.getConfig)().LOGGER.info("Shutting down HTTP queues...");
+            await Promise.all([
+                ...Array.from(this.workers.values()).map((worker) => worker.close()),
+                ...Array.from(this.queues.values()).map((queue) => queue.close()),
+            ]);
+            this.workers.clear();
+            this.queues.clear();
+            this.jobResults.clear();
+            (0, config_1.getConfig)().LOGGER.info("HTTP queues shutdown complete");
+        }
+    };
+    __setFunctionName(_classThis, "HybridHttpQueue");
+    (() => {
+        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);
+        HybridHttpQueue = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return HybridHttpQueue = _classThis;
+})();
+exports.HybridHttpQueue = HybridHttpQueue;

package/dist/queue/entities/index.d.ts

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

package/dist/queue/entities/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HybridHttpQueue"), exports);

package/dist/queue/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./entities";
+export * from "./interfaces";
+export * from "./services";
+export * from "./types";
+export * from "./utils";

package/dist/queue/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Main queue exports
+__exportStar(require("./entities"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/queue/interfaces/IHttpRequestJob.d.ts

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

package/dist/queue/interfaces/IHttpRequestJob.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue/interfaces/IHybridHttpQueue.d.ts

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

package/dist/queue/interfaces/IHybridHttpQueue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue/interfaces/IJobResult.d.ts

@@ -0,0 +1,6 @@
+export interface IJobResult {
+    result?: any;
+    error?: string;
+    resolved: boolean;
+    timestamp: number;
+}

package/dist/queue/interfaces/IJobResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue/interfaces/IRateLimitConfig.d.ts

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

package/dist/queue/interfaces/IRateLimitConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue/interfaces/index.d.ts

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

package/dist/queue/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IHybridHttpQueue"), exports);
+__exportStar(require("./IHttpRequestJob"), exports);
+__exportStar(require("./IJobResult"), exports);
+__exportStar(require("./IRateLimitConfig"), exports);

package/dist/queue/services/QueueService.d.ts

@@ -0,0 +1,19 @@
+import { IHybridHttpQueue } from "../interfaces";
+import { HttpCallOption } from "../types/http.types";
+export declare class QueueService implements IHybridHttpQueue {
+    private readonly hybridQueue;
+    constructor();
+    request(options: {
+        method: string;
+        url: string;
+        body?: any;
+        headers?: Record<string, string>;
+        queueOptions?: {
+            connectionId: string;
+            connectionProvider: string;
+            microservice: string;
+        };
+    }): Promise<any>;
+    handleRequest(url: string, method: string, options: HttpCallOption): Promise<any>;
+    shutdown(): Promise<void>;
+}

package/dist/queue/services/QueueService.js

@@ -0,0 +1,73 @@
+"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.QueueService = void 0;
+const typedi_1 = require("typedi");
+const HybridHttpQueue_1 = require("../entities/HybridHttpQueue");
+let QueueService = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var QueueService = _classThis = class {
+        constructor() {
+            this.hybridQueue = new HybridHttpQueue_1.HybridHttpQueue();
+        }
+        async request(options) {
+            return this.hybridQueue.request(options);
+        }
+        async handleRequest(url, method, options) {
+            return this.hybridQueue.handleRequest(url, method, options);
+        }
+        async shutdown() {
+            return this.hybridQueue.shutdown();
+        }
+    };
+    __setFunctionName(_classThis, "QueueService");
+    (() => {
+        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);
+        QueueService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return QueueService = _classThis;
+})();
+exports.QueueService = QueueService;

package/dist/queue/services/index.d.ts

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

package/dist/queue/services/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./QueueService"), exports);

package/dist/queue/types/http.types.d.ts

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

package/dist/queue/types/http.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./http.types";
+export * from "./queue.types";

package/dist/queue/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http.types"), exports);
+__exportStar(require("./queue.types"), exports);

package/dist/queue/types/queue.types.d.ts

@@ -0,0 +1,35 @@
+export interface QueueConfig {
+    concurrency: number;
+    removeOnComplete: {
+        age: number;
+        count: number;
+    };
+    removeOnFail: {
+        age: number;
+        count: number;
+    };
+    lockDuration: number;
+    stalledInterval: number;
+}
+export interface JobOptions {
+    attempts: number;
+    backoff: {
+        type: string;
+        delay: number;
+    };
+    removeOnComplete: {
+        age: number;
+        count: number;
+    };
+    removeOnFail: {
+        age: number;
+        count: number;
+    };
+}
+export interface QueueMetrics {
+    totalJobs: number;
+    completedJobs: number;
+    failedJobs: number;
+    pendingJobs: number;
+    activeJobs: number;
+}

package/dist/queue/types/queue.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/queue/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./rateLimit.utils";
+export * from "./jobUtils";
+export * from "./queueUtils";

package/dist/queue/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rateLimit.utils"), exports);
+__exportStar(require("./jobUtils"), exports);
+__exportStar(require("./queueUtils"), exports);

package/dist/queue/utils/jobUtils.d.ts

@@ -0,0 +1,10 @@
+import { Job } from "bullmq";
+import { IJobResult } from "../interfaces";
+export declare class JobUtils {
+    static waitForJobCompletion(job: Job, queueKey: string, jobResults: Map<string, IJobResult>): Promise<any>;
+    static extractConnectionDetails(options: any): {
+        connectionId: string;
+        provider: string;
+        microservice: string;
+    };
+}

package/dist/queue/utils/jobUtils.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobUtils = void 0;
+class JobUtils {
+    static async waitForJobCompletion(job, 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 state = await job.getState();
+                    if (state === "completed") {
+                        clearTimeout(timeoutId);
+                        const memoryResult = jobResults.get(job.id);
+                        if (memoryResult?.resolved) {
+                            return memoryResult.result !== undefined
+                                ? resolve(memoryResult.result)
+                                : reject(new Error(memoryResult.error || "Unknown error"));
+                        }
+                        // Fallback to job result
+                        resolve(await job.returnvalue);
+                    }
+                    else if (state === "failed") {
+                        clearTimeout(timeoutId);
+                        const memoryResult = jobResults.get(job.id);
+                        const errorMsg = memoryResult?.error ||
+                            (await job.failedReason) ||
+                            "Unknown error";
+                        reject(new Error(`Job failed: ${errorMsg}`));
+                    }
+                    else {
+                        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);
+        });
+    }
+    static extractConnectionDetails(options) {
+        const { connectionId, connectionProvider: provider, microservice, } = options?.queueOptions ?? {};
+        if (!connectionId)
+            throw new Error("Connection ID not found in options");
+        if (!provider)
+            throw new Error("Connection provider not found in options");
+        if (!microservice)
+            throw new Error("Microservice not found in options");
+        return { connectionId, provider, microservice };
+    }
+}
+exports.JobUtils = JobUtils;

package/dist/queue/utils/queueUtils.d.ts

@@ -0,0 +1,5 @@
+export declare class QueueUtils {
+    static getQueueKey(microservice: string, connectionId: string, provider: string): string;
+    static getOrCreateQueue(queueKey: string, queues: Map<string, any>): any;
+    static getOrCreateWorker(queueKey: string, workers: Map<string, any>, processFunction: (job: any) => Promise<any>, jobResults: Map<string, any>): void;
+}