runmq 1.5.0 → 2.0.0

package/dist/index.d.ts

@@ -22,15 +22,49 @@ interface RunMQConnectionConfig {
         username: string;
         password: string;
     };
+    /**
+     * Controls publisher confirms on the user-publish path. When enabled
+     * (default), `runMQ.publish()` resolves only after RabbitMQ acknowledges
+     * each message, and rejects on broker error (e.g. mandatory routing
+     * failure, alarm state). Set to `false` to opt out and fall back to
+     * fire-and-forget — publish resolves once the message is written to the
+     * TCP socket, with no delivery guarantee.
+     *
+     * Trade-off: confirms add a broker round-trip per publish (typically a
+     * few hundred microseconds). They're the only way to detect silent
+     * publish failures, so we default to safety. DLQ publishes from the
+     * consumer chain are *always* confirmed regardless of this setting —
+     * the message-loss risk there is not negotiable.
+     */
+    usePublisherConfirms?: boolean;
+    logFullMessagePayload?: boolean;
 }
 type SchemaFailureStrategy = 'dlq';
 type SchemaType = 'ajv';
 interface RunMQProcessorConfiguration {
     name: string;
     /**
-     * The number of concurrent consumers to run for this processor.
+     * The number of concurrent consumers (independent AMQP channels) to run
+     * for this processor.
+     *
+     * Each consumer holds its own channel with its own `prefetch` window, so
+     * the maximum number of unacknowledged in-flight messages for the
+     * processor is `consumersCount * prefetch` — not `prefetch` alone.
+     * For example, `consumersCount: 10` with the default `prefetch: 20`
+     * allows up to 200 messages to be held unacknowledged at once.
+     *
+     * Tune both values together to control memory footprint and the size of
+     * the redelivery surface on a crash.
      */
     consumersCount: number;
+    /**
+     * The per-channel prefetch count applied to each consumer's channel.
+     * Defaults to 20.
+     *
+     * NOTE: this is per-consumer, not per-processor. Total in-flight messages
+     * for the processor is `consumersCount * prefetch`.
+     */
+    prefetch?: number;
     /**
      * The maximum number attempts processing a message, default is 1 attempt.
      */
@@ -119,6 +153,7 @@ declare class RunMQ {
     private readonly logger;
     private retryAttempts;
     private defaultChannel;
+    private publishChannel;
     private constructor();
     /**
      * Starts the RunMQ instance by establishing a connection to RabbitMQ and initializing necessary components.
@@ -135,12 +170,20 @@ declare class RunMQ {
      */
     process<T = Record<string, never>>(topic: string, config: RunMQProcessorConfiguration, processor: (message: RunMQMessageContent<T>) => Promise<void>): Promise<void>;
     /**
-     * Publishes a message to the specified topic with an optional correlation ID
+     * Publishes a message to the specified topic with an optional correlation ID.
+     *
+     * If publisher confirms are enabled (`usePublisherConfirms: true` in the
+     * connection config), the returned promise resolves only after RabbitMQ
+     * acknowledges the message; if the broker rejects, the promise rejects.
+     * Otherwise it resolves once the message is flushed to the TCP socket
+     * (fire-and-forget, no delivery guarantee — same behavior as before
+     * publisher confirms were introduced).
+     *
      * @param topic The name of the topic to publish the message to
      * @param message The message payload to be published
      * @param correlationId (Optional) A unique identifier for correlating messages; if not provided, a new UUID will be generated
      */
-    publish(topic: string, message: Record<string, any>, correlationId?: string): void;
+    publish(topic: string, message: Record<string, any>, correlationId?: string): Promise<void>;
     /**
      * Disconnects from RabbitMQ, handling any errors that may occur during the disconnection process.
      */