@signaltree/events 7.3.1

package/nestjs.esm.js

@@ -0,0 +1,944 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject, Logger, Module, SetMetadata } from '@nestjs/common';
+import { Queue, QueueEvents, Worker } from 'bullmq';
+import { g as generateEventId, b as generateCorrelationId } from './factory.esm.js';
+import { E as EventRegistry, c as createEventRegistry, e as createInMemoryIdempotencyStore, b as createErrorClassifier } from './idempotency.esm.js';
+import 'reflect-metadata';
+
+/**
+ * Injection tokens for the EventBus module
+ */
+const EVENT_BUS_CONFIG = Symbol('EVENT_BUS_CONFIG');
+const EVENT_REGISTRY = Symbol('EVENT_REGISTRY');
+const IDEMPOTENCY_STORE = Symbol('IDEMPOTENCY_STORE');
+const ERROR_CLASSIFIER = Symbol('ERROR_CLASSIFIER');
+
+var DlqService_1;
+let DlqService = DlqService_1 = class DlqService {
+  config;
+  logger = new Logger(DlqService_1.name);
+  queue;
+  queueName;
+  constructor(config) {
+    this.config = config;
+    this.queueName = config.dlqQueueName ?? 'dead-letter';
+  }
+  async onModuleInit() {
+    if (!this.config.enableDlq) {
+      this.logger.log('DLQ is disabled');
+      return;
+    }
+    this.queue = new Queue(this.queueName, {
+      connection: {
+        host: this.config.redis.host,
+        port: this.config.redis.port,
+        password: this.config.redis.password,
+        db: this.config.redis.db
+      },
+      defaultJobOptions: {
+        removeOnComplete: false,
+        // Keep for inspection
+        removeOnFail: false,
+        attempts: 1 // No retries in DLQ
+      }
+    });
+    this.logger.log(`DLQ "${this.queueName}" initialized`);
+  }
+  async onModuleDestroy() {
+    if (this.queue) {
+      await this.queue.close();
+    }
+  }
+  /**
+   * Send an event to the DLQ
+   */
+  async send(entry) {
+    if (!this.queue) {
+      throw new Error('DLQ is not initialized');
+    }
+    const job = await this.queue.add(`dlq:${entry.event.type}`, entry, {
+      jobId: `dlq:${entry.event.id}:${entry.subscriber}`
+    });
+    this.logger.debug(`Event ${entry.event.id} sent to DLQ (job: ${job.id})`);
+    return job.id ?? `dlq:${entry.event.id}:${entry.subscriber}`;
+  }
+  /**
+   * Get entries from DLQ
+   */
+  async getEntries(options = {}) {
+    if (!this.queue) {
+      return [];
+    }
+    const start = options.start ?? 0;
+    const end = options.end ?? 100;
+    const jobs = await this.queue.getJobs(['waiting', 'active', 'delayed', 'failed'], start, end);
+    let entries = jobs.map(job => job.data);
+    // Apply filters
+    if (options.eventType) {
+      entries = entries.filter(e => e.event.type === options.eventType);
+    }
+    if (options.subscriber) {
+      entries = entries.filter(e => e.subscriber === options.subscriber);
+    }
+    if (options.classification) {
+      entries = entries.filter(e => e.error.classification === options.classification);
+    }
+    if (options.from) {
+      const fromDate = options.from;
+      entries = entries.filter(e => new Date(e.failedAt) >= fromDate);
+    }
+    if (options.to) {
+      const toDate = options.to;
+      entries = entries.filter(e => new Date(e.failedAt) <= toDate);
+    }
+    return entries;
+  }
+  /**
+   * Get a specific entry by event ID
+   */
+  async getEntry(eventId, subscriber) {
+    if (!this.queue) {
+      return null;
+    }
+    // Try with subscriber suffix first
+    if (subscriber) {
+      const job = await this.queue.getJob(`dlq:${eventId}:${subscriber}`);
+      if (job) {
+        return job.data;
+      }
+    }
+    // Search through jobs
+    const jobs = await this.queue.getJobs(['waiting', 'active', 'delayed', 'failed']);
+    const job = jobs.find(j => j.data.event.id === eventId);
+    return job ? job.data : null;
+  }
+  /**
+   * Get DLQ statistics
+   */
+  async getStats() {
+    const entries = await this.getEntries({
+      start: 0,
+      end: 10000
+    });
+    const stats = {
+      total: entries.length,
+      byEventType: {},
+      bySubscriber: {},
+      byClassification: {
+        transient: 0,
+        permanent: 0,
+        poison: 0,
+        unknown: 0
+      }
+    };
+    for (const entry of entries) {
+      // By event type
+      stats.byEventType[entry.event.type] = (stats.byEventType[entry.event.type] ?? 0) + 1;
+      // By subscriber
+      stats.bySubscriber[entry.subscriber] = (stats.bySubscriber[entry.subscriber] ?? 0) + 1;
+      // By classification
+      stats.byClassification[entry.error.classification]++;
+      // Date tracking
+      const failedDate = new Date(entry.failedAt);
+      if (!stats.oldestEntry || failedDate < stats.oldestEntry) {
+        stats.oldestEntry = failedDate;
+      }
+      if (!stats.newestEntry || failedDate > stats.newestEntry) {
+        stats.newestEntry = failedDate;
+      }
+    }
+    return stats;
+  }
+  /**
+   * Replay an event from DLQ
+   *
+   * This removes the event from DLQ and republishes to original queue
+   */
+  async replay(eventId, subscriber, targetQueue) {
+    if (!this.queue) {
+      throw new Error('DLQ is not initialized');
+    }
+    const jobId = `dlq:${eventId}:${subscriber}`;
+    const job = await this.queue.getJob(jobId);
+    if (!job) {
+      this.logger.warn(`DLQ entry not found: ${jobId}`);
+      return false;
+    }
+    const entry = job.data;
+    // Get target queue
+    const targetQueueInstance = new Queue(targetQueue, {
+      connection: {
+        host: this.config.redis.host,
+        port: this.config.redis.port,
+        password: this.config.redis.password,
+        db: this.config.redis.db
+      }
+    });
+    try {
+      // Republish to original queue
+      await targetQueueInstance.add(entry.event.type, entry.event, {
+        jobId: `replay:${entry.event.id}`
+      });
+      // Remove from DLQ
+      await job.remove();
+      this.logger.log(`Replayed event ${eventId} to queue ${targetQueue}`);
+      return true;
+    } finally {
+      await targetQueueInstance.close();
+    }
+  }
+  /**
+   * Replay all events matching criteria
+   */
+  async replayBatch(options) {
+    const entries = await this.getEntries(options);
+    let replayed = 0;
+    let failed = 0;
+    for (const entry of entries) {
+      try {
+        const success = await this.replay(entry.event.id, entry.subscriber, options.targetQueue);
+        if (success) replayed++;else failed++;
+      } catch {
+        failed++;
+      }
+    }
+    return {
+      replayed,
+      failed
+    };
+  }
+  /**
+   * Remove an entry from DLQ
+   */
+  async remove(eventId, subscriber) {
+    if (!this.queue) {
+      return false;
+    }
+    const job = await this.queue.getJob(`dlq:${eventId}:${subscriber}`);
+    if (job) {
+      await job.remove();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Purge old entries from DLQ
+   */
+  async purge(olderThan) {
+    const entries = await this.getEntries({
+      to: olderThan,
+      start: 0,
+      end: 10000
+    });
+    let purged = 0;
+    for (const entry of entries) {
+      const removed = await this.remove(entry.event.id, entry.subscriber);
+      if (removed) purged++;
+    }
+    this.logger.log(`Purged ${purged} entries from DLQ older than ${olderThan.toISOString()}`);
+    return purged;
+  }
+  /**
+   * Clear all entries from DLQ
+   */
+  async clear() {
+    if (!this.queue) {
+      return 0;
+    }
+    const count = await this.queue.getJobCounts();
+    const total = count.waiting + count.active + count.delayed + count.failed;
+    await this.queue.obliterate({
+      force: true
+    });
+    this.logger.warn(`Cleared all ${total} entries from DLQ`);
+    return total;
+  }
+};
+DlqService = DlqService_1 = __decorate([Injectable(), __param(0, Inject(EVENT_BUS_CONFIG)), __metadata("design:paramtypes", [Object])], DlqService);
+
+var EventBusService_1;
+let EventBusService = EventBusService_1 = class EventBusService {
+  config;
+  registry;
+  logger = new Logger(EventBusService_1.name);
+  queues = new Map();
+  priorityToQueue = new Map();
+  connection;
+  isReady = false;
+  constructor(config, registry) {
+    this.config = config;
+    this.registry = registry;
+    this.connection = {
+      host: config.redis.host,
+      port: config.redis.port,
+      password: config.redis.password,
+      db: config.redis.db,
+      maxRetriesPerRequest: config.redis.maxRetriesPerRequest ?? 3
+    };
+  }
+  async onModuleInit() {
+    this.logger.log('Initializing EventBus queues...');
+    // Create queues
+    for (const queueConfig of this.config.queues ?? []) {
+      const queue = new Queue(queueConfig.name, {
+        connection: this.connection,
+        defaultJobOptions: {
+          removeOnComplete: 1000,
+          // Keep last 1000 completed jobs
+          removeOnFail: 5000,
+          // Keep last 5000 failed jobs
+          attempts: 5,
+          backoff: {
+            type: 'exponential',
+            delay: 1000
+          }
+        }
+      });
+      // Map priorities to this queue
+      for (const priority of queueConfig.priorities) {
+        this.priorityToQueue.set(priority, queueConfig.name);
+      }
+      const instance = {
+        config: queueConfig,
+        queue
+      };
+      // Optionally create queue events listener for monitoring
+      if (this.config.enableMetrics) {
+        instance.events = new QueueEvents(queueConfig.name, {
+          connection: this.connection
+        });
+        this.setupQueueEventListeners(instance);
+      }
+      this.queues.set(queueConfig.name, instance);
+      this.logger.log(`Queue "${queueConfig.name}" initialized for priorities: ${queueConfig.priorities.join(', ')}`);
+    }
+    this.isReady = true;
+    this.logger.log(`EventBus ready with ${this.queues.size} queues`);
+  }
+  async onModuleDestroy() {
+    this.logger.log('Shutting down EventBus...');
+    const closePromises = [];
+    for (const [name, instance] of this.queues) {
+      this.logger.debug(`Closing queue "${name}"...`);
+      closePromises.push(instance.queue.close());
+      if (instance.events) {
+        closePromises.push(instance.events.close());
+      }
+    }
+    await Promise.all(closePromises);
+    this.queues.clear();
+    this.isReady = false;
+    this.logger.log('EventBus shutdown complete');
+  }
+  /**
+   * Publish an event
+   *
+   * @example
+   * ```typescript
+   * await eventBus.publish({
+   *   type: 'TradeProposalCreated',
+   *   data: {
+   *     tradeId: '123',
+   *     initiatorId: 'user-1',
+   *     recipientId: 'user-2',
+   *   },
+   * });
+   * ```
+   */
+  async publish(event, options = {}) {
+    if (!this.isReady) {
+      throw new Error('EventBus is not ready. Wait for module initialization.');
+    }
+    // Build complete event
+    const eventId = options.id ?? event.id ?? generateEventId();
+    const correlationId = options.correlationId ?? event.correlationId ?? generateCorrelationId();
+    const timestamp = event.timestamp ?? new Date().toISOString();
+    const fullEvent = {
+      ...event,
+      id: eventId,
+      correlationId,
+      causationId: options.causationId ?? event.causationId,
+      timestamp,
+      priority: options.priority ?? event.priority ?? 'normal'
+    };
+    // Validate event against registry
+    const validated = this.registry.validate(fullEvent);
+    // Determine queue based on priority
+    const priority = validated.priority ?? 'normal';
+    const queueName = options.queue ?? this.getQueueForPriority(priority);
+    const instance = this.queues.get(queueName);
+    if (!instance) {
+      throw new Error(`Queue "${queueName}" not found. Available: ${Array.from(this.queues.keys()).join(', ')}`);
+    }
+    // Publish to BullMQ
+    const jobId = options.jobId ?? eventId;
+    const job = await instance.queue.add(validated.type,
+    // Job name = event type
+    validated, {
+      jobId,
+      delay: options.delay,
+      priority: this.getPriorityNumber(priority),
+      ...options.jobOptions
+    });
+    this.logger.debug(`Published event ${validated.type}:${eventId} to queue ${queueName} (job: ${job.id})`);
+    return {
+      eventId,
+      jobId: job.id ?? eventId,
+      queue: queueName,
+      correlationId
+    };
+  }
+  /**
+   * Publish multiple events in a batch
+   */
+  async publishBatch(events, options = {}) {
+    // Use same correlation ID for all events in batch
+    const correlationId = options.correlationId ?? generateCorrelationId();
+    const results = await Promise.all(events.map((event, index) => this.publish(event, {
+      ...options,
+      correlationId,
+      causationId: index > 0 ? events[index - 1].id : options.causationId
+    })));
+    return results;
+  }
+  /**
+   * Get queue for a given priority
+   */
+  getQueueForPriority(priority) {
+    const queueName = this.priorityToQueue.get(priority);
+    if (!queueName) {
+      // Fall back to normal queue
+      return this.priorityToQueue.get('normal') ?? 'events-normal';
+    }
+    return queueName;
+  }
+  /**
+   * Get queue stats
+   */
+  async getQueueStats(queueName) {
+    const instance = this.queues.get(queueName);
+    if (!instance) {
+      throw new Error(`Queue "${queueName}" not found`);
+    }
+    const [waiting, active, completed, failed, delayed] = await Promise.all([instance.queue.getWaitingCount(), instance.queue.getActiveCount(), instance.queue.getCompletedCount(), instance.queue.getFailedCount(), instance.queue.getDelayedCount()]);
+    return {
+      waiting,
+      active,
+      completed,
+      failed,
+      delayed
+    };
+  }
+  /**
+   * Get all queue names
+   */
+  getQueueNames() {
+    return Array.from(this.queues.keys());
+  }
+  /**
+   * Get underlying BullMQ queue for advanced operations
+   */
+  getQueue(name) {
+    return this.queues.get(name)?.queue;
+  }
+  /**
+   * Check if service is ready
+   */
+  isServiceReady() {
+    return this.isReady;
+  }
+  /**
+   * Convert priority string to number for BullMQ (lower = higher priority)
+   */
+  getPriorityNumber(priority) {
+    switch (priority) {
+      case 'critical':
+        return 1;
+      case 'high':
+        return 2;
+      case 'normal':
+        return 3;
+      case 'low':
+        return 4;
+      case 'bulk':
+        return 5;
+      default:
+        return 3;
+    }
+  }
+  /**
+   * Setup event listeners for monitoring
+   */
+  setupQueueEventListeners(instance) {
+    if (!instance.events) return;
+    instance.events.on('completed', ({
+      jobId
+    }) => {
+      this.logger.debug(`Job ${jobId} completed in queue ${instance.config.name}`);
+    });
+    instance.events.on('failed', ({
+      jobId,
+      failedReason
+    }) => {
+      this.logger.warn(`Job ${jobId} failed in queue ${instance.config.name}: ${failedReason}`);
+    });
+    instance.events.on('stalled', ({
+      jobId
+    }) => {
+      this.logger.warn(`Job ${jobId} stalled in queue ${instance.config.name}`);
+    });
+  }
+};
+EventBusService = EventBusService_1 = __decorate([Injectable(), __param(0, Inject(EVENT_BUS_CONFIG)), __param(1, Inject(EVENT_REGISTRY)), __metadata("design:paramtypes", [Object, EventRegistry])], EventBusService);
+
+var EventBusModule_1;
+/**
+ * Default queue configuration based on priorities
+ */
+const DEFAULT_QUEUES = [{
+  name: 'events-critical',
+  priorities: ['critical'],
+  concurrency: 10
+}, {
+  name: 'events-high',
+  priorities: ['high'],
+  concurrency: 8
+}, {
+  name: 'events-normal',
+  priorities: ['normal'],
+  concurrency: 5
+}, {
+  name: 'events-low',
+  priorities: ['low'],
+  concurrency: 3
+}, {
+  name: 'events-bulk',
+  priorities: ['bulk'],
+  concurrency: 2,
+  rateLimit: {
+    max: 100,
+    duration: 1000
+  }
+}];
+let EventBusModule = EventBusModule_1 = class EventBusModule {
+  /**
+   * Register the EventBus module with configuration
+   *
+   * @example
+   * ```typescript
+   * @Module({
+   *   imports: [
+   *     EventBusModule.forRoot({
+   *       redis: { host: 'localhost', port: 6379 },
+   *       queues: [
+   *         { name: 'critical', priorities: ['critical'], concurrency: 10 },
+   *         { name: 'normal', priorities: ['high', 'normal'], concurrency: 5 },
+   *       ],
+   *     }),
+   *   ],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRoot(config) {
+    const providers = EventBusModule_1.createProviders(config);
+    return {
+      module: EventBusModule_1,
+      global: true,
+      providers,
+      exports: [EventBusService, DlqService, EVENT_BUS_CONFIG, EVENT_REGISTRY, IDEMPOTENCY_STORE, ERROR_CLASSIFIER]
+    };
+  }
+  /**
+   * Register the EventBus module with async configuration
+   *
+   * @example
+   * ```typescript
+   * @Module({
+   *   imports: [
+   *     EventBusModule.forRootAsync({
+   *       imports: [ConfigModule],
+   *       useFactory: (configService: ConfigService) => ({
+   *         redis: {
+   *           host: configService.get('REDIS_HOST'),
+   *           port: configService.get('REDIS_PORT'),
+   *         },
+   *       }),
+   *       inject: [ConfigService],
+   *     }),
+   *   ],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRootAsync(asyncConfig) {
+    const configProvider = {
+      provide: EVENT_BUS_CONFIG,
+      useFactory: asyncConfig.useFactory,
+      inject: asyncConfig.inject ?? []
+    };
+    const registryProvider = {
+      provide: EVENT_REGISTRY,
+      useFactory: config => {
+        return createEventRegistry(config.registry);
+      },
+      inject: [EVENT_BUS_CONFIG]
+    };
+    const idempotencyProvider = {
+      provide: IDEMPOTENCY_STORE,
+      useFactory: config => {
+        return config.idempotencyStore ?? createInMemoryIdempotencyStore();
+      },
+      inject: [EVENT_BUS_CONFIG]
+    };
+    const errorClassifierProvider = {
+      provide: ERROR_CLASSIFIER,
+      useFactory: config => {
+        return createErrorClassifier(config.errorClassifier);
+      },
+      inject: [EVENT_BUS_CONFIG]
+    };
+    return {
+      module: EventBusModule_1,
+      global: true,
+      imports: asyncConfig.imports ?? [],
+      providers: [configProvider, registryProvider, idempotencyProvider, errorClassifierProvider, EventBusService, DlqService],
+      exports: [EventBusService, DlqService, EVENT_BUS_CONFIG, EVENT_REGISTRY, IDEMPOTENCY_STORE, ERROR_CLASSIFIER]
+    };
+  }
+  static createProviders(config) {
+    const queues = config.queues ?? DEFAULT_QUEUES;
+    const fullConfig = {
+      ...config,
+      queues,
+      enableDlq: config.enableDlq ?? true,
+      dlqQueueName: config.dlqQueueName ?? 'dead-letter',
+      enableMetrics: config.enableMetrics ?? true,
+      metricsPrefix: config.metricsPrefix ?? 'signaltree_events'
+    };
+    return [{
+      provide: EVENT_BUS_CONFIG,
+      useValue: fullConfig
+    }, {
+      provide: EVENT_REGISTRY,
+      useFactory: () => createEventRegistry(config.registry)
+    }, {
+      provide: IDEMPOTENCY_STORE,
+      useValue: config.idempotencyStore ?? createInMemoryIdempotencyStore()
+    }, {
+      provide: ERROR_CLASSIFIER,
+      useFactory: () => createErrorClassifier(config.errorClassifier)
+    }, EventBusService, DlqService];
+  }
+};
+EventBusModule = EventBusModule_1 = __decorate([Module({})], EventBusModule);
+
+/**
+ * Base class for event subscribers
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class TradeSubscriber extends BaseSubscriber {
+ *   protected readonly config: SubscriberConfig = {
+ *     name: 'trade-subscriber',
+ *     eventTypes: ['TradeProposalCreated', 'TradeAccepted'],
+ *     priority: 'high',
+ *     concurrency: 5,
+ *   };
+ *
+ *   async handle(event: TradeProposalCreated | TradeAccepted): Promise<ProcessingResult> {
+ *     switch (event.type) {
+ *       case 'TradeProposalCreated':
+ *         await this.handleTradeCreated(event);
+ *         break;
+ *       case 'TradeAccepted':
+ *         await this.handleTradeAccepted(event);
+ *         break;
+ *     }
+ *     return { success: true };
+ *   }
+ * }
+ * ```
+ */
+let BaseSubscriber = class BaseSubscriber {
+  busConfig;
+  idempotencyStore;
+  errorClassifier;
+  dlqService;
+  logger;
+  worker;
+  connection;
+  metrics = {
+    processed: 0,
+    succeeded: 0,
+    failed: 0,
+    retried: 0,
+    dlqSent: 0,
+    duplicatesSkipped: 0,
+    avgProcessingTimeMs: 0
+  };
+  constructor(busConfig, idempotencyStore, errorClassifier, dlqService) {
+    this.busConfig = busConfig;
+    this.idempotencyStore = idempotencyStore;
+    this.errorClassifier = errorClassifier;
+    this.dlqService = dlqService;
+    this.logger = new Logger(this.constructor.name);
+    this.connection = {
+      host: busConfig.redis.host,
+      port: busConfig.redis.port,
+      password: busConfig.redis.password,
+      db: busConfig.redis.db
+    };
+  }
+  /**
+   * Called before processing starts (for setup/validation)
+   */
+  async beforeProcess(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _event) {
+    // Override in subclass if needed
+  }
+  /**
+   * Called after processing completes (for cleanup)
+   */
+  async afterProcess(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _event,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _result) {
+    // Override in subclass if needed
+  }
+  async onModuleInit() {
+    const queueName = this.getQueueName();
+    this.logger.log(`Initializing subscriber "${this.config.name}" on queue "${queueName}" ` + `for events: ${this.config.eventTypes.join(', ')}`);
+    this.worker = new Worker(queueName, async job => this.processJob(job), {
+      connection: this.connection,
+      concurrency: this.config.concurrency ?? 5,
+      lockDuration: this.config.lockDuration ?? 30000,
+      stalledInterval: this.config.stalledInterval ?? 30000
+    });
+    this.setupWorkerListeners();
+    this.logger.log(`Subscriber "${this.config.name}" started`);
+  }
+  async onModuleDestroy() {
+    this.logger.log(`Shutting down subscriber "${this.config.name}"...`);
+    if (this.worker) {
+      await this.worker.close();
+    }
+    this.logger.log(`Subscriber "${this.config.name}" stopped`);
+  }
+  /**
+   * Get queue name based on config
+   */
+  getQueueName() {
+    if (this.config.queue) {
+      return this.config.queue;
+    }
+    // Find queue for priority
+    const priority = this.config.priority ?? 'normal';
+    const queueConfig = this.busConfig.queues?.find(q => q.priorities.includes(priority));
+    return queueConfig?.name ?? `events-${priority}`;
+  }
+  /**
+   * Process a job with idempotency and error handling
+   */
+  async processJob(job) {
+    const event = job.data;
+    const startTime = Date.now();
+    // Filter by event type
+    if (!this.config.eventTypes.includes(event.type)) {
+      // Not our event type, skip silently
+      return {
+        skipped: true,
+        reason: 'event_type_not_handled'
+      };
+    }
+    this.logger.debug(`Processing event ${event.type}:${event.id} (attempt ${job.attemptsMade + 1})`);
+    try {
+      // Check idempotency
+      if (this.config.idempotency !== false) {
+        const idempotencyResult = await this.checkIdempotency(event);
+        if (idempotencyResult.isDuplicate) {
+          this.metrics.duplicatesSkipped++;
+          this.logger.debug(`Skipping duplicate event ${event.id}`);
+          return idempotencyResult.result ?? {
+            skipped: true,
+            reason: 'duplicate'
+          };
+        }
+      }
+      // Before hook
+      await this.beforeProcess(event);
+      // Process event
+      const result = await this.handle(event);
+      // After hook
+      await this.afterProcess(event, result);
+      // Update idempotency store
+      if (this.config.idempotency !== false) {
+        await this.idempotencyStore.markCompleted(event, this.config.name, result.result);
+      }
+      // Update metrics
+      this.updateMetrics(startTime, true);
+      return result.result;
+    } catch (error) {
+      return this.handleError(job, event, error, startTime);
+    }
+  }
+  /**
+   * Handle processing error
+   */
+  async handleError(job, event, error, startTime) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    const classification = this.errorClassifier.classify(error);
+    this.logger.error(`Error processing event ${event.type}:${event.id}: ${errorObj.message}`, errorObj.stack);
+    // Update idempotency store with failure
+    if (this.config.idempotency !== false) {
+      await this.idempotencyStore.markFailed(event, this.config.name, error);
+    }
+    // Check if we should retry
+    const maxAttempts = classification.retryConfig?.maxAttempts ?? 5;
+    const shouldRetry = job.attemptsMade < maxAttempts && classification.classification !== 'poison';
+    if (shouldRetry) {
+      this.metrics.retried++;
+      this.logger.debug(`Will retry event ${event.id}, attempt ${job.attemptsMade + 1}/${maxAttempts}`);
+      throw errorObj; // BullMQ will retry
+    }
+    // Send to DLQ
+    if (this.busConfig.enableDlq && !this.config.skipDlq) {
+      await this.sendToDlq(event, errorObj, classification, job.attemptsMade + 1);
+    }
+    // Update metrics
+    this.updateMetrics(startTime, false);
+    // Don't throw - we've handled it by sending to DLQ
+    return {
+      failed: true,
+      error: errorObj.message,
+      sentToDlq: true
+    };
+  }
+  /**
+   * Check idempotency
+   */
+  async checkIdempotency(event) {
+    return this.idempotencyStore.check(event, this.config.name, {
+      acquireLock: true,
+      lockTtlMs: this.config.lockDuration ?? 30000
+    });
+  }
+  /**
+   * Send failed event to DLQ
+   */
+  async sendToDlq(event, error, classification, attempts) {
+    await this.dlqService.send({
+      event,
+      error: {
+        message: error.message,
+        stack: error.stack,
+        classification: classification.classification,
+        reason: classification.reason
+      },
+      subscriber: this.config.name,
+      attempts,
+      failedAt: new Date().toISOString()
+    });
+    this.metrics.dlqSent++;
+    this.logger.warn(`Event ${event.id} sent to DLQ after ${attempts} attempts. ` + `Classification: ${classification.classification}`);
+  }
+  /**
+   * Update metrics
+   */
+  updateMetrics(startTime, success) {
+    const duration = Date.now() - startTime;
+    this.metrics.processed++;
+    if (success) {
+      this.metrics.succeeded++;
+    } else {
+      this.metrics.failed++;
+    }
+    // Rolling average
+    this.metrics.avgProcessingTimeMs = (this.metrics.avgProcessingTimeMs * (this.metrics.processed - 1) + duration) / this.metrics.processed;
+    this.metrics.lastProcessedAt = new Date();
+  }
+  /**
+   * Setup worker event listeners
+   */
+  setupWorkerListeners() {
+    if (!this.worker) return;
+    this.worker.on('completed', job => {
+      this.logger.debug(`Job ${job.id} completed`);
+    });
+    this.worker.on('failed', (job, error) => {
+      this.logger.warn(`Job ${job?.id} failed: ${error.message}`);
+    });
+    this.worker.on('error', error => {
+      this.logger.error(`Worker error: ${error.message}`, error.stack);
+    });
+    this.worker.on('stalled', jobId => {
+      this.logger.warn(`Job ${jobId} stalled`);
+    });
+  }
+  /**
+   * Get current metrics
+   */
+  getMetrics() {
+    return {
+      ...this.metrics
+    };
+  }
+  /**
+   * Pause processing
+   */
+  async pause() {
+    if (this.worker) {
+      await this.worker.pause();
+      this.logger.log(`Subscriber "${this.config.name}" paused`);
+    }
+  }
+  /**
+   * Resume processing
+   */
+  async resume() {
+    if (this.worker) {
+      this.worker.resume();
+      this.logger.log(`Subscriber "${this.config.name}" resumed`);
+    }
+  }
+  /**
+   * Check if worker is running
+   */
+  isRunning() {
+    return this.worker?.isRunning() ?? false;
+  }
+};
+BaseSubscriber = __decorate([Injectable(), __param(0, Inject(EVENT_BUS_CONFIG)), __param(1, Inject(IDEMPOTENCY_STORE)), __param(2, Inject(ERROR_CLASSIFIER)), __metadata("design:paramtypes", [Object, Object, Object, DlqService])], BaseSubscriber);
+
+/**
+ * Decorators for event handling
+ */
+/**
+ * Metadata key for event handlers
+ */
+const EVENT_HANDLER_METADATA = 'EVENT_HANDLER_METADATA';
+/**
+ * Decorator to mark a method as an event handler
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class TradeSubscriber extends BaseSubscriber {
+ *   @OnEvent('TradeProposalCreated', { priority: 'high' })
+ *   async handleTradeCreated(event: TradeProposalCreated) {
+ *     // Handle the event
+ *   }
+ * }
+ * ```
+ */
+function OnEvent(eventType, options) {
+  return SetMetadata(EVENT_HANDLER_METADATA, {
+    eventType,
+    ...options
+  });
+}
+
+export { BaseSubscriber, DlqService, ERROR_CLASSIFIER, EVENT_BUS_CONFIG, EVENT_HANDLER_METADATA, EVENT_REGISTRY, EventBusModule, EventBusService, IDEMPOTENCY_STORE, OnEvent };