@woltz/rich-domain 0.2.2 → 1.1.0

package/src/domain-event-bus.ts

@@ -1,166 +1,152 @@
-// ============================================================================
-// Domain Event Bus - Pub/Sub for Domain Events
-// ============================================================================
-
-import {
-  IDomainEvent,
-  DomainEventHandler,
-  IDomainEventHandler,
-} from "./domain-event";
-
-type EventConstructor<T extends IDomainEvent = IDomainEvent> = new (
-  ...args: any[]
-) => T;
-
-/**
- * Domain Event Bus - Singleton pattern for event pub/sub
- */
-export class DomainEventBus {
-  private static instance: DomainEventBus;
-  private handlers: Map<
-    string,
-    Set<DomainEventHandler<any> | IDomainEventHandler<any>>
-  > = new Map();
-  private wildcardHandlers: Set<
-    DomainEventHandler<any> | IDomainEventHandler<any>
-  > = new Set();
-
-  private constructor() {}
-
-  /**
-   * Get the singleton instance
-   */
-  static getInstance(): DomainEventBus {
-    if (!DomainEventBus.instance) {
-      DomainEventBus.instance = new DomainEventBus();
-    }
-    return DomainEventBus.instance;
-  }
-
-  /**
-   * Subscribe to a specific event type
-   */
-  subscribe<T extends IDomainEvent>(
-    eventType: EventConstructor<T> | string,
-    handler: DomainEventHandler<T> | IDomainEventHandler<T>
-  ): void {
-    const eventName =
-      typeof eventType === "string" ? eventType : eventType.name;
-
-    if (!this.handlers.has(eventName)) {
-      this.handlers.set(eventName, new Set());
-    }
-
-    this.handlers.get(eventName)!.add(handler);
-  }
-
-  /**
-   * Subscribe to all events (wildcard)
-   */
-  subscribeAll(
-    handler: DomainEventHandler<IDomainEvent> | IDomainEventHandler<IDomainEvent>
-  ): void {
-    this.wildcardHandlers.add(handler);
-  }
-
-  /**
-   * Unsubscribe from a specific event type
-   */
-  unsubscribe<T extends IDomainEvent>(
-    eventType: EventConstructor<T> | string,
-    handler: DomainEventHandler<T> | IDomainEventHandler<T>
-  ): void {
-    const eventName =
-      typeof eventType === "string" ? eventType : eventType.name;
-    const handlers = this.handlers.get(eventName);
-
-    if (handlers) {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.handlers.delete(eventName);
-      }
-    }
-  }
-
-  /**
-   * Unsubscribe from all events
-   */
-  unsubscribeAll(
-    handler: DomainEventHandler<IDomainEvent> | IDomainEventHandler<IDomainEvent>
-  ): void {
-    this.wildcardHandlers.delete(handler);
-  }
-
-  /**
-   * Publish a single event
-   */
-  async publish<T extends IDomainEvent>(event: T): Promise<void> {
-    const eventName = event.eventName;
-    const handlers = this.handlers.get(eventName) || new Set();
-
-    // Execute specific handlers
-    const specificPromises = Array.from(handlers).map((handler) =>
-      this.executeHandler(handler, event)
-    );
-
-    // Execute wildcard handlers
-    const wildcardPromises = Array.from(this.wildcardHandlers).map((handler) =>
-      this.executeHandler(handler, event)
-    );
-
-    await Promise.all([...specificPromises, ...wildcardPromises]);
-  }
-
-  /**
-   * Publish multiple events
-   */
-  async publishAll(events: IDomainEvent[]): Promise<void> {
-    await Promise.all(events.map((event) => this.publish(event)));
-  }
-
-  /**
-   * Clear all handlers (useful for testing)
-   */
-  clearAllHandlers(): void {
-    this.handlers.clear();
-    this.wildcardHandlers.clear();
-  }
-
-  /**
-   * Get count of handlers for an event type
-   */
-  getHandlerCount(eventType: EventConstructor | string): number {
-    const eventName =
-      typeof eventType === "string" ? eventType : eventType.name;
-    return this.handlers.get(eventName)?.size || 0;
-  }
-
-  /**
-   * Execute a handler (function or class)
-   */
-  private async executeHandler(
-    handler: DomainEventHandler<any> | IDomainEventHandler<any>,
-    event: IDomainEvent
-  ): Promise<void> {
-    try {
-      if (typeof handler === "function") {
-        await handler(event);
-      } else {
-        await handler.handle(event);
-      }
-    } catch (error) {
-      console.error(
-        `Error handling event ${event.eventName}:`,
-        error
-      );
-      // Don't throw - we don't want one handler failure to break others
-    }
-  }
-}
-
-/**
- * Convenience function to get the event bus instance
- */
-export function getEventBus(): DomainEventBus {
-  return DomainEventBus.getInstance();
-}
+import { IDomainEvent, DomainEventHandler, IDomainEventHandler } from ".";
+
+type EventConstructor<T extends IDomainEvent = IDomainEvent> = new (
+  ...args: any[]
+) => T;
+
+/**
+ * Domain Event Bus - Singleton pattern for event pub/sub
+ */
+export class DomainEventBus {
+  private static instance: DomainEventBus;
+  private handlers: Map<
+    string,
+    Set<DomainEventHandler<any> | IDomainEventHandler<any>>
+  > = new Map();
+  private wildcardHandlers: Set<
+    DomainEventHandler<any> | IDomainEventHandler<any>
+  > = new Set();
+
+  private constructor() {}
+
+  /**
+   * Get the singleton instance
+   */
+  static getInstance(): DomainEventBus {
+    if (!DomainEventBus.instance) {
+      DomainEventBus.instance = new DomainEventBus();
+    }
+    return DomainEventBus.instance;
+  }
+
+  /**
+   * Subscribe to a specific event type
+   */
+  subscribe<T extends IDomainEvent>(props: {
+    event: EventConstructor<T> | string;
+    handler: DomainEventHandler<T> | IDomainEventHandler<T>;
+  }): void {
+    const { event, handler } = props;
+    const eventName = typeof event === "string" ? event : event.name;
+
+    if (!this.handlers.has(eventName)) {
+      this.handlers.set(eventName, new Set());
+    }
+
+    this.handlers.get(eventName)!.add(handler);
+  }
+
+  /**
+   * Subscribe to all events (wildcard)
+   */
+  subscribeAll(
+    handler:
+      | DomainEventHandler<IDomainEvent>
+      | IDomainEventHandler<IDomainEvent>
+  ): void {
+    this.wildcardHandlers.add(handler);
+  }
+
+  /**
+   * Unsubscribe from a specific event type
+   */
+  unsubscribe<T extends IDomainEvent>(
+    eventType: EventConstructor<T> | string,
+    handler: DomainEventHandler<T> | IDomainEventHandler<T>
+  ): void {
+    const eventName =
+      typeof eventType === "string" ? eventType : eventType.name;
+    const handlers = this.handlers.get(eventName);
+
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(eventName);
+      }
+    }
+  }
+
+  /**
+   * Unsubscribe from all events
+   */
+  unsubscribeAll(
+    handler:
+      | DomainEventHandler<IDomainEvent>
+      | IDomainEventHandler<IDomainEvent>
+  ): void {
+    this.wildcardHandlers.delete(handler);
+  }
+
+  /**
+   * Publish a single event
+   */
+  async publish<T extends IDomainEvent>(event: T): Promise<void> {
+    const eventName = event.eventName;
+    const handlers = this.handlers.get(eventName) || new Set();
+
+    // Execute specific handlers
+    const specificPromises = Array.from(handlers).map((handler) =>
+      this.executeHandler(handler, event)
+    );
+
+    // Execute wildcard handlers
+    const wildcardPromises = Array.from(this.wildcardHandlers).map((handler) =>
+      this.executeHandler(handler, event)
+    );
+
+    await Promise.all([...specificPromises, ...wildcardPromises]);
+  }
+
+  /**
+   * Publish multiple events
+   */
+  async publishAll(events: IDomainEvent[]): Promise<void> {
+    await Promise.all(events.map((event) => this.publish(event)));
+  }
+
+  /**
+   * Clear all handlers (useful for testing)
+   */
+  clearAllHandlers(): void {
+    this.handlers.clear();
+    this.wildcardHandlers.clear();
+  }
+
+  /**
+   * Get count of handlers for an event type
+   */
+  getHandlerCount(eventType: EventConstructor | string): number {
+    const eventName =
+      typeof eventType === "string" ? eventType : eventType.name;
+    return this.handlers.get(eventName)?.size || 0;
+  }
+
+  /**
+   * Execute a handler (function or class)
+   */
+  private async executeHandler(
+    handler: DomainEventHandler<any> | IDomainEventHandler<any>,
+    event: IDomainEvent
+  ): Promise<void> {
+    try {
+      if (typeof handler === "function") {
+        await handler(event);
+      } else {
+        await handler.handle(event);
+      }
+    } catch (error) {
+      console.error(`Error handling event ${event.eventName}:`, error);
+      // Don't throw - we don't want one handler failure to break others
+    }
+  }
+}

package/src/domain-event.ts

@@ -1,90 +1,53 @@
-// ============================================================================
-// Domain Events - Event-Driven Architecture Support
-// ============================================================================
-
-import { Id } from "./id";
-
-/**
- * Interface for all domain events
- */
-export interface IDomainEvent {
-  /**
-   * Unique identifier for this event occurrence
-   */
-  readonly eventId: string;
-
-  /**
-   * When the event occurred
-   */
-  readonly occurredOn: Date;
-
-  /**
-   * Name/type of the event (e.g., "UserCreated", "OrderPlaced")
-   */
-  readonly eventName: string;
-
-  /**
-   * ID of the aggregate that raised this event
-   */
-  readonly aggregateId: string;
-}
-
-/**
- * Base class for domain events
- */
-export abstract class DomainEvent implements IDomainEvent {
-  public readonly eventId: string;
-  public readonly occurredOn: Date;
-  public readonly aggregateId: string;
-
-  constructor(aggregateId: Id | string) {
-    this.eventId = this.generateEventId();
-    this.occurredOn = new Date();
-    this.aggregateId = aggregateId instanceof Id ? aggregateId.value : aggregateId;
-  }
-
-  /**
-   * Get the event name (defaults to class name)
-   */
-  get eventName(): string {
-    return this.constructor.name;
-  }
-
-  private generateEventId(): string {
-    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Convert event to JSON
-   */
-  toJSON(): Record<string, any> {
-    return {
-      eventId: this.eventId,
-      eventName: this.eventName,
-      occurredOn: this.occurredOn.toISOString(),
-      aggregateId: this.aggregateId,
-      ...this.getPayload(),
-    };
-  }
-
-  /**
-   * Override this to provide event-specific data
-   */
-  protected getPayload(): Record<string, any> {
-    return {};
-  }
-}
-
-/**
- * Event handler function type
- */
-export type DomainEventHandler<T extends IDomainEvent = IDomainEvent> = (
-  event: T
-) => void | Promise<void>;
-
-/**
- * Event handler class type
- */
-export interface IDomainEventHandler<T extends IDomainEvent = IDomainEvent> {
-  handle(event: T): void | Promise<void>;
-}
+// ============================================================================
+// Domain Events - Event-Driven Architecture Support
+// ============================================================================
+
+import { IDomainEvent } from ".";
+import { Id } from "./id";
+
+/**
+ * Base class for domain events
+ */
+export abstract class DomainEvent implements IDomainEvent {
+  public readonly eventId: string;
+  public readonly occurredOn: Date;
+  public readonly aggregateId: string;
+
+  constructor(aggregateId: Id | string) {
+    this.eventId = this.generateEventId();
+    this.occurredOn = new Date();
+    this.aggregateId =
+      aggregateId instanceof Id ? aggregateId.value : aggregateId;
+  }
+
+  /**
+   * Get the event name (defaults to class name)
+   */
+  get eventName(): string {
+    return this.constructor.name;
+  }
+
+  private generateEventId(): string {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Convert event to JSON
+   */
+  toJSON(): Record<string, any> {
+    return {
+      eventId: this.eventId,
+      eventName: this.eventName,
+      occurredOn: this.occurredOn.toISOString(),
+      aggregateId: this.aggregateId,
+      ...this.getPayload(),
+    };
+  }
+
+  /**
+   * Override this to provide event-specific data
+   */
+  protected getPayload(): Record<string, any> {
+    return {};
+  }
+}

package/src/entity.ts

@@ -1,16 +1,16 @@
-// ============================================================================
-// Entity & Aggregate Classes
-// ============================================================================
-
-import { BaseEntity } from './base-entity';
-import { BaseProps } from './types';
-
-/**
- * Entity - Has identity and lifecycle, but is not an aggregate root
- */
-export class Entity<T extends BaseProps> extends BaseEntity<T> {}
-
-/**
- * Aggregate - Aggregate root that manages a consistency boundary
- */
-export class Aggregate<T extends BaseProps> extends BaseEntity<T> {}
+// ============================================================================
+// Entity & Aggregate Classes
+// ============================================================================
+
+import { BaseEntity } from "./base-entity";
+import { BaseProps } from "./types";
+
+/**
+ * Entity - Has identity and lifecycle, but is not an aggregate root
+ */
+export class Entity<T extends BaseProps> extends BaseEntity<T> {}
+
+/**
+ * Aggregate - Aggregate root that manages a consistency boundary
+ */
+export class Aggregate<T extends BaseProps> extends BaseEntity<T> {}