@signaltree/events 7.3.5 → 7.4.0

package/dist/testing/mock-event-bus.cjs

@@ -0,0 +1,237 @@
+'use strict';
+
+var factory = require('../core/factory.cjs');
+
+/**
+ * Mock Event Bus for testing
+ *
+ * @example
+ * ```typescript
+ * const eventBus = createMockEventBus();
+ *
+ * // Subscribe to events
+ * eventBus.subscribe('TradeProposalCreated', (event) => {
+ *   expect(event.data.tradeId).toBe('123');
+ * });
+ *
+ * // Publish an event
+ * await eventBus.publish({
+ *   type: 'TradeProposalCreated',
+ *   data: { tradeId: '123' },
+ * });
+ *
+ * // Assert published events
+ * expect(eventBus.getPublishedEvents()).toHaveLength(1);
+ * expect(eventBus.wasPublished('TradeProposalCreated')).toBe(true);
+ * ```
+ */
+class MockEventBus {
+  options;
+  publishedEvents = [];
+  subscriptions = new Map();
+  allSubscriptions = new Set();
+  constructor(options = {}) {
+    this.options = options;
+    this.options = {
+      simulateAsync: false,
+      asyncDelayMs: 10,
+      autoGenerateIds: true,
+      throwOnError: false,
+      ...options
+    };
+  }
+  /**
+   * Publish an event
+   */
+  async publish(event, options) {
+    // Complete the event
+    const fullEvent = {
+      ...event,
+      id: event.id ?? (this.options.autoGenerateIds ? factory.generateEventId() : 'test-event-id'),
+      timestamp: event.timestamp ?? new Date().toISOString(),
+      correlationId: event.correlationId ?? factory.generateCorrelationId()
+    };
+    const queue = options?.queue ?? this.getQueueForPriority(fullEvent.priority);
+    // Record the published event
+    this.publishedEvents.push({
+      event: fullEvent,
+      queue,
+      publishedAt: new Date(),
+      delay: options?.delay
+    });
+    // Simulate async if configured
+    if (this.options.simulateAsync) {
+      await this.delay(this.options.asyncDelayMs ?? 10);
+    }
+    // Notify subscribers
+    await this.notifySubscribers(fullEvent);
+    return {
+      eventId: fullEvent.id,
+      queue
+    };
+  }
+  /**
+   * Publish multiple events
+   */
+  async publishBatch(events, options) {
+    const correlationId = factory.generateCorrelationId();
+    return Promise.all(events.map(event => this.publish({
+      ...event,
+      correlationId
+    }, {
+      ...options
+    })));
+  }
+  /**
+   * Subscribe to a specific event type
+   */
+  subscribe(eventType, handler) {
+    let handlers = this.subscriptions.get(eventType);
+    if (!handlers) {
+      handlers = new Set();
+      this.subscriptions.set(eventType, handlers);
+    }
+    handlers.add(handler);
+    // Return unsubscribe function
+    // handlers is guaranteed to exist at this point since we just set it above
+    return () => {
+      const h = this.subscriptions.get(eventType);
+      if (h) {
+        h.delete(handler);
+      }
+    };
+  }
+  /**
+   * Subscribe to all events
+   */
+  subscribeAll(handler) {
+    this.allSubscriptions.add(handler);
+    return () => {
+      this.allSubscriptions.delete(handler);
+    };
+  }
+  /**
+   * Get all published events
+   */
+  getPublishedEvents() {
+    return [...this.publishedEvents];
+  }
+  /**
+   * Get published events by type
+   */
+  getPublishedEventsByType(type) {
+    return this.publishedEvents.filter(p => p.event.type === type);
+  }
+  /**
+   * Get the last published event
+   */
+  getLastPublishedEvent() {
+    return this.publishedEvents[this.publishedEvents.length - 1];
+  }
+  /**
+   * Get the last published event of a specific type
+   */
+  getLastPublishedEventByType(type) {
+    const events = this.getPublishedEventsByType(type);
+    return events[events.length - 1];
+  }
+  /**
+   * Check if an event type was published
+   */
+  wasPublished(eventType) {
+    return this.publishedEvents.some(p => p.event.type === eventType);
+  }
+  /**
+   * Check if an event with specific data was published
+   */
+  wasPublishedWith(eventType, predicate) {
+    return this.publishedEvents.some(p => p.event.type === eventType && predicate(p.event));
+  }
+  /**
+   * Get count of published events
+   */
+  getPublishedCount(eventType) {
+    if (eventType) {
+      return this.publishedEvents.filter(p => p.event.type === eventType).length;
+    }
+    return this.publishedEvents.length;
+  }
+  /**
+   * Clear all published events (for test cleanup)
+   */
+  clearHistory() {
+    this.publishedEvents = [];
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clearSubscriptions() {
+    this.subscriptions.clear();
+    this.allSubscriptions.clear();
+  }
+  /**
+   * Reset the mock (clear history and subscriptions)
+   */
+  reset() {
+    this.clearHistory();
+    this.clearSubscriptions();
+  }
+  /**
+   * Simulate an incoming event (as if received from server)
+   */
+  async simulateIncomingEvent(event) {
+    await this.notifySubscribers(event);
+  }
+  // Private methods
+  async notifySubscribers(event) {
+    const errors = [];
+    // Notify type-specific subscribers
+    const handlers = this.subscriptions.get(event.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          await handler(event);
+        } catch (error) {
+          errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    }
+    // Notify all-event subscribers
+    for (const handler of this.allSubscriptions) {
+      try {
+        await handler(event);
+      } catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    if (errors.length > 0 && this.options.throwOnError) {
+      throw new AggregateError(errors, 'Subscriber errors');
+    }
+  }
+  getQueueForPriority(priority) {
+    switch (priority) {
+      case 'critical':
+        return 'events-critical';
+      case 'high':
+        return 'events-high';
+      case 'low':
+        return 'events-low';
+      case 'bulk':
+        return 'events-bulk';
+      default:
+        return 'events-normal';
+    }
+  }
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+/**
+ * Create a mock event bus for testing
+ */
+function createMockEventBus(options) {
+  return new MockEventBus(options);
+}
+
+exports.MockEventBus = MockEventBus;
+exports.createMockEventBus = createMockEventBus;

package/dist/testing/mock-event-bus.js

@@ -0,0 +1,234 @@
+import { generateCorrelationId, generateEventId } from '../core/factory.js';
+
+/**
+ * Mock Event Bus for testing
+ *
+ * @example
+ * ```typescript
+ * const eventBus = createMockEventBus();
+ *
+ * // Subscribe to events
+ * eventBus.subscribe('TradeProposalCreated', (event) => {
+ *   expect(event.data.tradeId).toBe('123');
+ * });
+ *
+ * // Publish an event
+ * await eventBus.publish({
+ *   type: 'TradeProposalCreated',
+ *   data: { tradeId: '123' },
+ * });
+ *
+ * // Assert published events
+ * expect(eventBus.getPublishedEvents()).toHaveLength(1);
+ * expect(eventBus.wasPublished('TradeProposalCreated')).toBe(true);
+ * ```
+ */
+class MockEventBus {
+  options;
+  publishedEvents = [];
+  subscriptions = new Map();
+  allSubscriptions = new Set();
+  constructor(options = {}) {
+    this.options = options;
+    this.options = {
+      simulateAsync: false,
+      asyncDelayMs: 10,
+      autoGenerateIds: true,
+      throwOnError: false,
+      ...options
+    };
+  }
+  /**
+   * Publish an event
+   */
+  async publish(event, options) {
+    // Complete the event
+    const fullEvent = {
+      ...event,
+      id: event.id ?? (this.options.autoGenerateIds ? generateEventId() : 'test-event-id'),
+      timestamp: event.timestamp ?? new Date().toISOString(),
+      correlationId: event.correlationId ?? generateCorrelationId()
+    };
+    const queue = options?.queue ?? this.getQueueForPriority(fullEvent.priority);
+    // Record the published event
+    this.publishedEvents.push({
+      event: fullEvent,
+      queue,
+      publishedAt: new Date(),
+      delay: options?.delay
+    });
+    // Simulate async if configured
+    if (this.options.simulateAsync) {
+      await this.delay(this.options.asyncDelayMs ?? 10);
+    }
+    // Notify subscribers
+    await this.notifySubscribers(fullEvent);
+    return {
+      eventId: fullEvent.id,
+      queue
+    };
+  }
+  /**
+   * Publish multiple events
+   */
+  async publishBatch(events, options) {
+    const correlationId = generateCorrelationId();
+    return Promise.all(events.map(event => this.publish({
+      ...event,
+      correlationId
+    }, {
+      ...options
+    })));
+  }
+  /**
+   * Subscribe to a specific event type
+   */
+  subscribe(eventType, handler) {
+    let handlers = this.subscriptions.get(eventType);
+    if (!handlers) {
+      handlers = new Set();
+      this.subscriptions.set(eventType, handlers);
+    }
+    handlers.add(handler);
+    // Return unsubscribe function
+    // handlers is guaranteed to exist at this point since we just set it above
+    return () => {
+      const h = this.subscriptions.get(eventType);
+      if (h) {
+        h.delete(handler);
+      }
+    };
+  }
+  /**
+   * Subscribe to all events
+   */
+  subscribeAll(handler) {
+    this.allSubscriptions.add(handler);
+    return () => {
+      this.allSubscriptions.delete(handler);
+    };
+  }
+  /**
+   * Get all published events
+   */
+  getPublishedEvents() {
+    return [...this.publishedEvents];
+  }
+  /**
+   * Get published events by type
+   */
+  getPublishedEventsByType(type) {
+    return this.publishedEvents.filter(p => p.event.type === type);
+  }
+  /**
+   * Get the last published event
+   */
+  getLastPublishedEvent() {
+    return this.publishedEvents[this.publishedEvents.length - 1];
+  }
+  /**
+   * Get the last published event of a specific type
+   */
+  getLastPublishedEventByType(type) {
+    const events = this.getPublishedEventsByType(type);
+    return events[events.length - 1];
+  }
+  /**
+   * Check if an event type was published
+   */
+  wasPublished(eventType) {
+    return this.publishedEvents.some(p => p.event.type === eventType);
+  }
+  /**
+   * Check if an event with specific data was published
+   */
+  wasPublishedWith(eventType, predicate) {
+    return this.publishedEvents.some(p => p.event.type === eventType && predicate(p.event));
+  }
+  /**
+   * Get count of published events
+   */
+  getPublishedCount(eventType) {
+    if (eventType) {
+      return this.publishedEvents.filter(p => p.event.type === eventType).length;
+    }
+    return this.publishedEvents.length;
+  }
+  /**
+   * Clear all published events (for test cleanup)
+   */
+  clearHistory() {
+    this.publishedEvents = [];
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clearSubscriptions() {
+    this.subscriptions.clear();
+    this.allSubscriptions.clear();
+  }
+  /**
+   * Reset the mock (clear history and subscriptions)
+   */
+  reset() {
+    this.clearHistory();
+    this.clearSubscriptions();
+  }
+  /**
+   * Simulate an incoming event (as if received from server)
+   */
+  async simulateIncomingEvent(event) {
+    await this.notifySubscribers(event);
+  }
+  // Private methods
+  async notifySubscribers(event) {
+    const errors = [];
+    // Notify type-specific subscribers
+    const handlers = this.subscriptions.get(event.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          await handler(event);
+        } catch (error) {
+          errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    }
+    // Notify all-event subscribers
+    for (const handler of this.allSubscriptions) {
+      try {
+        await handler(event);
+      } catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    if (errors.length > 0 && this.options.throwOnError) {
+      throw new AggregateError(errors, 'Subscriber errors');
+    }
+  }
+  getQueueForPriority(priority) {
+    switch (priority) {
+      case 'critical':
+        return 'events-critical';
+      case 'high':
+        return 'events-high';
+      case 'low':
+        return 'events-low';
+      case 'bulk':
+        return 'events-bulk';
+      default:
+        return 'events-normal';
+    }
+  }
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+/**
+ * Create a mock event bus for testing
+ */
+function createMockEventBus(options) {
+  return new MockEventBus(options);
+}
+
+export { MockEventBus, createMockEventBus };

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "@signaltree/events",
-  "version": "7.3.5",
+  "version": "7.4.0",
   "description": "Event-driven architecture infrastructure for SignalTree - event bus, subscribers, validation, and real-time sync",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
-  "main": "./index.cjs.js",
+  "main": "./dist/index.cjs",
   "module": "./index.esm.js",
-  "types": "./index.d.ts",
+  "types": "./src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "import": "./index.esm.js",
-      "require": "./index.cjs.js",
-      "default": "./index.esm.js"
+      "types": "./src/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
     },
     "./nestjs": {
-      "types": "./nestjs.d.ts",
-      "import": "./nestjs.esm.js",
-      "require": "./nestjs.cjs.js",
-      "default": "./nestjs.esm.js"
+      "types": "./src/nestjs/index.d.ts",
+      "import": "./dist/nestjs/index.js",
+      "require": "./dist/nestjs/index.cjs",
+      "default": "./dist/nestjs/index.js"
     },
     "./angular": {
-      "types": "./angular.d.ts",
-      "import": "./angular.esm.js",
-      "require": "./angular.cjs.js",
-      "default": "./angular.esm.js"
+      "types": "./src/angular/index.d.ts",
+      "import": "./dist/angular/index.js",
+      "require": "./dist/angular/index.cjs",
+      "default": "./dist/angular/index.js"
     },
     "./testing": {
-      "types": "./testing.d.ts",
-      "import": "./testing.esm.js",
-      "require": "./testing.cjs.js",
-      "default": "./testing.esm.js"
+      "types": "./src/testing/index.d.ts",
+      "import": "./dist/testing/index.js",
+      "require": "./dist/testing/index.cjs",
+      "default": "./dist/testing/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -89,8 +89,8 @@
     "access": "public"
   },
   "files": [
-    "*.esm.js",
-    "*.d.ts",
+    "dist/**/*.js",
+    "dist/**/*.cjs",
     "src/**/*.d.ts",
     "README.md"
   ],
@@ -115,4 +115,4 @@
     "url": "https://github.com/JBorgia/signaltree/issues"
   },
   "homepage": "https://github.com/JBorgia/signaltree/tree/main/packages/events#readme"
-}
+}

package/angular.d.ts

@@ -1 +0,0 @@
-export * from "./src/angular";