@warlock.js/herald 4.0.174 → 4.1.2

package/esm/drivers/rabbitmq/rabbitmq-driver.mjs

@@ -0,0 +1,291 @@
+import { prepareConsumerSubscription } from "../../message-managers/prepare-consumer-subscription.mjs";
+import { RabbitMQChannel } from "./rabbitmq-channel.mjs";
+import { EventEmitter } from "node:events";
+
+//#region ../../@warlock.js/herald/src/drivers/rabbitmq/rabbitmq-driver.ts
+/**
+* Cached amqplib module (loaded once, reused)
+*/
+let amqplibModule;
+/**
+* Module availability flag
+*/
+let isModuleExists = null;
+/**
+* Installation instructions for amqplib
+*/
+const AMQPLIB_INSTALL_INSTRUCTIONS = `
+RabbitMQ driver requires the amqplib package.
+Install it with:
+
+  npx warlock add herald --driver=rabbitmq
+
+Or manually:
+
+  npm install amqplib
+  pnpm add amqplib
+  yarn add amqplib
+`.trim();
+/**
+* Load amqplib module
+*/
+async function loadAmqplibModule() {
+	try {
+		amqplibModule = await import("amqplib");
+		isModuleExists = true;
+	} catch {
+		isModuleExists = false;
+	}
+}
+loadAmqplibModule();
+/**
+* RabbitMQ Driver
+*
+* Implementation of BrokerDriverContract for RabbitMQ/AMQP.
+*
+* **Important:** This driver requires the `amqplib` package to be installed.
+* Install it with: `npx warlock add herald --driver=rabbitmq` or `npm install amqplib`
+*
+* @example
+* ```typescript
+* const driver = new RabbitMQDriver({
+*   driver: "rabbitmq",
+*   host: "localhost",
+*   port: 5672,
+*   username: "guest",
+*   password: "guest",
+* });
+*
+* await driver.connect();
+* const channel = driver.channel("user.created");
+* ```
+*/
+var RabbitMQDriver = class {
+	/**
+	* Create a new RabbitMQ driver
+	*
+	* @param options - RabbitMQ connection options
+	*/
+	constructor(options) {
+		this.name = "rabbitmq";
+		this.consumers = [];
+		this.events = new EventEmitter();
+		this.channels = /* @__PURE__ */ new Map();
+		this.connection = null;
+		this.amqpChannel = null;
+		this._isConnected = false;
+		this.options = options;
+	}
+	/**
+	* Whether connected to RabbitMQ
+	*/
+	get isConnected() {
+		return this._isConnected;
+	}
+	/**
+	* Subscribe the given consumer class to the driver
+	*
+	* @param consumer - Consumer class to subscribe
+	*
+	* @example
+	* ```typescript
+	* driver.subscribe(UserUpdatedConsumer);
+	* ```
+	*/
+	subscribe(Consumer) {
+		if (this.isConnected) this.channel(Consumer.eventName).subscribe(prepareConsumerSubscription(Consumer, (error, eventName) => {
+			this.events.emit("error", error, eventName);
+		}), { consumerId: Consumer.consumerId });
+		else this.consumers.push(Consumer);
+		return () => {
+			this.unsubscribe(Consumer);
+		};
+	}
+	/**
+	* Unsubscribe the given consumer
+	*/
+	unsubscribe(Consumer) {
+		if (this.isConnected) this.channel(Consumer.eventName).unsubscribeById(Consumer.consumerId);
+		const index = this.consumers.indexOf(Consumer);
+		if (index > -1) this.consumers.splice(index, 1);
+	}
+	/**
+	* Publish the given event message.
+	* Auto-creates the channel if it hasn't been accessed before.
+	*/
+	publish(event) {
+		this.channel(event.eventName).publish(event.serialize());
+	}
+	/**
+	* Connect to RabbitMQ
+	*/
+	async connect() {
+		if (isModuleExists === false) throw new Error(`amqplib is not installed.\n\n${AMQPLIB_INSTALL_INSTRUCTIONS}`);
+		if (isModuleExists === null) {
+			await loadAmqplibModule();
+			if (!isModuleExists) throw new Error(`amqplib is not installed.\n\n${AMQPLIB_INSTALL_INSTRUCTIONS}`);
+		}
+		try {
+			const url = this.buildConnectionUrl();
+			const connectOptions = {
+				heartbeat: this.options.heartbeat ?? 60,
+				timeout: this.options.connectionTimeout,
+				...this.options.clientOptions
+			};
+			this.connection = await amqplibModule.connect(url, connectOptions);
+			this.amqpChannel = await this.connection.createChannel();
+			if (this.options.prefetch) await this.amqpChannel.prefetch(this.options.prefetch);
+			this._isConnected = true;
+			this.events.emit("connected");
+			for (const consumer of this.consumers) this.subscribe(consumer);
+			this.consumers.length = 0;
+			this.connection.on("close", () => {
+				this._isConnected = false;
+				this.events.emit("disconnected");
+				if (this.options.reconnect !== false) this.handleReconnect();
+			});
+			this.connection.on("error", (error) => {
+				this.events.emit("error", error);
+			});
+		} catch (error) {
+			this._isConnected = false;
+			throw new Error(`Failed to connect to RabbitMQ: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Build connection URL from options
+	*/
+	buildConnectionUrl() {
+		if (this.options.uri) return this.options.uri;
+		const protocol = "amqp";
+		const host = this.options.host ?? "localhost";
+		const port = this.options.port ?? 5672;
+		const vhost = this.options.vhost ?? "/";
+		return `${protocol}://${this.options.username ?? "guest"}:${this.options.password ?? "guest"}@${host}:${port}/${encodeURIComponent(vhost)}`;
+	}
+	/**
+	* Handle reconnection
+	*/
+	async handleReconnect() {
+		const delay = this.options.reconnectDelay ?? 5e3;
+		let attempt = 0;
+		const tryReconnect = async () => {
+			attempt++;
+			this.events.emit("reconnecting", attempt);
+			try {
+				await this.connect();
+			} catch {
+				setTimeout(tryReconnect, delay);
+			}
+		};
+		setTimeout(tryReconnect, delay);
+	}
+	/**
+	* Disconnect from RabbitMQ
+	*/
+	async disconnect() {
+		if (this.amqpChannel) {
+			try {
+				await this.amqpChannel.close();
+			} catch {}
+			this.amqpChannel = null;
+		}
+		if (this.connection) {
+			try {
+				await this.connection.close();
+			} catch {}
+			this.connection = null;
+		}
+		this._isConnected = false;
+		this.events.emit("disconnected");
+	}
+	/**
+	* Register event listener
+	*/
+	on(event, listener) {
+		this.events.on(event, listener);
+	}
+	/**
+	* Remove event listener
+	*/
+	off(event, listener) {
+		this.events.off(event, listener);
+	}
+	/**
+	* Get or create a channel
+	*/
+	channel(name, options) {
+		const existing = this.channels.get(name);
+		if (existing) return existing;
+		const channel = new RabbitMQChannel(name, this.amqpChannel, options);
+		this.channels.set(name, channel);
+		return channel;
+	}
+	/**
+	* Start consuming messages
+	*/
+	async startConsuming() {}
+	/**
+	* Stop consuming messages from all subscribed channels.
+	* Gracefully cancels all active consumers.
+	*/
+	async stopConsuming() {
+		const stops = Array.from(this.channels.values()).map((channel) => channel.stopConsuming());
+		await Promise.all(stops);
+	}
+	/**
+	* Health check
+	*/
+	async healthCheck() {
+		if (!this._isConnected || !this.connection) return {
+			healthy: false,
+			error: "Not connected to RabbitMQ"
+		};
+		const start = Date.now();
+		try {
+			await this.amqpChannel.checkQueue("amq.rabbitmq.reply-to").catch(() => {});
+			return {
+				healthy: true,
+				latency: Date.now() - start
+			};
+		} catch (error) {
+			return {
+				healthy: false,
+				error: error instanceof Error ? error.message : String(error),
+				latency: Date.now() - start
+			};
+		}
+	}
+	/**
+	* Get all channel names
+	*/
+	getChannelNames() {
+		return Array.from(this.channels.keys());
+	}
+	/**
+	* Close a specific channel
+	*/
+	async closeChannel(name) {
+		const channel = this.channels.get(name);
+		if (channel) {
+			await channel.delete();
+			this.channels.delete(name);
+		}
+	}
+	/**
+	* Get the raw AMQP channel (for advanced use)
+	*/
+	getRawChannel() {
+		return this.amqpChannel;
+	}
+	/**
+	* Get the raw connection (for advanced use)
+	*/
+	getRawConnection() {
+		return this.connection;
+	}
+};
+
+//#endregion
+export { RabbitMQDriver };
+//# sourceMappingURL=rabbitmq-driver.mjs.map

package/esm/drivers/rabbitmq/rabbitmq-driver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmq-driver.mjs","names":[],"sources":["../../../../../../../@warlock.js/herald/src/drivers/rabbitmq/rabbitmq-driver.ts"],"sourcesContent":["import { EventEmitter } from \"node:events\";\r\nimport type { BrokerDriverContract, ChannelContract } from \"../../contracts\";\r\nimport { EventMessage } from \"../../message-managers/event-message\";\r\nimport { EventConsumerClass } from \"../../message-managers/types\";\r\nimport type {\r\n  BrokerDriverType,\r\n  BrokerEvent,\r\n  BrokerEventListener,\r\n  ChannelOptions,\r\n  HealthCheckResult,\r\n  RabbitMQConnectionOptions,\r\n} from \"../../types\";\r\nimport { prepareConsumerSubscription } from \"./../../message-managers/prepare-consumer-subscription\";\r\nimport { RabbitMQChannel } from \"./rabbitmq-channel\";\r\n\r\n// ============================================================\r\n// Lazy-loaded amqplib Module\r\n// ============================================================\r\n\r\n/**\r\n * Cached amqplib module (loaded once, reused)\r\n */\r\nlet amqplibModule: typeof import(\"amqplib\");\r\n\r\n/**\r\n * Module availability flag\r\n */\r\nlet isModuleExists: boolean | null = null;\r\n\r\n/**\r\n * Installation instructions for amqplib\r\n */\r\nconst AMQPLIB_INSTALL_INSTRUCTIONS = `\r\nRabbitMQ driver requires the amqplib package.\r\nInstall it with:\r\n\r\n  npx warlock add herald --driver=rabbitmq\r\n\r\nOr manually:\r\n\r\n  npm install amqplib\r\n  pnpm add amqplib\r\n  yarn add amqplib\r\n`.trim();\r\n\r\n/**\r\n * Load amqplib module\r\n */\r\nasync function loadAmqplibModule() {\r\n  try {\r\n    amqplibModule = await import(\"amqplib\");\r\n    isModuleExists = true;\r\n  } catch {\r\n    isModuleExists = false;\r\n  }\r\n}\r\n\r\n// Kick off eager loading immediately\r\nloadAmqplibModule();\r\n\r\n// ============================================================\r\n// RabbitMQ Driver\r\n// ============================================================\r\n\r\n/**\r\n * RabbitMQ Driver\r\n *\r\n * Implementation of BrokerDriverContract for RabbitMQ/AMQP.\r\n *\r\n * **Important:** This driver requires the `amqplib` package to be installed.\r\n * Install it with: `npx warlock add herald --driver=rabbitmq` or `npm install amqplib`\r\n *\r\n * @example\r\n * ```typescript\r\n * const driver = new RabbitMQDriver({\r\n *   driver: \"rabbitmq\",\r\n *   host: \"localhost\",\r\n *   port: 5672,\r\n *   username: \"guest\",\r\n *   password: \"guest\",\r\n * });\r\n *\r\n * await driver.connect();\r\n * const channel = driver.channel(\"user.created\");\r\n * ```\r\n */\r\nexport class RabbitMQDriver implements BrokerDriverContract {\r\n  public readonly name = \"rabbitmq\" as const;\r\n\r\n  public readonly consumers: EventConsumerClass[] = [];\r\n\r\n  private readonly options: RabbitMQConnectionOptions;\r\n  private readonly events = new EventEmitter();\r\n  private readonly channels = new Map<string, ChannelContract<any>>();\r\n\r\n  private connection: any = null;\r\n  private amqpChannel: any = null;\r\n  private _isConnected = false;\r\n\r\n  /**\r\n   * Create a new RabbitMQ driver\r\n   *\r\n   * @param options - RabbitMQ connection options\r\n   */\r\n  public constructor(options: RabbitMQConnectionOptions) {\r\n    this.options = options;\r\n  }\r\n\r\n  /**\r\n   * Whether connected to RabbitMQ\r\n   */\r\n  public get isConnected(): boolean {\r\n    return this._isConnected;\r\n  }\r\n\r\n  /**\r\n   * Subscribe the given consumer class to the driver\r\n   *\r\n   * @param consumer - Consumer class to subscribe\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * driver.subscribe(UserUpdatedConsumer);\r\n   * ```\r\n   */\r\n  public subscribe(Consumer: EventConsumerClass) {\r\n    if (this.isConnected) {\r\n      this.channel(Consumer.eventName).subscribe(\r\n        prepareConsumerSubscription(Consumer, (error, eventName) => {\r\n          this.events.emit(\"error\", error, eventName);\r\n        }),\r\n        {\r\n          consumerId: Consumer.consumerId,\r\n        },\r\n      );\r\n    } else {\r\n      this.consumers.push(Consumer);\r\n    }\r\n\r\n    return () => {\r\n      this.unsubscribe(Consumer);\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe the given consumer\r\n   */\r\n  public unsubscribe(Consumer: EventConsumerClass): void {\r\n    if (this.isConnected) {\r\n      this.channel(Consumer.eventName).unsubscribeById(Consumer.consumerId);\r\n    }\r\n    const index = this.consumers.indexOf(Consumer);\r\n    if (index > -1) {\r\n      this.consumers.splice(index, 1);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Publish the given event message.\r\n   * Auto-creates the channel if it hasn't been accessed before.\r\n   */\r\n  public publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>): void {\r\n    this.channel(event.eventName).publish(event.serialize());\r\n  }\r\n\r\n  /**\r\n   * Connect to RabbitMQ\r\n   */\r\n  public async connect(): Promise<void> {\r\n    // Check if amqplib is installed\r\n    if (isModuleExists === false) {\r\n      throw new Error(`amqplib is not installed.\\n\\n${AMQPLIB_INSTALL_INSTRUCTIONS}`);\r\n    }\r\n\r\n    // Wait for module to load if still loading\r\n    if (isModuleExists === null) {\r\n      await loadAmqplibModule();\r\n      if (!isModuleExists) {\r\n        throw new Error(`amqplib is not installed.\\n\\n${AMQPLIB_INSTALL_INSTRUCTIONS}`);\r\n      }\r\n    }\r\n\r\n    try {\r\n      // Build connection URL\r\n      const url = this.buildConnectionUrl();\r\n\r\n      // Build connection options merging our options with native client options\r\n      const connectOptions = {\r\n        heartbeat: this.options.heartbeat ?? 60,\r\n        timeout: this.options.connectionTimeout,\r\n        // Merge native amqplib client options\r\n        ...this.options.clientOptions,\r\n      };\r\n\r\n      // Connect using cached module\r\n      this.connection = await amqplibModule.connect(url, connectOptions);\r\n\r\n      // Create channel\r\n      this.amqpChannel = await this.connection.createChannel();\r\n\r\n      // Set prefetch if specified\r\n      if (this.options.prefetch) {\r\n        await this.amqpChannel.prefetch(this.options.prefetch);\r\n      }\r\n\r\n      this._isConnected = true;\r\n      this.events.emit(\"connected\");\r\n\r\n      for (const consumer of this.consumers) {\r\n        this.subscribe(consumer);\r\n      }\r\n\r\n      this.consumers.length = 0;\r\n\r\n      // Handle connection close\r\n      this.connection.on(\"close\", () => {\r\n        this._isConnected = false;\r\n        this.events.emit(\"disconnected\");\r\n\r\n        if (this.options.reconnect !== false) {\r\n          this.handleReconnect();\r\n        }\r\n      });\r\n\r\n      // Handle errors\r\n      this.connection.on(\"error\", (error: Error) => {\r\n        this.events.emit(\"error\", error);\r\n      });\r\n    } catch (error) {\r\n      this._isConnected = false;\r\n      throw new Error(\r\n        `Failed to connect to RabbitMQ: ${error instanceof Error ? error.message : String(error)}`,\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Build connection URL from options\r\n   */\r\n  private buildConnectionUrl(): string {\r\n    if (this.options.uri) {\r\n      return this.options.uri;\r\n    }\r\n\r\n    const protocol = \"amqp\";\r\n    const host = this.options.host ?? \"localhost\";\r\n    const port = this.options.port ?? 5672;\r\n    const vhost = this.options.vhost ?? \"/\";\r\n    const username = this.options.username ?? \"guest\";\r\n    const password = this.options.password ?? \"guest\";\r\n\r\n    const encodedVhost = encodeURIComponent(vhost);\r\n\r\n    return `${protocol}://${username}:${password}@${host}:${port}/${encodedVhost}`;\r\n  }\r\n\r\n  /**\r\n   * Handle reconnection\r\n   */\r\n  private async handleReconnect(): Promise<void> {\r\n    const delay = this.options.reconnectDelay ?? 5000;\r\n    let attempt = 0;\r\n\r\n    const tryReconnect = async () => {\r\n      attempt++;\r\n      this.events.emit(\"reconnecting\", attempt);\r\n\r\n      try {\r\n        await this.connect();\r\n      } catch {\r\n        setTimeout(tryReconnect, delay);\r\n      }\r\n    };\r\n\r\n    setTimeout(tryReconnect, delay);\r\n  }\r\n\r\n  /**\r\n   * Disconnect from RabbitMQ\r\n   */\r\n  public async disconnect(): Promise<void> {\r\n    if (this.amqpChannel) {\r\n      try {\r\n        await this.amqpChannel.close();\r\n      } catch {\r\n        // Ignore close errors\r\n      }\r\n      this.amqpChannel = null;\r\n    }\r\n\r\n    if (this.connection) {\r\n      try {\r\n        await this.connection.close();\r\n      } catch {\r\n        // Ignore close errors\r\n      }\r\n      this.connection = null;\r\n    }\r\n\r\n    this._isConnected = false;\r\n    this.events.emit(\"disconnected\");\r\n  }\r\n\r\n  /**\r\n   * Register event listener\r\n   */\r\n  public on(event: BrokerEvent, listener: BrokerEventListener): void {\r\n    this.events.on(event, listener as any);\r\n  }\r\n\r\n  /**\r\n   * Remove event listener\r\n   */\r\n  public off(event: BrokerEvent, listener: BrokerEventListener): void {\r\n    this.events.off(event, listener as any);\r\n  }\r\n\r\n  /**\r\n   * Get or create a channel\r\n   */\r\n  public channel<TPayload = unknown>(\r\n    name: string,\r\n    options?: ChannelOptions<TPayload>,\r\n  ): ChannelContract<TPayload> {\r\n    // Check cache\r\n    const existing = this.channels.get(name);\r\n    if (existing) {\r\n      return existing as ChannelContract<TPayload>;\r\n    }\r\n\r\n    // Create new channel\r\n    const channel = new RabbitMQChannel<TPayload>(name, this.amqpChannel, options);\r\n\r\n    this.channels.set(name, channel);\r\n    return channel;\r\n  }\r\n\r\n  /**\r\n   * Start consuming messages\r\n   */\r\n  public async startConsuming(): Promise<void> {\r\n    // Channels start consuming when subscribe() is called\r\n    // This method is for batch start if needed\r\n  }\r\n\r\n  /**\r\n   * Stop consuming messages from all subscribed channels.\r\n   * Gracefully cancels all active consumers.\r\n   */\r\n  public async stopConsuming(): Promise<void> {\r\n    const stops = Array.from(this.channels.values()).map(channel =>\r\n      (channel as RabbitMQChannel<any>).stopConsuming(),\r\n    );\r\n    await Promise.all(stops);\r\n  }\r\n\r\n  /**\r\n   * Health check\r\n   */\r\n  public async healthCheck(): Promise<HealthCheckResult> {\r\n    if (!this._isConnected || !this.connection) {\r\n      return {\r\n        healthy: false,\r\n        error: \"Not connected to RabbitMQ\",\r\n      };\r\n    }\r\n\r\n    const start = Date.now();\r\n\r\n    try {\r\n      // Simple check - verify channel is open\r\n      await this.amqpChannel.checkQueue(\"amq.rabbitmq.reply-to\").catch(() => {\r\n        // Queue might not exist, but if we get here, connection is alive\r\n      });\r\n\r\n      return {\r\n        healthy: true,\r\n        latency: Date.now() - start,\r\n      };\r\n    } catch (error) {\r\n      return {\r\n        healthy: false,\r\n        error: error instanceof Error ? error.message : String(error),\r\n        latency: Date.now() - start,\r\n      };\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get all channel names\r\n   */\r\n  public getChannelNames(): string[] {\r\n    return Array.from(this.channels.keys());\r\n  }\r\n\r\n  /**\r\n   * Close a specific channel\r\n   */\r\n  public async closeChannel(name: string): Promise<void> {\r\n    const channel = this.channels.get(name);\r\n    if (channel) {\r\n      await channel.delete();\r\n      this.channels.delete(name);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the raw AMQP channel (for advanced use)\r\n   */\r\n  public getRawChannel(): any {\r\n    return this.amqpChannel;\r\n  }\r\n\r\n  /**\r\n   * Get the raw connection (for advanced use)\r\n   */\r\n  public getRawConnection(): any {\r\n    return this.connection;\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/index.d.mts

@@ -0,0 +1,20 @@
+import { DeadLetterOptions, RetryOptions, SubscribeOptions } from "./types/subscribe.types.mjs";
+import { ChannelOptions, ChannelStats } from "./types/channel.types.mjs";
+import { BaseConnectionOptions, BrokerConfigurations, ConnectionOptions, KafkaClientOptions, KafkaConnectionOptions, RabbitMQClientOptions, RabbitMQConnectionOptions, RabbitMQSocketOptions } from "./types/connection.types.mjs";
+import { BrokerDriverType, BrokerEvent, BrokerEventListener, HealthCheckResult } from "./types/driver.types.mjs";
+import { Message, MessageContext, MessageHandler, MessageMetadata, ResponseHandler, Subscription } from "./types/message.types.mjs";
+import { PublishOptions, RequestOptions } from "./types/publish.types.mjs";
+import { ChannelContract } from "./contracts/channel.contract.mjs";
+import { EventMessage, defineEvent } from "./message-managers/event-message.mjs";
+import { EventConsumer, defineConsumer } from "./message-managers/event-consumer.mjs";
+import { ConsumedEventMessage, EventConsumerClass } from "./message-managers/types.mjs";
+import { BrokerDriverContract } from "./contracts/broker-driver.contract.mjs";
+import { Broker, BrokerOptions } from "./communicators/broker.mjs";
+import { BrokerRegistryEvent, BrokerRegistryListener } from "./types/registry.types.mjs";
+import { MissingBrokerError, brokerRegistry } from "./communicators/broker-registry.mjs";
+import { RabbitMQDriver } from "./drivers/rabbitmq/rabbitmq-driver.mjs";
+import { RabbitMQChannel } from "./drivers/rabbitmq/rabbitmq-channel.mjs";
+import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./utils/connect-to-broker.mjs";
+import { Consumable, ConsumableOptions, pendingSubscribers } from "./decorators/consumable.mjs";
+import { UseCaseBroadcastEvent, heraldBroadcast } from "./use-case-broadcast.mjs";
+export { BaseConnectionOptions, Broker, BrokerConfigurations, BrokerDriverContract, BrokerDriverType, BrokerEvent, BrokerEventListener, BrokerOptions, BrokerRegistryEvent, BrokerRegistryListener, ChannelContract, ChannelOptions, ChannelStats, ConnectionOptions, Consumable, ConsumableOptions, ConsumedEventMessage, DeadLetterOptions, EventConsumer, EventConsumerClass, EventMessage, HealthCheckResult, KafkaClientOptions, KafkaConnectionOptions, Message, MessageContext, MessageHandler, MessageMetadata, MissingBrokerError, PublishOptions, RabbitMQChannel, RabbitMQClientOptions, RabbitMQConnectionOptions, RabbitMQDriver, RabbitMQSocketOptions, RequestOptions, ResponseHandler, RetryOptions, SubscribeOptions, Subscription, UseCaseBroadcastEvent, brokerRegistry, connectToBroker, defineConsumer, defineEvent, herald, heraldBroadcast, heraldChannel, pendingSubscribers, publishEvent, subscribeConsumer };

package/esm/index.mjs

@@ -0,0 +1,16 @@
+import { Broker } from "./communicators/broker.mjs";
+import { MissingBrokerError, brokerRegistry } from "./communicators/broker-registry.mjs";
+import "./communicators/index.mjs";
+import { RabbitMQChannel } from "./drivers/rabbitmq/rabbitmq-channel.mjs";
+import { RabbitMQDriver } from "./drivers/rabbitmq/rabbitmq-driver.mjs";
+import "./drivers/index.mjs";
+import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./utils/connect-to-broker.mjs";
+import "./utils/index.mjs";
+import { Consumable, pendingSubscribers } from "./decorators/consumable.mjs";
+import "./decorators/index.mjs";
+import { EventConsumer, defineConsumer } from "./message-managers/event-consumer.mjs";
+import { EventMessage, defineEvent } from "./message-managers/event-message.mjs";
+import "./message-managers/index.mjs";
+import { heraldBroadcast } from "./use-case-broadcast.mjs";
+
+export { Broker, Consumable, EventConsumer, EventMessage, MissingBrokerError, RabbitMQChannel, RabbitMQDriver, brokerRegistry, connectToBroker, defineConsumer, defineEvent, herald, heraldBroadcast, heraldChannel, pendingSubscribers, publishEvent, subscribeConsumer };

package/esm/message-managers/event-consumer.d.mts

@@ -0,0 +1,61 @@
+import { ConsumedEventMessage, EventConsumerClass } from "./types.mjs";
+import { ObjectValidator, ValidationResult } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/herald/src/message-managers/event-consumer.d.ts
+declare abstract class EventConsumer<Payload = Record<string, any>> {
+  /**
+   * Event name
+   */
+  static eventName: string;
+  private static _consumerId?;
+  static get consumerId(): string;
+  get eventName(): string;
+  /**
+   * Min version accepted to be consumed by this class
+   */
+  static minVersion?: number;
+  /**
+   * Max version accepted to be consumed by this class
+   */
+  static maxVersion?: number;
+  /**
+   * Payload validation to auto reject the received event before accessing it in the handle method
+   */
+  schema?: ObjectValidator;
+  /**
+   * The method that will be called when the event is received
+   */
+  abstract handle(payload: Payload, event: ConsumedEventMessage): Promise<void>;
+  /**
+   * Determine whether this is accepted version to be used by this consumer
+   */
+  static isAcceptedVersion(version: number): boolean;
+  /**
+   * Validate the given data
+   */
+  validate(data: Payload): Promise<ValidationResult | void>;
+}
+/**
+ * Define Consumer options
+ */
+type ConsumerOptions<Payload> = {
+  /**
+   * Payload validation to auto reject the received event before accessing it in the handle method
+   */
+  schema?: ObjectValidator;
+  /**
+   * Handle data
+   */
+  handle: (payload: Payload, event: ConsumedEventMessage) => Promise<void>;
+  /**
+   * Validate the payload before executing `handle`
+   */
+  validate?: (payload: Payload) => Promise<ValidationResult | boolean>;
+};
+/**
+ * A shorthand to define an event consumer without declaring an entire class
+ */
+declare function defineConsumer<Payload = Record<string, any>>(eventName: string, options: ConsumerOptions<Payload>): EventConsumerClass;
+//#endregion
+export { EventConsumer, defineConsumer };
+//# sourceMappingURL=event-consumer.d.mts.map

package/esm/message-managers/event-consumer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-consumer.d.mts","names":[],"sources":["../../../../../../@warlock.js/herald/src/message-managers/event-consumer.ts"],"mappings":";;;;uBAWsB,aAAA,WAAwB,MAAA;EAqCZ;;;EAAA,OAjClB,SAAA;EAAA,eAEC,WAAA;EAAA,WAEG,UAAA,CAAA;EAAA,IAOP,SAAA,CAAA;EAqCkC;;;EAAA,OA9B/B,UAAA;EAhBC;;;EAAA,OAqBD,UAAA;EAAA;;;EAKP,MAAA,GAAS,eAAA;EAKgB;;;EAAA,SAAhB,MAAA,CAAO,OAAA,EAAS,OAAA,EAAS,KAAA,EAAO,oBAAA,GAAuB,OAAA;EAAA;;;EAAA,OAKzD,iBAAA,CAAkB,OAAA;EAUJ;;;EAAf,QAAA,CAAS,IAAA,EAAM,OAAA,GAAU,OAAA,CAAQ,gBAAA;AAAA;AAAgB;AAK/D;;AAL+D,KAU3D,eAAA;EAIM;;;EAAT,MAAA,GAAS,eAAA;EAQY;;;EAJrB,MAAA,GAAS,OAAA,EAAS,OAAA,EAAS,KAAA,EAAO,oBAAA,KAAyB,OAAA;EAInB;;;EAAxC,QAAA,IAAY,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,gBAAA;AAAA;;;;iBAM3B,cAAA,WAAyB,MAAA,cAAA,CACvC,SAAA,UACA,OAAA,EAAS,eAAA,CAAgB,OAAA,IACxB,kBAAA"}

package/esm/message-managers/event-consumer.mjs

@@ -0,0 +1,63 @@
+import { Consumable } from "../decorators/consumable.mjs";
+import "../decorators/index.mjs";
+import { v } from "@warlock.js/seal";
+import { randomUUID } from "crypto";
+
+//#region ../../@warlock.js/herald/src/message-managers/event-consumer.ts
+/**
+* This class is used to be part of the Herald Event Consumer Manager.
+* It should be used to consume events from Either RabbitMQ or Kafka through Herald
+*
+* It's highly recommended using it instead of declaring manual channel namd and subscribing to event
+*/
+var EventConsumer = class {
+	static get consumerId() {
+		if (!this._consumerId) this._consumerId = randomUUID();
+		return this._consumerId;
+	}
+	get eventName() {
+		return this.constructor.eventName;
+	}
+	/**
+	* Determine whether this is accepted version to be used by this consumer
+	*/
+	static isAcceptedVersion(version) {
+		if (this.minVersion && version < this.minVersion) return false;
+		if (this.maxVersion && version > this.maxVersion) return false;
+		return true;
+	}
+	/**
+	* Validate the given data
+	*/
+	async validate(data) {
+		if (!this.schema) return;
+		return await v.validate(this.schema, data);
+	}
+};
+/**
+* A shorthand to define an event consumer without declaring an entire class
+*/
+function defineConsumer(eventName, options) {
+	const Class = class AnnouncedConsumer extends EventConsumer {
+		constructor(..._args) {
+			super(..._args);
+			this.schema = options.schema;
+		}
+		static {
+			this.eventName = eventName;
+		}
+		async handle(payload, event) {
+			if (options.validate) {
+				const result = await options.validate(payload);
+				if (!result || !result.isValid) return;
+			}
+			return options.handle(payload, event);
+		}
+	};
+	Consumable()(Class);
+	return Class;
+}
+
+//#endregion
+export { EventConsumer, defineConsumer };
+//# sourceMappingURL=event-consumer.mjs.map

package/esm/message-managers/event-consumer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-consumer.mjs","names":[],"sources":["../../../../../../@warlock.js/herald/src/message-managers/event-consumer.ts"],"sourcesContent":["/**\n * This class is used to be part of the Herald Event Consumer Manager.\n * It should be used to consume events from Either RabbitMQ or Kafka through Herald\n *\n * It's highly recommended using it instead of declaring manual channel namd and subscribing to event\n */\nimport { v, ValidationResult, type ObjectValidator } from \"@warlock.js/seal\";\nimport { randomUUID } from \"crypto\";\nimport { Consumable } from \"../decorators\";\nimport { ConsumedEventMessage, EventConsumerClass } from \"./types\";\n\nexport abstract class EventConsumer<Payload = Record<string, any>> {\n  /**\n   * Event name\n   */\n  public static eventName: string;\n\n  private static _consumerId?: string;\n\n  public static get consumerId(): string {\n    if (!this._consumerId) {\n      this._consumerId = randomUUID();\n    }\n    return this._consumerId;\n  }\n\n  public get eventName() {\n    return (this.constructor as typeof EventConsumer).eventName;\n  }\n\n  /**\n   * Min version accepted to be consumed by this class\n   */\n  public static minVersion?: number;\n\n  /**\n   * Max version accepted to be consumed by this class\n   */\n  public static maxVersion?: number;\n\n  /**\n   * Payload validation to auto reject the received event before accessing it in the handle method\n   */\n  public schema?: ObjectValidator;\n\n  /**\n   * The method that will be called when the event is received\n   */\n  public abstract handle(payload: Payload, event: ConsumedEventMessage): Promise<void>;\n\n  /**\n   * Determine whether this is accepted version to be used by this consumer\n   */\n  public static isAcceptedVersion(version: number): boolean {\n    if (this.minVersion && version < this.minVersion) return false;\n    if (this.maxVersion && version > this.maxVersion) return false;\n\n    return true;\n  }\n\n  /**\n   * Validate the given data\n   */\n  public async validate(data: Payload): Promise<ValidationResult | void> {\n    if (!this.schema) return;\n\n    return await v.validate(this.schema, data);\n  }\n}\n\n/**\n * Define Consumer options\n */\ntype ConsumerOptions<Payload> = {\n  /**\n   * Payload validation to auto reject the received event before accessing it in the handle method\n   */\n  schema?: ObjectValidator;\n  /**\n   * Handle data\n   */\n  handle: (payload: Payload, event: ConsumedEventMessage) => Promise<void>;\n  /**\n   * Validate the payload before executing `handle`\n   */\n  validate?: (payload: Payload) => Promise<ValidationResult | boolean>;\n};\n\n/**\n * A shorthand to define an event consumer without declaring an entire class\n */\nexport function defineConsumer<Payload = Record<string, any>>(\n  eventName: string,\n  options: ConsumerOptions<Payload>,\n): EventConsumerClass {\n  const Class = class AnnouncedConsumer extends EventConsumer<Payload> {\n    public static eventName = eventName;\n    public schema = options.schema;\n\n    public async handle(payload: Payload, event: ConsumedEventMessage) {\n      if (options.validate) {\n        const result = await options.validate(payload);\n        if (!result || !(result as ValidationResult).isValid) return;\n      }\n\n      return options.handle(payload, event);\n    }\n  };\n\n  Consumable()(Class as EventConsumerClass);\n\n  return Class as EventConsumerClass;\n}\n"],"mappings":";;;;;;;;;;;;AAWA,IAAsB,gBAAtB,MAAmE;CAQjE,WAAkB,aAAqB;EACrC,IAAI,CAAC,KAAK,aACR,KAAK,cAAc,WAAW;EAEhC,OAAO,KAAK;CACd;CAEA,IAAW,YAAY;EACrB,OAAQ,KAAK,YAAqC;CACpD;;;;CAyBA,OAAc,kBAAkB,SAA0B;EACxD,IAAI,KAAK,cAAc,UAAU,KAAK,YAAY,OAAO;EACzD,IAAI,KAAK,cAAc,UAAU,KAAK,YAAY,OAAO;EAEzD,OAAO;CACT;;;;CAKA,MAAa,SAAS,MAAiD;EACrE,IAAI,CAAC,KAAK,QAAQ;EAElB,OAAO,MAAM,EAAE,SAAS,KAAK,QAAQ,IAAI;CAC3C;AACF;;;;AAuBA,SAAgB,eACd,WACA,SACoB;CACpB,MAAM,QAAQ,MAAM,0BAA0B,cAAuB;;;iBAEnD,QAAQ;;;oBADE;;EAG1B,MAAa,OAAO,SAAkB,OAA6B;GACjE,IAAI,QAAQ,UAAU;IACpB,MAAM,SAAS,MAAM,QAAQ,SAAS,OAAO;IAC7C,IAAI,CAAC,UAAU,CAAE,OAA4B,SAAS;GACxD;GAEA,OAAO,QAAQ,OAAO,SAAS,KAAK;EACtC;CACF;CAEA,WAAW,EAAE,KAA2B;CAExC,OAAO;AACT"}

package/esm/message-managers/event-message.d.mts

@@ -0,0 +1,87 @@
+import { ObjectValidator } from "@warlock.js/seal";
+import { GenericObject } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/herald/src/message-managers/event-message.d.ts
+declare abstract class EventMessage<TPayload = Record<string, any>> {
+  protected data?: TPayload | undefined;
+  /**
+   * Event Name
+   */
+  abstract eventName: string;
+  /**
+   * Event version
+   */
+  version?: number;
+  /**
+   * Additional metadata (if any)
+   */
+  metadata?: Record<string, any>;
+  /**
+   * Event Message id
+   */
+  messageId?: string;
+  /**
+   * Schema of payload that will be used to determine whether this event should be published
+   */
+  schema?: ObjectValidator;
+  /**
+   * Data that will be sent with the event (Payload)
+   */
+  toJSON(): TPayload;
+  constructor(data?: TPayload | undefined);
+  /**
+   * Serialize the event to be ready for publishing.
+   * Delegates payload resolution to toJSON() — override toJSON() to customize.
+   *
+   * @throws Error if toJSON() throws (e.g. no data provided)
+   */
+  serialize(): {
+    payload: TPayload;
+    metadata: Record<string, any> | undefined;
+    messageId: string;
+    eventName: string;
+    version: number | undefined;
+    occurredAt: Date;
+    __through: string;
+  };
+}
+type EventOptions<T> = {
+  /**
+   * Shapen the data that will be used
+   */
+  toJSON?: (data: T) => GenericObject;
+  /**
+   * Validation schema
+   */
+  schema?: ObjectValidator;
+};
+/**
+ * Represents an EventMessage class constructor.
+ *
+ * @template TIncoming - The type of data accepted by the constructor
+ * @template TOutgoing - The type of data returned by toJSON() (defaults to TIncoming)
+ */
+type EventMessageClass<TIncoming = Record<string, any>, TOutgoing = TIncoming> = new (data?: TIncoming) => EventMessage<TOutgoing>;
+/**
+ * A shorthand to define an event without declaring an entire class.
+ *
+ * This factory function creates an EventMessage subclass that transforms
+ * input data (IncomingData) into a different output format (OutgoingData).
+ *
+ * @template IncomingData - The type of data passed to the constructor
+ * @template OutgoingData - The type of data returned by toJSON()
+ *
+ * @example
+ * ```typescript
+ * const UserCreatedEvent = defineEvent<User, { id: number; name: string }>(
+ *   "user.created",
+ *   { toJSON: (user) => user.only(["id", "name"]) }
+ * );
+ *
+ * publishEvent(new UserCreatedEvent(user));
+ * ```
+ */
+declare function defineEvent<IncomingData = unknown, OutgoingData = unknown>(eventName: string, options?: EventOptions<IncomingData>): EventMessageClass<IncomingData, OutgoingData>;
+//#endregion
+export { EventMessage, defineEvent };
+//# sourceMappingURL=event-message.d.mts.map

package/esm/message-managers/event-message.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-message.d.mts","names":[],"sources":["../../../../../../@warlock.js/herald/src/message-managers/event-message.ts"],"mappings":";;;;uBAUsB,YAAA,YAAwB,MAAA;EAAA,UAqCf,IAAA,GAAO,QAAA;EAbpB;;;EAAA,SApBA,SAAA;;;;EAKT,OAAA;EAT0B;;;EAc1B,QAAA,GAAW,MAAA;EAVF;;;EAeT,SAAA;EAAA;;;EAKA,MAAA,GAAS,eAAA;EAKC;;;EAAV,MAAA,CAAA,GAAU,QAAA;cAQY,IAAA,GAAO,QAAA;;;;;;;EAQ7B,SAAA,CAAA;;;;;;;;;;KAeJ,YAAA;EAQM;;;EAJT,MAAA,IAAU,IAAA,EAAM,CAAA,KAAM,aAAA;EAAtB;;;EAIA,MAAA,GAAS,eAAA;AAAA;;;AAAe;AAAA;;;KASrB,iBAAA,aAA8B,MAAA,2BAAiC,SAAA,SAClE,IAAA,GAAO,SAAA,KACJ,YAAA,CAAa,SAAA;;;;;;;;;;;;;;;;AAAS;AAqB3B;;;iBAAgB,WAAA,gDAAA,CACd,SAAA,UACA,OAAA,GAAS,YAAA,CAAa,YAAA,IACrB,iBAAA,CAAkB,YAAA,EAAc,YAAA"}

package/esm/message-managers/event-message.mjs

@@ -0,0 +1,68 @@
+import { randomUUID } from "crypto";
+
+//#region ../../@warlock.js/herald/src/message-managers/event-message.ts
+var EventMessage = class {
+	/**
+	* Data that will be sent with the event (Payload)
+	*/
+	toJSON() {
+		if (!this.data) throw new Error(`no Data is defined for Event: ${this.eventName}`);
+		return this.data;
+	}
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Serialize the event to be ready for publishing.
+	* Delegates payload resolution to toJSON() — override toJSON() to customize.
+	*
+	* @throws Error if toJSON() throws (e.g. no data provided)
+	*/
+	serialize() {
+		return {
+			payload: this.toJSON(),
+			metadata: this.metadata,
+			messageId: this.messageId ?? randomUUID(),
+			eventName: this.eventName,
+			version: this.version,
+			occurredAt: /* @__PURE__ */ new Date(),
+			__through: "EventMessage"
+		};
+	}
+};
+/**
+* A shorthand to define an event without declaring an entire class.
+*
+* This factory function creates an EventMessage subclass that transforms
+* input data (IncomingData) into a different output format (OutgoingData).
+*
+* @template IncomingData - The type of data passed to the constructor
+* @template OutgoingData - The type of data returned by toJSON()
+*
+* @example
+* ```typescript
+* const UserCreatedEvent = defineEvent<User, { id: number; name: string }>(
+*   "user.created",
+*   { toJSON: (user) => user.only(["id", "name"]) }
+* );
+*
+* publishEvent(new UserCreatedEvent(user));
+* ```
+*/
+function defineEvent(eventName, options = {}) {
+	return class AnnouncedEvent extends EventMessage {
+		constructor(data) {
+			super(data);
+			this.eventName = eventName;
+			this.schema = options.schema;
+		}
+		toJSON() {
+			if (!options.toJSON) return this.data;
+			return options.toJSON(this.data);
+		}
+	};
+}
+
+//#endregion
+export { EventMessage, defineEvent };
+//# sourceMappingURL=event-message.mjs.map