@warlock.js/herald 4.0.100

package/cjs/contracts/communicator-driver.contract.d.ts

@@ -0,0 +1,168 @@
+import type { ChannelContract } from "./channel.contract";
+import type { ChannelOptions, CommunicatorEvent, CommunicatorEventListener, CommunicatorDriverType, HealthCheckResult } from "../types";
+/**
+ * Communicator Driver Contract
+ *
+ * Base contract for all message bus drivers (RabbitMQ, Kafka, etc.)
+ * Similar to DriverContract in @warlock.js/cascade
+ *
+ * @example
+ * ```typescript
+ * // Driver implementation
+ * class RabbitMQDriver implements CommunicatorDriverContract {
+ *   readonly name = "rabbitmq";
+ *   // ...
+ * }
+ * ```
+ */
+export interface CommunicatorDriverContract {
+    /**
+     * Driver name identifier
+     *
+     * @example "rabbitmq", "kafka", "redis-streams"
+     */
+    readonly name: CommunicatorDriverType;
+    /**
+     * Whether currently connected to the message broker
+     */
+    readonly isConnected: boolean;
+    /**
+     * Establish connection to the message broker
+     *
+     * @throws Error if connection fails
+     *
+     * @example
+     * ```typescript
+     * await driver.connect();
+     * console.log("Connected to RabbitMQ");
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Close connection gracefully
+     *
+     * Ensures all pending operations complete before disconnecting.
+     *
+     * @example
+     * ```typescript
+     * await driver.disconnect();
+     * ```
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Register event listeners for driver lifecycle events
+     *
+     * @param event - Event name to listen for
+     * @param listener - Callback function
+     *
+     * @example
+     * ```typescript
+     * driver.on("connected", () => {
+     *   console.log("Connected to broker");
+     * });
+     *
+     * driver.on("disconnected", () => {
+     *   console.log("Disconnected from broker");
+     * });
+     *
+     * driver.on("error", (error) => {
+     *   console.error("Driver error:", error);
+     * });
+     *
+     * driver.on("reconnecting", (attempt) => {
+     *   console.log(`Reconnection attempt ${attempt}`);
+     * });
+     * ```
+     */
+    on(event: CommunicatorEvent, listener: CommunicatorEventListener): void;
+    /**
+     * Remove an event listener
+     *
+     * @param event - Event name
+     * @param listener - Callback to remove
+     */
+    off(event: CommunicatorEvent, listener: CommunicatorEventListener): void;
+    /**
+     * Get or create a channel
+     *
+     * Channels are lazy-created and cached for reuse.
+     *
+     * @param name - Channel/queue/topic name
+     * @param options - Channel configuration
+     * @returns Channel instance
+     *
+     * @example
+     * ```typescript
+     * // Simple channel
+     * const channel = driver.channel("user.created");
+     *
+     * // With options
+     * const orderChannel = driver.channel("orders", {
+     *   durable: true,
+     *   deadLetter: { channel: "orders.failed" },
+     * });
+     *
+     * // Typed channel
+     * const typedChannel = driver.channel<OrderPayload>("orders", {
+     *   schema: OrderSchema,
+     * });
+     * ```
+     */
+    channel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
+    /**
+     * Start consuming messages from all subscribed channels
+     *
+     * Call this after setting up all subscriptions to begin processing.
+     *
+     * @example
+     * ```typescript
+     * // Set up subscriptions
+     * channel1.subscribe(handler1);
+     * channel2.subscribe(handler2);
+     *
+     * // Start consuming
+     * await driver.startConsuming();
+     * ```
+     */
+    startConsuming(): Promise<void>;
+    /**
+     * Stop consuming messages gracefully
+     *
+     * Waits for currently processing messages to complete.
+     *
+     * @example
+     * ```typescript
+     * await driver.stopConsuming();
+     * ```
+     */
+    stopConsuming(): Promise<void>;
+    /**
+     * Perform a health check on the connection
+     *
+     * @returns Health check result with status and optional latency
+     *
+     * @example
+     * ```typescript
+     * const health = await driver.healthCheck();
+     * if (health.healthy) {
+     *   console.log(`Healthy, latency: ${health.latency}ms`);
+     * } else {
+     *   console.error(`Unhealthy: ${health.error}`);
+     * }
+     * ```
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Get list of all channels managed by this driver
+     *
+     * @returns Array of channel names
+     */
+    getChannelNames(): string[];
+    /**
+     * Close and remove a specific channel
+     *
+     * @param name - Channel name to close
+     */
+    closeChannel(name: string): Promise<void>;
+}
+//# sourceMappingURL=communicator-driver.contract.d.ts.map

package/cjs/contracts/communicator-driver.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"communicator-driver.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/communicator-driver.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EACjB,yBAAyB,EACzB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAE9B;;;;;;;;;;OAUG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;;;;;;;OASG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAExE;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,QAAQ,GAAG,OAAO,EACxB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GACjC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAE7B;;;;;;;;;;;;;;OAcG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;;;;;;;OASG;IACH,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;OAcG;IACH,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAE1C;;;;OAIG;IACH,eAAe,IAAI,MAAM,EAAE,CAAC;IAE5B;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}

package/cjs/contracts/index.d.ts

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

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

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

package/cjs/drivers/index.d.ts

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

package/cjs/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/cjs/drivers/rabbitmq/index.d.ts

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

package/cjs/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/cjs/drivers/rabbitmq/rabbitmq-channel.d.ts

@@ -0,0 +1,70 @@
+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>;
+    /**
+     * 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/cjs/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;IAmLxB;;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"}

package/cjs/drivers/rabbitmq/rabbitmq-channel.js

@@ -0,0 +1,400 @@
+'use strict';var seal=require('@warlock.js/seal'),node_crypto=require('node:crypto');/**
+ * RabbitMQ Channel Implementation
+ *
+ * Wraps a RabbitMQ queue/exchange with a unified API.
+ *
+ * @template TPayload - The typed payload
+ */
+class RabbitMQChannel {
+    name;
+    options;
+    amqpChannel;
+    subscriptions = new Map();
+    asserted = false;
+    /**
+     * Create a new RabbitMQ channel
+     */
+    constructor(name, amqpChannel, options) {
+        this.name = name;
+        this.amqpChannel = amqpChannel;
+        this.options = options ?? {};
+    }
+    /**
+     * Assert the queue exists
+     */
+    async assert() {
+        if (this.asserted)
+            return;
+        const queueOptions = {
+            durable: this.options.durable ?? true,
+            autoDelete: this.options.autoDelete ?? false,
+            exclusive: this.options.exclusive ?? false,
+            messageTtl: this.options.messageTtl,
+            maxLength: this.options.maxLength,
+            deadLetterExchange: this.options.deadLetter?.channel ? "" : undefined,
+            deadLetterRoutingKey: this.options.deadLetter?.channel,
+        };
+        await this.amqpChannel.assertQueue(this.name, queueOptions);
+        this.asserted = true;
+    }
+    /**
+     * Publish a message
+     */
+    async publish(payload, options) {
+        await this.assert();
+        // Validate with schema if provided
+        if (this.options.schema) {
+            const context = {
+                allValues: payload,
+                value: payload,
+            };
+            const result = await seal.v.validate(this.options.schema, payload, { context });
+            if (!result.isValid) {
+                throw new Error(`Message validation failed: ${JSON.stringify(result.errors)}`);
+            }
+            payload = result.data;
+        }
+        const messageId = node_crypto.randomUUID();
+        const timestamp = new Date();
+        const messageContent = JSON.stringify({
+            payload,
+            metadata: {
+                messageId,
+                timestamp: timestamp.toISOString(),
+                correlationId: options?.correlationId,
+                headers: options?.headers,
+            },
+        });
+        const publishOptions = {
+            persistent: options?.persistent ?? true,
+            messageId,
+            timestamp: timestamp.getTime(),
+            correlationId: options?.correlationId,
+            expiration: options?.expiration?.toString(),
+            priority: options?.priority,
+            headers: options?.headers,
+        };
+        // Handle delayed messages (requires rabbitmq-delayed-message-exchange plugin)
+        if (options?.delay) {
+            publishOptions.headers = {
+                ...publishOptions.headers,
+                "x-delay": options.delay,
+            };
+        }
+        this.amqpChannel.sendToQueue(this.name, Buffer.from(messageContent), publishOptions);
+    }
+    /**
+     * Publish multiple messages
+     */
+    async publishBatch(messages, options) {
+        for (const payload of messages) {
+            await this.publish(payload, options);
+        }
+    }
+    /**
+     * 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
+     */
+    async subscribe(handler, options) {
+        await this.assert();
+        const subscriptionId = node_crypto.randomUUID();
+        // Set prefetch if specified
+        if (options?.prefetch) {
+            await this.amqpChannel.prefetch(options.prefetch);
+        }
+        // If autoAck is true, RabbitMQ handles ack immediately (fire-and-forget)
+        const isFireAndForget = options?.autoAck === true;
+        const consumerOptions = {
+            noAck: isFireAndForget,
+            exclusive: options?.exclusive ?? false,
+            consumerTag: options?.group ?? subscriptionId,
+        };
+        const { consumerTag } = await this.amqpChannel.consume(this.name, async (msg) => {
+            if (!msg)
+                return;
+            // Track if acknowledgment was handled explicitly
+            let ackHandled = isFireAndForget;
+            try {
+                const content = JSON.parse(msg.content.toString());
+                let payload = content.payload;
+                // Validate with schema if provided
+                if (this.options.schema) {
+                    const schemaContext = {
+                        allValues: payload,
+                        parent: null,
+                        value: payload,
+                        key: "",
+                        path: "",
+                        translateRule: (t) => t.rule?.defaultErrorMessage ?? "Validation failed",
+                        translateAttribute: (t) => t.attribute ?? "",
+                    };
+                    const result = await this.options.schema.validate(payload, schemaContext);
+                    if (!result.isValid) {
+                        // Reject invalid messages
+                        this.amqpChannel.nack(msg, false, false);
+                        return;
+                    }
+                    payload = result.data;
+                }
+                const metadata = {
+                    messageId: msg.properties.messageId || content.metadata?.messageId || node_crypto.randomUUID(),
+                    timestamp: new Date(msg.properties.timestamp || content.metadata?.timestamp),
+                    correlationId: msg.properties.correlationId || content.metadata?.correlationId,
+                    replyTo: msg.properties.replyTo,
+                    priority: msg.properties.priority,
+                    headers: msg.properties.headers,
+                    retryCount: msg.properties.headers?.["x-retry-count"] || 0,
+                    originalChannel: this.name,
+                };
+                const message = {
+                    metadata,
+                    payload,
+                    raw: msg,
+                };
+                const context = {
+                    ack: async () => {
+                        if (!ackHandled) {
+                            ackHandled = true;
+                            this.amqpChannel.ack(msg);
+                        }
+                    },
+                    nack: async (requeue = true) => {
+                        if (!ackHandled) {
+                            ackHandled = true;
+                            this.amqpChannel.nack(msg, false, requeue);
+                        }
+                    },
+                    reject: async () => {
+                        if (!ackHandled) {
+                            ackHandled = true;
+                            this.amqpChannel.reject(msg, false);
+                        }
+                    },
+                    reply: async (replyPayload) => {
+                        if (msg.properties.replyTo) {
+                            const replyContent = JSON.stringify({
+                                payload: replyPayload,
+                                metadata: {
+                                    messageId: node_crypto.randomUUID(),
+                                    timestamp: new Date().toISOString(),
+                                    correlationId: msg.properties.correlationId,
+                                },
+                            });
+                            this.amqpChannel.sendToQueue(msg.properties.replyTo, Buffer.from(replyContent), {
+                                correlationId: msg.properties.correlationId,
+                            });
+                        }
+                    },
+                    retry: async (delay) => {
+                        if (ackHandled)
+                            return;
+                        ackHandled = true;
+                        const retryCount = (metadata.retryCount || 0) + 1;
+                        const maxRetries = options?.retry?.maxRetries ?? 3;
+                        if (retryCount > maxRetries) {
+                            // Send to dead-letter if configured
+                            if (options?.deadLetter) {
+                                await this.sendToDeadLetter(message, options.deadLetter.channel);
+                            }
+                            this.amqpChannel.ack(msg);
+                            return;
+                        }
+                        // Republish with retry count
+                        const headers = {
+                            ...msg.properties.headers,
+                            "x-retry-count": retryCount,
+                        };
+                        if (delay) {
+                            headers["x-delay"] = delay;
+                        }
+                        this.amqpChannel.sendToQueue(this.name, msg.content, { ...msg.properties, headers });
+                        this.amqpChannel.ack(msg);
+                    },
+                };
+                // Execute handler
+                await handler(message, context);
+                // Smart auto-ack: if handler succeeded and didn't explicitly handle ack
+                if (!ackHandled) {
+                    this.amqpChannel.ack(msg);
+                }
+            }
+            catch (error) {
+                // Smart auto-nack: if handler threw and didn't explicitly handle ack
+                if (ackHandled)
+                    return;
+                // Handle errors - nack and potentially retry
+                if (options?.retry) {
+                    const retryCount = msg.properties.headers?.["x-retry-count"] || 0;
+                    if (retryCount < options.retry.maxRetries) {
+                        // Requeue for retry
+                        this.amqpChannel.nack(msg, false, true);
+                    }
+                    else if (options.deadLetter) {
+                        // Send to dead-letter
+                        this.amqpChannel.nack(msg, false, false);
+                    }
+                    else {
+                        this.amqpChannel.reject(msg, false);
+                    }
+                }
+                else {
+                    // No retry configured - reject without requeue
+                    this.amqpChannel.nack(msg, false, false);
+                }
+            }
+        }, consumerOptions);
+        const subscription = new RabbitMQSubscription(subscriptionId, this.name, consumerTag, this.amqpChannel);
+        this.subscriptions.set(subscriptionId, subscription);
+        return subscription;
+    }
+    /**
+     * Send message to dead-letter queue
+     */
+    async sendToDeadLetter(message, deadLetterChannel) {
+        const content = JSON.stringify({
+            payload: message.payload,
+            metadata: {
+                ...message.metadata,
+                originalChannel: this.name,
+            },
+        });
+        this.amqpChannel.sendToQueue(deadLetterChannel, Buffer.from(content), { persistent: true });
+    }
+    /**
+     * Request-response pattern
+     */
+    async request(payload, options) {
+        await this.assert();
+        const correlationId = node_crypto.randomUUID();
+        const timeout = options?.timeout ?? 30000;
+        // Create exclusive reply queue
+        const { queue: replyQueue } = await this.amqpChannel.assertQueue("", {
+            exclusive: true,
+            autoDelete: true,
+        });
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Request timeout after ${timeout}ms`));
+            }, timeout);
+            // Consume reply
+            this.amqpChannel.consume(replyQueue, (msg) => {
+                if (msg?.properties.correlationId === correlationId) {
+                    clearTimeout(timeoutId);
+                    const content = JSON.parse(msg.content.toString());
+                    resolve(content.payload);
+                }
+            }, { noAck: true });
+            // Send request
+            const messageContent = JSON.stringify({
+                payload,
+                metadata: {
+                    messageId: node_crypto.randomUUID(),
+                    timestamp: new Date().toISOString(),
+                    correlationId,
+                },
+            });
+            this.amqpChannel.sendToQueue(this.name, Buffer.from(messageContent), {
+                correlationId,
+                replyTo: replyQueue,
+                expiration: timeout.toString(),
+                ...options,
+            });
+        });
+    }
+    /**
+     * Register response handler for RPC
+     */
+    async respond(handler) {
+        return this.subscribe(async (message, ctx) => {
+            const response = await handler(message, ctx);
+            await ctx.reply(response);
+            await ctx.ack();
+        });
+    }
+    /**
+     * Get queue statistics
+     */
+    async stats() {
+        await this.assert();
+        const queueInfo = await this.amqpChannel.checkQueue(this.name);
+        return {
+            name: this.name,
+            messageCount: queueInfo.messageCount,
+            consumerCount: queueInfo.consumerCount,
+        };
+    }
+    /**
+     * Purge all messages
+     */
+    async purge() {
+        await this.assert();
+        const result = await this.amqpChannel.purgeQueue(this.name);
+        return result.messageCount;
+    }
+    /**
+     * Check if queue exists
+     */
+    async exists() {
+        try {
+            await this.amqpChannel.checkQueue(this.name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Delete the queue
+     */
+    async delete() {
+        // Cancel all subscriptions
+        for (const subscription of this.subscriptions.values()) {
+            await subscription.unsubscribe();
+        }
+        this.subscriptions.clear();
+        try {
+            await this.amqpChannel.deleteQueue(this.name);
+        }
+        catch {
+            // Ignore if queue doesn't exist
+        }
+        this.asserted = false;
+    }
+}
+/**
+ * RabbitMQ Subscription Implementation
+ */
+class RabbitMQSubscription {
+    id;
+    channel;
+    consumerTag;
+    amqpChannel;
+    _isActive = true;
+    constructor(id, channel, consumerTag, amqpChannel) {
+        this.id = id;
+        this.channel = channel;
+        this.consumerTag = consumerTag;
+        this.amqpChannel = amqpChannel;
+    }
+    async unsubscribe() {
+        if (!this._isActive)
+            return;
+        await this.amqpChannel.cancel(this.consumerTag);
+        this._isActive = false;
+    }
+    async pause() {
+        // RabbitMQ doesn't have native pause, cancel consumer
+        await this.amqpChannel.cancel(this.consumerTag);
+    }
+    async resume() {
+        // Would need to re-subscribe - not directly supported
+        throw new Error("Resume is not supported for RabbitMQ. Please create a new subscription.");
+    }
+    isActive() {
+        return this._isActive;
+    }
+}exports.RabbitMQChannel=RabbitMQChannel;//# sourceMappingURL=rabbitmq-channel.js.map