@quatrain/queue-amqp 1.2.21 → 1.2.23

package/README.md

@@ -0,0 +1,38 @@
+# @quatrain/queue-amqp
+
+The AMQP (Advanced Message Queuing Protocol) adapter for `@quatrain/queue`. 
+
+## Introduction
+
+This adapter enables communication with AMQP 0-9-1 brokers such as RabbitMQ. It is ideal for high-throughput, low-latency messaging requirements where you have full control over the broker infrastructure.
+
+## Installation
+
+```bash
+npm install @quatrain/queue-amqp amqplib
+# or
+yarn add @quatrain/queue-amqp amqplib
+```
+
+## Configuration
+
+Register the adapter by providing the connection URL for your AMQP broker.
+
+```typescript
+import { Queue } from '@quatrain/queue'
+import { AmqpQueueAdapter } from '@quatrain/queue-amqp'
+
+const amqpAdapter = new AmqpQueueAdapter({
+    config: {
+        url: 'amqp://user:password@localhost:5672',
+        // Optional: specify an exchange if not using default
+        exchange: 'quatrain-exchange' 
+    }
+})
+
+Queue.addAdapter('rabbitmq', amqpAdapter, true)
+```
+
+## License
+
+AGPL-3.0-only

package/dist/AmqpQueueAdapter.d.ts

@@ -2,6 +2,8 @@ import { AbstractQueueAdapter } from '@quatrain/queue';
 import amqplib, { ChannelModel } from 'amqplib';
 export declare class AmqpQueueAdapter extends AbstractQueueAdapter {
     protected _client: ChannelModel | undefined;
+    protected _logger: any;
+    constructor(params: any);
     protected _connect(): Promise<ChannelModel>;
     protected _disconnect(): Promise<void>;
     send(data: any, topic: string): Promise<string>;

package/dist/AmqpQueueAdapter.js

@@ -16,6 +16,10 @@ exports.AmqpQueueAdapter = void 0;
 const queue_1 = require("@quatrain/queue");
 const amqplib_1 = __importDefault(require("amqplib"));
 class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
+    constructor(params) {
+        super(params);
+        this._logger = queue_1.Queue.logger.clone('AMQP');
+    }
     _connect() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._client) {
@@ -37,11 +41,11 @@ class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
             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}`);
+            this._logger.info(`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}`);
+            this._logger.info(`Message send with id ${id}`);
             return String(id);
         });
     }
@@ -58,7 +62,7 @@ class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
                 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}`);
+            this._logger.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();
@@ -69,7 +73,7 @@ class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
                     return;
                 }
                 concurrents++;
-                queue_1.Queue.info(`Job #${concurrents} of ${concurrency > 0 ? concurrency : 'unlimited'} started`);
+                this._logger.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);
@@ -80,14 +84,14 @@ class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
                     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`);
+                        this._logger.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}`);
+                    this._logger.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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/queue-amqp",
-  "version": "1.2.21",
+  "version": "1.2.23",
   "description": "Queue adapter for AMQP compatible queue",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@cloudamqp/amqp-client": "^3.4.1",
-    "@quatrain/core": "^1.1.48",
-    "@quatrain/queue": "^1.1.28",
+    "@quatrain/core": "^1.1.49",
+    "@quatrain/queue": "^1.1.29",
     "amqplib": "^0.10.9"
   },
   "scripts": {

package/src/AmqpQueueAdapter.ts

@@ -3,6 +3,12 @@ import amqplib, { ChannelModel, ConsumeMessage, Message } from 'amqplib'
 
 export class AmqpQueueAdapter extends AbstractQueueAdapter {
    protected _client: ChannelModel | undefined
+   protected _logger: any
+
+   constructor(params: any) {
+      super(params)
+      this._logger = (Queue as any).logger.clone('AMQP')
+   }
 
    protected async _connect(): Promise<ChannelModel> {
       if (!this._client) {
@@ -31,13 +37,13 @@ export class AmqpQueueAdapter extends AbstractQueueAdapter {
       const channel = await this._client?.createChannel()
 
       const dataBuffer = Buffer.from(JSON.stringify(data))
-      Queue.info(`[AMQP] Sending message to ${topic}`)
+      this._logger.info(`Sending message to ${topic}`)
 
       channel?.sendToQueue(topic, dataBuffer)
       channel?.close()
 
       const id = Date.now() // fake
-      Queue.info(`[AMQP] Message send with id ${id}`)
+      this._logger.info(`Message send with id ${id}`)
 
       return String(id)
    }
@@ -60,7 +66,7 @@ export class AmqpQueueAdapter extends AbstractQueueAdapter {
 
       const concurrency = params?.concurrency || 0
 
-      Queue.info(
+      this._logger.info(
          `Starting to listen to topic ${topic} with max concurrency set to ${concurrency}`
       )
 
@@ -79,7 +85,7 @@ export class AmqpQueueAdapter extends AbstractQueueAdapter {
             }
 
             concurrents++
-            Queue.info(
+            this._logger.info(
                `Job #${concurrents} of ${
                   concurrency > 0 ? concurrency : 'unlimited'
                } started`
@@ -103,7 +109,7 @@ export class AmqpQueueAdapter extends AbstractQueueAdapter {
 
                // 3. Check if we reached the limit of messages to process
                if (concurrency > 0 && concurrents >= concurrency) {
-                  Queue.info(
+                  this._logger.info(
                      `Reached max concurrency of ${concurrency}, disconnecting from queue`
                   )
                   await channel.close()
@@ -111,7 +117,7 @@ export class AmqpQueueAdapter extends AbstractQueueAdapter {
                   process.exit(0)
                }
             } catch (err) {
-               Queue.error(
+               this._logger.error(
                   `messageHandler function failed with message: ${
                      (err as Error).message
                   }`