@signaltree/events 7.3.6 → 7.4.1

package/{index.cjs.js → dist/core/validation.cjs}

@@ -1,8 +1,6 @@
 'use strict';
 
-var factory = require('./factory.cjs.js');
 var zod = require('zod');
-var idempotency = require('./idempotency.cjs.js');
 
 /**
  * Event validation using Zod schemas
@@ -174,27 +172,7 @@ function parseEvent(schema, event) {
   return schema.safeParse(event);
 }
 
-exports.DEFAULT_EVENT_VERSION = factory.DEFAULT_EVENT_VERSION;
-exports.EVENT_PRIORITIES = factory.EVENT_PRIORITIES;
-exports.createEvent = factory.createEvent;
-exports.createEventFactory = factory.createEventFactory;
-exports.generateCorrelationId = factory.generateCorrelationId;
-exports.generateEventId = factory.generateEventId;
-Object.defineProperty(exports, "z", {
-    enumerable: true,
-    get: function () { return zod.z; }
-});
-exports.DEFAULT_RETRY_CONFIGS = idempotency.DEFAULT_RETRY_CONFIGS;
-exports.EventRegistry = idempotency.EventRegistry;
-exports.InMemoryIdempotencyStore = idempotency.InMemoryIdempotencyStore;
-exports.classifyError = idempotency.classifyError;
-exports.createErrorClassifier = idempotency.createErrorClassifier;
-exports.createEventRegistry = idempotency.createEventRegistry;
-exports.createInMemoryIdempotencyStore = idempotency.createInMemoryIdempotencyStore;
-exports.defaultErrorClassifier = idempotency.defaultErrorClassifier;
-exports.generateCorrelationKey = idempotency.generateCorrelationKey;
-exports.generateIdempotencyKey = idempotency.generateIdempotencyKey;
-exports.isRetryableError = idempotency.isRetryableError;
+exports.AggregateSchema = AggregateSchema;
 exports.BaseEventSchema = BaseEventSchema;
 exports.EventActorSchema = EventActorSchema;
 exports.EventMetadataSchema = EventMetadataSchema;

package/{index.esm.js → dist/core/validation.js}

@@ -1,7 +1,4 @@
-export { D as DEFAULT_EVENT_VERSION, E as EVENT_PRIORITIES, c as createEvent, a as createEventFactory, b as generateCorrelationId, g as generateEventId } from './factory.esm.js';
 import { z } from 'zod';
-export { z } from 'zod';
-export { D as DEFAULT_RETRY_CONFIGS, E as EventRegistry, I as InMemoryIdempotencyStore, a as classifyError, b as createErrorClassifier, c as createEventRegistry, e as createInMemoryIdempotencyStore, d as defaultErrorClassifier, f as generateCorrelationKey, g as generateIdempotencyKey, i as isRetryableError } from './idempotency.esm.js';
 
 /**
  * Event validation using Zod schemas
@@ -173,4 +170,4 @@ function parseEvent(schema, event) {
   return schema.safeParse(event);
 }
 
-export { BaseEventSchema, EventActorSchema, EventMetadataSchema, EventValidationError, EventVersionSchema, createEventSchema, createEventSchemaFromZod, isValidEvent, parseEvent, validateEvent };
+export { AggregateSchema, BaseEventSchema, EventActorSchema, EventMetadataSchema, EventValidationError, EventVersionSchema, createEventSchema, createEventSchemaFromZod, isValidEvent, parseEvent, validateEvent };

package/dist/index.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var types = require('./core/types.cjs');
+var validation = require('./core/validation.cjs');
+var registry = require('./core/registry.cjs');
+var factory = require('./core/factory.cjs');
+var errorClassification = require('./core/error-classification.cjs');
+var idempotency = require('./core/idempotency.cjs');
+var zod = require('zod');
+
+
+
+exports.DEFAULT_EVENT_VERSION = types.DEFAULT_EVENT_VERSION;
+exports.EVENT_PRIORITIES = types.EVENT_PRIORITIES;
+exports.BaseEventSchema = validation.BaseEventSchema;
+exports.EventActorSchema = validation.EventActorSchema;
+exports.EventMetadataSchema = validation.EventMetadataSchema;
+exports.EventValidationError = validation.EventValidationError;
+exports.EventVersionSchema = validation.EventVersionSchema;
+exports.createEventSchema = validation.createEventSchema;
+exports.createEventSchemaFromZod = validation.createEventSchemaFromZod;
+exports.isValidEvent = validation.isValidEvent;
+exports.parseEvent = validation.parseEvent;
+exports.validateEvent = validation.validateEvent;
+exports.EventRegistry = registry.EventRegistry;
+exports.createEventRegistry = registry.createEventRegistry;
+exports.createEvent = factory.createEvent;
+exports.createEventFactory = factory.createEventFactory;
+exports.generateCorrelationId = factory.generateCorrelationId;
+exports.generateEventId = factory.generateEventId;
+exports.DEFAULT_RETRY_CONFIGS = errorClassification.DEFAULT_RETRY_CONFIGS;
+exports.classifyError = errorClassification.classifyError;
+exports.createErrorClassifier = errorClassification.createErrorClassifier;
+exports.defaultErrorClassifier = errorClassification.defaultErrorClassifier;
+exports.isRetryableError = errorClassification.isRetryableError;
+exports.InMemoryIdempotencyStore = idempotency.InMemoryIdempotencyStore;
+exports.createInMemoryIdempotencyStore = idempotency.createInMemoryIdempotencyStore;
+exports.generateCorrelationKey = idempotency.generateCorrelationKey;
+exports.generateIdempotencyKey = idempotency.generateIdempotencyKey;
+Object.defineProperty(exports, "z", {
+	enumerable: true,
+	get: function () { return zod.z; }
+});

package/dist/index.js

@@ -0,0 +1,7 @@
+export { DEFAULT_EVENT_VERSION, EVENT_PRIORITIES } from './core/types.js';
+export { BaseEventSchema, EventActorSchema, EventMetadataSchema, EventValidationError, EventVersionSchema, createEventSchema, createEventSchemaFromZod, isValidEvent, parseEvent, validateEvent } from './core/validation.js';
+export { EventRegistry, createEventRegistry } from './core/registry.js';
+export { createEvent, createEventFactory, generateCorrelationId, generateEventId } from './core/factory.js';
+export { DEFAULT_RETRY_CONFIGS, classifyError, createErrorClassifier, defaultErrorClassifier, isRetryableError } from './core/error-classification.js';
+export { InMemoryIdempotencyStore, createInMemoryIdempotencyStore, generateCorrelationKey, generateIdempotencyKey } from './core/idempotency.js';
+export { z } from 'zod';

package/dist/nestjs/base.subscriber.cjs

@@ -0,0 +1,287 @@
+'use strict';
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var bullmq = require('bullmq');
+var dlq_service = require('./dlq.service.cjs');
+var tokens = require('./tokens.cjs');
+
+/**
+ * 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 };
+ *   }
+ * }
+ * ```
+ */
+exports.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 common.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 bullmq.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;
+  }
+};
+exports.BaseSubscriber = tslib.__decorate([common.Injectable(), tslib.__param(0, common.Inject(tokens.EVENT_BUS_CONFIG)), tslib.__param(1, common.Inject(tokens.IDEMPOTENCY_STORE)), tslib.__param(2, common.Inject(tokens.ERROR_CLASSIFIER)), tslib.__metadata("design:paramtypes", [Object, Object, Object, dlq_service.DlqService])], exports.BaseSubscriber);

package/dist/nestjs/base.subscriber.js

@@ -0,0 +1,287 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { Worker } from 'bullmq';
+import { DlqService } from './dlq.service.js';
+import { EVENT_BUS_CONFIG, IDEMPOTENCY_STORE, ERROR_CLASSIFIER } from './tokens.js';
+
+/**
+ * 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);
+
+export { BaseSubscriber };