@warlock.js/herald 4.0.174 → 4.1.1

package/esm/communicators/broker.mjs

@@ -0,0 +1,104 @@
+//#region ../../@warlock.js/herald/src/communicators/broker.ts
+/**
+* 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");
+* ```
+*/
+var Broker = class {
+	/**
+	* 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();
+	}
+};
+
+//#endregion
+export { Broker };
+//# sourceMappingURL=broker.mjs.map

package/esm/communicators/broker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"broker.mjs","names":[],"sources":["../../../../../../@warlock.js/herald/src/communicators/broker.ts"],"sourcesContent":["import type { BrokerDriverContract } from \"../contracts\";\r\nimport type { ChannelContract } from \"../contracts/channel.contract\";\r\nimport { EventMessage } from \"../message-managers/event-message\";\r\nimport { EventConsumerClass } from \"../message-managers/types\";\r\nimport type { ChannelOptions } from \"../types\";\r\n\r\n/**\r\n * Options for creating a Broker\r\n */\r\nexport interface BrokerOptions {\r\n  /** Unique name for this broker */\r\n  name: string;\r\n  /** The underlying driver */\r\n  driver: BrokerDriverContract;\r\n  /** Whether this is the default broker */\r\n  isDefault?: boolean;\r\n}\r\n\r\n/**\r\n * Broker - wrapper around a driver with metadata\r\n *\r\n * Similar to DataSource in @warlock.js/cascade\r\n *\r\n * @example\r\n * ```typescript\r\n * const broker = new Broker({\r\n *   name: \"default\",\r\n *   driver: rabbitMQDriver,\r\n *   isDefault: true,\r\n * });\r\n *\r\n * // Get a channel\r\n * const channel = broker.channel(\"user.created\");\r\n * ```\r\n */\r\nexport class Broker {\r\n  /** Unique name identifying this broker */\r\n  public readonly name: string;\r\n\r\n  /** The underlying driver */\r\n  public readonly driver: BrokerDriverContract;\r\n\r\n  /** Whether this is the default broker */\r\n  public readonly isDefault: boolean;\r\n\r\n  /**\r\n   * Create a new Broker\r\n   *\r\n   * @param options - Broker configuration\r\n   */\r\n  public constructor(options: BrokerOptions) {\r\n    this.name = options.name;\r\n    this.driver = options.driver;\r\n    this.isDefault = Boolean(options.isDefault);\r\n  }\r\n\r\n  /**\r\n   * Subscribe the given consumer\r\n   */\r\n  public subscribe(consumer: EventConsumerClass<any>) {\r\n    return this.driver.subscribe(consumer);\r\n  }\r\n\r\n  /**\r\n   * Publish the given event message\r\n   */\r\n  public publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>) {\r\n    this.driver.publish(event);\r\n  }\r\n\r\n  /**\r\n   * Get or create a channel\r\n   *\r\n   * @param name - Channel name\r\n   * @param options - Channel options\r\n   * @returns Channel instance\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Simple channel\r\n   * const channel = broker.channel(\"notifications\");\r\n   *\r\n   * // Typed channel with schema\r\n   * const orderChannel = broker.channel<OrderPayload>(\"orders\", {\r\n   *   schema: OrderSchema,\r\n   *   durable: true,\r\n   * });\r\n   * ```\r\n   */\r\n  public channel<TPayload = unknown>(\r\n    name: string,\r\n    options?: ChannelOptions<TPayload>,\r\n  ): ChannelContract<TPayload> {\r\n    return this.driver.channel<TPayload>(name, options);\r\n  }\r\n\r\n  /**\r\n   * Check if the broker is connected\r\n   */\r\n  public get isConnected(): boolean {\r\n    return this.driver.isConnected;\r\n  }\r\n\r\n  /**\r\n   * Connect the underlying driver\r\n   */\r\n  public async connect(): Promise<void> {\r\n    await this.driver.connect();\r\n  }\r\n\r\n  /**\r\n   * Disconnect the underlying driver\r\n   */\r\n  public async disconnect(): Promise<void> {\r\n    await this.driver.disconnect();\r\n  }\r\n\r\n  /**\r\n   * Start consuming messages\r\n   */\r\n  public async startConsuming(): Promise<void> {\r\n    await this.driver.startConsuming();\r\n  }\r\n\r\n  /**\r\n   * Stop consuming messages\r\n   */\r\n  public async stopConsuming(): Promise<void> {\r\n    await this.driver.stopConsuming();\r\n  }\r\n\r\n  /**\r\n   * Health check\r\n   */\r\n  public async healthCheck() {\r\n    return this.driver.healthCheck();\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,IAAa,SAAb,MAAoB;;;;;;CAelB,AAAO,YAAY,SAAwB;EACzC,KAAK,OAAO,QAAQ;EACpB,KAAK,SAAS,QAAQ;EACtB,KAAK,YAAY,QAAQ,QAAQ,SAAS;CAC5C;;;;CAKA,AAAO,UAAU,UAAmC;EAClD,OAAO,KAAK,OAAO,UAAU,QAAQ;CACvC;;;;CAKA,AAAO,QAAwC,OAA+B;EAC5E,KAAK,OAAO,QAAQ,KAAK;CAC3B;;;;;;;;;;;;;;;;;;;;CAqBA,AAAO,QACL,MACA,SAC2B;EAC3B,OAAO,KAAK,OAAO,QAAkB,MAAM,OAAO;CACpD;;;;CAKA,IAAW,cAAuB;EAChC,OAAO,KAAK,OAAO;CACrB;;;;CAKA,MAAa,UAAyB;EACpC,MAAM,KAAK,OAAO,QAAQ;CAC5B;;;;CAKA,MAAa,aAA4B;EACvC,MAAM,KAAK,OAAO,WAAW;CAC/B;;;;CAKA,MAAa,iBAAgC;EAC3C,MAAM,KAAK,OAAO,eAAe;CACnC;;;;CAKA,MAAa,gBAA+B;EAC1C,MAAM,KAAK,OAAO,cAAc;CAClC;;;;CAKA,MAAa,cAAc;EACzB,OAAO,KAAK,OAAO,YAAY;CACjC;AACF"}

package/esm/communicators/index.d.mts

@@ -0,0 +1,2 @@
+import { Broker, BrokerOptions } from "./broker.mjs";
+import { MissingBrokerError, brokerRegistry } from "./broker-registry.mjs";

package/esm/communicators/index.mjs

@@ -0,0 +1,4 @@
+import { Broker } from "./broker.mjs";
+import { MissingBrokerError, brokerRegistry } from "./broker-registry.mjs";
+
+export {  };

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

@@ -0,0 +1,200 @@
+import { ChannelOptions } from "../types/channel.types.mjs";
+import { BrokerDriverType, BrokerEvent, BrokerEventListener, HealthCheckResult } from "../types/driver.types.mjs";
+import { ChannelContract } from "./channel.contract.mjs";
+import { EventMessage } from "../message-managers/event-message.mjs";
+import { EventConsumerClass } from "../message-managers/types.mjs";
+//#region ../../@warlock.js/herald/src/contracts/broker-driver.contract.d.ts
+/**
+ * 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";
+ *   // ...
+ * }
+ * ```
+ */
+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>;
+}
+//#endregion
+export { BrokerDriverContract };
+//# sourceMappingURL=broker-driver.contract.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"broker-driver.contract.d.mts","names":[],"sources":["../../../../../../@warlock.js/herald/src/contracts/broker-driver.contract.ts"],"mappings":";;;;;;;;;;AA0BA;;;;;;;;;;;UAAiB,oBAAA;EAoGI;;;;;EAAA,SA9FV,IAAA,EAAM,gBAAA;EA6HZ;;;EAAA,SAxHM,WAAA;EAsKM;;;;;;;;;;;EAzJf,OAAA,IAAW,OAAA;EAuCD;;;;;;;;;;EA3BV,UAAA,IAAc,OAAA;EA+CJ;;;;;;;;;;;;;;;;;;;;;;;;;EApBV,EAAA,CAAG,KAAA,EAAO,WAAA,EAAa,QAAA,EAAU,mBAAA;EAgIjC;;;;AAAmC;;EAxHnC,GAAA,CAAI,KAAA,EAAO,WAAA,EAAa,QAAA,EAAU,mBAAA;;;;;;;;;;;EAYlC,SAAA,CAAU,QAAA,EAAU,kBAAA;;;;;;;;;;;EAYpB,WAAA,CAAY,QAAA,EAAU,kBAAA;;;;EAKtB,OAAA,YAAmB,MAAA,eAAqB,KAAA,EAAO,YAAA,CAAa,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B5D,OAAA,qBACE,IAAA,UACA,OAAA,GAAU,cAAA,CAAe,QAAA,IACxB,eAAA,CAAgB,QAAA;;;;;;;;;;;;;;;;EAiBnB,cAAA,IAAkB,OAAA;;;;;;;;;;;EAYlB,aAAA,IAAiB,OAAA;;;;;;;;;;;;;;;;EAiBjB,WAAA,IAAe,OAAA,CAAQ,iBAAA;;;;;;EAOvB,eAAA;;;;;;EAOA,YAAA,CAAa,IAAA,WAAe,OAAA;AAAA"}

package/esm/contracts/channel.contract.d.mts

@@ -0,0 +1,197 @@
+import { SubscribeOptions } from "../types/subscribe.types.mjs";
+import { ChannelOptions, ChannelStats } from "../types/channel.types.mjs";
+import { MessageHandler, ResponseHandler, Subscription } from "../types/message.types.mjs";
+import { PublishOptions, RequestOptions } from "../types/publish.types.mjs";
+//#region ../../@warlock.js/herald/src/contracts/channel.contract.d.ts
+/**
+ * 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();
+ * });
+ * ```
+ */
+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>;
+}
+//#endregion
+export { ChannelContract };
+//# sourceMappingURL=channel.contract.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"channel.contract.d.mts","names":[],"sources":["../../../../../../@warlock.js/herald/src/contracts/channel.contract.ts"],"mappings":";;;;;;;;;;;AAiCA;;;;;;;;;;;;;;;;UAAiB,eAAA;EAyGuB;;;EAAA,SArG7B,IAAA;EAwHkB;;;EAAA,SAnHlB,OAAA,EAAS,cAAA,CAAe,QAAA;EAoH9B;;;;;;;;;;;;;;;;;;EAhGH,OAAA,CAAQ,OAAA,EAAS,QAAA,EAAU,OAAA,GAAU,cAAA,GAAiB,OAAA;EAA3B;;;;;;;;;;;;;;;;EAkB3B,YAAA,CAAa,QAAA,EAAU,QAAA,IAAY,OAAA,GAAU,cAAA,GAAiB,OAAA;EAsC9C;;;;;;;;;;;;;;;;;;;;;;;;EAZhB,SAAA,CAAU,OAAA,EAAS,cAAA,CAAe,QAAA,GAAW,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,YAAA;EA8FlF;;;;;;;AAawB;;;EA/FxB,eAAA,CAAgB,UAAA,WAAqB,OAAA;;;;;;;;;;;;;;;;;;;EAoBrC,OAAA,sBAA6B,OAAA,EAAS,QAAA,EAAU,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,SAAA;;;;;;;;;;;;;;;;;EAkBnF,OAAA,sBACE,OAAA,EAAS,eAAA,CAAgB,QAAA,EAAU,SAAA,IAClC,OAAA,CAAQ,YAAA;;;;;;;;;;;;EAaX,KAAA,IAAS,OAAA,CAAQ,YAAA;;;;;;;;;;;;;;EAejB,KAAA,IAAS,OAAA;;;;;;EAOT,MAAA,IAAU,OAAA;;;;;;EAOV,MAAA,IAAU,OAAA;;;;;;EAOV,MAAA,IAAU,OAAA;;;;;EAMV,aAAA,IAAiB,OAAA;AAAA"}

package/esm/contracts/index.d.mts

@@ -0,0 +1,2 @@
+import { ChannelContract } from "./channel.contract.mjs";
+import { BrokerDriverContract } from "./broker-driver.contract.mjs";

package/esm/decorators/consumable.d.mts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"consumable.d.mts","names":[],"sources":["../../../../../../@warlock.js/herald/src/decorators/consumable.ts"],"mappings":";;;KAGY,iBAAA;EACV,MAAM;AAAA;AAAA,cAGK,kBAAA,EAAkB,GAAA;YACnB,kBAAA;YACA,iBAAA;AAAA;AAFZ;;;AAAA,iBAQgB,UAAA,CAAW,OAAA,GAAU,iBAAA,IAClB,MAAA,EAAQ,kBAAkB"}

package/esm/decorators/consumable.mjs

@@ -0,0 +1,36 @@
+import { brokerRegistry } from "../communicators/broker-registry.mjs";
+import "../communicators/index.mjs";
+
+//#region ../../@warlock.js/herald/src/decorators/consumable.ts
+const pendingSubscribers = /* @__PURE__ */ 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 (currentBroker?.isConnected) currentBroker.subscribe(target);
+			else pendingSubscribers.add({
+				Consumer: target,
+				options
+			});
+		} catch {
+			pendingSubscribers.add({
+				Consumer: target,
+				options
+			});
+		}
+	};
+}
+brokerRegistry.on("connected", (broker) => {
+	for (const { Consumer, options } of pendingSubscribers) {
+		if (options?.broker && broker.name !== options.broker) continue;
+		broker.subscribe(Consumer);
+	}
+});
+
+//#endregion
+export { Consumable, pendingSubscribers };
+//# sourceMappingURL=consumable.mjs.map

package/esm/decorators/consumable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumable.mjs","names":[],"sources":["../../../../../../@warlock.js/herald/src/decorators/consumable.ts"],"sourcesContent":["import { brokerRegistry } from \"../communicators\";\nimport { type EventConsumerClass } from \"../message-managers/types\";\n\nexport type ConsumableOptions = {\n  broker?: string;\n};\n\nexport const pendingSubscribers = new Set<{\n  Consumer: EventConsumerClass;\n  options?: ConsumableOptions;\n}>();\n\n/**\n * Register the consumer to the broker\n */\nexport function Consumable(options?: ConsumableOptions) {\n  return function (target: EventConsumerClass) {\n    const brokerName = options?.broker;\n\n    try {\n      const currentBroker = brokerRegistry.get(brokerName);\n\n      // if broker is connected, subscribe the consumer\n      if (currentBroker?.isConnected) {\n        currentBroker.subscribe(target);\n      } else {\n        pendingSubscribers.add({ Consumer: target, options });\n      }\n    } catch {\n      // mostly it will be an error that broker is not registered yet\n      // then add it to the pending subscribers\n      pendingSubscribers.add({ Consumer: target, options });\n    }\n  };\n}\n\n// Register pending consumers on broker's connection is done\nbrokerRegistry.on(\"connected\", (broker) => {\n  for (const { Consumer, options } of pendingSubscribers) {\n    if (options?.broker && broker.name !== options.broker) {\n      continue;\n    }\n\n    broker.subscribe(Consumer);\n  }\n});\n"],"mappings":";;;;AAOA,MAAa,qCAAqB,IAAI,IAGnC;;;;AAKH,SAAgB,WAAW,SAA6B;CACtD,OAAO,SAAU,QAA4B;EAC3C,MAAM,aAAa,SAAS;EAE5B,IAAI;GACF,MAAM,gBAAgB,eAAe,IAAI,UAAU;GAGnD,IAAI,eAAe,aACjB,cAAc,UAAU,MAAM;QAE9B,mBAAmB,IAAI;IAAE,UAAU;IAAQ;GAAQ,CAAC;EAExD,QAAQ;GAGN,mBAAmB,IAAI;IAAE,UAAU;IAAQ;GAAQ,CAAC;EACtD;CACF;AACF;AAGA,eAAe,GAAG,cAAc,WAAW;CACzC,KAAK,MAAM,EAAE,UAAU,aAAa,oBAAoB;EACtD,IAAI,SAAS,UAAU,OAAO,SAAS,QAAQ,QAC7C;EAGF,OAAO,UAAU,QAAQ;CAC3B;AACF,CAAC"}

package/esm/decorators/index.d.mts

@@ -0,0 +1 @@
+import { Consumable, ConsumableOptions, pendingSubscribers } from "./consumable.mjs";

package/esm/decorators/index.mjs

@@ -0,0 +1,3 @@
+import { Consumable, pendingSubscribers } from "./consumable.mjs";
+
+export {  };

package/esm/drivers/index.d.mts

@@ -0,0 +1,2 @@
+import { RabbitMQDriver } from "./rabbitmq/rabbitmq-driver.mjs";
+import { RabbitMQChannel } from "./rabbitmq/rabbitmq-channel.mjs";

package/esm/drivers/index.mjs

@@ -0,0 +1,5 @@
+import { RabbitMQChannel } from "./rabbitmq/rabbitmq-channel.mjs";
+import { RabbitMQDriver } from "./rabbitmq/rabbitmq-driver.mjs";
+import "./rabbitmq/index.mjs";
+
+export {  };

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

@@ -0,0 +1,2 @@
+import { RabbitMQDriver } from "./rabbitmq-driver.mjs";
+import { RabbitMQChannel } from "./rabbitmq-channel.mjs";

package/esm/drivers/rabbitmq/index.mjs

@@ -0,0 +1,4 @@
+import { RabbitMQChannel } from "./rabbitmq-channel.mjs";
+import { RabbitMQDriver } from "./rabbitmq-driver.mjs";
+
+export {  };