@kaushverse/rabbitmq-core 1.0.8 → 1.1.0

package/dist/index.d.ts

@@ -31,21 +31,66 @@ interface PublishOptions {
 
 declare const rabbitEvents: EventEmitter<[never]>;
 declare function getChannel(): Channel;
-
-declare function consumeMessage(options: ConsumeOptions, handler: (data: any, raw: ConsumeMessage) => Promise<void> | void): Promise<void>;
-
-declare function publishMessage({ exchange, type, routingKey, message, headers, }: PublishOptions): Promise<void>;
+declare function closeRabbitMQ(): Promise<void>;
+declare function isRabbitConnected(): boolean;
 
 type BootstrapOptions = {
     serviceName: string;
     start: () => void | Promise<void>;
-    rabbit: {
-        url: string;
-        tls?: RabbitTLSOptions;
-    };
+    rabbit: RabbitConnectionOptions;
 };
 declare function bootstrap({ serviceName, rabbit, start, }: BootstrapOptions): Promise<void>;
 
+declare function publishMessage({ exchange, type, routingKey, message, headers, }: PublishOptions): Promise<void>;
+
+declare function consumeMessage(options: ConsumeOptions, handler: (data: any, raw: ConsumeMessage) => Promise<void> | void): Promise<void>;
+
+type ExchangeConfig = {
+    name: string;
+    type: ExchangeType;
+    durable?: boolean;
+    autoDelete?: boolean;
+};
+declare function setupExchange(channel: Channel, exchange: ExchangeConfig): Promise<void>;
+
+type QueueConfig = {
+    name: string;
+    durable?: boolean;
+    priority?: boolean;
+    maxPriority?: number;
+    ttl?: number;
+    arguments?: Record<string, any>;
+};
+declare function setupQueue(channel: Channel, queue: QueueConfig): Promise<void>;
+
+type BindingConfig = {
+    queue: string;
+    exchange: string;
+    routingKeys: string | string[];
+};
+declare function setupBindings(channel: Channel, binding: BindingConfig): Promise<void>;
+
+type RetryConfig = {
+    exchange: string;
+    queue: string;
+    routingKey: string;
+    delay: number;
+};
+declare function setupRetry(channel: Channel, config: RetryConfig): Promise<{
+    retryExchange: string;
+    retryQueue: string;
+}>;
+
+type DLQConfig = {
+    exchange: string;
+    queue: string;
+    routingKey?: string;
+};
+declare function setupDLQ(channel: Channel, config: DLQConfig): Promise<{
+    deadLetterExchange: string;
+    deadLetterQueue: string;
+}>;
+
 declare function rabbitHealth(): {
     "\uD83D\uDC07": {
         service: string;
@@ -63,4 +108,4 @@ declare const logger: {
     debug: (msg: string, meta?: any) => void;
 };
 
-export { type ConsumeOptions, type ExchangeType, type LogLevel, type PublishOptions, type RabbitConnectionOptions, type RabbitTLSOptions, bootstrap, consumeMessage, getChannel, logger, publishMessage, rabbitEvents, rabbitHealth, setLoggerService, setPrettyLogs };
+export { type BindingConfig, type ConsumeOptions, type DLQConfig, type ExchangeConfig, type ExchangeType, type LogLevel, type PublishOptions, type QueueConfig, type RabbitConnectionOptions, type RabbitTLSOptions, type RetryConfig, bootstrap, closeRabbitMQ, consumeMessage, getChannel, isRabbitConnected, logger, publishMessage, rabbitEvents, rabbitHealth, setLoggerService, setPrettyLogs, setupBindings, setupDLQ, setupExchange, setupQueue, setupRetry };

package/dist/index.js

@@ -31,14 +31,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   bootstrap: () => bootstrap,
+  closeRabbitMQ: () => closeRabbitMQ,
   consumeMessage: () => consumeMessage,
   getChannel: () => getChannel,
+  isRabbitConnected: () => isRabbitConnected,
   logger: () => logger,
   publishMessage: () => publishMessage,
   rabbitEvents: () => rabbitEvents,
   rabbitHealth: () => rabbitHealth,
   setLoggerService: () => setLoggerService,
-  setPrettyLogs: () => setPrettyLogs
+  setPrettyLogs: () => setPrettyLogs,
+  setupBindings: () => setupBindings,
+  setupDLQ: () => setupDLQ,
+  setupExchange: () => setupExchange,
+  setupQueue: () => setupQueue,
+  setupRetry: () => setupRetry
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -122,66 +129,6 @@ function isRabbitConnected() {
   return Boolean(connection && channel);
 }
 
-// src/consumer.ts
-async function consumeMessage(options, handler) {
-  const channel2 = getChannel();
-  const {
-    queue,
-    exchange,
-    type,
-    routingKey = "",
-    prefetch = 1,
-    noAck = false
-  } = options;
-  await channel2.assertExchange(exchange, type, { durable: true });
-  await channel2.assertQueue(queue, { durable: true });
-  await channel2.bindQueue(queue, exchange, routingKey);
-  channel2.prefetch(prefetch);
-  console.log(`\u{1F4E5} Waiting for messages on queue: ${queue}`);
-  await channel2.consume(
-    queue,
-    async (msg) => {
-      if (!msg) return;
-      try {
-        const content = msg.content.toString();
-        const data = tryParseJSON(content);
-        await handler(data, msg);
-        if (!noAck) channel2.ack(msg);
-      } catch (err) {
-        console.error("\u274C Message processing failed:", err);
-        if (!noAck) channel2.nack(msg, false, false);
-      }
-    },
-    { noAck }
-  );
-}
-function tryParseJSON(data) {
-  try {
-    return JSON.parse(data);
-  } catch {
-    return data;
-  }
-}
-
-// src/publisher.ts
-async function publishMessage({
-  exchange,
-  type,
-  routingKey = "",
-  message,
-  headers = {}
-}) {
-  const channel2 = getChannel();
-  await channel2.assertExchange(exchange, type, { durable: true });
-  const payload = Buffer.isBuffer(message) ? message : Buffer.from(
-    typeof message === "string" ? message : JSON.stringify(message)
-  );
-  channel2.publish(exchange, routingKey, payload, {
-    persistent: true,
-    headers
-  });
-}
-
 // src/logger/index.ts
 var serviceName = "service";
 var prettyLogs = true;
@@ -247,6 +194,133 @@ async function bootstrap({
   }
 }
 
+// src/publisher.ts
+async function publishMessage({
+  exchange,
+  type,
+  routingKey = "",
+  message,
+  headers = {}
+}) {
+  const channel2 = getChannel();
+  await channel2.assertExchange(exchange, type, { durable: true });
+  const payload = Buffer.isBuffer(message) ? message : Buffer.from(
+    typeof message === "string" ? message : JSON.stringify(message)
+  );
+  channel2.publish(exchange, routingKey, payload, {
+    persistent: true,
+    headers
+  });
+}
+
+// src/consumer.ts
+async function consumeMessage(options, handler) {
+  const channel2 = getChannel();
+  const {
+    queue,
+    exchange,
+    type,
+    routingKey = "",
+    prefetch = 1,
+    noAck = false
+  } = options;
+  await channel2.assertExchange(exchange, type, { durable: true });
+  await channel2.assertQueue(queue, { durable: true });
+  await channel2.bindQueue(queue, exchange, routingKey);
+  channel2.prefetch(prefetch);
+  console.log(`\u{1F4E5} Waiting for messages on queue: ${queue}`);
+  await channel2.consume(
+    queue,
+    async (msg) => {
+      if (!msg) return;
+      try {
+        const content = msg.content.toString();
+        const data = tryParseJSON(content);
+        await handler(data, msg);
+        if (!noAck) channel2.ack(msg);
+      } catch (err) {
+        console.error("\u274C Message processing failed:", err);
+        if (!noAck) channel2.nack(msg, false, false);
+      }
+    },
+    { noAck }
+  );
+}
+function tryParseJSON(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
+
+// src/builder/exchange.ts
+async function setupExchange(channel2, exchange) {
+  await channel2.assertExchange(exchange.name, exchange.type, {
+    durable: exchange.durable ?? true,
+    autoDelete: exchange.autoDelete ?? false
+  });
+}
+
+// src/builder/queue.ts
+async function setupQueue(channel2, queue) {
+  await channel2.assertQueue(queue.name, {
+    durable: queue.durable ?? true,
+    arguments: {
+      ...queue.priority && {
+        "x-max-priority": queue.maxPriority ?? 10
+      },
+      ...queue.ttl && {
+        "x-message-ttl": queue.ttl
+      },
+      ...queue.arguments ?? {}
+    }
+  });
+}
+
+// src/builder/binding.ts
+async function setupBindings(channel2, binding) {
+  const keys = Array.isArray(binding.routingKeys) ? binding.routingKeys : [binding.routingKeys];
+  for (const key of keys) {
+    await channel2.bindQueue(binding.queue, binding.exchange, key);
+  }
+}
+
+// src/builder/retry.ts
+async function setupRetry(channel2, config) {
+  const retryExchange = `${config.exchange}.retry`;
+  const retryQueue = `${config.queue}.retry.${config.delay}`;
+  await channel2.assertExchange(retryExchange, "direct", {
+    durable: true
+  });
+  await channel2.assertQueue(retryQueue, {
+    durable: true,
+    arguments: {
+      "x-message-ttl": config.delay,
+      "x-dead-letter-exchange": config.exchange,
+      "x-dead-letter-routing-key": config.routingKey
+    }
+  });
+  await channel2.bindQueue(retryQueue, retryExchange, config.routingKey);
+  return {
+    retryExchange,
+    retryQueue
+  };
+}
+
+// src/builder/dlq.ts
+async function setupDLQ(channel2, config) {
+  const dlx = `${config.exchange}.dlx`;
+  const dlq = `${config.queue}.dlq`;
+  await channel2.assertExchange(dlx, "direct", { durable: true });
+  await channel2.assertQueue(dlq, { durable: true });
+  await channel2.bindQueue(dlq, dlx, config.routingKey ?? config.queue);
+  return {
+    deadLetterExchange: dlx,
+    deadLetterQueue: dlq
+  };
+}
+
 // src/health/index.ts
 function rabbitHealth() {
   const connected = isRabbitConnected();
@@ -261,12 +335,19 @@ function rabbitHealth() {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   bootstrap,
+  closeRabbitMQ,
   consumeMessage,
   getChannel,
+  isRabbitConnected,
   logger,
   publishMessage,
   rabbitEvents,
   rabbitHealth,
   setLoggerService,
-  setPrettyLogs
+  setPrettyLogs,
+  setupBindings,
+  setupDLQ,
+  setupExchange,
+  setupQueue,
+  setupRetry
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaushverse/rabbitmq-core",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Reusable RabbitMQ (AMQP / AMQPS) core for Node.js & microservices",
   "author": "Kaushik (KaushVerse)",
   "license": "MIT",
@@ -17,10 +17,12 @@
   "keywords": [
     "rabbitmq",
     "amqp",
-    "amqps",
     "microservices",
-    "messaging",
-    "nodejs"
+    "message-queue",
+    "event-driven",
+    "dlq",
+    "retry",
+    "amqps"
   ],
   "dependencies": {
     "amqplib": "^0.10.9"