@vytches/ddd-aggregates 0.26.0

package/dist/index.js

@@ -0,0 +1,1283 @@
+import { Logger as _ } from "/home/runner/work/ddd/ddd/packages/logging/dist/index.js";
+import { IDomainError as I, DomainErrorCode as c } from "/home/runner/work/ddd/ddd/packages/domain-primitives/dist/index.js";
+function $() {
+  return globalThis.crypto.randomUUID();
+}
+function N(s, t, e) {
+  return {
+    eventName: s,
+    payload: t,
+    metadata: {
+      eventId: $(),
+      timestamp: /* @__PURE__ */ new Date(),
+      ...e
+    }
+  };
+}
+class p {
+  /**
+   * Checks if this capability is of a specific type
+   */
+  isType(t) {
+    return this.type === t;
+  }
+  /**
+   * Static type getter for compile-time type extraction
+   * Each capability must override this
+   */
+  static get capabilityType() {
+    throw new Error("Capability subclass must override static capabilityType getter");
+  }
+}
+class D {
+  constructor() {
+    this.capabilities = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a capability
+   */
+  register(t) {
+    return this.capabilities.set(t.type, t), this;
+  }
+  /**
+   * Get a capability by its constructor
+   */
+  get(t) {
+    const e = t.capabilityType;
+    return this.capabilities.get(e);
+  }
+  /**
+   * Get a capability by its type string
+   */
+  getByType(t) {
+    return this.capabilities.get(t);
+  }
+  /**
+   * Check if a capability exists
+   */
+  has(t) {
+    const e = t.capabilityType;
+    return this.capabilities.has(e);
+  }
+  /**
+   * Check if a capability exists by type
+   */
+  hasByType(t) {
+    return this.capabilities.has(t);
+  }
+  /**
+   * Remove a capability
+   */
+  remove(t) {
+    const e = t.capabilityType;
+    return this.capabilities.delete(e);
+  }
+  /**
+   * Remove a capability by type
+   */
+  removeByType(t) {
+    return this.capabilities.delete(t);
+  }
+  /**
+   * Get all registered capabilities
+   */
+  getAll() {
+    return Array.from(this.capabilities.values());
+  }
+  /**
+   * Get all capability types
+   */
+  getTypes() {
+    return Array.from(this.capabilities.keys());
+  }
+  /**
+   * Clear all capabilities
+   */
+  clear() {
+    this.capabilities.clear();
+  }
+  /**
+   * Get the number of registered capabilities
+   */
+  get size() {
+    return this.capabilities.size;
+  }
+}
+class u {
+  constructor(t, e = "text") {
+    this.value = t, this.type = e;
+  }
+  /**
+   * Returns the stored identifier value
+   * @returns The identifier value
+   * @example
+   * ```typescript
+   * const id = EntityId.fromText('user-123');
+   * const value = id.getValue(); // Returns: 'user-123'
+   * ```
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Returns the identifier type (text, uuid, integer, bigint)
+   * @returns The identifier type
+   * @example
+   * ```typescript
+   * const id = EntityId.fromUUID('550e8400-e29b-41d4-a716-446655440000');
+   * const type = id.getType(); // Returns: 'uuid'
+   * ```
+   */
+  getType() {
+    return this.type;
+  }
+  validate(t) {
+    return t != null && t !== void 0;
+  }
+  /**
+   * Compares this EntityId with another for equality
+   * @returns True if entities have same value and type
+   * @example
+   * ```typescript
+   * const id1 = EntityId.fromText('user-123');
+   * const id2 = EntityId.fromText('user-123');
+   * const isEqual = id1.equals(id2); // Returns: true
+   * ```
+   */
+  equals(t) {
+    return t.getValue() === this.value && t.getType() === this.type;
+  }
+  isType(t) {
+    return this.type === t;
+  }
+  toString() {
+    return String(this.value);
+  }
+  toJSON() {
+    return JSON.stringify({
+      value: this.value,
+      type: this.type
+    });
+  }
+  /**
+   * Primary factory method - creates a new EntityId with a randomly generated UUID
+   * @returns New EntityId with random UUID
+   * @example
+   * ```typescript
+   * const id = EntityId.create();
+   * console.log(id.getValue()); // Returns: '550e8400-e29b-41d4-a716-446655440000'
+   * ```
+   */
+  static create() {
+    const t = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+      const i = Math.random() * 16 | 0;
+      return (e === "x" ? i : i & 3 | 8).toString(16);
+    });
+    return new u(t, "uuid");
+  }
+  /**
+   * @deprecated Use `fromText()` instead. Will be removed in next major version.
+   */
+  static createText(t) {
+    return new u(t, "text");
+  }
+  /**
+   * @deprecated Use `fromUUID()` instead. Will be removed in next major version.
+   */
+  static createUuid(t) {
+    return new u(t, "uuid");
+  }
+  /**
+   * @deprecated Use `fromInteger()` instead. Will be removed in next major version.
+   */
+  static createInteger(t) {
+    return new u(t.toString(), "integer");
+  }
+  /**
+   * @deprecated Use `fromBigInt()` instead. Will be removed in next major version.
+   */
+  static createBigInt(t) {
+    const e = typeof t == "bigint" ? t.toString() : t;
+    return new u(e, "bigint");
+  }
+  /**
+   * @deprecated Use `create()` instead. Will be removed in next major version.
+   * Creates a new EntityId with a randomly generated UUID
+   * @returns New EntityId with random UUID
+   */
+  static createWithRandomUUID() {
+    return u.create();
+  }
+  /**
+   * Creates an EntityId from a UUID string with validation
+   * @returns EntityId from UUID string
+   * @example
+   * ```typescript
+   * const id = EntityId.fromUUID('550e8400-e29b-41d4-a716-446655440000');
+   * console.log(id.getType()); // Returns: 'uuid'
+   * ```
+   */
+  static fromUUID(t) {
+    if (!t || typeof t != "string")
+      throw new Error("entity identifier must be provided");
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(t))
+      throw new Error("entity identifier must be valid UUID");
+    return new u(t, "uuid");
+  }
+  static fromInteger(t) {
+    if (typeof t != "number" || t < 0 || !Number.isInteger(t))
+      throw new Error("entity identifier must be a non-negative integer");
+    return new u(t.toString(), "integer");
+  }
+  static fromBigInt(t) {
+    const e = typeof t == "bigint" ? t.toString() : t;
+    if (!e || typeof e != "string")
+      throw new Error("entity identifier must be a valid bigint");
+    return new u(e, "bigint");
+  }
+  /**
+   * Creates an EntityId from a text string with validation
+   * @returns EntityId from text string
+   * @example
+   * ```typescript
+   * const id = EntityId.fromText('user-123');
+   * console.log(id.getValue()); // Returns: 'user-123'
+   * ```
+   */
+  static fromText(t) {
+    if (!t || typeof t != "string")
+      throw new Error("entity identifier must be provided");
+    if (!/^[a-zA-Z0-9_-]+$/.test(t))
+      throw new Error("entity identifier contains invalid characters");
+    return new u(t, "text");
+  }
+}
+class o {
+  constructor(t, e, i) {
+    this._isSuccess = t, this._value = e, this._error = i;
+  }
+  /**
+   * Check if the result is successful
+   */
+  get isSuccess() {
+    return this._isSuccess;
+  }
+  /**
+   * Check if the result is a failure
+   */
+  get isFailure() {
+    return !this._isSuccess;
+  }
+  /**
+   * Get the success value
+   * @throws Error if the result is a failure
+   */
+  get value() {
+    if (!this._isSuccess)
+      throw new Error("Cannot get value of a failure result");
+    return this._value;
+  }
+  /**
+   * Get the error value
+   * @throws Error if the result is successful
+   */
+  get error() {
+    if (this._isSuccess)
+      throw new Error("Cannot get error of a success result");
+    return this._error;
+  }
+  /**
+   * Create a successful result
+   * @param value - The success value (required — use Result.empty() for void operations)
+   */
+  static ok(t) {
+    return new o(!0, t);
+  }
+  /**
+   * Create a successful void result (no value).
+   */
+  static empty() {
+    return new o(!0, void 0);
+  }
+  /**
+   * Create a failure result
+   * @param error - The error value
+   */
+  static fail(t) {
+    return new o(!1, void 0, t);
+  }
+  /**
+   * Try to execute a function and wrap the result
+   * @param fn - The function to try
+   * @returns A Result containing the function result or error
+   */
+  static try(t) {
+    try {
+      return o.ok(t());
+    } catch (e) {
+      return o.fail(e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+  /**
+   * Transform the success value
+   * @param fn - The transformation function
+   */
+  map(t) {
+    return this.isFailure ? o.fail(this.error) : o.ok(t(this.value));
+  }
+  /**
+   * Transform the success value with a function that returns a Result
+   * @param fn - The transformation function
+   */
+  flatMap(t) {
+    return this.isFailure ? o.fail(this.error) : t(this.value);
+  }
+  /**
+   * Apply a function based on success or failure
+   * @param onSuccess - Function to call on success
+   * @param onFailure - Function to call on failure
+   */
+  match(t, e) {
+    return this.isSuccess ? t(this.value) : e(this.error);
+  }
+  /**
+   * Apply a side effect if the result is successful
+   * @param fn - The side effect function
+   */
+  tap(t) {
+    return this.isSuccess && t(this.value), this;
+  }
+  /**
+   * Apply a side effect if the result is a failure
+   * @param fn - The side effect function
+   */
+  tapError(t) {
+    return this.isFailure && t(this.error), this;
+  }
+  /**
+   * Transform the error value if the result is a failure
+   * @param fn - The error transformation function
+   */
+  mapError(t) {
+    return this.isSuccess ? o.ok(this.value) : o.fail(t(this.error));
+  }
+  /**
+   * Try to execute an async function and wrap the result
+   * @param fn - The async function to try
+   * @returns A Promise of a Result containing the function result or error
+   */
+  static async tryAsync(t) {
+    try {
+      const e = await t();
+      return o.ok(e);
+    } catch (e) {
+      return o.fail(e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+  /**
+   * Transform the success value with an async function
+   * @param fn - The async transformation function
+   */
+  async mapAsync(t) {
+    if (this.isFailure)
+      return o.fail(this.error);
+    try {
+      const e = await t(this.value);
+      return o.ok(e);
+    } catch (e) {
+      const i = e instanceof Error ? e : new Error(String(e));
+      return o.fail(i);
+    }
+  }
+  /**
+   * Transform the success value with an async function that returns a Result
+   * @param fn - The async transformation function
+   */
+  async flatMapAsync(t) {
+    return this.isFailure ? o.fail(this.error) : await t(this.value);
+  }
+}
+class f extends p {
+  constructor() {
+    super(...arguments), this.type = "versioning", this.upcasters = /* @__PURE__ */ new Map();
+  }
+  static get capabilityType() {
+    return "versioning";
+  }
+  /**
+   * @param {unknown} aggregate - Aggregate to attach this capability to
+   */
+  attach(t) {
+    this.aggregate = t;
+  }
+  detach() {
+    this.aggregate = void 0, this.upcasters.clear();
+  }
+  /**
+   * @param {string} eventType - Type of event to register upcaster for
+   * @param {number} sourceVersion - Source version number to upcast from
+   * @param {IEventUpcaster<TFrom, TTo>} upcaster - Upcaster instance to transform events
+   */
+  registerUpcaster(t, e, i) {
+    this.upcasters.has(t) || this.upcasters.set(t, /* @__PURE__ */ new Map()), this.upcasters.get(t).set(e, i);
+  }
+  /**
+   * @param {IDomainEvent} event - Event to process with version handling
+   * @param {Map<string, IAggregateEventHandler>} handlers - Map of event handlers
+   */
+  handleVersionedEvent(t, e) {
+    const i = t.metadata?.version || 1, r = t.metadata?.targetVersion || i;
+    let a = t;
+    if (i < r && this.upcasters.has(t.eventName)) {
+      const g = this.upcasters.get(t.eventName), d = _.forContext("VersioningCapability");
+      for (let l = i; l < r; l++) {
+        const y = g.get(l);
+        if (!y) {
+          d.warn(
+            "Missing upcaster for event version — event will be processed without upcast",
+            {
+              eventName: t.eventName,
+              fromVersion: l,
+              toVersion: l + 1
+            }
+          );
+          continue;
+        }
+        const T = y.upcast(a.payload, a.metadata);
+        a = {
+          ...a,
+          payload: T,
+          metadata: {
+            ...a.metadata,
+            version: l + 1
+          }
+        };
+      }
+    }
+    const h = e.get(a.eventName);
+    h && h(a.payload, a.metadata);
+  }
+  /**
+   * @returns {string[]} Array of event types that have registered upcasters
+   */
+  getRegisteredEventTypes() {
+    return Array.from(this.upcasters.keys());
+  }
+  /**
+   * @param {string} eventType - Event type to check
+   * @param {number} version - Version number to check for upcaster
+   * @returns {boolean} True if upcaster exists for specified event type and version
+   */
+  hasUpcaster(t, e) {
+    return this.upcasters.get(t)?.has(e) || !1;
+  }
+  /**
+   * @param {string} eventType - Event type to get upcasters for
+   * @returns {Map<number, IEventUpcaster> | undefined} Map of upcasters by version or undefined
+   */
+  getUpcastersForType(t) {
+    return this.upcasters.get(t);
+  }
+  /**
+   * @param {string} eventType - Event type to clear upcasters for
+   */
+  clearUpcastersForType(t) {
+    this.upcasters.delete(t);
+  }
+  /**
+   * @returns {number} Total count of all registered upcasters across all event types
+   */
+  getTotalUpcasterCount() {
+    let t = 0;
+    for (const e of this.upcasters.values())
+      t += e.size;
+    return t;
+  }
+}
+class v {
+  constructor(t) {
+    this._version = 0, this._initialVersion = 0, this._domainEvents = [], this._eventHandlers = /* @__PURE__ */ new Map(), this._capabilities = new D(), this._id = t.id, this._version = t.version || 0, this._initialVersion = t.version || 0, this._maxEvents = t.maxEvents;
+  }
+  // ==========================================
+  // CORE AGGREGATE FUNCTIONALITY
+  // ==========================================
+  /**
+   * Get the unique identifier of this aggregate
+   */
+  getId() {
+    return this._id;
+  }
+  /**
+   *
+   * @returns {number} Current version number for optimistic locking
+   */
+  getVersion() {
+    return this._version;
+  }
+  /**
+   *
+   * @returns {number} Initial version when aggregate was loaded
+   */
+  getInitialVersion() {
+    return this._initialVersion;
+  }
+  /**
+   *
+   * @returns {boolean} True if aggregate has uncommitted domain events
+   */
+  hasChanges() {
+    return this._domainEvents.length > 0;
+  }
+  /**
+   *
+   * @returns {ReadonlyArray<IDomainEvent>} Array of uncommitted domain events
+   */
+  getDomainEvents() {
+    return [...this._domainEvents];
+  }
+  /**
+   * Clear all uncommitted domain events and update initial version
+   */
+  commit() {
+    this._domainEvents = [], this._initialVersion = this._version;
+  }
+  // ==========================================
+  // EVENT HANDLING - Type-safe approach
+  // ==========================================
+  /**
+   * @param {string} eventType - Event type to register handler for
+   * @param {IAggregateEventHandler<T>} handler - Event handler function
+   * @returns {this} The aggregate instance for method chaining
+   */
+  registerEventHandler(t, e) {
+    return this._eventHandlers.set(t, e), this;
+  }
+  /**
+   * Apply domain event to aggregate and add to pending events
+   * @param {string | IDomainEvent<P>} eventTypeOrEvent - Event type string or complete event object
+   * @param {P} payload - Event payload data
+   * @param {Partial<IEventMetadata>} metadata - Optional event metadata
+   */
+  apply(t, e, i) {
+    this._version++;
+    let r, a;
+    typeof t == "string" ? (r = N(t, e, i), a = r.metadata) : (r = t, a = i ? { ...r.metadata, ...i } : r.metadata);
+    const h = v.sanitizeMetadata({
+      ...a,
+      aggregateId: this._id.toString(),
+      aggregateType: this.constructor.name,
+      aggregateVersion: this._version,
+      timestamp: a?.timestamp ?? /* @__PURE__ */ new Date()
+    }), g = Object.assign(
+      Object.create(Object.getPrototypeOf(r)),
+      r,
+      { metadata: h }
+    );
+    if (this._maxEvents !== void 0 && this._domainEvents.length >= this._maxEvents)
+      throw new Error(
+        `Aggregate ${this.constructor.name} (id=${this._id.toString()}) exceeded maxEvents limit of ${this._maxEvents}. This usually indicates a runaway loop or replay of a corrupted event stream. Increase maxEvents in the aggregate constructor params if the limit is too restrictive for your domain.`
+      );
+    this._domainEvents.push(g), this.handleEvent(g);
+  }
+  handleEvent(t) {
+    const e = this.getCapability(f);
+    if (e)
+      e.handleVersionedEvent(t, this._eventHandlers);
+    else {
+      const i = this._eventHandlers.get(t.eventName);
+      i && i(t.payload, t.metadata);
+    }
+  }
+  /**
+   * Reconstruct aggregate state from historical domain events
+   * @param {IDomainEvent[]} events - Array of events to replay for state reconstruction
+   */
+  loadFromHistory(t) {
+    this._version = this._initialVersion, this._domainEvents = [];
+    for (const e of t)
+      this.handleEvent(e), this._version++;
+    this._initialVersion = this._version;
+  }
+  // ==========================================
+  // TYPE-SAFE CAPABILITY MANAGEMENT
+  // ==========================================
+  /**
+   * Add capability to enhance aggregate functionality
+   * @param {T} capability - Capability instance to add to the aggregate
+   * @returns {this} The aggregate instance for method chaining
+   */
+  addCapability(t) {
+    return "attach" in t && typeof t.attach == "function" && t.attach(this), this._capabilities.register(t), this;
+  }
+  /**
+   * @param {CapabilityConstructor<T>} CapabilityClass - Constructor of the capability to retrieve
+   * @returns {T | undefined} The capability instance or undefined if not found
+   */
+  getCapability(t) {
+    return this._capabilities.get(t);
+  }
+  /**
+   * @param {CapabilityConstructor<T>} CapabilityClass - Constructor of the capability to check
+   * @returns {boolean} True if the capability is present
+   */
+  hasCapability(t) {
+    return this._capabilities.has(t);
+  }
+  /**
+   * @param {CapabilityConstructor<T>} CapabilityClass - Constructor of the capability to remove
+   * @returns {this} The aggregate instance for method chaining
+   */
+  removeCapability(t) {
+    const e = this._capabilities.get(t);
+    return e && "detach" in e && typeof e.detach == "function" && e.detach(), this._capabilities.remove(t), this;
+  }
+  /**
+   * @returns {Capability[]} Array of all registered capabilities
+   */
+  getAllCapabilities() {
+    return this._capabilities.getAll();
+  }
+  /**
+   * @returns {string[]} Array of capability type names
+   */
+  getCapabilityTypes() {
+    return this._capabilities.getTypes();
+  }
+  // ==========================================
+  // SECURITY UTILITIES
+  // ==========================================
+  static sanitizeMetadata(t) {
+    if (!Object.prototype.hasOwnProperty.call(t, "__proto__") && !Object.prototype.hasOwnProperty.call(t, "constructor") && !Object.prototype.hasOwnProperty.call(t, "prototype"))
+      return t;
+    const e = {};
+    for (const i of Object.keys(t))
+      i === "__proto__" || i === "constructor" || i === "prototype" || (e[i] = t[i]);
+    return e;
+  }
+  // ==========================================
+  // INTERNAL ACCESS FOR CAPABILITIES
+  // ==========================================
+  /**
+   * Internal method for capabilities to access private state
+   * Should only be used by capabilities, not directly by domain code
+   */
+  _internal_setState(t) {
+    this._version = t.version, this._initialVersion = t.initialVersion, this._domainEvents = [...t.domainEvents];
+  }
+}
+class b extends p {
+  constructor() {
+    super(...arguments), this.type = "audit", this.auditLog = [];
+  }
+  static get capabilityType() {
+    return "audit";
+  }
+  /**
+   * @param {unknown} aggregate - Aggregate to attach this capability to
+   */
+  attach(t) {
+    this.aggregate = t;
+    const e = this.aggregate;
+    typeof e.apply == "function" && (this.originalApply = e.apply, this.originalApply && (this.aggregate.apply = (...i) => {
+      const r = this.originalApply.call(this.aggregate, ...i);
+      return this.recordAuditEvent(), r;
+    }));
+  }
+  detach() {
+    this.aggregate && this.originalApply && (this.aggregate.apply = this.originalApply), this.aggregate = void 0, this.auditLog = [], this.originalApply = void 0;
+  }
+  /**
+   * @returns {IAuditEvent[]} Copy of the current audit log
+   */
+  getAuditLog() {
+    return [...this.auditLog];
+  }
+  clearAuditLog() {
+    this.auditLog = [];
+  }
+  /**
+   * @returns {{totalEvents: number, eventsByType: Record<string, number>, averageTimeBetweenEvents: number}} Audit statistics summary
+   */
+  getAuditStatistics() {
+    const t = {};
+    let e = 0;
+    this.auditLog.forEach((r, a) => {
+      if (t[r.eventName] = (t[r.eventName] || 0) + 1, a > 0) {
+        const h = this.auditLog[a - 1];
+        if (h) {
+          const g = new Date(h.timestamp).getTime(), d = new Date(r.timestamp).getTime();
+          e += d - g;
+        }
+      }
+    });
+    const i = this.auditLog.length > 1 ? e / (this.auditLog.length - 1) : 0;
+    return {
+      totalEvents: this.auditLog.length,
+      eventsByType: t,
+      averageTimeBetweenEvents: i
+    };
+  }
+  /**
+   * Record an audit event when domain events are added
+   */
+  recordAuditEvent() {
+    const t = this.aggregate.getDomainEvents(), e = t[t.length - 1];
+    e && this.recordEvent(e);
+  }
+  /**
+   * @param {IDomainEvent} event - Domain event to record in audit log
+   */
+  recordEvent(t) {
+    const e = {
+      eventId: t.metadata?.eventId || `audit-${Date.now()}-${Math.random()}`,
+      eventName: t.eventName,
+      aggregateId: this.aggregate.getId().toString(),
+      aggregateType: this.aggregate.constructor.name,
+      aggregateVersion: this.aggregate.getVersion(),
+      timestamp: /* @__PURE__ */ new Date(),
+      payload: t.payload,
+      metadata: {
+        ...t.metadata,
+        auditCapability: !0
+      },
+      actor: t.metadata?.userId
+    };
+    this.auditLog.push(e);
+  }
+  /**
+   * @param {string} eventName - Name of events to filter by
+   * @returns {IAuditEvent[]} Array of audit events matching the specified name
+   */
+  getEventsByName(t) {
+    return this.auditLog.filter((e) => e.eventName === t);
+  }
+  /**
+   * @param {Date} startDate - Start date for time range filter
+   * @param {Date} endDate - End date for time range filter
+   * @returns {IAuditEvent[]} Array of audit events within the specified time range
+   */
+  getEventsByTimeRange(t, e) {
+    return this.auditLog.filter((i) => {
+      const r = new Date(i.timestamp).getTime();
+      return r >= t.getTime() && r <= e.getTime();
+    });
+  }
+  /**
+   * @returns {IAuditEvent | null} First audit event in chronological order or null if none exists
+   */
+  getFirstEvent() {
+    return this.auditLog[0] || null;
+  }
+  /**
+   * @returns {IAuditEvent | null} Last audit event in chronological order or null if none exists
+   */
+  getLastEvent() {
+    return this.auditLog[this.auditLog.length - 1] || null;
+  }
+}
+class n extends I {
+  /**
+   * Error for invalid arguments provided to the aggregate
+   */
+  static invalidArguments(t, e) {
+    const i = {
+      code: c.InvalidParameter,
+      data: e
+    };
+    return new n(t, i);
+  }
+  /**
+   * Error for version conflicts in the aggregate
+   */
+  static versionConflict(t, e, i, r) {
+    const a = `Version conflict: Aggregate ${t} with ID ${e} has version ${i}, but expected ${r}`, h = {
+      code: c.ValidationFailed,
+      data: {
+        aggregateType: t,
+        aggregateId: e,
+        currentVersion: i,
+        expectedVersion: r
+      }
+    };
+    return new n(a, h);
+  }
+  /**
+   * Error for when a required feature is not enabled
+   */
+  static featureNotEnabled(t) {
+    const e = `Feature '${t}' is not enabled on aggregate`, i = {
+      code: c.ValidationFailed,
+      data: {
+        feature: t
+      }
+    };
+    return new n(e, i);
+  }
+  /**
+   * Error for when a required method is not implemented
+   */
+  static methodNotImplemented(t, e) {
+    const i = `Method '${t}' must be implemented by ${e} to use this feature`, r = {
+      code: c.MissingValue,
+      data: {
+        methodName: t,
+        aggregateType: e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for invalid snapshot
+   */
+  static invalidSnapshot(t, e) {
+    const i = `Invalid snapshot for aggregate ${t}${e ? `: ${e}` : ""}`, r = {
+      code: c.InvalidFormat,
+      data: {
+        aggregateType: t,
+        reason: e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for ID mismatch during snapshot restoration
+   */
+  static idMismatch(t, e) {
+    const i = `ID mismatch: Snapshot is for ID ${t}, but aggregate has ID ${e}`, r = {
+      code: c.ValidationFailed,
+      data: {
+        snapshotId: t,
+        aggregateId: e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for type mismatch during snapshot restoration
+   */
+  static typeMismatch(t, e) {
+    const i = `Aggregate type mismatch: Snapshot is for type ${t}, but trying to load into ${e}`, r = {
+      code: c.ValidationFailed,
+      data: {
+        snapshotType: t,
+        aggregateType: e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for duplicate upcaster registration
+   */
+  static duplicateUpcaster(t, e) {
+    const i = `Upcaster for event ${t} version ${e} already exists`, r = {
+      code: c.DuplicateEntry,
+      data: {
+        eventType: t,
+        sourceVersion: e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for missing upcaster
+   */
+  static missingUpcaster(t, e, i) {
+    const r = `Missing upcaster for event ${t} from version ${e} to ${i}`, a = {
+      code: c.MissingValue,
+      data: {
+        eventType: t,
+        fromVersion: e,
+        toVersion: i
+      }
+    };
+    return new n(r, a);
+  }
+  /**
+   * Error for configuration problems
+   */
+  static configurationError(t, e) {
+    const i = `Configuration error in ${t}: ${e}`, r = {
+      code: c.ValidationFailed,
+      data: {
+        aggregateType: t,
+        configurationError: e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for when apply method interception fails (e.g. method not found)
+   */
+  static cannotInterceptApplyMethod(t, e) {
+    const i = `Cannot intercept apply method - method not found on aggregate ${t}`, r = {
+      code: c.InternalError,
+      data: {
+        aggergateId: t,
+        ...e
+      }
+    };
+    return new n(i, r);
+  }
+  /**
+   * Error for when event store is not configured
+   */
+  static eventStoreNotConfigured(t) {
+    const e = "Event store not configured", i = {
+      code: c.MissingValue,
+      data: t
+    };
+    return new n(e, i);
+  }
+  /**
+   * Error for when aggregate does not support event replay
+   */
+  static aggregateDoesNotSupportReplay(t, e) {
+    const i = `Aggregate ${t} does not support event replay`, r = {
+      code: c.MethodNotSupported,
+      data: {
+        aggregateType: t,
+        ...e
+      }
+    };
+    return new n(i, r);
+  }
+}
+class w extends p {
+  constructor() {
+    super(...arguments), this.type = "eventSourcing", this.eventStore = null;
+  }
+  static get capabilityType() {
+    return "eventSourcing";
+  }
+  /**
+   * @param {unknown} aggregate - Aggregate to attach this capability to
+   */
+  attach(t) {
+    this.aggregate = t;
+  }
+  detach() {
+    this.aggregate = void 0, this.eventStore = null;
+  }
+  /**
+   * @param {IEventStore} eventStore - Event store instance to use for persistence
+   */
+  setEventStore(t) {
+    this.eventStore = t;
+  }
+  /**
+   * @returns {IEventStore | null} Currently configured event store or null
+   */
+  getEventStore() {
+    return this.eventStore;
+  }
+  /**
+   * @param {string | number} aggregateId - ID of aggregate to load events for
+   * @throws {AggregateError} When event store is not configured
+   */
+  async loadFromEventStore(t) {
+    if (!this.eventStore)
+      throw n.configurationError(
+        this.aggregate.constructor.name,
+        "Event store not configured"
+      );
+    const e = await this.eventStore.getEvents(t);
+    if (e.length === 0)
+      return;
+    const i = this.aggregate;
+    i.loadFromHistory && i.loadFromHistory(e);
+  }
+  /**
+   * @throws {AggregateError} When event store is not configured
+   */
+  async saveToEventStore() {
+    if (!this.eventStore)
+      throw n.configurationError(
+        this.aggregate.constructor.name,
+        "Event store not configured"
+      );
+    const t = this.aggregate.getDomainEvents();
+    t.length !== 0 && await this.eventStore.saveEvents(
+      this.aggregate.getId().toString(),
+      [...t],
+      this.aggregate.getInitialVersion()
+    );
+  }
+  /**
+   * @returns {boolean} True if event store is configured
+   */
+  hasEventStore() {
+    return this.eventStore !== null;
+  }
+  /**
+   * @returns {string} Stream name combining aggregate type and ID
+   */
+  getStreamName() {
+    return `${this.aggregate.constructor.name}-${this.aggregate.getId().toString()}`;
+  }
+  /**
+   * @param {string | number} aggregateId - ID of aggregate to load events for
+   * @param {number} fromVersion - Version number to start loading from
+   * @throws {AggregateError} When event store is not configured
+   */
+  async loadFromVersion(t, e) {
+    if (!this.eventStore)
+      throw n.configurationError(
+        this.aggregate.constructor.name,
+        "Event store not configured"
+      );
+    const i = await this.eventStore.getEventsAfterVersion(t, e), r = this.aggregate;
+    r.loadFromHistory && i.length > 0 && r.loadFromHistory(i);
+  }
+}
+class S extends p {
+  constructor() {
+    super(...arguments), this.type = "snapshot", this._snapshot = null;
+  }
+  static get capabilityType() {
+    return "snapshot";
+  }
+  /**
+   * @param {unknown} aggregate - Aggregate to attach this capability to
+   */
+  attach(t) {
+    this.aggregate = t;
+  }
+  detach() {
+    this.aggregate = void 0, this._snapshot = null;
+  }
+  /**
+   * @param {() => TState} serializer - Function to serialize aggregate state
+   * @param {() => TMeta} metadataCreator - Optional function to create snapshot metadata
+   * @returns {IAggregateSnapshot<TState, TMeta>} Created snapshot with state and metadata
+   */
+  createSnapshot(t, e) {
+    const i = this.aggregate.getDomainEvents(), a = (i.length > 0 ? i[i.length - 1] : null)?.metadata?.eventId, g = {
+      aggregateId: this.aggregate.getId().toString(),
+      version: this.aggregate.getVersion(),
+      aggregateType: this.aggregate.constructor.name,
+      state: t(),
+      timestamp: /* @__PURE__ */ new Date(),
+      ...a !== void 0 && { lastEventId: a }
+    };
+    return e && (g.metadata = e()), g;
+  }
+  /**
+   * @param {IAggregateSnapshot<TState, TMeta>} snapshot - Snapshot to restore from
+   * @param {(state: TState) => void} deserializer - Function to deserialize state into aggregate
+   * @param {(metadata: TMeta) => void} metadataRestorer - Optional function to restore metadata
+   * @throws {AggregateError} When snapshot is invalid or IDs don't match
+   */
+  restoreFromSnapshot(t, e, i) {
+    if (!t || !t.state)
+      throw n.invalidSnapshot(this.aggregate.constructor.name, "Invalid snapshot");
+    const r = this.aggregate.getId().toString();
+    if (t.aggregateId !== r)
+      throw n.idMismatch(t.aggregateId, r);
+    if (t.aggregateType !== this.aggregate.constructor.name)
+      throw n.typeMismatch(t.aggregateType, this.aggregate.constructor.name);
+    e(t.state), t.metadata && i && i(t.metadata);
+    const a = this.aggregate;
+    a._internal_setState && a._internal_setState({
+      version: t.version,
+      initialVersion: t.version,
+      domainEvents: []
+    });
+  }
+  /**
+   * @param {TState} state - State to save temporarily
+   */
+  saveTemporaryState(t) {
+    this._snapshot = this.createSnapshot(() => t);
+  }
+  /**
+   * @returns {Date | null} Timestamp of last snapshot or null if none exists
+   */
+  getLastSnapshotTimestamp() {
+    return this._snapshot?.timestamp || null;
+  }
+  /**
+   * @param {() => TState} serializer - Function to serialize aggregate state
+   * @param {() => TMeta} metadataCreator - Optional metadata creator function
+   */
+  saveSnapshot(t, e) {
+    this._snapshot = this.createSnapshot(t, e);
+  }
+  /**
+   * @returns {IAggregateSnapshot<TState, TMeta> | null} Previous snapshot state if exists
+   */
+  getPreviousState() {
+    const t = this._snapshot;
+    return this._snapshot = null, t;
+  }
+}
+class m {
+  constructor(t) {
+    this.capabilities = [], this.params = t;
+  }
+  /**
+   * @returns Aggregate
+   */
+  static create(t) {
+    const e = {
+      id: t.id instanceof u ? t.id : new u(t.id, "text"),
+      version: t.version || 0
+    };
+    return new m(e);
+  }
+  withSnapshots() {
+    return this.capabilities.push({ capability: new S() }), this;
+  }
+  /**
+   * @returns {this} Builder instance for method chaining
+   */
+  withVersioning() {
+    return this.capabilities.push({ capability: new f() }), this;
+  }
+  /**
+   * @returns {this} Builder instance for method chaining
+   */
+  withAudit() {
+    return this.capabilities.push({ capability: new b() }), this;
+  }
+  /**
+   * @param {IEventStore} [eventStore] - Optional event store for event sourcing
+   * @returns {this} Builder instance for method chaining
+   */
+  withEventSourcing(t) {
+    const e = new w();
+    return this.capabilities.push({
+      capability: e,
+      configure: (i) => {
+        const r = i;
+        t ? r.setEventStore(t) : this.eventStore && r.setEventStore(this.eventStore);
+      }
+    }), this;
+  }
+  /**
+   * @param {T} capability - Custom capability instance to add
+   * @param {(cap: T) => void} configure - Optional configuration function for the capability
+   * @returns {this} Builder instance for method chaining
+   */
+  withCapability(t, e) {
+    return this.capabilities.push({
+      capability: t,
+      configure: e ? (i) => e(i) : void 0
+    }), this;
+  }
+  /**
+   * @param {IEventStore} eventStore - Event store instance for event sourcing capability
+   * @returns {this} Builder instance for method chaining
+   */
+  setEventStore(t) {
+    return this.eventStore = t, this;
+  }
+  build(t) {
+    const e = t || v, i = new e(this.params);
+    for (const { capability: r, configure: a } of this.capabilities)
+      i.addCapability(r), a && a(r);
+    return i;
+  }
+  /**
+   * @param {new (params: IAggregateConstructorParams<TId>) => TAgg} AggregateClass - Optional aggregate class constructor
+   * @returns {TAgg} Fully configured aggregate with all standard capabilities
+   */
+  buildWithAllCapabilities(t) {
+    return this.withSnapshots().withVersioning().withAudit().withEventSourcing().build(t);
+  }
+}
+function L(s) {
+  return m.create(s);
+}
+class E {
+  constructor(t) {
+    this._id = t;
+  }
+  /**
+   * Return this entity's unique identifier.
+   */
+  getId() {
+    return this._id;
+  }
+  /**
+   * Identity-based equality. Two entities are equal iff they have the same
+   * id (compared via the EntityId's own equality). Attribute differences
+   * are ignored.
+   *
+   * @param other - Entity to compare against. May be `null` or `undefined`.
+   * @returns `true` if both entities have the same id; `false` otherwise.
+   */
+  equals(t) {
+    return t == null ? !1 : t === this ? !0 : t instanceof E ? this._id.equals(t._id) : !1;
+  }
+}
+function x(s) {
+  return s.hasCapability(S);
+}
+function C(s) {
+  return s.hasCapability(f);
+}
+function V(s) {
+  return s.hasCapability(b);
+}
+function A(s) {
+  return s.hasCapability(w);
+}
+function U(s) {
+  if (!x(s))
+    throw n.featureNotEnabled("snapshot");
+  return s;
+}
+function k(s) {
+  return x(s) ? o.ok(s) : o.fail(n.featureNotEnabled("snapshot"));
+}
+function O(s) {
+  if (!C(s))
+    throw n.featureNotEnabled("versioning");
+  return s;
+}
+function B(s) {
+  return C(s) ? o.ok(s) : o.fail(n.featureNotEnabled("versioning"));
+}
+function H(s) {
+  if (!V(s))
+    throw n.featureNotEnabled("audit");
+  return s;
+}
+function P(s) {
+  return V(s) ? o.ok(s) : o.fail(n.featureNotEnabled("audit"));
+}
+function j(s) {
+  if (!A(s))
+    throw n.featureNotEnabled("eventSourcing");
+  return s;
+}
+function z(s) {
+  return A(s) ? o.ok(s) : o.fail(n.featureNotEnabled("eventSourcing"));
+}
+function W(s) {
+  return s.getCapabilityTypes();
+}
+function q(s, t) {
+  return t.every((e) => s.hasCapability(e));
+}
+export {
+  m as AggregateBuilder,
+  n as AggregateError,
+  v as AggregateRoot,
+  b as AuditCapability,
+  E as Entity,
+  w as EventSourcingCapability,
+  S as SnapshotCapability,
+  f as VersioningCapability,
+  L as aggregateBuilder,
+  H as asAuditAggregate,
+  j as asEventSourcingAggregate,
+  U as asSnapshotAggregate,
+  O as asVersioningAggregate,
+  W as getAggregateCapabilities,
+  q as hasAllCapabilities,
+  P as tryAsAuditAggregate,
+  z as tryAsEventSourcingAggregate,
+  k as tryAsSnapshotAggregate,
+  B as tryAsVersioningAggregate
+};