@signaltree/events 7.6.0 → 8.0.0

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

@@ -1,218 +0,0 @@
-'use strict';
-
-var tslib = require('tslib');
-var common = require('@nestjs/common');
-var dlq_service = require('./dlq.service.cjs');
-var eventBus_service = require('./event-bus.service.cjs');
-var tokens = require('./tokens.cjs');
-var registry = require('../core/registry.cjs');
-var idempotency = require('../core/idempotency.cjs');
-var errorClassification = require('../core/error-classification.cjs');
-
-var EventBusModule_1;
-/**
- * Preset definitions
- */
-const QUEUE_PRESETS = {
-  /**
-   * Full priority-based queues (default) - separate queues per priority
-   */
-  'priority-based': [{
-    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
-    }
-  }],
-  /**
-   * Single queue for all priorities - simpler setup, uses BullMQ priority numbers
-   */
-  'single-queue': [{
-    name: 'events',
-    priorities: ['critical', 'high', 'normal', 'low', 'bulk'],
-    concurrency: 10
-  }],
-  /**
-   * Minimal setup - one queue, low concurrency, good for development
-   */
-  'minimal': [{
-    name: 'events',
-    priorities: ['critical', 'high', 'normal', 'low', 'bulk'],
-    concurrency: 3
-  }]
-};
-/**
- * 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
-  }
-}];
-exports.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: [eventBus_service.EventBusService, dlq_service.DlqService, tokens.EVENT_BUS_CONFIG, tokens.EVENT_REGISTRY, tokens.IDEMPOTENCY_STORE, tokens.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: tokens.EVENT_BUS_CONFIG,
-      useFactory: asyncConfig.useFactory,
-      inject: asyncConfig.inject ?? []
-    };
-    const registryProvider = {
-      provide: tokens.EVENT_REGISTRY,
-      useFactory: config => {
-        return registry.createEventRegistry(config.registry);
-      },
-      inject: [tokens.EVENT_BUS_CONFIG]
-    };
-    const idempotencyProvider = {
-      provide: tokens.IDEMPOTENCY_STORE,
-      useFactory: config => {
-        return config.idempotencyStore ?? idempotency.createInMemoryIdempotencyStore();
-      },
-      inject: [tokens.EVENT_BUS_CONFIG]
-    };
-    const errorClassifierProvider = {
-      provide: tokens.ERROR_CLASSIFIER,
-      useFactory: config => {
-        return errorClassification.createErrorClassifier(config.errorClassifier);
-      },
-      inject: [tokens.EVENT_BUS_CONFIG]
-    };
-    return {
-      module: EventBusModule_1,
-      global: true,
-      imports: asyncConfig.imports ?? [],
-      providers: [configProvider, registryProvider, idempotencyProvider, errorClassifierProvider, eventBus_service.EventBusService, dlq_service.DlqService],
-      exports: [eventBus_service.EventBusService, dlq_service.DlqService, tokens.EVENT_BUS_CONFIG, tokens.EVENT_REGISTRY, tokens.IDEMPOTENCY_STORE, tokens.ERROR_CLASSIFIER]
-    };
-  }
-  /**
-   * Resolve queue configuration from preset or explicit config
-   */
-  static resolveQueues(config) {
-    // Explicit queues take precedence
-    if (config.queues && config.queues.length > 0) {
-      return config.queues;
-    }
-    // Use preset if specified
-    if (config.preset) {
-      return QUEUE_PRESETS[config.preset];
-    }
-    // Default to priority-based
-    return DEFAULT_QUEUES;
-  }
-  static createProviders(config) {
-    const queues = EventBusModule_1.resolveQueues(config);
-    const fullConfig = {
-      ...config,
-      queues,
-      enableDlq: config.enableDlq ?? true,
-      dlqQueueName: config.dlqQueueName ?? 'dead-letter',
-      enableMetrics: config.enableMetrics ?? true,
-      metricsPrefix: config.metricsPrefix ?? 'signaltree_events'
-    };
-    return [{
-      provide: tokens.EVENT_BUS_CONFIG,
-      useValue: fullConfig
-    }, {
-      provide: tokens.EVENT_REGISTRY,
-      useFactory: () => registry.createEventRegistry(config.registry)
-    }, {
-      provide: tokens.IDEMPOTENCY_STORE,
-      useValue: config.idempotencyStore ?? idempotency.createInMemoryIdempotencyStore()
-    }, {
-      provide: tokens.ERROR_CLASSIFIER,
-      useFactory: () => errorClassification.createErrorClassifier(config.errorClassifier)
-    }, eventBus_service.EventBusService, dlq_service.DlqService];
-  }
-};
-exports.EventBusModule = EventBusModule_1 = tslib.__decorate([common.Module({})], exports.EventBusModule);
-
-exports.QUEUE_PRESETS = QUEUE_PRESETS;

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

@@ -1,318 +0,0 @@
-'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 types = require('../core/types.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
-    };
-  }
-  /**
-   * Create an event with defaults from module configuration
-   *
-   * This is a convenience method that auto-fills id, timestamp, version,
-   * correlationId, and metadata.source from the module config.
-   *
-   * @example
-   * ```typescript
-   * // Instead of constructing the full event manually:
-   * const event = this.eventBus.createEvent('TradeProposalCreated', {
-   *   tradeId: '123',
-   *   initiatorId: 'user-1',
-   *   recipientId: 'user-2',
-   * }, {
-   *   actor: { id: userId, type: 'user' },
-   *   priority: 'high',
-   * });
-   *
-   * await this.eventBus.publish(event);
-   * ```
-   */
-  createEvent(type, data, options = {}) {
-    const id = options.id ?? factory.generateEventId();
-    const correlationId = options.correlationId ?? factory.generateCorrelationId();
-    const timestamp = options.timestamp ?? new Date().toISOString();
-    const actor = options.actor ?? {
-      id: 'system',
-      type: 'system'
-    };
-    const metadata = {
-      source: this.config.source ?? 'signaltree',
-      environment: this.config.environment ?? process.env['NODE_ENV'] ?? 'development',
-      ...options.metadata
-    };
-    return {
-      id,
-      type,
-      version: options.version ?? types.DEFAULT_EVENT_VERSION,
-      timestamp,
-      correlationId,
-      causationId: options.causationId,
-      actor,
-      metadata,
-      data,
-      priority: options.priority,
-      aggregate: options.aggregate
-    };
-  }
-  /**
-   * Convenience method to create and publish an event in one call
-   *
-   * Combines createEvent() and publish() for the common case.
-   *
-   * @example
-   * ```typescript
-   * await this.eventBus.publishEvent('TradeProposalCreated', {
-   *   tradeId: '123',
-   *   initiatorId: 'user-1',
-   * }, {
-   *   actor: { id: userId, type: 'user' },
-   *   priority: 'high',
-   * });
-   * ```
-   */
-  async publishEvent(type, data, options = {}) {
-    const event = this.createEvent(type, data, options);
-    return this.publish(event, {
-      delay: options.delay,
-      queue: options.queue,
-      jobId: options.jobId,
-      jobOptions: options.jobOptions,
-      priority: options.priority
-    });
-  }
-  /**
-   * 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/index.cjs

@@ -1,34 +0,0 @@
-'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; }
-});
-exports.QUEUE_PRESETS = eventBus_module.QUEUE_PRESETS;
-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/tokens.cjs

@@ -1,14 +0,0 @@
-'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;