@zdavison/matador 2.0.9 → 2.0.10

package/dist/core/fanout.d.ts

@@ -0,0 +1,59 @@
+import type { SafeHooks } from '../hooks/index.js';
+import type { SchemaRegistry } from '../schema/index.js';
+import type { Transport } from '../transport/index.js';
+import type { Event, EventClass, EventOptions } from '../types/index.js';
+/**
+ * Configuration for the fanout engine.
+ */
+export interface FanoutConfig {
+    readonly transport: Transport;
+    readonly schema: SchemaRegistry;
+    readonly hooks: SafeHooks;
+    readonly namespace: string;
+    readonly defaultQueue: string;
+}
+/**
+ * Result of sending an event.
+ */
+export interface SendResult {
+    readonly eventKey: string;
+    readonly subscribersSent: number;
+    readonly subscribersSkipped: number;
+    readonly errors: readonly SendError[];
+}
+/**
+ * Error during send.
+ */
+export interface SendError {
+    readonly subscriberName: string;
+    readonly queue: string;
+    readonly error: Error;
+}
+/**
+ * Engine for fanning out events to subscribers.
+ *
+ * Handles:
+ * 1. Getting subscribers from schema
+ * 2. Filtering by enabled() hook
+ * 3. Creating envelopes for each subscriber
+ * 4. Sending to appropriate queues via transport
+ */
+export declare class FanoutEngine {
+    private readonly transport;
+    private readonly schema;
+    private readonly hooks;
+    private readonly namespace;
+    private readonly defaultQueue;
+    private enqueuingCount;
+    constructor(config: FanoutConfig);
+    /**
+     * Current count of events being enqueued.
+     */
+    get eventsBeingEnqueuedCount(): number;
+    /**
+     * Sends an event to all registered subscribers.
+     */
+    send<T>(eventClass: EventClass<T>, event: Event<T>, options?: EventOptions): Promise<SendResult>;
+    private isSubscriberEnabled;
+}
+//# sourceMappingURL=fanout.d.ts.map

package/dist/core/fanout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fanout.d.ts","sourceRoot":"","sources":["../../src/core/fanout.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAEV,KAAK,EACL,UAAU,EACV,YAAY,EACb,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,cAAc,CAAK;gBAEf,MAAM,EAAE,YAAY;IAQhC;;OAEG;IACH,IAAI,wBAAwB,IAAI,MAAM,CAErC;IAED;;OAEG;IACG,IAAI,CAAC,CAAC,EACV,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,UAAU,CAAC;YAsFR,mBAAmB;CAelC"}

package/dist/core/fanout.js

@@ -0,0 +1,121 @@
+import { TransportSendError } from '../errors/index.js';
+import { getQualifiedQueueName } from '../topology/index.js';
+import { createEnvelope } from '../types/index.js';
+/**
+ * Engine for fanning out events to subscribers.
+ *
+ * Handles:
+ * 1. Getting subscribers from schema
+ * 2. Filtering by enabled() hook
+ * 3. Creating envelopes for each subscriber
+ * 4. Sending to appropriate queues via transport
+ */
+export class FanoutEngine {
+    transport;
+    schema;
+    hooks;
+    namespace;
+    defaultQueue;
+    enqueuingCount = 0;
+    constructor(config) {
+        this.transport = config.transport;
+        this.schema = config.schema;
+        this.hooks = config.hooks;
+        this.namespace = config.namespace;
+        this.defaultQueue = config.defaultQueue;
+    }
+    /**
+     * Current count of events being enqueued.
+     */
+    get eventsBeingEnqueuedCount() {
+        return this.enqueuingCount;
+    }
+    /**
+     * Sends an event to all registered subscribers.
+     */
+    async send(eventClass, event, options = {}) {
+        const eventKey = eventClass.key;
+        const subscribers = this.schema.getSubscribers(eventKey);
+        const errors = [];
+        let sent = 0;
+        let skipped = 0;
+        // Load universal metadata
+        const universalMetadata = await this.hooks.loadUniversalMetadata();
+        // Merge event.metadata with options.metadata (options takes precedence)
+        const mergedMetadata = event.metadata || options.metadata
+            ? { ...event.metadata, ...options.metadata }
+            : undefined;
+        for (const subscriber of subscribers) {
+            // Check if subscriber is enabled
+            const enabled = await this.isSubscriberEnabled(subscriber);
+            if (!enabled) {
+                skipped++;
+                continue;
+            }
+            // Determine target queue
+            const targetQueue = subscriber.targetQueue ?? this.defaultQueue;
+            const qualifiedQueue = getQualifiedQueueName(this.namespace, targetQueue);
+            // Create envelope
+            const envelope = createEnvelope({
+                eventKey,
+                eventDescription: eventClass.description,
+                targetSubscriber: subscriber.name,
+                data: event.data,
+                importance: subscriber.importance ?? 'should-investigate',
+                correlationId: options.correlationId,
+                metadata: mergedMetadata,
+                universalMetadata,
+                delayMs: options.delayMs,
+            });
+            // Send to transport
+            this.enqueuingCount++;
+            try {
+                const usedTransport = await this.transport.send(qualifiedQueue, envelope, options.delayMs !== undefined
+                    ? { delay: options.delayMs }
+                    : undefined);
+                sent++;
+                await this.hooks.onEnqueueSuccess({
+                    envelope,
+                    queue: qualifiedQueue,
+                    transport: usedTransport,
+                });
+            }
+            catch (error) {
+                const cause = error instanceof Error ? error : new Error(String(error));
+                const err = new TransportSendError(qualifiedQueue, cause);
+                errors.push({
+                    subscriberName: subscriber.name,
+                    queue: qualifiedQueue,
+                    error: err,
+                });
+                await this.hooks.onEnqueueError({
+                    envelope,
+                    error: err,
+                    transport: this.transport.name,
+                });
+            }
+            finally {
+                this.enqueuingCount--;
+            }
+        }
+        return {
+            eventKey,
+            subscribersSent: sent,
+            subscribersSkipped: skipped,
+            errors,
+        };
+    }
+    async isSubscriberEnabled(subscriber) {
+        if (!subscriber.enabled) {
+            return true;
+        }
+        try {
+            const result = await subscriber.enabled();
+            return result;
+        }
+        catch {
+            // If enabled check fails, consider it enabled
+            return true;
+        }
+    }
+}

package/dist/core/fanout.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fanout.test.d.ts.map

package/dist/core/fanout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fanout.test.d.ts","sourceRoot":"","sources":["../../src/core/fanout.test.ts"],"names":[],"mappings":""}