@woltz/rich-domain 1.3.1 → 1.4.0

package/src/domain-event-bus.ts

@@ -1,152 +0,0 @@
-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,49 +0,0 @@
-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-changes.ts

@@ -1,146 +0,0 @@
-import {
-  Operation,
-  CreateOperation,
-  UpdateOperation,
-  DeleteOperation,
-} from "./types/change-tracker";
-
-/**
- * Represents the changes filtered for a specific entity.
- *
- * @example
- * ```typescript
- * const changes = user.getChanges();
- * const postChanges = changes.for('Post');
- *
- * if (postChanges.hasCreates()) {
- *   console.log('Created posts:', postChanges.creates);
- * }
- *
- * if (postChanges.hasUpdates()) {
- *   postChanges.updates.forEach(({ entity, changed }) => {
- *     console.log(`Post ${entity.id} has changed:`, changed);
- *   });
- * }
- * ```
- */
-export class EntityChanges<T = any> {
-  constructor(private readonly operations: Operation<T>[]) {}
-
-  /**
-   * Returns all created entities
-   */
-  get creates(): T[] {
-    return this.operations
-      .filter((op): op is CreateOperation<T> => op.type === "create")
-      .map((op) => op.data);
-  }
-
-  /**
-   * Returns all updated entities with their changed fields
-   */
-  get updates(): Array<{ entity: T; changed: Record<string, any> }> {
-    return this.operations
-      .filter((op): op is UpdateOperation<T> => op.type === "update")
-      .map((op) => ({
-        entity: op.data,
-        changed: op.changedFields,
-      }));
-  }
-
-  /**
-   * Returns all deleted entities
-   */
-  get deletes(): T[] {
-    return this.operations
-      .filter((op): op is DeleteOperation<T> => op.type === "delete")
-      .map((op) => op.data);
-  }
-
-  /**
-   * Returns the IDs of the created entities
-   */
-  get createIds(): string[] {
-    return this.operations
-      .filter((op): op is CreateOperation<T> => op.type === "create")
-      .map((op) => this.extractId(op.data))
-      .filter((id): id is string => id !== undefined);
-  }
-
-  /**
-   * Returns the IDs of the updated entities
-   */
-  get updateIds(): string[] {
-    return this.operations
-      .filter((op): op is UpdateOperation<T> => op.type === "update")
-      .map((op) => op.id);
-  }
-
-  /**
-   * Returns the IDs of the deleted entities
-   */
-  get deleteIds(): string[] {
-    return this.operations
-      .filter((op): op is DeleteOperation<T> => op.type === "delete")
-      .map((op) => op.id);
-  }
-
-  /**
-   * Checks if there are any creates
-   */
-  hasCreates(): boolean {
-    return this.creates.length > 0;
-  }
-
-  /**
-   * Checks if there are any updates
-   */
-  hasUpdates(): boolean {
-    return this.updates.length > 0;
-  }
-
-  /**
-   * Checks if there are any deletes
-   */
-  hasDeletes(): boolean {
-    return this.deletes.length > 0;
-  }
-
-  /**
-   * Checks if there is any change
-   */
-  hasChanges(): boolean {
-    return this.operations.length > 0;
-  }
-
-  /**
-   * Checks if it is empty (no changes)
-   */
-  isEmpty(): boolean {
-    return this.operations.length === 0;
-  }
-
-  /**
-   * Returns the total number of operations
-   */
-  get count(): number {
-    return this.operations.length;
-  }
-
-  /**
-   * Returns the raw operations (for advanced use cases)
-   */
-  get rawOperations(): Operation<T>[] {
-    return [...this.operations];
-  }
-
-  /**
-   * Extracts the ID from an entity
-   */
-  private extractId(entity: any): string | undefined {
-    if (!entity) return undefined;
-    if (entity.id?.value) return entity.id.value;
-    if (typeof entity.id === "string") return entity.id;
-    return undefined;
-  }
-}