@signaltree/events 7.6.1 → 8.0.0

package/dist/nestjs/base.subscriber.cjs

@@ -1,287 +0,0 @@
-'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/decorators.cjs

@@ -1,35 +0,0 @@
-'use strict';
-
-require('reflect-metadata');
-var common = require('@nestjs/common');
-
-/**
- * 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 common.SetMetadata(EVENT_HANDLER_METADATA, {
-    eventType,
-    ...options
-  });
-}
-
-exports.EVENT_HANDLER_METADATA = EVENT_HANDLER_METADATA;
-exports.OnEvent = OnEvent;

package/dist/nestjs/dlq.service.cjs

@@ -1,249 +0,0 @@
-'use strict';
-
-var tslib = require('tslib');
-var common = require('@nestjs/common');
-var bullmq = require('bullmq');
-var tokens = require('./tokens.cjs');
-
-var DlqService_1;
-exports.DlqService = DlqService_1 = class DlqService {
-  config;
-  logger = new common.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 bullmq.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 bullmq.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;
-  }
-};
-exports.DlqService = DlqService_1 = tslib.__decorate([common.Injectable(), tslib.__param(0, common.Inject(tokens.EVENT_BUS_CONFIG)), tslib.__metadata("design:paramtypes", [Object])], exports.DlqService);