@zintrust/queue-rabbitmq 0.1.30 → 0.1.41

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/queue-rabbitmq",
   "version": "0.1.27",
-  "buildDate": "2026-01-29T08:06:44.824Z",
+  "buildDate": "2026-02-14T22:45:58.578Z",
   "buildEnvironment": {
     "node": "v20.20.0",
     "platform": "linux",
     "arch": "x64"
   },
   "git": {
-    "commit": "1555458",
+    "commit": "e20c137",
     "branch": "master"
   },
   "package": {
@@ -24,12 +24,12 @@
   },
   "files": {
     "index.d.ts": {
-      "size": 862,
-      "sha256": "c3514221f9c8279ce5dd5b3f2dcbca57f6180fe4159a9074825eb256372602a7"
+      "size": 1061,
+      "sha256": "f6fc93a659264f237824fb0d4c2a7c661b172b657f041739edb3ceb21a9690b2"
     },
     "index.js": {
-      "size": 4185,
-      "sha256": "9d2b64a708f9310ca8ec4043b7fd77c7799dc95095d720fbe8313560cc342423"
+      "size": 10030,
+      "sha256": "7fd38bf82a8d73ad911945cddab98f63d140119bfe089911a232a77133b33579"
     },
     "register.d.ts": {
       "size": 172,

package/dist/index.d.ts

@@ -6,6 +6,14 @@ export type QueueMessage<T = unknown> = {
 export type RabbitMqQueueConfig = {
     driver: 'rabbitmq';
     url?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    vhost?: string;
+    httpGatewayUrl?: string;
+    httpGatewayToken?: string;
+    httpGatewayTimeoutMs?: number;
 };
 export declare const RabbitMqQueue: Readonly<{
     create(config?: RabbitMqQueueConfig): {

package/dist/index.js

@@ -1,16 +1,132 @@
-import { ErrorFactory, generateUuid } from '@zintrust/core';
+import { Cloudflare, ErrorFactory, Logger, 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));
 }
+const IN_FLIGHT_MAX_ENTRIES = 10000;
+const IN_FLIGHT_TTL_MS = 15 * 60 * 1000;
+const pruneInFlight = (state) => {
+    const now = Date.now();
+    for (const [id, value] of state.inFlight.entries()) {
+        if (now - value.seenAt > IN_FLIGHT_TTL_MS) {
+            state.inFlight.delete(id);
+        }
+    }
+    if (state.inFlight.size <= IN_FLIGHT_MAX_ENTRIES)
+        return;
+    const overflow = state.inFlight.size - IN_FLIGHT_MAX_ENTRIES;
+    let removed = 0;
+    for (const id of state.inFlight.keys()) {
+        state.inFlight.delete(id);
+        removed++;
+        if (removed >= overflow)
+            break;
+    }
+    Logger.warn('RabbitMQ in-flight map exceeded max entries; pruned oldest items', {
+        removed,
+        sizeAfter: state.inFlight.size,
+    });
+};
+/**
+ * Helper to resolve configuration value from config object or environment
+ */
+const getConfigValue = (config, configKey, envKey, defaultValue) => {
+    return (config?.[configKey] ?? process.env[envKey] ?? defaultValue).toString().trim();
+};
+/**
+ * Build AMQP URL from components
+ */
+const buildAmqpUrl = (host, port, username, password, vhost) => {
+    const auth = `${encodeURIComponent(username)}:${encodeURIComponent(password)}`;
+    const vhostSegment = vhost === '/' ? '/' : `/${encodeURIComponent(vhost)}`;
+    const resolvedPort = Number.isFinite(port) ? port : 5672;
+    return `amqp://${auth}@${host}:${resolvedPort}${vhostSegment}`;
+};
 function resolveUrl(config) {
-    const url = (config?.url ?? process.env['RABBITMQ_URL'] ?? '').toString().trim();
-    if (url === '') {
-        throw ErrorFactory.createConfigError('RabbitMQ queue driver requires RABBITMQ_URL');
+    const url = getConfigValue(config, 'url', 'RABBITMQ_URL', '');
+    if (url !== '')
+        return url;
+    const host = getConfigValue(config, 'host', 'RABBITMQ_HOST', '');
+    if (host === '') {
+        throw ErrorFactory.createConfigError('RabbitMQ queue driver requires RABBITMQ_URL or host');
     }
-    return url;
+    const port = Number(getConfigValue(config, 'port', 'RABBITMQ_PORT', '5672'));
+    const username = getConfigValue(config, 'username', 'RABBITMQ_USER', 'guest');
+    const password = getConfigValue(config, 'password', 'RABBITMQ_PASSWORD', 'guest');
+    const vhost = getConfigValue(config, 'vhost', 'RABBITMQ_VHOST', '/');
+    return buildAmqpUrl(host, port, username, password, vhost);
 }
+const resolveGatewayUrl = (config) => {
+    return getConfigValue(config, 'httpGatewayUrl', 'RABBITMQ_HTTP_GATEWAY_URL', '');
+};
+const resolveGatewayToken = (config) => {
+    const token = getConfigValue(config, 'httpGatewayToken', 'RABBITMQ_HTTP_GATEWAY_TOKEN', '');
+    return token === '' ? null : token;
+};
+const resolveGatewayTimeoutMs = (config) => {
+    const raw = config?.httpGatewayTimeoutMs ?? process.env['RABBITMQ_HTTP_GATEWAY_TIMEOUT_MS'];
+    const parsed = Number(raw ?? 15000);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 15000;
+};
+const shouldUseGateway = (config) => {
+    const gatewayUrl = resolveGatewayUrl(config);
+    if (gatewayUrl !== '')
+        return true;
+    return Cloudflare.getWorkersEnv() !== null;
+};
+const buildGatewayHeaders = (config) => {
+    const headers = {
+        'content-type': 'application/json',
+    };
+    const token = resolveGatewayToken(config);
+    if (token) {
+        headers.authorization = `Bearer ${token}`;
+    }
+    return headers;
+};
+const fetchGateway = async (config, path, body) => {
+    const base = resolveGatewayUrl(config);
+    if (base === '') {
+        throw ErrorFactory.createConfigError('RabbitMQ HTTP gateway requires RABBITMQ_HTTP_GATEWAY_URL');
+    }
+    const timeoutMs = resolveGatewayTimeoutMs(config);
+    const hasAbortController = typeof AbortController === 'function';
+    const controller = hasAbortController ? new AbortController() : undefined;
+    const timeoutId = controller
+        ? globalThis.setTimeout(() => controller.abort(), timeoutMs)
+        : undefined;
+    try {
+        const res = await fetch(`${base.replace(/\/$/, '')}${path}`, {
+            method: 'POST',
+            headers: buildGatewayHeaders(config),
+            body: JSON.stringify(body ?? {}),
+            signal: controller?.signal,
+        });
+        // Clear timeout on successful fetch
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+        if (!res.ok) {
+            const text = await res.text();
+            throw ErrorFactory.createConnectionError(`RabbitMQ gateway error (${res.status})`, {
+                status: res.status,
+                body: text,
+            });
+        }
+        return (await res.json());
+    }
+    catch (error) {
+        // Clear timeout on error
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+        throw error;
+    }
+    finally {
+        // Final cleanup safeguard
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+    }
+};
 async function ensureChannel(state, config) {
     if (state.channel !== undefined)
         return state.channel;
@@ -25,13 +141,18 @@ async function ensureQueue(state, config, queue) {
 }
 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);
+    while (true) {
+        // eslint-disable-next-line no-await-in-loop
+        const msg = await ch.get(queue, { noAck: false });
+        if (msg === false)
+            return;
+        ch.ack(msg);
+    }
 }
 function createRabbitMqQueueDriver(config) {
+    if (shouldUseGateway(config)) {
+        return createRabbitMqHttpGatewayDriver(config);
+    }
     const state = { inFlight: new Map() };
     return {
         async enqueue(queue, payload) {
@@ -44,6 +165,7 @@ function createRabbitMqQueueDriver(config) {
         },
         async dequeue(queue) {
             await ensureQueue(state, config, queue);
+            pruneInFlight(state);
             const ch = await ensureChannel(state, config);
             const msg = await ch.get(queue, { noAck: false });
             if (msg === false)
@@ -51,7 +173,7 @@ function createRabbitMqQueueDriver(config) {
             try {
                 const parsed = JSON.parse(msg.content.toString('utf-8'));
                 if (typeof parsed?.id === 'string' && parsed.id.trim() !== '') {
-                    state.inFlight.set(parsed.id, msg);
+                    state.inFlight.set(parsed.id, { message: msg, seenAt: Date.now() });
                 }
                 return parsed;
             }
@@ -67,12 +189,13 @@ function createRabbitMqQueueDriver(config) {
             }
         },
         async ack(_queue, id) {
+            pruneInFlight(state);
             const ch = await ensureChannel(state, config);
-            const msg = state.inFlight.get(id);
-            if (msg === undefined)
+            const inFlight = state.inFlight.get(id);
+            if (inFlight === undefined)
                 return;
             state.inFlight.delete(id);
-            ch.ack(msg);
+            ch.ack(inFlight.message);
         },
         async length(queue) {
             await ensureQueue(state, config, queue);
@@ -94,6 +217,37 @@ function createRabbitMqQueueDriver(config) {
         },
     };
 }
+function createRabbitMqHttpGatewayDriver(config) {
+    return {
+        async enqueue(queue, payload) {
+            const response = await fetchGateway(config, '/enqueue', {
+                queue,
+                payload,
+            });
+            return typeof response?.id === 'string' && response.id.trim() !== ''
+                ? response.id
+                : generateUuid();
+        },
+        async dequeue(queue) {
+            const response = await fetchGateway(config, '/dequeue', { queue });
+            const msg = response?.message ?? null;
+            if (msg === null || msg === undefined)
+                return undefined;
+            return msg;
+        },
+        async ack(queue, id) {
+            await fetchGateway(config, '/ack', { queue, id });
+        },
+        async length(queue) {
+            const response = await fetchGateway(config, '/length', { queue });
+            const length = Number(response?.length ?? 0);
+            return Number.isFinite(length) ? length : 0;
+        },
+        async drain(queue) {
+            await fetchGateway(config, '/drain', { queue });
+        },
+    };
+}
 export const RabbitMqQueue = Object.freeze({
     create(config) {
         return createRabbitMqQueueDriver(config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/queue-rabbitmq",
-  "version": "0.1.30",
+  "version": "0.1.41",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "amqplib": "^0.10.3"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.1.30"
+    "@zintrust/core": "^0.1.41"
   },
   "publishConfig": {
     "access": "public"