@warlock.js/herald 4.0.162 → 4.0.164

package/cjs/utils/connect-to-communicator.d.ts

@@ -0,0 +1,129 @@
+import { Communicator } from "../communicators";
+import type { ChannelContract } from "../contracts";
+import { EventConsumerClass, EventMessage } from "../message-managers";
+import type { ChannelOptions, ConnectionOptions } from "../types";
+/**
+ * Connect to a message broker and register the communicator.
+ *
+ * This is a high-level utility function that simplifies connection setup
+ * for most projects. It handles driver instantiation, connection,
+ * communicator creation, and automatic registration.
+ *
+ * **Supported Drivers:**
+ * - `rabbitmq` (default) - RabbitMQ/AMQP driver
+ * - `kafka` - Apache Kafka driver (coming soon)
+ *
+ * @param options - Connection configuration options
+ * @returns A connected and registered Communicator instance
+ * @throws {Error} If connection fails or driver is not implemented
+ *
+ * @example
+ * ```typescript
+ * // RabbitMQ connection
+ * const communicator = await connectToCommunicator({
+ *   driver: "rabbitmq",
+ *   host: "localhost",
+ *   port: 5672,
+ *   username: "guest",
+ *   password: "guest",
+ * });
+ *
+ * // Use the communicator
+ * await communicator.channel("user.created").publish({ userId: 1 });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple communicators
+ * await connectToCommunicator({
+ *   driver: "rabbitmq",
+ *   name: "notifications",
+ *   isDefault: true,
+ *   host: process.env.RABBITMQ_HOST,
+ * });
+ *
+ * await connectToCommunicator({
+ *   driver: "rabbitmq",
+ *   name: "analytics",
+ *   host: process.env.ANALYTICS_RABBITMQ_HOST,
+ * });
+ *
+ * // Use default communicator
+ * communicators().channel("notifications").publish({ ... });
+ *
+ * // Use specific communicator
+ * communicators("analytics").channel("events").publish({ ... });
+ * ```
+ */
+export declare function connectToCommunicator(options: ConnectionOptions): Promise<Communicator>;
+/**
+ * Get a communicator by name or the default one.
+ *
+ * This is the main entry point for using communicators in your application.
+ *
+ * @param name - Optional communicator name (uses default if not provided)
+ * @returns Communicator instance
+ * @throws MissingCommunicatorError if communicator not found
+ *
+ * @example
+ * ```typescript
+ * // Get default communicator
+ * const channel = communicators().channel("user.created");
+ * await channel.publish({ userId: 1 });
+ *
+ * // Get specific communicator
+ * const analyticsChannel = communicators("analytics").channel("events");
+ * await analyticsChannel.publish({ event: "page_view" });
+ *
+ * // Subscribe to messages
+ * communicators()
+ *   .channel<UserPayload>("user.created")
+ *   .subscribe(async (message, ctx) => {
+ *     console.log("User created:", message.payload);
+ *     await ctx.ack();
+ *   });
+ * ```
+ */
+export declare function communicators(name?: string): Communicator;
+/**
+ * Get channel instance for the given name from default communicator
+ * @param name - Channel name
+ * @returns Channel instance
+ * @throws MissingCommunicatorError if communicator not found
+ *
+ * @example
+ * ```typescript
+ * const channel = communicatorChannel("user.created");
+ * await channel.publish({ userId: 1 });
+ * ```
+ */
+export declare function communicatorChannel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
+/**
+ * Publish the given
+ * @param event - Event message to publish
+ * @returns Promise that resolves when the event is published
+ * @throws Error if the event is not published
+ *
+ * @example
+ * ```typescript
+ * await publishEvent(new UserUpdatedEvent({ id: 1, name: "John Doe" }));
+ * ```
+ */
+export declare function publishEvent<TPayload = Record<string, any>>(event: EventMessage<TPayload>): Promise<void>;
+/**
+ * Subscribe the given consumer to the default communicator
+ * @param Consumer - Event consumer class
+ * @returns Function to unsubscribe the consumer
+ * @throws Error if the consumer is not subscribed
+ *
+ * @example
+ * ```typescript
+ * await subscribeConsumer(UserUpdatedConsumer);
+ * });
+ *
+ * // Unsubscribe
+ * await unsubscribeConsumer(UserUpdatedConsumer);
+ * ```
+ */
+export declare function subscribeConsumer<TPayload = Record<string, any>>(Consumer: EventConsumerClass<TPayload>): Promise<() => void>;
+//# sourceMappingURL=connect-to-communicator.d.ts.map

package/cjs/utils/connect-to-communicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-to-communicator.d.ts","sourceRoot":"","sources":["../../src/utils/connect-to-communicator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAwB,MAAM,kBAAkB,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAA8B,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAA6B,MAAM,UAAU,CAAC;AAE7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CA+C7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,YAAY,CAEzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,GAAG,OAAO,EACpD,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GACjC,eAAe,CAAC,QAAQ,CAAC,CAE3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,iBAE/F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACpE,QAAQ,EAAE,kBAAkB,CAAC,QAAQ,CAAC,uBAGvC"}

package/cjs/utils/connect-to-communicator.js

@@ -0,0 +1,169 @@
+'use strict';var communicatorRegistry=require('../communicators/communicator-registry.js');/**
+ * Connect to a message broker and register the communicator.
+ *
+ * This is a high-level utility function that simplifies connection setup
+ * for most projects. It handles driver instantiation, connection,
+ * communicator creation, and automatic registration.
+ *
+ * **Supported Drivers:**
+ * - `rabbitmq` (default) - RabbitMQ/AMQP driver
+ * - `kafka` - Apache Kafka driver (coming soon)
+ *
+ * @param options - Connection configuration options
+ * @returns A connected and registered Communicator instance
+ * @throws {Error} If connection fails or driver is not implemented
+ *
+ * @example
+ * ```typescript
+ * // RabbitMQ connection
+ * const communicator = await connectToCommunicator({
+ *   driver: "rabbitmq",
+ *   host: "localhost",
+ *   port: 5672,
+ *   username: "guest",
+ *   password: "guest",
+ * });
+ *
+ * // Use the communicator
+ * await communicator.channel("user.created").publish({ userId: 1 });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple communicators
+ * await connectToCommunicator({
+ *   driver: "rabbitmq",
+ *   name: "notifications",
+ *   isDefault: true,
+ *   host: process.env.RABBITMQ_HOST,
+ * });
+ *
+ * await connectToCommunicator({
+ *   driver: "rabbitmq",
+ *   name: "analytics",
+ *   host: process.env.ANALYTICS_RABBITMQ_HOST,
+ * });
+ *
+ * // Use default communicator
+ * communicators().channel("notifications").publish({ ... });
+ *
+ * // Use specific communicator
+ * communicators("analytics").channel("events").publish({ ... });
+ * ```
+ */
+async function connectToCommunicator(options) {
+    // Default values
+    const driverType = options.driver ?? "rabbitmq";
+    const communicatorName = options.name ?? "default";
+    const isDefault = options.isDefault ?? true;
+    // Create driver based on type
+    let driver;
+    switch (driverType) {
+        case "rabbitmq": {
+            const rabbitOptions = options;
+            // Dynamic import to avoid requiring amqplib if not used
+            const { RabbitMQDriver } = await Promise.resolve().then(function(){return require('../drivers/rabbitmq/rabbitmq-driver.js')});
+            driver = new RabbitMQDriver(rabbitOptions);
+            break;
+        }
+        case "kafka": {
+            // const kafkaOptions = options as KafkaConnectionOptions;
+            // Dynamic import to avoid requiring kafkajs if not used
+            throw new Error("Kafka driver is not yet implemented. Coming soon! For now, please use RabbitMQ.");
+        }
+        default:
+            throw new Error(`Unknown driver: "${driverType}". Supported drivers: rabbitmq, kafka`);
+    }
+    // Create communicator
+    const communicator = communicatorRegistry.communicatorRegistry.register({
+        name: communicatorName,
+        driver,
+        isDefault,
+    });
+    // Connect to the message broker
+    try {
+        await driver.connect();
+    }
+    catch (error) {
+        throw new Error(`Failed to connect to ${driverType}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return communicator;
+}
+/**
+ * Get a communicator by name or the default one.
+ *
+ * This is the main entry point for using communicators in your application.
+ *
+ * @param name - Optional communicator name (uses default if not provided)
+ * @returns Communicator instance
+ * @throws MissingCommunicatorError if communicator not found
+ *
+ * @example
+ * ```typescript
+ * // Get default communicator
+ * const channel = communicators().channel("user.created");
+ * await channel.publish({ userId: 1 });
+ *
+ * // Get specific communicator
+ * const analyticsChannel = communicators("analytics").channel("events");
+ * await analyticsChannel.publish({ event: "page_view" });
+ *
+ * // Subscribe to messages
+ * communicators()
+ *   .channel<UserPayload>("user.created")
+ *   .subscribe(async (message, ctx) => {
+ *     console.log("User created:", message.payload);
+ *     await ctx.ack();
+ *   });
+ * ```
+ */
+function communicators(name) {
+    return communicatorRegistry.communicatorRegistry.get(name);
+}
+/**
+ * Get channel instance for the given name from default communicator
+ * @param name - Channel name
+ * @returns Channel instance
+ * @throws MissingCommunicatorError if communicator not found
+ *
+ * @example
+ * ```typescript
+ * const channel = communicatorChannel("user.created");
+ * await channel.publish({ userId: 1 });
+ * ```
+ */
+function communicatorChannel(name, options) {
+    return communicators().channel(name, options);
+}
+/**
+ * Publish the given
+ * @param event - Event message to publish
+ * @returns Promise that resolves when the event is published
+ * @throws Error if the event is not published
+ *
+ * @example
+ * ```typescript
+ * await publishEvent(new UserUpdatedEvent({ id: 1, name: "John Doe" }));
+ * ```
+ */
+async function publishEvent(event) {
+    return communicators().publish(event);
+}
+/**
+ * Subscribe the given consumer to the default communicator
+ * @param Consumer - Event consumer class
+ * @returns Function to unsubscribe the consumer
+ * @throws Error if the consumer is not subscribed
+ *
+ * @example
+ * ```typescript
+ * await subscribeConsumer(UserUpdatedConsumer);
+ * });
+ *
+ * // Unsubscribe
+ * await unsubscribeConsumer(UserUpdatedConsumer);
+ * ```
+ */
+async function subscribeConsumer(Consumer) {
+    return communicators().subscribe(Consumer);
+}exports.communicatorChannel=communicatorChannel;exports.communicators=communicators;exports.connectToCommunicator=connectToCommunicator;exports.publishEvent=publishEvent;exports.subscribeConsumer=subscribeConsumer;//# sourceMappingURL=connect-to-communicator.js.map

package/cjs/utils/connect-to-communicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-to-communicator.js","sources":["../../src/utils/connect-to-communicator.ts"],"sourcesContent":[null],"names":["communicatorRegistry"],"mappings":"2FAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,eAAe,qBAAqB,CAAC,OAA0B,EAAA;;AAEpE,IAAA,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,IAAI,UAAU,CAAC;AAChD,IAAA,MAAM,gBAAgB,GAAG,OAAO,CAAC,IAAI,IAAI,SAAS,CAAC;AACnD,IAAA,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC;;AAG5C,IAAA,IAAI,MAAkC,CAAC;AAEvC,IAAA,QAAQ,UAAU;QAChB,KAAK,UAAU,EAAE;YACf,MAAM,aAAa,GAAG,OAAoC,CAAC;;YAE3D,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,iDAAO,wCAAqC,GAAC,CAAC;AAC/E,YAAA,MAAM,GAAG,IAAI,cAAc,CAAC,aAAa,CAAC,CAAC;YAC3C,MAAM;AACP,SAAA;QAED,KAAK,OAAO,EAAE;;;AAGZ,YAAA,MAAM,IAAI,KAAK,CACb,iFAAiF,CAClF,CAAC;AACH,SAAA;AAED,QAAA;AACE,YAAA,MAAM,IAAI,KAAK,CAAC,oBAAoB,UAAU,CAAA,qCAAA,CAAuC,CAAC,CAAC;AAC1F,KAAA;;AAGD,IAAA,MAAM,YAAY,GAAGA,yCAAoB,CAAC,QAAQ,CAAC;AACjD,QAAA,IAAI,EAAE,gBAAgB;QACtB,MAAM;QACN,SAAS;AACV,KAAA,CAAC,CAAC;;IAGH,IAAI;AACF,QAAA,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;AACxB,KAAA;AAAC,IAAA,OAAO,KAAK,EAAE;QACd,MAAM,IAAI,KAAK,CACb,CAAwB,qBAAA,EAAA,UAAU,KAAK,KAAK,YAAY,KAAK,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAE,CAAA,CAChG,CAAC;AACH,KAAA;AAED,IAAA,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACG,SAAU,aAAa,CAAC,IAAa,EAAA;AACzC,IAAA,OAAOA,yCAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;AAWG;AACa,SAAA,mBAAmB,CACjC,IAAY,EACZ,OAAkC,EAAA;IAElC,OAAO,aAAa,EAAE,CAAC,OAAO,CAAW,IAAI,EAAE,OAAO,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;AAUG;AACI,eAAe,YAAY,CAAiC,KAA6B,EAAA;AAC9F,IAAA,OAAO,aAAa,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;;AAcG;AACI,eAAe,iBAAiB,CACrC,QAAsC,EAAA;AAEtC,IAAA,OAAO,aAAa,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AAC7C"}

package/cjs/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./connect-to-communicator";
+//# sourceMappingURL=index.d.ts.map

package/cjs/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/esm/decorators/consumable.d.ts

@@ -0,0 +1,13 @@
+import { type EventConsumerClass } from "../message-managers/types";
+export type ConsumableOptions = {
+    communicator?: string;
+};
+export declare const pendingSubscribers: Set<{
+    Consumer: EventConsumerClass;
+    options?: ConsumableOptions;
+}>;
+/**
+ * Register the consumer to the communicator
+ */
+export declare function Consumable(options?: ConsumableOptions): (target: EventConsumerClass) => void;
+//# sourceMappingURL=consumable.d.ts.map

package/esm/decorators/consumable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumable.d.ts","sourceRoot":"","sources":["../../src/decorators/consumable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,kBAAkB;cACnB,kBAAkB;cAClB,iBAAiB;EACzB,CAAC;AAEL;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,YAC3B,kBAAkB,UAkB5C"}

package/esm/decorators/consumable.js

@@ -0,0 +1,33 @@
+import {communicatorRegistry}from'../communicators/communicator-registry.js';const pendingSubscribers = new Set();
+/**
+ * Register the consumer to the communicator
+ */
+function Consumable(options) {
+    return function (target) {
+        const communicatorDriver = options?.communicator;
+        try {
+            const currentCommunicator = communicatorRegistry.get(communicatorDriver);
+            // if communicator is connected, subscribe the consumer
+            if (currentCommunicator?.isConnected) {
+                currentCommunicator.subscribe(target);
+            }
+            else {
+                pendingSubscribers.add({ Consumer: target, options });
+            }
+        }
+        catch {
+            // mostly it will be an error that communicator is not registered yet
+            // then add it to the pending subscribers
+            pendingSubscribers.add({ Consumer: target, options });
+        }
+    };
+}
+// Register pending consumers on communicator's connection is done
+communicatorRegistry.on("connected", (communicator) => {
+    for (const { Consumer, options } of pendingSubscribers) {
+        if (options?.communicator && communicator.name !== options.communicator) {
+            continue;
+        }
+        communicator.subscribe(Consumer);
+    }
+});export{Consumable,pendingSubscribers};//# sourceMappingURL=consumable.js.map

package/esm/decorators/consumable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumable.js","sources":["../../src/decorators/consumable.ts"],"sourcesContent":[null],"names":[],"mappings":"6EAOa,MAAA,kBAAkB,GAAG,IAAI,GAAG,GAGpC;AAEL;;AAEG;AACG,SAAU,UAAU,CAAC,OAA2B,EAAA;AACpD,IAAA,OAAO,UAAU,MAA0B,EAAA;AACzC,QAAA,MAAM,kBAAkB,GAAG,OAAO,EAAE,YAAY,CAAC;QAEjD,IAAI;YACF,MAAM,mBAAmB,GAAG,oBAAoB,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;;YAGzE,IAAI,mBAAmB,EAAE,WAAW,EAAE;AACpC,gBAAA,mBAAmB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AACvC,aAAA;AAAM,iBAAA;gBACL,kBAAkB,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AACvD,aAAA;AACF,SAAA;QAAC,MAAM;;;YAGN,kBAAkB,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AACvD,SAAA;AACH,KAAC,CAAC;AACJ,CAAC;AAED;AACA,oBAAoB,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,YAAY,KAAI;IACpD,KAAK,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,kBAAkB,EAAE;QACtD,IAAI,OAAO,EAAE,YAAY,IAAI,YAAY,CAAC,IAAI,KAAK,OAAO,CAAC,YAAY,EAAE;YACvE,SAAS;AACV,SAAA;AAED,QAAA,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AAClC,KAAA;AACH,CAAC,CAAC"}

package/esm/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./consumable";
+//# sourceMappingURL=index.d.ts.map

package/esm/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/esm/drivers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./rabbitmq";
+//# sourceMappingURL=index.d.ts.map

package/esm/drivers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drivers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/esm/drivers/rabbitmq/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./rabbitmq-driver";
+export * from "./rabbitmq-channel";
+//# sourceMappingURL=index.d.ts.map

package/esm/drivers/rabbitmq/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/drivers/rabbitmq/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/esm/drivers/rabbitmq/rabbitmq-channel.d.ts

@@ -0,0 +1,78 @@
+import type { ChannelContract } from "../../contracts";
+import type { ChannelOptions, ChannelStats, MessageHandler, PublishOptions, RequestOptions, ResponseHandler, SubscribeOptions, Subscription } from "../../types";
+/**
+ * RabbitMQ Channel Implementation
+ *
+ * Wraps a RabbitMQ queue/exchange with a unified API.
+ *
+ * @template TPayload - The typed payload
+ */
+export declare class RabbitMQChannel<TPayload = unknown> implements ChannelContract<TPayload> {
+    readonly name: string;
+    readonly options: ChannelOptions<TPayload>;
+    private readonly amqpChannel;
+    private readonly subscriptions;
+    private asserted;
+    /**
+     * Create a new RabbitMQ channel
+     */
+    constructor(name: string, amqpChannel: any, options?: ChannelOptions<TPayload>);
+    /**
+     * Assert the queue exists
+     */
+    assert(): Promise<void>;
+    /**
+     * Publish a message
+     */
+    publish(payload: TPayload, options?: PublishOptions): Promise<void>;
+    /**
+     * Publish multiple messages
+     */
+    publishBatch(messages: TPayload[], options?: PublishOptions): Promise<void>;
+    /**
+     * Subscribe to messages
+     *
+     * Smart auto-ack behavior (when autoAck is not true):
+     * - If handler completes successfully without explicit ack/nack/reject → auto-ack
+     * - If handler throws an error → auto-nack (with retry if configured)
+     * - If handler explicitly calls ack/nack/reject → respects that call
+     */
+    subscribe(handler: MessageHandler<TPayload>, options?: SubscribeOptions): Promise<Subscription>;
+    /**
+     * Unsubscribe by consumer ID
+     */
+    unsubscribeById(consumerId: string): Promise<void>;
+    /**
+     * Stop consuming subscriptions
+     */
+    stopConsuming(): Promise<void>;
+    /**
+     * Send message to dead-letter queue
+     */
+    private sendToDeadLetter;
+    /**
+     * Request-response pattern
+     */
+    request<TResponse = unknown>(payload: TPayload, options?: RequestOptions): Promise<TResponse>;
+    /**
+     * Register response handler for RPC
+     */
+    respond<TResponse = unknown>(handler: ResponseHandler<TPayload, TResponse>): Promise<Subscription>;
+    /**
+     * Get queue statistics
+     */
+    stats(): Promise<ChannelStats>;
+    /**
+     * Purge all messages
+     */
+    purge(): Promise<number>;
+    /**
+     * Check if queue exists
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Delete the queue
+     */
+    delete(): Promise<void>;
+}
+//# sourceMappingURL=rabbitmq-channel.d.ts.map

package/esm/drivers/rabbitmq/rabbitmq-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmq-channel.d.ts","sourceRoot":"","sources":["../../../src/drivers/rabbitmq/rabbitmq-channel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EAGZ,cAAc,EAEd,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,YAAY,EACb,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,qBAAa,eAAe,CAAC,QAAQ,GAAG,OAAO,CAAE,YAAW,eAAe,CAAC,QAAQ,CAAC;IACnF,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IAElD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAM;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2C;IACzE,OAAO,CAAC,QAAQ,CAAS;IAEzB;;OAEG;gBACgB,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC;IAMrF;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBpC;;OAEG;IACU,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAkDhF;;OAEG;IACU,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxF;;;;;;;OAOG;IACU,SAAS,CACpB,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EACjC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,CAAC;IA+KxB;;OAEG;IACU,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/D;;OAEG;IACU,aAAa;IAI1B;;OAEG;YACW,gBAAgB;IAe9B;;OAEG;IACU,OAAO,CAAC,SAAS,GAAG,OAAO,EACtC,OAAO,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,SAAS,CAAC;IAiDrB;;OAEG;IACU,OAAO,CAAC,SAAS,GAAG,OAAO,EACtC,OAAO,EAAE,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,GAC5C,OAAO,CAAC,YAAY,CAAC;IAQxB;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC;IAY3C;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAOrC;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IASvC;;OAEG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAerC"}