@quatrain/queue-amqp 1.2.12 → 1.2.13

package/LICENSE.md

@@ -0,0 +1,15 @@
+# LICENSE UPDATE NOTICE
+
+As of 01/01/2026, Quatrain Core is licensed under the **GNU Affero General Public License v3.0 (AGPL v3)**.
+Previous versions remain under the MIT License.
+
+## Why AGPL?
+
+We believe in open collaboration for the development ecosystem. The AGPL ensures that any modification or deployment of this BaaS stack, including over a network, benefits the entire community.
+
+## Commercial Services & Enterprise Usage
+
+We provide official deployment services, technical training, and certification for Quatrain Core.
+For organizations requiring a non-copyleft license (commercial license) or custom proprietary integrations, please contact the copyright holder: **Quatrain Technologies**.
+
+Copyright © 2024-2026 Quatrain Technologies. All Rights Reserved.

package/lib/AmqpQueueAdapter.d.ts

@@ -5,5 +5,12 @@ export declare class AmqpQueueAdapter extends AbstractQueueAdapter {
     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/lib/AmqpQueueAdapter.js

@@ -45,6 +45,13 @@ class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
             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) {
@@ -65,7 +72,10 @@ class AmqpQueueAdapter extends queue_1.AbstractQueueAdapter {
                 queue_1.Queue.info(`Job #${concurrents} of ${concurrency > 0 ? concurrency : 'unlimited'} started`);
                 try {
                     // 1. Process the message synchronously (wait for it to finish)
-                    yield messageHandler(msg.content.toString(), params);
+                    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

package/package.json

@@ -1,44 +1,42 @@
 {
-  "name": "@quatrain/queue-amqp",
-  "version": "1.2.12",
-  "description": "Queue adapter for AMQP compatible queue",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib/",
-    "README.md"
-  ],
-  "author": "Quatrain Développement SAS <developers@quatrain.com>",
-  "license": "MIT",
-  "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": "^27.4.7",
-    "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.23",
-    "@quatrain/queue": "^1.1.19",
-    "amqplib": "^0.10.9"
-  },
-  "scripts": {
-    "test-ci": "jest --runInBand",
-    "build": "tsc",
-    "wbuild": "tsc --watch",
-    "bump-to": "yarn version",
-    "hash": "node ../../bin/hashFolder.js",
-    "hash:persist": "yarn hash  > .hash_latest.txt",
-    "hash:compare": "yarn hash > .hash_newest.txt && cmp -s .hash_latest.txt .hash_newest.txt",
-    "publish": "yarn hash:compare || yarn publish:process",
-    "publish:process": "yarn version patch && yarn build && yarn npm publish --access public && yarn hash:persist"
-  }
-}
+   "name": "@quatrain/queue-amqp",
+   "version": "1.2.13",
+   "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.20",
+      "amqplib": "^0.10.9"
+   },
+   "scripts": {
+      "test-ci": "jest --runInBand",
+      "build": "tsc",
+      "wbuild": "tsc --watch",
+      "bump-to": "yarn version"
+   }
+}

package/src/AmqpQueueAdapter.test.ts

@@ -0,0 +1,150 @@
+import { AmqpQueueAdapter } from './AmqpQueueAdapter'
+import { AMQPClient, AMQPMessage } from '@cloudamqp/amqp-client'
+import { Queue } from '@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', () => ({
+   ...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 = AMQPClient as jest.Mock
+
+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.info as jest.Mock).mockClear()
+   })
+
+   it('should construct with default and custom parameters', () => {
+      new AmqpQueueAdapter({ config: {} })
+      expect(AMQPClientMock).toHaveBeenCalledWith(
+         'amqp://guest:guest@localhost:5672?frameMax=0'
+      )
+
+      new 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', async () => {
+         const adapter = new AmqpQueueAdapter(params)
+         const data = { key: 'value' }
+         const topic = 'test-topic'
+
+         const confirmId = await 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.info).toHaveBeenCalledWith(
+            `[AMQP] Sending message to ${topic}`
+         )
+         expect(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', async () => {
+         const adapter = new AmqpQueueAdapter(params)
+         const handler = jest.fn()
+
+         await 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', async () => {
+         const adapter = new AmqpQueueAdapter(params)
+         const handler = jest.fn()
+         const topic = 'specific-topic'
+
+         await adapter.listen(topic, handler)
+
+         expect(mockQueue).toHaveBeenCalledWith(topic)
+      })
+
+      it('should throw an error if no topic is available', async () => {
+         const adapter = new AmqpQueueAdapter({ config: {} })
+         const handler = jest.fn()
+
+         await expect(adapter.listen(undefined, handler)).rejects.toThrow(
+            'No topic provided for listening.'
+         )
+      })
+
+      it('should call the message handler with the message body', async () => {
+         const adapter = new AmqpQueueAdapter(params)
+         const handler = jest.fn()
+         const messageContent = { data: 'test message' }
+         const message = {
+            bodyToString: () => JSON.stringify(messageContent),
+         } as AMQPMessage
+
+         mockSubscribe.mockImplementation(async (options, callback) => {
+            await callback(message)
+         })
+
+         await adapter.listen('any-topic', handler)
+
+         expect(handler).toHaveBeenCalledWith(JSON.stringify(messageContent))
+      })
+   })
+})

package/src/AmqpQueueAdapter.ts

@@ -0,0 +1,127 @@
+import { AbstractQueueAdapter, Queue } from '@quatrain/queue'
+import amqplib, { ChannelModel, ConsumeMessage, Message } from 'amqplib'
+
+export class AmqpQueueAdapter extends AbstractQueueAdapter {
+   protected _client: ChannelModel | undefined
+
+   protected async _connect(): Promise<ChannelModel> {
+      if (!this._client) {
+         const {
+            host = 'localhost',
+            user = 'guest',
+            password = 'guest',
+            port = 5672,
+         } = this._params.config || {}
+
+         this._client = await amqplib.connect(
+            `amqp://${user}:${password}@${host}:${port}`
+         )
+      }
+
+      return this._client
+   }
+
+   protected async _disconnect() {
+      await this._client?.close()
+   }
+
+   async send(data: any, topic: string): Promise<string> {
+      await this._connect()
+
+      const channel = await this._client?.createChannel()
+
+      const dataBuffer = Buffer.from(JSON.stringify(data))
+      Queue.info(`[AMQP] Sending message to ${topic}`)
+
+      channel?.sendToQueue(topic, dataBuffer)
+      channel?.close()
+
+      const id = Date.now() // fake
+      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
+    */
+   async listen(
+      topic: string | undefined = this._params.topic,
+      messageHandler: Function,
+      params?: any
+   ) {
+      if (!topic) {
+         throw new Error(`No topic provided for listening.`)
+      }
+
+      const concurrency = params?.concurrency || 0
+
+      Queue.info(
+         `Starting to listen to topic ${topic} with max concurrency set to ${concurrency}`
+      )
+
+      let concurrents = 0
+      const client = await this._connect()
+      const channel = await client.createChannel()
+
+      await channel.assertQueue(topic, { durable: true, autoDelete: false })
+      await channel.prefetch(concurrency) // only get one message at a time
+
+      return channel.consume(
+         topic,
+         async (msg: ConsumeMessage | null) => {
+            if (msg === null || !channel) {
+               return
+            }
+
+            concurrents++
+            Queue.info(
+               `Job #${concurrents} of ${
+                  concurrency > 0 ? concurrency : 'unlimited'
+               } started`
+            )
+
+            try {
+               // 1. Process the message synchronously (wait for it to finish)
+               const result = await 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.info(
+                     `Reached max concurrency of ${concurrency}, disconnecting from queue`
+                  )
+                  await channel.close()
+                  await client.close()
+                  process.exit(0)
+               }
+            } catch (err) {
+               Queue.error(
+                  `messageHandler function failed with message: ${
+                     (err as Error).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
+      )
+   }
+}

package/src/index.ts

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