@quatrain/queue-amqp 1.2.15 → 1.2.16

package/dist/AmqpQueueAdapter.d.ts

@@ -0,0 +1,16 @@
+import { AbstractQueueAdapter } from '@quatrain/queue';
+import amqplib, { ChannelModel } from 'amqplib';
+export declare class AmqpQueueAdapter extends AbstractQueueAdapter {
+    protected _client: ChannelModel | undefined;
+    protected _connect(): Promise<ChannelModel>;
+    protected _disconnect(): Promise<void>;
+    send(data: any, topic: string): Promise<string>;
+    /**
+     * Listen to given queue and process messages with messageHandler function
+     * @param topic
+     * @param messageHandler
+     * @param params
+     * @returns
+     */
+    listen(topic: string | undefined, messageHandler: Function, params?: any): Promise<amqplib.Replies.Consume>;
+}

package/dist/AmqpQueueAdapter.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmqpQueueAdapter = void 0;
+const queue_1 = require("@quatrain/queue");
+const amqplib_1 = __importDefault(require("amqplib"));
+class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
+    _connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._client) {
+                const { host = 'localhost', user = 'guest', password = 'guest', port = 5672, } = this._params.config || {};
+                this._client = yield amqplib_1.default.connect(`amqp://${user}:${password}@${host}:${port}`);
+            }
+            return this._client;
+        });
+    }
+    _disconnect() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this._client) === null || _a === void 0 ? void 0 : _a.close());
+        });
+    }
+    send(data, topic) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._connect();
+            const channel = yield ((_a = this._client) === null || _a === void 0 ? void 0 : _a.createChannel());
+            const dataBuffer = Buffer.from(JSON.stringify(data));
+            queue_1.Queue.info(`[AMQP] Sending message to ${topic}`);
+            channel === null || channel === void 0 ? void 0 : channel.sendToQueue(topic, dataBuffer);
+            channel === null || channel === void 0 ? void 0 : channel.close();
+            const id = Date.now(); // fake
+            queue_1.Queue.info(`[AMQP] Message send with id ${id}`);
+            return String(id);
+        });
+    }
+    /**
+     * Listen to given queue and process messages with messageHandler function
+     * @param topic
+     * @param messageHandler
+     * @param params
+     * @returns
+     */
+    listen(topic = this._params.topic, messageHandler, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!topic) {
+                throw new Error(`No topic provided for listening.`);
+            }
+            const concurrency = (params === null || params === void 0 ? void 0 : params.concurrency) || 0;
+            queue_1.Queue.info(`Starting to listen to topic ${topic} with max concurrency set to ${concurrency}`);
+            let concurrents = 0;
+            const client = yield this._connect();
+            const channel = yield client.createChannel();
+            yield channel.assertQueue(topic, { durable: true, autoDelete: false });
+            yield channel.prefetch(concurrency); // only get one message at a time
+            return channel.consume(topic, (msg) => __awaiter(this, void 0, void 0, function* () {
+                if (msg === null || !channel) {
+                    return;
+                }
+                concurrents++;
+                queue_1.Queue.info(`Job #${concurrents} of ${concurrency > 0 ? concurrency : 'unlimited'} started`);
+                try {
+                    // 1. Process the message synchronously (wait for it to finish)
+                    const result = yield messageHandler(msg.content.toString(), params);
+                    if (result === false) {
+                        throw new Error('messageHandler function failed, see status log in jobExecution for more information');
+                    }
+                    // 2. Acknowledge the message only after successful processing
+                    channel.ack(msg);
+                    // 3. Check if we reached the limit of messages to process
+                    if (concurrency > 0 && concurrents >= concurrency) {
+                        queue_1.Queue.info(`Reached max concurrency of ${concurrency}, disconnecting from queue`);
+                        yield channel.close();
+                        yield client.close();
+                        process.exit(0);
+                    }
+                }
+                catch (err) {
+                    queue_1.Queue.error(`messageHandler function failed with message: ${err.message}`);
+                    // Negative acknowledge the message so it can be requeued or handled by DLQ
+                    channel.nack(msg);
+                    process.exit(1);
+                }
+            }), { noAck: false } // disable auto-hack
+            );
+        });
+    }
+}
+exports.AmqpQueueAdapter = AmqpQueueAdapter;

package/dist/AmqpQueueAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/AmqpQueueAdapter.test.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AmqpQueueAdapter_1 = require("./AmqpQueueAdapter");
+const amqp_client_1 = require("@cloudamqp/amqp-client");
+const queue_1 = require("@quatrain/queue");
+// Mock the @cloudamqp/amqp-client library
+jest.mock('@cloudamqp/amqp-client');
+// Mock @quatrain/queue to spy on Queue.info
+jest.mock('@quatrain/queue', () => (Object.assign(Object.assign({}, jest.requireActual('@quatrain/queue')), { Queue: {
+        info: jest.fn(),
+    } })));
+const mockPublish = jest
+    .fn()
+    .mockResolvedValue({ confirmId: 'mock-confirm-id' });
+const mockSubscribe = jest.fn();
+const mockQueue = jest.fn().mockResolvedValue({
+    publish: mockPublish,
+    subscribe: mockSubscribe,
+});
+const mockChannel = jest.fn().mockResolvedValue({
+    queue: mockQueue,
+});
+const mockConnect = jest.fn().mockResolvedValue({
+    channel: mockChannel,
+});
+const AMQPClientMock = amqp_client_1.AMQPClient;
+AMQPClientMock.mockImplementation(() => {
+    return {
+        connect: mockConnect,
+    };
+});
+describe('AmqpQueueAdapter', () => {
+    const params = {
+        config: {
+            host: 'test-host',
+            user: 'test-user',
+            password: 'test-password',
+            port: 1234,
+        },
+        topic: 'default-topic',
+    };
+    beforeEach(() => {
+        // Clear all instances and calls to constructor and all methods:
+        AMQPClientMock.mockClear();
+        mockConnect.mockClear();
+        mockChannel.mockClear();
+        mockQueue.mockClear();
+        mockPublish.mockClear();
+        mockSubscribe.mockClear();
+        queue_1.Queue.info.mockClear();
+    });
+    it('should construct with default and custom parameters', () => {
+        new AmqpQueueAdapter_1.AmqpQueueAdapter({ config: {} });
+        expect(AMQPClientMock).toHaveBeenCalledWith('amqp://guest:guest@localhost:5672?frameMax=0');
+        new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
+        expect(AMQPClientMock).toHaveBeenCalledWith('amqp://test-user:test-password@test-host:1234?frameMax=0');
+    });
+    describe('send', () => {
+        it('should send a message to the specified topic', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
+            const data = { key: 'value' };
+            const topic = 'test-topic';
+            const confirmId = yield adapter.send(data, topic);
+            expect(mockConnect).toHaveBeenCalledTimes(1);
+            expect(mockChannel).toHaveBeenCalledTimes(1);
+            expect(mockQueue).toHaveBeenCalledWith(topic);
+            expect(mockPublish).toHaveBeenCalledWith(Buffer.from(JSON.stringify(data)), { deliveryMode: 2 });
+            expect(queue_1.Queue.info).toHaveBeenCalledWith(`[AMQP] Sending message to ${topic}`);
+            expect(queue_1.Queue.info).toHaveBeenCalledWith(`[AMQP] Message send with id mock-confirm-id`);
+            expect(confirmId).toBe('mock-confirm-id');
+        }));
+    });
+    describe('listen', () => {
+        it('should listen to the default topic if none is provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
+            const handler = jest.fn();
+            yield adapter.listen(undefined, handler);
+            expect(mockConnect).toHaveBeenCalledTimes(1);
+            expect(mockChannel).toHaveBeenCalledTimes(1);
+            expect(mockQueue).toHaveBeenCalledWith(params.topic);
+            expect(mockSubscribe).toHaveBeenCalledWith({ noAck: true }, expect.any(Function));
+        }));
+        it('should listen to a specific topic', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
+            const handler = jest.fn();
+            const topic = 'specific-topic';
+            yield adapter.listen(topic, handler);
+            expect(mockQueue).toHaveBeenCalledWith(topic);
+        }));
+        it('should throw an error if no topic is available', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter({ config: {} });
+            const handler = jest.fn();
+            yield expect(adapter.listen(undefined, handler)).rejects.toThrow('No topic provided for listening.');
+        }));
+        it('should call the message handler with the message body', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
+            const handler = jest.fn();
+            const messageContent = { data: 'test message' };
+            const message = {
+                bodyToString: () => JSON.stringify(messageContent),
+            };
+            mockSubscribe.mockImplementation((options, callback) => __awaiter(void 0, void 0, void 0, function* () {
+                yield callback(message);
+            }));
+            yield adapter.listen('any-topic', handler);
+            expect(handler).toHaveBeenCalledWith(JSON.stringify(messageContent));
+        }));
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { AmqpQueueAdapter } from './AmqpQueueAdapter';
+export { AmqpQueueAdapter };

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmqpQueueAdapter = void 0;
+const AmqpQueueAdapter_1 = require("./AmqpQueueAdapter");
+Object.defineProperty(exports, "AmqpQueueAdapter", { enumerable: true, get: function () { return AmqpQueueAdapter_1.AmqpQueueAdapter; } });

package/package.json

@@ -1,42 +1,42 @@
 {
-   "name": "@quatrain/queue-amqp",
-   "version": "1.2.15",
-   "description": "Queue adapter for AMQP compatible queue",
-   "main": "lib/index.js",
-   "types": "lib/index.d.ts",
-   "bun": "src/index.ts",
-   "files": [
-      "LICENSE.md",
-      "src/",
-      "lib/",
-      "README.md"
-   ],
-   "author": "Quatrain Développement SAS <developers@quatrain.com>",
-   "license": "AGPL-3.0-only",
-   "devDependencies": {
-      "@tsconfig/recommended": "^1.0.1",
-      "@types/amqplib": "^0.10.8",
-      "@types/fs-extra": "^11.0.4",
-      "@types/jest": "^27.0.3",
-      "@types/node": "^22.10.1",
-      "@types/object-hash": "^3.0.6",
-      "jest": "^30.2.0",
-      "jest-node-exports-resolver": "^1.1.6",
-      "trace-unhandled": "^2.0.1",
-      "ts-jest": "^27.1.2",
-      "ts-node": "^10.4.0",
-      "typescript": "^5.1.5"
-   },
-   "dependencies": {
-      "@cloudamqp/amqp-client": "^3.4.1",
-      "@quatrain/core": "^1.1.43",
-      "@quatrain/queue": "^1.1.22",
-      "amqplib": "^0.10.9"
-   },
-   "scripts": {
-      "test-ci": "jest --runInBand",
-      "build": "tsc",
-      "wbuild": "tsc --watch",
-      "bump-to": "yarn version"
-   }
-}
+  "name": "@quatrain/queue-amqp",
+  "version": "1.2.16",
+  "description": "Queue adapter for AMQP compatible queue",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
+  "files": [
+    "LICENSE.md",
+    "src/",
+    "dist/",
+    "README.md"
+  ],
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "license": "AGPL-3.0-only",
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/amqplib": "^0.10.8",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^22.10.1",
+    "@types/object-hash": "^3.0.6",
+    "jest": "^30.2.0",
+    "jest-node-exports-resolver": "^1.1.6",
+    "trace-unhandled": "^2.0.1",
+    "ts-jest": "^27.1.2",
+    "ts-node": "^10.4.0",
+    "typescript": "^5.1.5"
+  },
+  "dependencies": {
+    "@cloudamqp/amqp-client": "^3.4.1",
+    "@quatrain/core": "^1.1.45",
+    "@quatrain/queue": "^1.1.23",
+    "amqplib": "^0.10.9"
+  },
+  "scripts": {
+    "test-ci": "jest --runInBand",
+    "build": "tsc",
+    "wbuild": "tsc --watch",
+    "bump-to": "yarn version"
+  }
+}