@warlock.js/herald 4.0.174 → 4.1.2

package/esm/communicators/broker.js

@@ -1,105 +0,0 @@
-/**
- * Broker - wrapper around a driver with metadata
- *
- * Similar to DataSource in @warlock.js/cascade
- *
- * @example
- * ```typescript
- * const broker = new Broker({
- *   name: "default",
- *   driver: rabbitMQDriver,
- *   isDefault: true,
- * });
- *
- * // Get a channel
- * const channel = broker.channel("user.created");
- * ```
- */
-class Broker {
-    /** Unique name identifying this broker */
-    name;
-    /** The underlying driver */
-    driver;
-    /** Whether this is the default broker */
-    isDefault;
-    /**
-     * Create a new Broker
-     *
-     * @param options - Broker configuration
-     */
-    constructor(options) {
-        this.name = options.name;
-        this.driver = options.driver;
-        this.isDefault = Boolean(options.isDefault);
-    }
-    /**
-     * Subscribe the given consumer
-     */
-    subscribe(consumer) {
-        return this.driver.subscribe(consumer);
-    }
-    /**
-     * Publish the given event message
-     */
-    publish(event) {
-        this.driver.publish(event);
-    }
-    /**
-     * Get or create a channel
-     *
-     * @param name - Channel name
-     * @param options - Channel options
-     * @returns Channel instance
-     *
-     * @example
-     * ```typescript
-     * // Simple channel
-     * const channel = broker.channel("notifications");
-     *
-     * // Typed channel with schema
-     * const orderChannel = broker.channel<OrderPayload>("orders", {
-     *   schema: OrderSchema,
-     *   durable: true,
-     * });
-     * ```
-     */
-    channel(name, options) {
-        return this.driver.channel(name, options);
-    }
-    /**
-     * Check if the broker is connected
-     */
-    get isConnected() {
-        return this.driver.isConnected;
-    }
-    /**
-     * Connect the underlying driver
-     */
-    async connect() {
-        await this.driver.connect();
-    }
-    /**
-     * Disconnect the underlying driver
-     */
-    async disconnect() {
-        await this.driver.disconnect();
-    }
-    /**
-     * Start consuming messages
-     */
-    async startConsuming() {
-        await this.driver.startConsuming();
-    }
-    /**
-     * Stop consuming messages
-     */
-    async stopConsuming() {
-        await this.driver.stopConsuming();
-    }
-    /**
-     * Health check
-     */
-    async healthCheck() {
-        return this.driver.healthCheck();
-    }
-}export{Broker};//# sourceMappingURL=broker.js.map

package/esm/communicators/broker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"broker.js","sources":["../../src/communicators/broker.ts"],"sourcesContent":[null],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;AAgBG;MACU,MAAM,CAAA;;AAED,IAAA,IAAI,CAAS;;AAGb,IAAA,MAAM,CAAuB;;AAG7B,IAAA,SAAS,CAAU;AAEnC;;;;AAIG;AACH,IAAA,WAAA,CAAmB,OAAsB,EAAA;AACvC,QAAA,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;AACzB,QAAA,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;KAC7C;AAED;;AAEG;AACI,IAAA,SAAS,CAAC,QAAiC,EAAA;QAChD,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;KACxC;AAED;;AAEG;AACI,IAAA,OAAO,CAAiC,KAA6B,EAAA;AAC1E,QAAA,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;KAC5B;AAED;;;;;;;;;;;;;;;;;;AAkBG;IACI,OAAO,CACZ,IAAY,EACZ,OAAkC,EAAA;QAElC,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAW,IAAI,EAAE,OAAO,CAAC,CAAC;KACrD;AAED;;AAEG;AACH,IAAA,IAAW,WAAW,GAAA;AACpB,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;KAChC;AAED;;AAEG;AACI,IAAA,MAAM,OAAO,GAAA;AAClB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;KAC7B;AAED;;AAEG;AACI,IAAA,MAAM,UAAU,GAAA;AACrB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;KAChC;AAED;;AAEG;AACI,IAAA,MAAM,cAAc,GAAA;AACzB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;KACpC;AAED;;AAEG;AACI,IAAA,MAAM,aAAa,GAAA;AACxB,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;KACnC;AAED;;AAEG;AACI,IAAA,MAAM,WAAW,GAAA;AACtB,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;KAClC;AACF"}

package/esm/communicators/index.d.ts

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

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

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

package/esm/contracts/broker-driver.contract.d.ts

@@ -1,196 +0,0 @@
-import { type EventMessage } from "../message-managers/event-message";
-import { EventConsumerClass } from "../message-managers/types";
-import type { BrokerDriverType, BrokerEvent, BrokerEventListener, ChannelOptions, HealthCheckResult } from "../types";
-import type { ChannelContract } from "./channel.contract";
-/**
- * Broker 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 BrokerDriverContract {
- *   readonly name = "rabbitmq";
- *   // ...
- * }
- * ```
- */
-export interface BrokerDriverContract {
-    /**
-     * Driver name identifier
-     *
-     * @example "rabbitmq", "kafka", "redis-streams"
-     */
-    readonly name: BrokerDriverType;
-    /**
-     * 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: BrokerEvent, listener: BrokerEventListener): void;
-    /**
-     * Remove an event listener
-     *
-     * @param event - Event name
-     * @param listener - Callback to remove
-     */
-    off(event: BrokerEvent, listener: BrokerEventListener): void;
-    /**
-     * Subscribe the given consumer class to the driver
-     *
-     * @param consumer - Consumer class to subscribe
-     * @returns Unsubscribe function
-     * @example
-     * ```typescript
-     * driver.subscribe(UserUpdatedConsumer);
-     * ```
-     */
-    subscribe(consumer: EventConsumerClass): () => void;
-    /**
-     * Unsubscribe the given consumer class from the driver
-     *
-     * @param consumer - Consumer class to unsubscribe
-     *
-     * @example
-     * ```typescript
-     * driver.unsubscribe(UserUpdatedConsumer);
-     * ```
-     */
-    unsubscribe(consumer: EventConsumerClass): void;
-    /**
-     * Publish the given event message
-     */
-    publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>): 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=broker-driver.contract.d.ts.map

package/esm/contracts/broker-driver.contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"broker-driver.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/broker-driver.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEhC;;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,WAAW,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAE5D;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAE7D;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI,CAAC;IAEpD;;;;;;;;;OASG;IACH,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAEhD;;OAEG;IACH,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IAE7E;;;;;;;;;;;;;;;;;;;;;;;;;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/esm/contracts/channel.contract.d.ts

@@ -1,191 +0,0 @@
-import type { ChannelOptions, ChannelStats, MessageHandler, PublishOptions, RequestOptions, ResponseHandler, SubscribeOptions, Subscription } from "../types";
-/**
- * Channel contract - represents a queue (RabbitMQ) or topic (Kafka)
- *
- * Provides a unified pub/sub interface across different message brokers.
- *
- * @template TPayload - The typed payload for messages on this channel
- *
- * @example
- * ```typescript
- * // Get a typed channel
- * const userChannel = herald().channel<UserPayload>("user.created");
- *
- * // Publish
- * await userChannel.publish({ userId: 1, email: "test@example.com" });
- *
- * // Subscribe
- * userChannel.subscribe(async (message, ctx) => {
- *   console.log(message.payload.userId);
- *   await ctx.ack();
- * });
- * ```
- */
-export interface ChannelContract<TPayload = unknown> {
-    /**
-     * Channel name/routing key
-     */
-    readonly name: string;
-    /**
-     * Channel options
-     */
-    readonly options: ChannelOptions<TPayload>;
-    /**
-     * Publish a message to this channel
-     *
-     * @param payload - The message payload
-     * @param options - Optional publish options
-     *
-     * @example
-     * ```typescript
-     * await channel.publish({ orderId: 123 });
-     *
-     * // With options
-     * await channel.publish({ orderId: 123 }, {
-     *   priority: 5,
-     *   persistent: true,
-     *   correlationId: "req-123",
-     * });
-     * ```
-     */
-    publish(payload: TPayload, options?: PublishOptions): Promise<void>;
-    /**
-     * Publish multiple messages in a batch
-     *
-     * More efficient than publishing one by one.
-     *
-     * @param messages - Array of payloads to publish
-     * @param options - Optional publish options (applied to all messages)
-     *
-     * @example
-     * ```typescript
-     * await channel.publishBatch([
-     *   { event: "page_view", page: "/home" },
-     *   { event: "page_view", page: "/products" },
-     * ]);
-     * ```
-     */
-    publishBatch(messages: TPayload[], options?: PublishOptions): Promise<void>;
-    /**
-     * Subscribe to messages on this channel
-     *
-     * @param handler - Function to handle incoming messages
-     * @param options - Optional subscribe options
-     * @returns Subscription object for managing the subscription
-     *
-     * @example
-     * ```typescript
-     * const subscription = await channel.subscribe(
-     *   async (message, ctx) => {
-     *     await processOrder(message.payload);
-     *     await ctx.ack();
-     *   },
-     *   {
-     *     prefetch: 10,
-     *     retry: { maxRetries: 3, delay: 1000 },
-     *   }
-     * );
-     *
-     * // Later: unsubscribe
-     * await subscription.unsubscribe();
-     * ```
-     */
-    subscribe(handler: MessageHandler<TPayload>, options?: SubscribeOptions): Promise<Subscription>;
-    /**
-     * Unsubscribe a consumer by its ID
-     *
-     * @param consumerId - The consumer ID to unsubscribe
-     *
-     * @example
-     * ```typescript
-     * await channel.unsubscribeById("consumer-uuid");
-     * ```
-     */
-    unsubscribeById(consumerId: string): Promise<void>;
-    /**
-     * Request-Response pattern (RPC)
-     *
-     * Publishes a message and waits for a response.
-     *
-     * @param payload - The request payload
-     * @param options - Request options including timeout
-     * @returns Promise resolving to the response
-     *
-     * @example
-     * ```typescript
-     * const result = await channel.request<ProcessResult>(
-     *   { imageUrl: "https://..." },
-     *   { timeout: 30000 }
-     * );
-     * console.log(result.processedUrl);
-     * ```
-     */
-    request<TResponse = unknown>(payload: TPayload, options?: RequestOptions): Promise<TResponse>;
-    /**
-     * Register a response handler for RPC pattern
-     *
-     * The return value of the handler becomes the response.
-     *
-     * @param handler - Function to handle requests and return responses
-     * @returns Subscription for managing the responder
-     *
-     * @example
-     * ```typescript
-     * channel.respond(async (message, ctx) => {
-     *   const result = await processImage(message.payload);
-     *   return { processedUrl: result.url };
-     * });
-     * ```
-     */
-    respond<TResponse = unknown>(handler: ResponseHandler<TPayload, TResponse>): Promise<Subscription>;
-    /**
-     * Get channel statistics
-     *
-     * @returns Channel stats including message count and consumer count
-     *
-     * @example
-     * ```typescript
-     * const stats = await channel.stats();
-     * console.log(`Messages: ${stats.messageCount}, Consumers: ${stats.consumerCount}`);
-     * ```
-     */
-    stats(): Promise<ChannelStats>;
-    /**
-     * Purge all messages from the channel
-     *
-     * Use with caution - this deletes all pending messages.
-     *
-     * @returns Number of messages purged
-     *
-     * @example
-     * ```typescript
-     * const purgedCount = await channel.purge();
-     * console.log(`Purged ${purgedCount} messages`);
-     * ```
-     */
-    purge(): Promise<number>;
-    /**
-     * Check if the channel exists
-     *
-     * @returns True if the channel exists on the broker
-     */
-    exists(): Promise<boolean>;
-    /**
-     * Delete the channel
-     *
-     * Use with caution - this removes the queue/topic entirely.
-     */
-    delete(): Promise<void>;
-    /**
-     * Assert/create the channel with its options
-     *
-     * Creates the channel if it doesn't exist, or verifies options match.
-     */
-    assert(): Promise<void>;
-    /**
-     * Stop consuming messages on this channel.
-     * Cancels all active subscriptions gracefully.
-     */
-    stopConsuming(): Promise<void>;
-}
-//# sourceMappingURL=channel.contract.d.ts.map

package/esm/contracts/channel.contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/channel.contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,YAAY,EACb,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,eAAe,CAAC,QAAQ,GAAG,OAAO;IACjD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SAAS,CAAC,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAEhG;;;;;;;;;OASG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAE9F;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,SAAS,GAAG,OAAO,EACzB,OAAO,EAAE,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,GAC5C,OAAO,CAAC,YAAY,CAAC,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAE/B;;;;;;;;;;;;OAYG;IACH,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3B;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;OAGG;IACH,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAChC"}

package/esm/contracts/index.d.ts

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

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

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

package/esm/decorators/consumable.d.ts

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

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

@@ -1 +0,0 @@
-{"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,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,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

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

package/esm/decorators/consumable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"consumable.js","sources":["../../src/decorators/consumable.ts"],"sourcesContent":[null],"names":[],"mappings":"iEAOa,MAAA,kBAAkB,GAAG,IAAI,GAAG,GAGpC;AAEL;;AAEG;AACG,SAAU,UAAU,CAAC,OAA2B,EAAA;AACpD,IAAA,OAAO,UAAU,MAA0B,EAAA;AACzC,QAAA,MAAM,UAAU,GAAG,OAAO,EAAE,MAAM,CAAC;QAEnC,IAAI;YACF,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;;YAGrD,IAAI,aAAa,EAAE,WAAW,EAAE;AAC9B,gBAAA,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AACjC,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,cAAc,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,MAAM,KAAI;IACxC,KAAK,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,kBAAkB,EAAE;QACtD,IAAI,OAAO,EAAE,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC,MAAM,EAAE;YACrD,SAAS;AACV,SAAA;AAED,QAAA,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;AAC5B,KAAA;AACH,CAAC,CAAC"}

package/esm/decorators/index.d.ts

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

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

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

package/esm/drivers/index.d.ts

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

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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,79 +0,0 @@
-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 messages on this channel.
-     * Cancels all active subscriptions gracefully.
-     */
-    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