@woltz/rich-domain 1.0.0 → 1.2.0

package/src/deep-proxy.ts

@@ -27,6 +27,8 @@ export class DeepProxy {
     const handler: ProxyHandler<any> = {
       get: (target, prop, receiver) => {
         const value = Reflect.get(target, prop, receiver);
+        if (!this.rootProxy) throw new Error("Root proxy is required");
+
         const currentPath = this.path
           ? `${this.path}.${String(prop)}`
           : String(prop);
@@ -44,8 +46,8 @@ export class DeepProxy {
         if (typeof value === "function") return value.bind(target);
 
         if (Array.isArray(value)) {
-          if (!this.rootProxy!.trackedArraysCloned.has(currentPath)) {
-            this.rootProxy!.storeArrayState(currentPath, value);
+          if (!this.rootProxy.trackedArraysCloned.has(currentPath)) {
+            this.rootProxy.storeArrayState(currentPath, value);
           }
           return this.createArrayProxy(value, currentPath);
         }
@@ -62,16 +64,18 @@ export class DeepProxy {
         const currentPath = this.path
           ? `${this.path}.${String(prop)}`
           : String(prop);
+        if (!this.rootProxy) throw new Error("Root proxy is required");
+
         const oldValue = Reflect.get(target, prop, receiver);
         const isArrayAssignment = Array.isArray(newValue);
 
         if (!isArrayAssignment && oldValue === newValue) return true;
 
-        if (!this.rootProxy!.originalValues.has(currentPath)) {
-          this.rootProxy!.originalValues.set(currentPath, oldValue);
+        if (!this.rootProxy.originalValues.has(currentPath)) {
+          this.rootProxy.originalValues.set(currentPath, oldValue);
         }
 
-        this.rootProxy!.history.push({
+        this.rootProxy.history.push({
           path: currentPath,
           previousValue: oldValue,
           currentValue: newValue,
@@ -81,28 +85,28 @@ export class DeepProxy {
         const result = Reflect.set(target, prop, newValue, receiver);
 
         if (isArrayAssignment) {
-          if (!this.rootProxy!.trackedArraysCloned.has(currentPath)) {
+          if (!this.rootProxy.trackedArraysCloned.has(currentPath)) {
             if (Array.isArray(oldValue)) {
-              this.rootProxy!.storeArrayState(currentPath, oldValue);
+              this.rootProxy.storeArrayState(currentPath, oldValue);
             } else {
-              this.rootProxy!.storeArrayState(currentPath, []);
+              this.rootProxy.storeArrayState(currentPath, []);
             }
           }
-          this.rootProxy!.scheduleNotification(() =>
+          this.rootProxy.scheduleNotification(() =>
             this.rootProxy!.notifyArrayChange(currentPath, newValue)
           );
         } else {
-          this.rootProxy!.scheduleNotification(() =>
+          this.rootProxy.scheduleNotification(() =>
             this.rootProxy!.notifySubscribers(currentPath, oldValue, newValue)
           );
         }
 
         // Notify global subscribers
-        this.rootProxy!.scheduleNotification(() =>
+        this.rootProxy.scheduleNotification(() =>
           this.rootProxy!.notifyGlobalSubscribers()
         );
 
-        this.rootProxy!.flushNotifications();
+        this.rootProxy.flushNotifications();
 
         return result;
       },
@@ -140,6 +144,8 @@ export class DeepProxy {
     return new Proxy(array, {
       get(target, prop, receiver) {
         const value = Reflect.get(target, prop, receiver);
+        if (!self.rootProxy) throw new Error("Root proxy is required");
+
         if (typeof value === "function") {
           const mutatingMethods = [
             "push",
@@ -153,23 +159,24 @@ export class DeepProxy {
           if (mutatingMethods.includes(String(prop))) {
             return function (...args: any[]) {
               // Capture state before mutation
+              if (!self.rootProxy) throw new Error("Root proxy is required");
               const oldArray = target.slice();
 
               const result = value.apply(target, args);
 
               // Add to history
-              self.rootProxy!.history.push({
+              self.rootProxy.history.push({
                 path: path,
                 previousValue: oldArray,
                 currentValue: target.slice(),
                 timestamp: Date.now(),
               });
 
-              if (!self.rootProxy!.trackedArraysCloned.has(path)) {
-                self.rootProxy!.storeArrayState(path, target);
+              if (!self.rootProxy.trackedArraysCloned.has(path)) {
+                self.rootProxy.storeArrayState(path, target);
               }
-              self.rootProxy!.notifyArrayChange(path, target);
-              self.rootProxy!.notifyGlobalSubscribers();
+              self.rootProxy.notifyArrayChange(path, target);
+              self.rootProxy.notifyGlobalSubscribers();
               return result;
             };
           }
@@ -184,24 +191,25 @@ export class DeepProxy {
       },
       set(target, prop, newValue, receiver) {
         if (!isNaN(Number(prop))) {
+          if (!self.rootProxy) throw new Error("Root proxy is required");
           // Capture state before change
           const oldArray = target.slice();
 
           const result = Reflect.set(target, prop, newValue, receiver);
 
           // Add to history
-          self.rootProxy!.history.push({
+          self.rootProxy.history.push({
             path: path,
             previousValue: oldArray,
             currentValue: target.slice(),
             timestamp: Date.now(),
           });
 
-          if (!self.rootProxy!.trackedArraysCloned.has(path)) {
-            self.rootProxy!.storeArrayState(path, target);
+          if (!self.rootProxy.trackedArraysCloned.has(path)) {
+            self.rootProxy.storeArrayState(path, target);
           }
-          self.rootProxy!.notifyArrayChange(path, target);
-          self.rootProxy!.notifyGlobalSubscribers();
+          self.rootProxy.notifyArrayChange(path, target);
+          self.rootProxy.notifyGlobalSubscribers();
           return result;
         }
         return Reflect.set(target, prop, newValue, receiver);
@@ -210,21 +218,24 @@ export class DeepProxy {
   }
 
   subscribe(path: string, callback: Function): void {
+    if (!this.rootProxy) throw new Error("Root proxy is required");
+
     if (path === "*") {
-      this.rootProxy!.globalSubscribers.add(callback);
+      this.rootProxy.globalSubscribers.add(callback);
       return;
     }
 
-    if (!this.rootProxy!.subscribers.has(path)) {
-      this.rootProxy!.subscribers.set(path, new Set());
+    if (!this.rootProxy.subscribers.has(path)) {
+      this.rootProxy.subscribers.set(path, new Set());
     }
-    this.rootProxy!.subscribers.get(path)!.add(callback);
 
-    const actualValue = this.rootProxy!.target[path];
+    this.rootProxy.subscribers.get(path)!.add(callback);
+
+    const actualValue = this.rootProxy.target[path];
     const isArray = Array.isArray(actualValue);
 
     // Fire callback immediately if there's a historical change for this path
-    const lastChange = this.rootProxy!.getLastChangeForPath(path);
+    const lastChange = this.rootProxy.getLastChangeForPath(path);
     if (lastChange) {
       if (isArray) {
         // For arrays, we need to detect changes and fire with toCreate/toUpdate/toDelete
@@ -236,14 +247,14 @@ export class DeepProxy {
           : actualValue;
 
         // Store the initial state before the change for comparison
-        if (!this.rootProxy!.trackedArraysCloned.has(path)) {
-          this.rootProxy!.storeArrayState(path, previousArray);
+        if (!this.rootProxy.trackedArraysCloned.has(path)) {
+          this.rootProxy.storeArrayState(path, previousArray);
         }
 
         // Detect changes between previous and current
-        const changes = this.rootProxy!.detectArrayChanges(
-          this.rootProxy!.trackedArraysCloned.get(path) ||
-            this.rootProxy!.cloneArray(previousArray),
+        const changes = this.rootProxy.detectArrayChanges(
+          this.rootProxy.trackedArraysCloned.get(path) ||
+            this.rootProxy.cloneArray(previousArray),
           previousArray,
           currentArray
         );
@@ -251,7 +262,7 @@ export class DeepProxy {
         callback({ ...changes, path });
 
         // Update tracked state to current
-        this.rootProxy!.storeArrayState(path, currentArray);
+        this.rootProxy.storeArrayState(path, currentArray);
       } else {
         // For non-arrays, use the simple property change format
         callback({
@@ -260,19 +271,20 @@ export class DeepProxy {
           path: lastChange.path,
         });
       }
-    } else if (isArray && !this.rootProxy!.trackedArraysCloned.has(path)) {
+    } else if (isArray && !this.rootProxy.trackedArraysCloned.has(path)) {
       // No historical changes, just store initial state
-      this.rootProxy!.storeArrayState(path, actualValue);
+      this.rootProxy.storeArrayState(path, actualValue);
     }
   }
 
   unsubscribe(path: string, callback: Function): void {
+    if (!this.rootProxy) throw new Error("Root proxy is required");
     if (path === "*") {
-      this.rootProxy!.globalSubscribers.delete(callback);
+      this.rootProxy.globalSubscribers.delete(callback);
       return;
     }
 
-    const subs = this.rootProxy!.subscribers.get(path);
+    const subs = this.rootProxy.subscribers.get(path);
     if (subs) {
       subs.delete(callback);
     }

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
+    }
+  }
+}