@signaltree/events 7.3.6 → 7.4.1

package/dist/nestjs/event-bus.module.js

@@ -0,0 +1,152 @@
+import { __decorate } from 'tslib';
+import { Module } from '@nestjs/common';
+import { DlqService } from './dlq.service.js';
+import { EventBusService } from './event-bus.service.js';
+import { EVENT_BUS_CONFIG, EVENT_REGISTRY, IDEMPOTENCY_STORE, ERROR_CLASSIFIER } from './tokens.js';
+import { createEventRegistry } from '../core/registry.js';
+import { createInMemoryIdempotencyStore } from '../core/idempotency.js';
+import { createErrorClassifier } from '../core/error-classification.js';
+
+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);
+
+export { EventBusModule };

package/dist/nestjs/event-bus.service.cjs

@@ -0,0 +1,243 @@
+'use strict';
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var bullmq = require('bullmq');
+var factory = require('../core/factory.cjs');
+var registry = require('../core/registry.cjs');
+var tokens = require('./tokens.cjs');
+
+var EventBusService_1;
+exports.EventBusService = EventBusService_1 = class EventBusService {
+  config;
+  registry;
+  logger = new common.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 bullmq.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 bullmq.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 ?? factory.generateEventId();
+    const correlationId = options.correlationId ?? event.correlationId ?? factory.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 ?? factory.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}`);
+    });
+  }
+};
+exports.EventBusService = EventBusService_1 = tslib.__decorate([common.Injectable(), tslib.__param(0, common.Inject(tokens.EVENT_BUS_CONFIG)), tslib.__param(1, common.Inject(tokens.EVENT_REGISTRY)), tslib.__metadata("design:paramtypes", [Object, registry.EventRegistry])], exports.EventBusService);

package/dist/nestjs/event-bus.service.js

@@ -0,0 +1,243 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { Queue, QueueEvents } from 'bullmq';
+import { generateEventId, generateCorrelationId } from '../core/factory.js';
+import { EventRegistry } from '../core/registry.js';
+import { EVENT_BUS_CONFIG, EVENT_REGISTRY } from './tokens.js';
+
+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);
+
+export { EventBusService };

package/dist/nestjs/index.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var eventBus_module = require('./event-bus.module.cjs');
+var eventBus_service = require('./event-bus.service.cjs');
+var base_subscriber = require('./base.subscriber.cjs');
+var dlq_service = require('./dlq.service.cjs');
+var decorators = require('./decorators.cjs');
+var tokens = require('./tokens.cjs');
+
+
+
+Object.defineProperty(exports, "EventBusModule", {
+	enumerable: true,
+	get: function () { return eventBus_module.EventBusModule; }
+});
+Object.defineProperty(exports, "EventBusService", {
+	enumerable: true,
+	get: function () { return eventBus_service.EventBusService; }
+});
+Object.defineProperty(exports, "BaseSubscriber", {
+	enumerable: true,
+	get: function () { return base_subscriber.BaseSubscriber; }
+});
+Object.defineProperty(exports, "DlqService", {
+	enumerable: true,
+	get: function () { return dlq_service.DlqService; }
+});
+exports.EVENT_HANDLER_METADATA = decorators.EVENT_HANDLER_METADATA;
+exports.OnEvent = decorators.OnEvent;
+exports.ERROR_CLASSIFIER = tokens.ERROR_CLASSIFIER;
+exports.EVENT_BUS_CONFIG = tokens.EVENT_BUS_CONFIG;
+exports.EVENT_REGISTRY = tokens.EVENT_REGISTRY;
+exports.IDEMPOTENCY_STORE = tokens.IDEMPOTENCY_STORE;

package/dist/nestjs/index.js

@@ -0,0 +1,6 @@
+export { EventBusModule } from './event-bus.module.js';
+export { EventBusService } from './event-bus.service.js';
+export { BaseSubscriber } from './base.subscriber.js';
+export { DlqService } from './dlq.service.js';
+export { EVENT_HANDLER_METADATA, OnEvent } from './decorators.js';
+export { ERROR_CLASSIFIER, EVENT_BUS_CONFIG, EVENT_REGISTRY, IDEMPOTENCY_STORE } from './tokens.js';

package/dist/nestjs/tokens.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * 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');
+
+exports.ERROR_CLASSIFIER = ERROR_CLASSIFIER;
+exports.EVENT_BUS_CONFIG = EVENT_BUS_CONFIG;
+exports.EVENT_REGISTRY = EVENT_REGISTRY;
+exports.IDEMPOTENCY_STORE = IDEMPOTENCY_STORE;

package/dist/nestjs/tokens.js

@@ -0,0 +1,9 @@
+/**
+ * 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');
+
+export { ERROR_CLASSIFIER, EVENT_BUS_CONFIG, EVENT_REGISTRY, IDEMPOTENCY_STORE };