@warlock.js/herald 4.0.161 → 4.0.163

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

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

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

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

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

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

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

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

package/cjs/utils/index.d.ts

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

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

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

package/esm/communicators/communicator-registry.d.ts

@@ -0,0 +1,155 @@
+import type { CommunicatorRegistryEvent, CommunicatorRegistryListener } from "../types";
+import { Communicator, type CommunicatorOptions } from "./communicator";
+/**
+ * Error thrown when a communicator is not found
+ */
+export declare class MissingCommunicatorError extends Error {
+    readonly communicatorName?: string;
+    constructor(message: string, communicatorName?: string);
+}
+/**
+ * Communicator Registry
+ *
+ * Maintains registry of named communicators.
+ * Similar to DataSourceRegistry in @warlock.js/cascade
+ *
+ * @example
+ * ```typescript
+ * // Register a communicator
+ * communicatorRegistry.register({
+ *   name: "default",
+ *   driver: rabbitMQDriver,
+ *   isDefault: true,
+ * });
+ *
+ * // Get the default communicator
+ * const comm = communicatorRegistry.get();
+ *
+ * // Get a specific communicator by name
+ * const analytics = communicatorRegistry.get("analytics");
+ *
+ * // Listen for events
+ * communicatorRegistry.on("connected", (comm) => {
+ *   console.log(`${comm.name} connected`);
+ * });
+ * ```
+ */
+declare class CommunicatorRegistry {
+    private readonly sources;
+    private defaultSource?;
+    private readonly events;
+    /**
+     * Register a new communicator
+     *
+     * Sets up event forwarding from the driver to the registry.
+     *
+     * @param options - Communicator configuration
+     * @returns The registered communicator instance
+     *
+     * @example
+     * ```typescript
+     * const communicator = communicatorRegistry.register({
+     *   name: "primary",
+     *   driver: myDriver,
+     *   isDefault: true,
+     * });
+     * ```
+     */
+    register(options: CommunicatorOptions): Communicator;
+    /**
+     * Clear all registered communicators
+     */
+    clear(): void;
+    /**
+     * Listen for registry events
+     *
+     * @param event - Event to listen for
+     * @param listener - Callback function
+     *
+     * @example
+     * ```typescript
+     * communicatorRegistry.on("registered", (comm) => {
+     *   console.log(`Communicator "${comm.name}" registered`);
+     * });
+     *
+     * communicatorRegistry.on("connected", (comm) => {
+     *   console.log(`Communicator "${comm.name}" connected`);
+     * });
+     * ```
+     */
+    on(event: CommunicatorRegistryEvent, listener: CommunicatorRegistryListener): void;
+    /**
+     * Listen for a registry event once
+     *
+     * @param event - Event to listen for
+     * @param listener - Callback function
+     */
+    once(event: CommunicatorRegistryEvent, listener: CommunicatorRegistryListener): void;
+    /**
+     * Remove an event listener
+     *
+     * @param event - Event to stop listening for
+     * @param listener - Callback to remove
+     */
+    off(event: CommunicatorRegistryEvent, listener: CommunicatorRegistryListener): void;
+    /**
+     * Get a communicator by name or the default one
+     *
+     * @param name - Optional communicator name
+     * @returns Communicator instance
+     * @throws MissingCommunicatorError if not found
+     *
+     * @example
+     * ```typescript
+     * // Get default communicator
+     * const comm = communicatorRegistry.get();
+     *
+     * // Get specific communicator
+     * const analytics = communicatorRegistry.get("analytics");
+     * ```
+     */
+    get(name?: string): Communicator;
+    /**
+     * Check if a communicator exists
+     *
+     * @param name - Communicator name to check
+     * @returns True if exists
+     */
+    has(name: string): boolean;
+    /**
+     * Check if any communicators are registered
+     */
+    hasAny(): boolean;
+    /**
+     * Get all registered communicators
+     *
+     * @returns Array of all communicators
+     *
+     * @example
+     * ```typescript
+     * // Disconnect all communicators
+     * for (const comm of communicatorRegistry.getAll()) {
+     *   await comm.disconnect();
+     * }
+     * ```
+     */
+    getAll(): Communicator[];
+    /**
+     * Get all communicator names
+     *
+     * @returns Array of communicator names
+     */
+    getNames(): string[];
+    /**
+     * Get the default communicator (if any)
+     *
+     * @returns Default communicator or undefined
+     */
+    getDefault(): Communicator | undefined;
+}
+/**
+ * Global communicator registry instance
+ */
+export declare const communicatorRegistry: CommunicatorRegistry;
+export {};
+//# sourceMappingURL=communicator-registry.d.ts.map

package/esm/communicators/communicator-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"communicator-registry.d.ts","sourceRoot":"","sources":["../../src/communicators/communicator-registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AACxF,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAExE;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,SAAgB,gBAAgB,CAAC,EAAE,MAAM,CAAC;gBAEvB,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM;CAK9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,cAAM,oBAAoB;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,aAAa,CAAC,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACI,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY;IA6B3D;;OAEG;IACI,KAAK,IAAI,IAAI;IAKpB;;;;;;;;;;;;;;;;OAgBG;IACI,EAAE,CAAC,KAAK,EAAE,yBAAyB,EAAE,QAAQ,EAAE,4BAA4B,GAAG,IAAI;IAIzF;;;;;OAKG;IACI,IAAI,CAAC,KAAK,EAAE,yBAAyB,EAAE,QAAQ,EAAE,4BAA4B,GAAG,IAAI;IAI3F;;;;;OAKG;IACI,GAAG,CAAC,KAAK,EAAE,yBAAyB,EAAE,QAAQ,EAAE,4BAA4B,GAAG,IAAI;IAI1F;;;;;;;;;;;;;;;OAeG;IACI,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,YAAY;IAgBvC;;;;;OAKG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC;;OAEG;IACI,MAAM,IAAI,OAAO;IAIxB;;;;;;;;;;;;OAYG;IACI,MAAM,IAAI,YAAY,EAAE;IAI/B;;;;OAIG;IACI,QAAQ,IAAI,MAAM,EAAE;IAI3B;;;;OAIG;IACI,UAAU,IAAI,YAAY,GAAG,SAAS;CAG9C;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}

package/esm/communicators/communicator-registry.js

@@ -0,0 +1,206 @@
+import {EventEmitter}from'node:events';import {Communicator}from'./communicator.js';/**
+ * Error thrown when a communicator is not found
+ */
+class MissingCommunicatorError extends Error {
+    communicatorName;
+    constructor(message, communicatorName) {
+        super(message);
+        this.name = "MissingCommunicatorError";
+        this.communicatorName = communicatorName;
+    }
+}
+/**
+ * Communicator Registry
+ *
+ * Maintains registry of named communicators.
+ * Similar to DataSourceRegistry in @warlock.js/cascade
+ *
+ * @example
+ * ```typescript
+ * // Register a communicator
+ * communicatorRegistry.register({
+ *   name: "default",
+ *   driver: rabbitMQDriver,
+ *   isDefault: true,
+ * });
+ *
+ * // Get the default communicator
+ * const comm = communicatorRegistry.get();
+ *
+ * // Get a specific communicator by name
+ * const analytics = communicatorRegistry.get("analytics");
+ *
+ * // Listen for events
+ * communicatorRegistry.on("connected", (comm) => {
+ *   console.log(`${comm.name} connected`);
+ * });
+ * ```
+ */
+class CommunicatorRegistry {
+    sources = new Map();
+    defaultSource;
+    events = new EventEmitter();
+    /**
+     * Register a new communicator
+     *
+     * Sets up event forwarding from the driver to the registry.
+     *
+     * @param options - Communicator configuration
+     * @returns The registered communicator instance
+     *
+     * @example
+     * ```typescript
+     * const communicator = communicatorRegistry.register({
+     *   name: "primary",
+     *   driver: myDriver,
+     *   isDefault: true,
+     * });
+     * ```
+     */
+    register(options) {
+        const communicator = new Communicator(options);
+        this.sources.set(communicator.name, communicator);
+        const isNewDefault = communicator.isDefault || !this.defaultSource;
+        if (isNewDefault) {
+            this.defaultSource = communicator;
+        }
+        // Emit registration events
+        this.events.emit("registered", communicator);
+        if (isNewDefault) {
+            this.events.emit("default-registered", communicator);
+        }
+        // Forward driver events to registry
+        communicator.driver.on("connected", () => {
+            this.events.emit("connected", communicator);
+        });
+        communicator.driver.on("disconnected", () => {
+            this.events.emit("disconnected", communicator);
+        });
+        return communicator;
+    }
+    /**
+     * Clear all registered communicators
+     */
+    clear() {
+        this.defaultSource = undefined;
+        this.sources.clear();
+    }
+    /**
+     * Listen for registry events
+     *
+     * @param event - Event to listen for
+     * @param listener - Callback function
+     *
+     * @example
+     * ```typescript
+     * communicatorRegistry.on("registered", (comm) => {
+     *   console.log(`Communicator "${comm.name}" registered`);
+     * });
+     *
+     * communicatorRegistry.on("connected", (comm) => {
+     *   console.log(`Communicator "${comm.name}" connected`);
+     * });
+     * ```
+     */
+    on(event, listener) {
+        this.events.on(event, listener);
+    }
+    /**
+     * Listen for a registry event once
+     *
+     * @param event - Event to listen for
+     * @param listener - Callback function
+     */
+    once(event, listener) {
+        this.events.once(event, listener);
+    }
+    /**
+     * Remove an event listener
+     *
+     * @param event - Event to stop listening for
+     * @param listener - Callback to remove
+     */
+    off(event, listener) {
+        this.events.off(event, listener);
+    }
+    /**
+     * Get a communicator by name or the default one
+     *
+     * @param name - Optional communicator name
+     * @returns Communicator instance
+     * @throws MissingCommunicatorError if not found
+     *
+     * @example
+     * ```typescript
+     * // Get default communicator
+     * const comm = communicatorRegistry.get();
+     *
+     * // Get specific communicator
+     * const analytics = communicatorRegistry.get("analytics");
+     * ```
+     */
+    get(name) {
+        if (name !== undefined) {
+            const source = this.sources.get(name);
+            if (!source) {
+                throw new MissingCommunicatorError(`Communicator "${name}" is not registered.`, name);
+            }
+            return source;
+        }
+        if (!this.defaultSource) {
+            throw new MissingCommunicatorError("No default communicator registered.");
+        }
+        return this.defaultSource;
+    }
+    /**
+     * Check if a communicator exists
+     *
+     * @param name - Communicator name to check
+     * @returns True if exists
+     */
+    has(name) {
+        return this.sources.has(name);
+    }
+    /**
+     * Check if any communicators are registered
+     */
+    hasAny() {
+        return this.sources.size > 0;
+    }
+    /**
+     * Get all registered communicators
+     *
+     * @returns Array of all communicators
+     *
+     * @example
+     * ```typescript
+     * // Disconnect all communicators
+     * for (const comm of communicatorRegistry.getAll()) {
+     *   await comm.disconnect();
+     * }
+     * ```
+     */
+    getAll() {
+        return Array.from(this.sources.values());
+    }
+    /**
+     * Get all communicator names
+     *
+     * @returns Array of communicator names
+     */
+    getNames() {
+        return Array.from(this.sources.keys());
+    }
+    /**
+     * Get the default communicator (if any)
+     *
+     * @returns Default communicator or undefined
+     */
+    getDefault() {
+        return this.defaultSource;
+    }
+}
+/**
+ * Global communicator registry instance
+ */
+const communicatorRegistry = new CommunicatorRegistry();export{MissingCommunicatorError,communicatorRegistry};//# sourceMappingURL=communicator-registry.js.map

package/esm/communicators/communicator-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"communicator-registry.js","sources":["../../src/communicators/communicator-registry.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}