@zintrust/queue-rabbitmq 0.1.12

package/README.md

@@ -0,0 +1,21 @@
+# @zintrust/queue-rabbitmq
+
+RabbitMQ queue driver registration for Zintrust.
+
+- Docs: https://zintrust.com/queue
+
+## Install
+
+```bash
+npm i @zintrust/queue-rabbitmq
+```
+
+## Usage
+
+```ts
+import '@zintrust/queue-rabbitmq/register';
+```
+
+Then set `QUEUE_DRIVER=rabbitmq` and configure:
+
+- `RABBITMQ_URL` (e.g. `amqp://localhost`)

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export type QueueMessage<T = unknown> = {
+    id: string;
+    payload: T;
+    attempts: number;
+};
+export type RabbitMqQueueConfig = {
+    driver: 'rabbitmq';
+    url?: string;
+};
+export declare const RabbitMqQueue: Readonly<{
+    create(config?: RabbitMqQueueConfig): {
+        enqueue<T = unknown>(queue: string, payload: T): Promise<string>;
+        dequeue<T = unknown>(queue: string): Promise<QueueMessage<T> | undefined>;
+        ack(queue: string, id: string): Promise<void>;
+        length(queue: string): Promise<number>;
+        drain(queue: string): Promise<void>;
+    };
+}>;
+export default RabbitMqQueue;

package/dist/index.js

@@ -0,0 +1,102 @@
+import { ErrorFactory, generateUuid } from '@zintrust/core';
+async function importAmqplib() {
+    // Avoid a string-literal import so TypeScript doesn't require the module at build time.
+    const specifier = 'amqplib';
+    return (await import(specifier));
+}
+function resolveUrl(config) {
+    const url = (config?.url ?? process.env['RABBITMQ_URL'] ?? '').toString().trim();
+    if (url === '') {
+        throw ErrorFactory.createConfigError('RabbitMQ queue driver requires RABBITMQ_URL');
+    }
+    return url;
+}
+async function ensureChannel(state, config) {
+    if (state.channel !== undefined)
+        return state.channel;
+    const { connect } = await importAmqplib();
+    state.connection = await connect(resolveUrl(config));
+    state.channel = await state.connection.createChannel();
+    return state.channel;
+}
+async function ensureQueue(state, config, queue) {
+    const ch = await ensureChannel(state, config);
+    await ch.assertQueue(queue, { durable: true });
+}
+async function drainFallback(state, config, queue) {
+    const ch = await ensureChannel(state, config);
+    const msg = await ch.get(queue, { noAck: false });
+    if (msg === false)
+        return;
+    ch.ack(msg);
+    await drainFallback(state, config, queue);
+}
+function createRabbitMqQueueDriver(config) {
+    const state = { inFlight: new Map() };
+    return {
+        async enqueue(queue, payload) {
+            const id = generateUuid();
+            await ensureQueue(state, config, queue);
+            const ch = await ensureChannel(state, config);
+            const msg = JSON.stringify({ id, payload, attempts: 0 });
+            ch.sendToQueue(queue, Buffer.from(msg), { persistent: true });
+            return id;
+        },
+        async dequeue(queue) {
+            await ensureQueue(state, config, queue);
+            const ch = await ensureChannel(state, config);
+            const msg = await ch.get(queue, { noAck: false });
+            if (msg === false)
+                return undefined;
+            try {
+                const parsed = JSON.parse(msg.content.toString('utf-8'));
+                if (typeof parsed?.id === 'string' && parsed.id.trim() !== '') {
+                    state.inFlight.set(parsed.id, msg);
+                }
+                return parsed;
+            }
+            catch (err) {
+                // If we can't parse, ack it so we don't get stuck.
+                try {
+                    ch.ack(msg);
+                }
+                catch {
+                    // ignore
+                }
+                throw ErrorFactory.createTryCatchError('Failed to parse queue message', err);
+            }
+        },
+        async ack(_queue, id) {
+            const ch = await ensureChannel(state, config);
+            const msg = state.inFlight.get(id);
+            if (msg === undefined)
+                return;
+            state.inFlight.delete(id);
+            ch.ack(msg);
+        },
+        async length(queue) {
+            await ensureQueue(state, config, queue);
+            const ch = await ensureChannel(state, config);
+            if (typeof ch.checkQueue === 'function') {
+                const r = await ch.checkQueue(queue);
+                return Number(r.messageCount ?? 0);
+            }
+            return 0;
+        },
+        async drain(queue) {
+            await ensureQueue(state, config, queue);
+            const ch = await ensureChannel(state, config);
+            if (typeof ch.purgeQueue === 'function') {
+                await ch.purgeQueue(queue);
+                return;
+            }
+            await drainFallback(state, config, queue);
+        },
+    };
+}
+export const RabbitMqQueue = Object.freeze({
+    create(config) {
+        return createRabbitMqQueueDriver(config);
+    },
+});
+export default RabbitMqQueue;

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type QueueApi = {
+    register: (name: string, driver: unknown) => void;
+};
+export declare function registerRabbitMqQueueDriver(queue: QueueApi): Promise<void>;
+export {};

package/dist/register.js

@@ -0,0 +1,21 @@
+export async function registerRabbitMqQueueDriver(queue) {
+    const { RabbitMqQueue } = (await import('./index.js'));
+    queue.register('rabbitmq', RabbitMqQueue.create());
+}
+const importCore = async () => {
+    try {
+        return await import('@zintrust/core');
+    }
+    catch {
+        try {
+            return await import('@zintrust/core');
+        }
+        catch {
+            return {};
+        }
+    }
+};
+const core = (await importCore());
+if (core.Queue !== undefined) {
+    await registerRabbitMqQueueDriver(core.Queue);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@zintrust/queue-rabbitmq",
+  "version": "0.1.12",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "^0.1.12"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  }
+}