dt-common-device 2.0.7 → 3.0.1

package/dist/queue/entities/HybridHttpQueue.js

@@ -0,0 +1,241 @@
+"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 handleRateLimitAndQueue(url, method, options) {
+            const { connectionId, provider, microservice } = jobUtils_1.JobUtils.extractConnectionDetails(options);
+            const key = `rate_limit:${provider}:${connectionId}`;
+            const config = this.rateLimitConfigs.get(provider);
+            const windowMs = config?.windowMs ?? 60000;
+            const timestamps = await rateLimit_utils_1.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_1.QueueUtils.getQueueKey(microservice, connectionId, provider);
+            const queue = queueUtils_1.QueueUtils.getOrCreateQueue(queueKey, this.queues);
+            queueUtils_1.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 (0, dt_audit_library_1.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,
+            };
+        }
+        async processHttpRequest(job) {
+            const { connectionId, provider, url, method, options } = job.data;
+            const allowed = await rateLimit_utils_1.RateLimitUtils.isRateLimitAllowed(connectionId, provider, this.rateLimitConfigs);
+            if (!allowed) {
+                // This shouldn't happen since we check before queuing, but handle it gracefully
+                (0, config_1.getConfig)().LOGGER.warn(`Job ${job.id} still rate limited after delay, skipping`);
+                return;
+            }
+            await rateLimit_utils_1.RateLimitUtils.recordRequest(connectionId, provider);
+            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);
+            // Check rate limit first
+            const allowed = await rateLimit_utils_1.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
+            (0, config_1.getConfig)().LOGGER.info(`Processing immediately: ${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}`);
+                return {
+                    success: true,
+                    data: response.data,
+                    queued: false,
+                };
+            }
+            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,
+                    },
+                });
+                return {
+                    success: false,
+                    error: `HTTP request failed: ${error.message}`,
+                    queued: false,
+                };
+            }
+        }
+        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,17 @@
+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/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,14 @@
+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/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, IQueueResponse } 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<IQueueResponse>;
+    handleRequest(url: string, method: string, options: HttpCallOption): Promise<IQueueResponse>;
+    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,31 @@
+export interface QueueConfig {
+    concurrency: number;
+    removeOnComplete: {
+        age: number;
+        count: number;
+    };
+    removeOnFail: {
+        age: number;
+        count: number;
+    };
+    lockDuration: number;
+    stalledInterval: number;
+}
+export interface JobOptions {
+    attempts: 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;
+    };
+}