@warlock.js/herald 4.0.158 → 4.0.162

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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"}

package/esm/communicators/communicator.d.ts

@@ -0,0 +1,100 @@
+import type { CommunicatorDriverContract } from "../contracts";
+import type { ChannelContract } from "../contracts/channel.contract";
+import { EventMessage } from "../message-managers/event-message";
+import { EventConsumerClass } from "../message-managers/types";
+import type { ChannelOptions } from "../types";
+/**
+ * Options for creating a Communicator
+ */
+export interface CommunicatorOptions {
+    /** Unique name for this communicator */
+    name: string;
+    /** The underlying driver */
+    driver: CommunicatorDriverContract;
+    /** Whether this is the default communicator */
+    isDefault?: boolean;
+}
+/**
+ * Communicator - wrapper around a driver with metadata
+ *
+ * Similar to DataSource in @warlock.js/cascade
+ *
+ * @example
+ * ```typescript
+ * const communicator = new Communicator({
+ *   name: "default",
+ *   driver: rabbitMQDriver,
+ *   isDefault: true,
+ * });
+ *
+ * // Get a channel
+ * const channel = communicator.channel("user.created");
+ * ```
+ */
+export declare class Communicator {
+    /** Unique name identifying this communicator */
+    readonly name: string;
+    /** The underlying driver */
+    readonly driver: CommunicatorDriverContract;
+    /** Whether this is the default communicator */
+    readonly isDefault: boolean;
+    /**
+     * Create a new Communicator
+     *
+     * @param options - Communicator configuration
+     */
+    constructor(options: CommunicatorOptions);
+    /**
+     * Subscribe the given consumer
+     */
+    subscribe(consumer: EventConsumerClass<any>): () => void;
+    /**
+     * Publish the given event message
+     */
+    publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>): void;
+    /**
+     * Get or create a channel
+     *
+     * @param name - Channel name
+     * @param options - Channel options
+     * @returns Channel instance
+     *
+     * @example
+     * ```typescript
+     * // Simple channel
+     * const channel = communicator.channel("notifications");
+     *
+     * // Typed channel with schema
+     * const orderChannel = communicator.channel<OrderPayload>("orders", {
+     *   schema: OrderSchema,
+     *   durable: true,
+     * });
+     * ```
+     */
+    channel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
+    /**
+     * Check if the communicator is connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Connect the underlying driver
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the underlying driver
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Start consuming messages
+     */
+    startConsuming(): Promise<void>;
+    /**
+     * Stop consuming messages
+     */
+    stopConsuming(): Promise<void>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<import("../types").HealthCheckResult>;
+}
+//# sourceMappingURL=communicator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"communicator.d.ts","sourceRoot":"","sources":["../../src/communicators/communicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,MAAM,EAAE,0BAA0B,CAAC;IACnC,+CAA+C;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY;IACvB,gDAAgD;IAChD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,4BAA4B;IAC5B,SAAgB,MAAM,EAAE,0BAA0B,CAAC;IAEnD,+CAA+C;IAC/C,SAAgB,SAAS,EAAE,OAAO,CAAC;IAEnC;;;;OAIG;gBACgB,OAAO,EAAE,mBAAmB;IAM/C;;OAEG;IACI,SAAS,CAAC,QAAQ,EAAE,kBAAkB,CAAC,GAAG,CAAC;IAIlD;;OAEG;IACI,OAAO,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC;IAI5E;;;;;;;;;;;;;;;;;;OAkBG;IACI,OAAO,CAAC,QAAQ,GAAG,OAAO,EAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GACjC,eAAe,CAAC,QAAQ,CAAC;IAI5B;;OAEG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED;;OAEG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC;;OAEG;IACU,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5C;;OAEG;IACU,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3C;;OAEG;IACU,WAAW;CAGzB"}

package/esm/communicators/communicator.js

@@ -0,0 +1,105 @@
+/**
+ * Communicator - wrapper around a driver with metadata
+ *
+ * Similar to DataSource in @warlock.js/cascade
+ *
+ * @example
+ * ```typescript
+ * const communicator = new Communicator({
+ *   name: "default",
+ *   driver: rabbitMQDriver,
+ *   isDefault: true,
+ * });
+ *
+ * // Get a channel
+ * const channel = communicator.channel("user.created");
+ * ```
+ */
+class Communicator {
+    /** Unique name identifying this communicator */
+    name;
+    /** The underlying driver */
+    driver;
+    /** Whether this is the default communicator */
+    isDefault;
+    /**
+     * Create a new Communicator
+     *
+     * @param options - Communicator 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 = communicator.channel("notifications");
+     *
+     * // Typed channel with schema
+     * const orderChannel = communicator.channel<OrderPayload>("orders", {
+     *   schema: OrderSchema,
+     *   durable: true,
+     * });
+     * ```
+     */
+    channel(name, options) {
+        return this.driver.channel(name, options);
+    }
+    /**
+     * Check if the communicator 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{Communicator};//# sourceMappingURL=communicator.js.map

package/esm/communicators/communicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"communicator.js","sources":["../../src/communicators/communicator.ts"],"sourcesContent":[null],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;AAgBG;MACU,YAAY,CAAA;;AAEP,IAAA,IAAI,CAAS;;AAGb,IAAA,MAAM,CAA6B;;AAGnC,IAAA,SAAS,CAAU;AAEnC;;;;AAIG;AACH,IAAA,WAAA,CAAmB,OAA4B,EAAA;AAC7C,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

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

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

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

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

@@ -0,0 +1,186 @@
+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 = communicators().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>;
+}
+//# sourceMappingURL=channel.contract.d.ts.map

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

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

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

@@ -0,0 +1,196 @@
+import { type EventMessage } from "../message-managers/event-message";
+import { EventConsumerClass } from "../message-managers/types";
+import type { ChannelOptions, CommunicatorDriverType, CommunicatorEvent, CommunicatorEventListener, HealthCheckResult } from "../types";
+import type { ChannelContract } from "./channel.contract";
+/**
+ * Communicator Driver Contract
+ *
+ * Base contract for all message bus drivers (RabbitMQ, Kafka, etc.)
+ * Similar to DriverContract in @warlock.js/cascade
+ *
+ * @example
+ * ```typescript
+ * // Driver implementation
+ * class RabbitMQDriver implements CommunicatorDriverContract {
+ *   readonly name = "rabbitmq";
+ *   // ...
+ * }
+ * ```
+ */
+export interface CommunicatorDriverContract {
+    /**
+     * Driver name identifier
+     *
+     * @example "rabbitmq", "kafka", "redis-streams"
+     */
+    readonly name: CommunicatorDriverType;
+    /**
+     * Whether currently connected to the message broker
+     */
+    readonly isConnected: boolean;
+    /**
+     * Establish connection to the message broker
+     *
+     * @throws Error if connection fails
+     *
+     * @example
+     * ```typescript
+     * await driver.connect();
+     * console.log("Connected to RabbitMQ");
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Close connection gracefully
+     *
+     * Ensures all pending operations complete before disconnecting.
+     *
+     * @example
+     * ```typescript
+     * await driver.disconnect();
+     * ```
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Register event listeners for driver lifecycle events
+     *
+     * @param event - Event name to listen for
+     * @param listener - Callback function
+     *
+     * @example
+     * ```typescript
+     * driver.on("connected", () => {
+     *   console.log("Connected to broker");
+     * });
+     *
+     * driver.on("disconnected", () => {
+     *   console.log("Disconnected from broker");
+     * });
+     *
+     * driver.on("error", (error) => {
+     *   console.error("Driver error:", error);
+     * });
+     *
+     * driver.on("reconnecting", (attempt) => {
+     *   console.log(`Reconnection attempt ${attempt}`);
+     * });
+     * ```
+     */
+    on(event: CommunicatorEvent, listener: CommunicatorEventListener): void;
+    /**
+     * Remove an event listener
+     *
+     * @param event - Event name
+     * @param listener - Callback to remove
+     */
+    off(event: CommunicatorEvent, listener: CommunicatorEventListener): void;
+    /**
+     * 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=communicator-driver.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"communicator-driver.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/communicator-driver.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,yBAAyB,EACzB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAE9B;;;;;;;;;;OAUG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;;;;;;;OASG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAExE;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;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/index.d.ts

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

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

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

package/package.json

@@ -1,14 +1,14 @@
 {
     "name": "@warlock.js/herald",
-    "version": "4.0.158",
+    "version": "4.0.162",
     "description": "Message bus/communicators for RabbitMQ, Kafka, and more",
     "main": "./cjs/index.js",
     "dependencies": {
         "@mongez/copper": "^1.0.1",
         "@mongez/events": "^2.1.0",
         "@mongez/reinforcements": "^2.3.17",
-        "@warlock.js/logger": "4.0.158",
-        "@warlock.js/seal": "4.0.158"
+        "@warlock.js/logger": "4.0.162",
+        "@warlock.js/seal": "4.0.162"
     },
     "scripts": {
         "update": "npx ncu -u",