@shirudo/ddd-kit 0.9.1 → 0.9.3

package/dist/index.d.ts

@@ -70,30 +70,40 @@ interface DomainEvent<T extends string, P> {
 }
 /**
  * Marker interface for Aggregate Roots.
- * Aggregate Roots are the entry points for modifying aggregates in DDD.
- * They have identity (id) and version for optimistic concurrency control.
  *
- * In Domain-Driven Design, an Aggregate Root is the only entity that external
- * objects are allowed to hold references to. All access to entities within the
- * aggregate must go through the Aggregate Root.
+ * In Domain-Driven Design, an Aggregate Root is an Entity (the parent Entity of the aggregate).
+ * It represents the aggregate externally and is the only object that external code
+ * is allowed to hold references to. All access to child entities within the aggregate
+ * must go through the Aggregate Root.
  *
- * @template TId - The type of the aggregate identifier
+ * An Aggregate consists of:
+ * - One Aggregate Root (Entity with id + version)
+ * - Optional child entities (Entities with id, but no own version)
+ * - Optional value objects
+ *
+ * The Aggregate Root has identity (id) and version for optimistic concurrency control.
+ * Child entities exist only within the aggregate boundary and are versioned through
+ * the Aggregate Root.
+ *
+ * @template TId - The type of the aggregate root identifier
  *
  * @example
  * ```typescript
  * class Order extends AggregateBase<OrderState, OrderId> implements AggregateRoot<OrderId> {
- *   // Order is an Aggregate Root
+ *   // Order is an Aggregate Root (an Entity)
+ *   // OrderState contains child entities (e.g., OrderItem) and value objects
  * }
  * ```
  */
 interface AggregateRoot<TId extends Id<string>> {
     /**
-     * Unique identifier of the aggregate root.
+     * Unique identifier of the aggregate root entity.
      */
     readonly id: TId;
     /**
      * Version number for optimistic concurrency control.
      * Incremented on each state change to detect concurrent modifications.
+     * This version applies to the entire aggregate, including all child entities.
      */
     readonly version: Version;
 }
@@ -254,23 +264,35 @@ interface AggregateConfig {
     autoVersionBump?: boolean;
 }
 /**
- * Base class for Aggregates without Event Sourcing.
- * Provides core functionality for aggregates:
+ * Base class for creating Aggregate Roots (Entities) without Event Sourcing.
+ *
+ * This class creates an Entity that serves as the Aggregate Root. The Aggregate Root
+ * is the parent Entity of the aggregate and represents it externally. It has identity
+ * (id) and version for optimistic concurrency control.
+ *
+ * The aggregate state (`TState`) contains:
+ * - Child entities (Entities with id, but no own version)
+ * - Value objects (immutable objects)
+ *
+ * All changes to child entities are versioned through the Aggregate Root. The version
+ * applies to the entire aggregate, including all child entities.
+ *
+ * Provides core functionality:
  * - ID and Version management (for Optimistic Concurrency Control)
- * - State management
+ * - State management (containing child entities and value objects)
  * - Snapshot support for performance optimization
  *
- * Implements `AggregateRoot<TId>` to explicitly mark this as an Aggregate Root
- * in Domain-Driven Design terms.
+ * Implements `AggregateRoot<TId>` to mark this as an Aggregate Root Entity.
  *
  * Use this class when you don't need Event Sourcing but still want
  * aggregate patterns with versioning and state management.
  *
- * @template TState - The type of the aggregate state
- * @template TId - The type of the aggregate identifier
+ * @template TState - The type of the aggregate state (contains child entities and value objects)
+ * @template TId - The type of the aggregate root identifier
  *
  * @example
  * ```typescript
+ * // Order is an Aggregate Root (an Entity)
  * class Order extends AggregateBase<OrderState, OrderId> implements AggregateRoot<OrderId> {
  *   constructor(id: OrderId, initialState: OrderState) {
  *     super(id, initialState);
@@ -278,7 +300,7 @@ interface AggregateConfig {
  *
  *   confirm(): void {
  *     this._state = { ...this._state, status: "confirmed" };
- *     this.bumpVersion();
+ *     this.bumpVersion(); // Versions the entire aggregate
  *   }
  * }
  * ```
@@ -433,6 +455,343 @@ declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
  * ```
  */
 declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+/**
+ * Chains Result operations (flatMap/bind).
+ * If the result is Ok, applies the function to the value.
+ * If Err, returns the error unchanged.
+ *
+ * @param result - The result to chain
+ * @param fn - Function that takes the Ok value and returns a new Result
+ * @returns A new Result
+ *
+ * @example
+ * ```typescript
+ * const result = validateUserId("123")
+ *   .andThen(userId => validateEmail("test@example.com")
+ *     .map(email => ({ id: userId, email }))
+ *   );
+ * ```
+ */
+declare function andThen<T, E, U>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/**
+ * Transforms the Ok value using a function.
+ * If the result is Err, returns the error unchanged.
+ *
+ * @param result - The result to transform
+ * @param fn - Function to transform the Ok value
+ * @returns A new Result with transformed value
+ *
+ * @example
+ * ```typescript
+ * const result = ok(5);
+ * const doubled = map(result, x => x * 2); // Ok<10>
+ * ```
+ */
+declare function map<T, E, U>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Transforms the Err value using a function.
+ * If the result is Ok, returns the value unchanged.
+ *
+ * @param result - The result to transform
+ * @param fn - Function to transform the Err value
+ * @returns A new Result with transformed error
+ *
+ * @example
+ * ```typescript
+ * const result = err("not found");
+ * const mapped = mapErr(result, e => `Error: ${e}`); // Err<"Error: not found">
+ * ```
+ */
+declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+/**
+ * Returns the value if Ok, otherwise returns the default value.
+ *
+ * @param result - The result to unwrap
+ * @param defaultValue - Default value to return if Err
+ * @returns The Ok value or the default value
+ *
+ * @example
+ * ```typescript
+ * const result = validateUserId("123");
+ * const userId = unwrapOr(result, "default-id");
+ * ```
+ */
+declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+/**
+ * Returns the value if Ok, otherwise computes default from error.
+ *
+ * @param result - The result to unwrap
+ * @param fn - Function to compute default from error
+ * @returns The Ok value or computed default
+ *
+ * @example
+ * ```typescript
+ * const result = validateUserId("");
+ * const userId = unwrapOrElse(result, err => `fallback-${Date.now()}`);
+ * ```
+ */
+declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
+/**
+ * Pattern matching for Result.
+ * Applies one function if Ok, another if Err.
+ *
+ * @param result - The result to match
+ * @param onOk - Function to apply if Ok
+ * @param onErr - Function to apply if Err
+ * @returns The result of applying the appropriate function
+ *
+ * @example
+ * ```typescript
+ * const message = match(result,
+ *   value => `Success: ${value}`,
+ *   error => `Error: ${error}`
+ * );
+ * ```
+ *
+ * @example Using object syntax
+ * ```typescript
+ * const message = match(result, {
+ *   ok: value => `Success: ${value}`,
+ *   err: error => `Error: ${error}`
+ * });
+ * ```
+ */
+declare function match<T, E, R>(result: Result<T, E>, onOk: (value: T) => R, onErr: (error: E) => R): R;
+declare function match<T, E, R>(result: Result<T, E>, handlers: {
+    ok: (value: T) => R;
+    err: (error: E) => R;
+}): R;
+/**
+ * Async pattern matching for Result.
+ * Applies one async function if Ok, another if Err.
+ * Both handlers must return Promises.
+ *
+ * @param result - The result to match
+ * @param onOk - Async function to apply if Ok
+ * @param onErr - Async function to apply if Err
+ * @returns Promise resolving to the result of applying the appropriate function
+ *
+ * @example
+ * ```typescript
+ * const message = await matchAsync(result,
+ *   async (value) => `Success: ${value}`,
+ *   async (error) => `Error: ${error}`
+ * );
+ * ```
+ *
+ * @example Using object syntax
+ * ```typescript
+ * const message = await matchAsync(result, {
+ *   ok: async (value) => `Success: ${value}`,
+ *   err: async (error) => `Error: ${error}`
+ * });
+ * ```
+ */
+declare function matchAsync<T, E, R>(result: Result<T, E>, onOk: (value: T) => Promise<R>, onErr: (error: E) => Promise<R>): Promise<R>;
+declare function matchAsync<T, E, R>(result: Result<T, E>, handlers: {
+    ok: (value: T) => Promise<R>;
+    err: (error: E) => Promise<R>;
+}): Promise<R>;
+
+/**
+ * Base class for Result with method chaining support.
+ * Provides common methods for both Ok and Err classes.
+ */
+declare abstract class ResultBase<T, E> {
+    protected readonly _result: Result<T, E>;
+    protected constructor(result: Result<T, E>);
+    /**
+     * Returns the value if Ok, otherwise throws an error.
+     * If error is an Error instance, throws it directly.
+     * Otherwise, wraps the error in a new Error.
+     *
+     * @throws Error if the result is Err
+     */
+    unwrap(): T;
+    /**
+     * Returns the value if Ok, otherwise returns the default value.
+     */
+    unwrapOr(defaultValue: T): T;
+    /**
+     * Returns the value if Ok, otherwise computes default from error.
+     */
+    unwrapOrElse(fn: (error: E) => T): T;
+    /**
+     * Pattern matching for Result.
+     * Applies one function if Ok, another if Err.
+     *
+     * @example
+     * ```typescript
+     * outcome.match(
+     *   value => `Success: ${value}`,
+     *   error => `Error: ${error}`
+     * );
+     * ```
+     *
+     * @example Using object syntax
+     * ```typescript
+     * outcome.match({
+     *   ok: value => `Success: ${value}`,
+     *   err: error => `Error: ${error}`
+     * });
+     * ```
+     */
+    match<R>(onOk: (value: T) => R, onErr: (error: E) => R): R;
+    match<R>(handlers: {
+        ok: (value: T) => R;
+        err: (error: E) => R;
+    }): R;
+    /**
+     * Async pattern matching for Result.
+     * Applies one async function if Ok, another if Err.
+     *
+     * @example
+     * ```typescript
+     * await outcome.matchAsync(
+     *   async (value) => `Success: ${value}`,
+     *   async (error) => `Error: ${error}`
+     * );
+     * ```
+     *
+     * @example Using object syntax
+     * ```typescript
+     * await outcome.matchAsync({
+     *   ok: async (value) => `Success: ${value}`,
+     *   err: async (error) => `Error: ${error}`
+     * });
+     * ```
+     */
+    matchAsync<R>(onOk: (value: T) => Promise<R>, onErr: (error: E) => Promise<R>): Promise<R>;
+    matchAsync<R>(handlers: {
+        ok: (value: T) => Promise<R>;
+        err: (error: E) => Promise<R>;
+    }): Promise<R>;
+    /**
+     * Type guard to check if the result is Ok.
+     */
+    isOk(): this is Success<T>;
+    /**
+     * Type guard to check if the result is Err.
+     */
+    isErr(): this is Erroneous<E>;
+    /**
+     * Gets the underlying Result value.
+     */
+    get result(): Result<T, E>;
+}
+/**
+ * Class representing a successful result with method chaining support.
+ * Use this for class-based API with method chaining.
+ *
+ * @example
+ * ```typescript
+ * const okResult = Ok(1);
+ * const doubled = okResult.map(x => x * 2).unwrap(); // 2
+ *
+ * const chained = Ok(5)
+ *   .andThen(x => Ok(x * 2))
+ *   .map(x => x + 1)
+ *   .unwrap(); // 11
+ * ```
+ */
+declare class Success<T> extends ResultBase<T, never> {
+    constructor(value: T);
+    /**
+     * Factory function to create an Ok instance.
+     * Can be called with or without `new`.
+     */
+    static of<T>(value: T): Success<T>;
+    /**
+     * Chains Result operations (flatMap/bind).
+     * If the result is Ok, applies the function to the value.
+     * If Err, returns the error unchanged.
+     */
+    andThen<U, E>(fn: (value: T) => Result<U, E>): Success<U> | Erroneous<E>;
+    /**
+     * Transforms the Ok value using a function.
+     * If the result is Err, returns the error unchanged.
+     */
+    map<U>(fn: (value: T) => U): Success<U>;
+    /**
+     * Transforms the Err value using a function.
+     * If the result is Ok, returns the value unchanged.
+     */
+    mapErr<F>(_fn: (error: never) => F): Success<T>;
+}
+
+/**
+ * Class representing an erroneous result with method chaining support.
+ * Use this for class-based API with method chaining.
+ *
+ * @example
+ * ```typescript
+ * const errResult = Err(new Error("error"));
+ * errResult.map(x => x * 2).unwrap(); // throws Error("error")
+ *
+ * const mapped = Err("original")
+ *   .mapErr(e => `Error: ${e}`)
+ *   .unwrap(); // throws Error("Error: original")
+ * ```
+ */
+declare class Erroneous<E> extends ResultBase<never, E> {
+    constructor(error: E);
+    /**
+     * Factory function to create an Err instance.
+     * Can be called with or without `new`.
+     */
+    static of<E>(error: E): Erroneous<E>;
+    /**
+     * Chains Result operations (flatMap/bind).
+     * If the result is Ok, applies the function to the value.
+     * If Err, returns the error unchanged.
+     */
+    andThen<U>(_fn: (value: never) => Result<U, E>): Erroneous<E>;
+    /**
+     * Transforms the Ok value using a function.
+     * If the result is Err, returns the error unchanged.
+     */
+    map<U>(_fn: (value: never) => U): Erroneous<E>;
+    /**
+     * Transforms the Err value using a function.
+     * If the result is Ok, returns the value unchanged.
+     */
+    mapErr<F>(fn: (error: E) => F): Erroneous<F>;
+}
+
+/**
+ * Class-based API for Result with method chaining support.
+ * Provides an object-oriented alternative to the functional Result type.
+ * Use `Outcome.from()` to wrap an existing Result, or `Outcome.ok()` / `Outcome.err()` to create new instances.
+ *
+ * @example
+ * ```typescript
+ * // Wrap an existing Result
+ * const result = Outcome.from(ok(1));
+ * const doubled = result.map(x => x * 2).unwrap(); // 2
+ *
+ * // Create directly
+ * const outcome = Outcome.ok(42);
+ * const value = outcome.map(x => x + 1).unwrap(); // 43
+ * ```
+ */
+declare class Outcome<T, E> extends ResultBase<T, E> {
+    private constructor();
+    /**
+     * Creates an Outcome from an Ok value.
+     */
+    static ok<T>(value: T): Success<T>;
+    /**
+     * Creates an Outcome from an Err value.
+     */
+    static err<E>(error: E): Erroneous<E>;
+    /**
+     * Creates an Outcome from a Result.
+     */
+    static from<T, E>(result: Result<T, E>): Outcome<T, E>;
+    andThen<U>(fn: (value: T) => Result<U, E>): Outcome<U, E>;
+    map<U>(fn: (value: T) => U): Outcome<U, E>;
+    mapErr<F>(fn: (error: E) => F): Outcome<T, F>;
+}
 
 type Handler<TState, TEvent> = (state: TState, event: TEvent) => TState;
 /**
@@ -446,7 +805,18 @@ interface AggregateEventSourcedConfig extends AggregateConfig {
     autoVersionBump?: boolean;
 }
 /**
- * Base class for Event-Sourced Aggregates.
+ * Base class for Event-Sourced Aggregate Roots (Entities).
+ *
+ * Extends `AggregateBase` to create an Aggregate Root Entity with Event Sourcing capabilities.
+ * The Aggregate Root is the parent Entity of the aggregate and represents it externally.
+ *
+ * The aggregate state (`TState`) contains:
+ * - Child entities (Entities with id, but no own version)
+ * - Value objects (immutable objects)
+ *
+ * All changes to child entities are versioned through the Aggregate Root. The version
+ * applies to the entire aggregate, including all child entities.
+ *
  * Extends `AggregateBase` with Event Sourcing capabilities:
  * - Event tracking (pendingEvents)
  * - Event handlers for state transitions
@@ -456,12 +826,13 @@ interface AggregateEventSourcedConfig extends AggregateConfig {
  * Use this class when you want Event Sourcing with full event tracking
  * and replay capabilities.
  *
- * @template TState - The type of the aggregate state
+ * @template TState - The type of the aggregate state (contains child entities and value objects)
  * @template TEvent - The union type of all domain events
- * @template TId - The type of the aggregate identifier
+ * @template TId - The type of the aggregate root identifier
  *
  * @example
  * ```typescript
+ * // Order is an Aggregate Root (an Entity) with Event Sourcing
  * class Order extends AggregateEventSourced<OrderState, OrderEvent, OrderId> {
  *   confirm(): void {
  *     this.apply(createDomainEvent("OrderConfirmed", {}));
@@ -957,6 +1328,11 @@ interface IQueryBus {
      */
     register<Q extends Query, R>(queryType: Q["type"], handler: QueryHandler<Q, R>): void;
 }
+/**
+ * Type map for query types to their return types.
+ * Used to improve type inference in QueryBus.
+ */
+type QueryTypeMap = Record<string, unknown>;
 /**
  * Simple in-memory query bus implementation.
  * Handlers are stored in a Map and dispatched based on query type.
@@ -983,9 +1359,12 @@ interface IQueryBus {
  * const order = await bus.execute({ type: "GetOrder", orderId: "123" });
  * ```
  */
-declare class QueryBus implements IQueryBus {
+declare class QueryBus<TMap extends QueryTypeMap = QueryTypeMap> implements IQueryBus {
     private readonly handlers;
     register<Q extends Query, R>(queryType: Q["type"], handler: QueryHandler<Q, R>): void;
+    execute<Q extends Query & {
+        type: keyof TMap;
+    }>(query: Q): Promise<Result<TMap[Q["type"]], string>>;
     execute<Q extends Query, R>(query: Q): Promise<Result<R, string>>;
     executeUnsafe<Q extends Query, R>(query: Q): Promise<R>;
 }
@@ -1009,18 +1388,42 @@ declare class QueryBus implements IQueryBus {
 declare function guard(cond: boolean, error: string): Result<true, string>;
 
 /**
- * Optional interface for entities with identity.
- * Use this when you need explicit entity types for nested entities
- * within aggregates or for entities that are not aggregate roots.
+ * Interface for entities with identity.
+ *
+ * In Domain-Driven Design, there are two types of entities:
+ *
+ * 1. **Aggregate Root Entity**: The parent Entity of an aggregate.
+ *    - Has identity (id) and version
+ *    - Implemented by classes extending `AggregateBase` or `AggregateEventSourced`
+ *    - Represents the aggregate externally
+ *    - Loaded/saved through repositories
+ *
+ * 2. **Child Entities**: Entities within an aggregate.
+ *    - Have identity (id), but no own version
+ *    - Exist only within the aggregate boundary
+ *    - Versioned through the Aggregate Root
+ *    - Cannot be referenced directly from outside the aggregate
+ *
+ * This interface is used for child entities within aggregates. The Aggregate Root
+ * also implements this interface (through `AggregateRoot<TId>`), but additionally
+ * has version management.
  *
  * @template TId - The type of the entity identifier
  *
  * @example
  * ```typescript
+ * // Child Entity within an aggregate
  * type OrderItem = Entity<ItemId> & {
  *   productId: string;
  *   quantity: number;
  * };
+ *
+ * // Aggregate Root (also an Entity, but with version)
+ * class Order extends AggregateBase<OrderState, OrderId>
+ *   implements AggregateRoot<OrderId> {
+ *   // Order is an Entity (the Aggregate Root)
+ *   // OrderState contains OrderItem (child entities)
+ * }
  * ```
  */
 interface Entity<TId> {
@@ -1222,16 +1625,23 @@ interface ISpecification<T> {
 }
 
 /**
- * The Repository works only with Aggregate Roots.
- * It encapsulates the complexity of the data source (DB, API, etc.).
+ * Repository interface for Aggregate Roots (Entities).
  *
- * Repositories work with Aggregate Roots, which are the entry points
- * for modifying aggregates in Domain-Driven Design.
+ * Repositories work exclusively with Aggregate Root Entities. The Aggregate Root
+ * is the Entity that represents the aggregate externally and is the only object
+ * that can be loaded/saved through repositories.
  *
- * @template TState - The type of the aggregate state
+ * When loading an Aggregate Root, all child entities and value objects within
+ * the aggregate state are loaded as well. When saving, the entire aggregate
+ * (including all child entities) is persisted as a unit.
+ *
+ * Child entities cannot be loaded or saved independently - they exist only
+ * within the aggregate boundary and are managed through the Aggregate Root.
+ *
+ * @template TState - The type of the aggregate state (contains child entities and value objects)
  * @template TEvent - The union type of all domain events
- * @template TAgg - The aggregate type (must be an Aggregate Root)
- * @template TId - The type of the aggregate identifier
+ * @template TAgg - The aggregate root type (must be an Aggregate Root Entity)
+ * @template TId - The type of the aggregate root identifier
  */
 interface IRepository<TState, TEvent extends DomainEvent<string, unknown>, TAgg extends AggregateRoot<TId> & Aggregate<TState, TEvent>, TId extends Id<string>> {
     getById(id: TId): Promise<TAgg | null>;
@@ -1325,4 +1735,4 @@ declare function voWithValidation<T>(t: T, validate: (value: T) => boolean, erro
  */
 declare function voWithValidationUnsafe<T>(t: T, validate: (value: T) => boolean, errorMessage?: string): ValueObject<T>;
 
-export { type Aggregate, AggregateBase, type AggregateConfig, AggregateEventSourced, type AggregateEventSourcedConfig, type AggregateRoot, type AggregateSnapshot, type Clock, type Command, CommandBus, type CommandHandler, type DomainEvent, type Entity, type Err, type EventBus, EventBusImpl, type EventHandler, type EventMetadata, type ICommandBus, type IQueryBus, type IRepository, type ISpecification, type Id, type IdGenerator, type Ok, type Outbox, type Query, QueryBus, type QueryHandler, type RepoProvider, type Result, type UnitOfWork, type ValueObject, type Version, aggregate, bump, copyMetadata, createDomainEvent, createDomainEventWithMetadata, entityIds, err, findEntityById, guard, hasEntityId, isErr, isOk, mergeMetadata, ok, removeEntityById, replaceEntityById, sameAggregate, sameEntity, updateEntityById, vo, voEquals, voWithValidation, voWithValidationUnsafe, withCommit, withEvent };
+export { type Aggregate, AggregateBase, type AggregateConfig, AggregateEventSourced, type AggregateEventSourcedConfig, type AggregateRoot, type AggregateSnapshot, type Clock, type Command, CommandBus, type CommandHandler, type DomainEvent, type Entity, type Err, Erroneous, type EventBus, EventBusImpl, type EventHandler, type EventMetadata, type ICommandBus, type IQueryBus, type IRepository, type ISpecification, type Id, type IdGenerator, type Ok, type Outbox, Outcome, type Query, QueryBus, type QueryHandler, type RepoProvider, type Result, Success, type UnitOfWork, type ValueObject, type Version, aggregate, andThen, bump, copyMetadata, createDomainEvent, createDomainEventWithMetadata, entityIds, err, findEntityById, guard, hasEntityId, isErr, isOk, map, mapErr, match, matchAsync, mergeMetadata, ok, removeEntityById, replaceEntityById, sameAggregate, sameEntity, unwrapOr, unwrapOrElse, updateEntityById, vo, voEquals, voWithValidation, voWithValidationUnsafe, withCommit, withEvent };

package/dist/index.js

@@ -1,2 +1,2 @@
-var c=Object.defineProperty;var o=(t,e)=>c(t,"name",{value:e,configurable:true});function T(t,e=0){return {state:t,version:e,pendingEvents:[]}}o(T,"aggregate");function E(t,e){return {...t,pendingEvents:[...t.pendingEvents,e]}}o(E,"withEvent");function h(t){return {...t,version:t.version+1}}o(h,"bump");function m(t,e,r){return {type:t,payload:e,occurredAt:r?.occurredAt??new Date,version:r?.version??1,metadata:r?.metadata}}o(m,"createDomainEvent");function x(t,e,r,n){return m(t,e,{...n,metadata:r})}o(x,"createDomainEventWithMetadata");function b(t,e){return {...t.metadata??{},...e??{}}}o(b,"copyMetadata");function I(...t){return Object.assign({},...t.filter(Boolean))}o(I,"mergeMetadata");function R(t,e){return t.id===e.id&&t.version===e.version}o(R,"sameAggregate");var d=class{static{o(this,"AggregateBase");}id;version=0;_config;_autoVersionBump;get state(){return this._state}_state;constructor(e,r,n){this.id=e,this._state=r,this._config=n??{},this._autoVersionBump=this._config.autoVersionBump??false;}bumpVersion(){this.version=this.version+1;}setState(e,r){this._state=e,(r??this._autoVersionBump)&&this.bumpVersion();}createSnapshot(){return {state:{...this._state},version:this.version,snapshotAt:new Date}}restoreFromSnapshot(e){this._state=e.state,this.version=e.version;}};function s(t){return {ok:true,value:t}}o(s,"ok");function a(t){return {ok:false,error:t}}o(a,"err");function _(t){return t.ok===true}o(_,"isOk");function w(t){return t.ok===false}o(w,"isErr");var u=class extends d{static{o(this,"AggregateEventSourced");}_eventConfig;_eventAutoVersionBump;_pendingEvents=[];constructor(e,r,n){super(e,r,n),this._eventConfig=n??{},this._eventAutoVersionBump=this._eventConfig.autoVersionBump??true;}get pendingEvents(){return this._pendingEvents}clearPendingEvents(){this._pendingEvents.length=0;}validateEvent(e){return s(true)}apply(e,r=true){let n=this.validateEvent(e);if(!n.ok)return a(`Event validation failed for ${e.type}: ${n.error}`);let i=this.handlers[e.type];return i?(this._state=i(this._state,e),r&&(this._pendingEvents.push(e),this._eventAutoVersionBump&&(this.version=this.version+1)),s()):a(`Missing handler for event type: ${e.type}`)}applyUnsafe(e,r=true){let n=this.validateEvent(e);if(!n.ok)throw new Error(`Event validation failed for ${e.type}: ${n.error}`);let i=this.handlers[e.type];if(!i)throw new Error(`Missing handler for event type: ${e.type}`);this._state=i(this._state,e),r&&(this._pendingEvents.push(e),this._eventAutoVersionBump&&(this.version=this.version+1));}bumpVersion(){this.version=this.version+1;}loadFromHistory(e){for(let r of e){let n=this.apply(r,false);if(!n.ok)return n}return this.version=e.length,s()}hasPendingEvents(){return this._pendingEvents.length>0}getEventCount(){return this._pendingEvents.length}getLatestEvent(){return this._pendingEvents[this._pendingEvents.length-1]}restoreFromSnapshotWithEvents(e,r){this._state=e.state,this.version=e.version;for(let n of r){let i=this.apply(n,false);if(!i.ok)return i}return this.version=e.version+r.length,s()}};var p=class{static{o(this,"CommandBus");}handlers=new Map;register(e,r){this.handlers.set(e,r);}async execute(e){let r=this.handlers.get(e.type);return r?r(e):a(`No handler registered for command type: ${e.type}`)}};function N(t,e){return t.uow.transactional(async()=>{let{result:r,events:n}=await e();return await t.outbox.add(n),t.bus&&await t.bus.publish(n),r})}o(N,"withCommit");var l=class{static{o(this,"QueryBus");}handlers=new Map;register(e,r){this.handlers.set(e,r);}async execute(e){let r=this.handlers.get(e.type);if(!r)return a(`No handler registered for query type: ${e.type}`);try{let n=await r(e);return s(n)}catch(n){return a(n instanceof Error?n.message:String(n))}}async executeUnsafe(e){let r=this.handlers.get(e.type);if(!r)throw new Error(`No handler registered for query type: ${e.type}`);return r(e)}};function z(t,e){return t?s(true):a(e)}o(z,"guard");function G(t,e){return t.id===e.id}o(G,"sameEntity");function X(t,e){return t.find(r=>r.id===e)}o(X,"findEntityById");function Y(t,e){return t.some(r=>r.id===e)}o(Y,"hasEntityId");function Z(t,e){return t.filter(r=>r.id!==e)}o(Z,"removeEntityById");function ee(t,e,r){return t.map(n=>n.id===e?r(n):n)}o(ee,"updateEntityById");function te(t,e,r){return t.map(n=>n.id===e?r:n)}o(te,"replaceEntityById");function re(t){return t.map(e=>e.id)}o(re,"entityIds");var g=class{static{o(this,"EventBusImpl");}handlers=new Map;subscribe(e,r){let n=e;this.handlers.has(n)||this.handlers.set(n,new Set);let i=this.handlers.get(n);return i.add(r),()=>{i.delete(r),i.size===0&&this.handlers.delete(n);}}async publish(e){for(let r of e){let n=this.handlers.get(r.type);n&&await Promise.all(Array.from(n).map(i=>i(r)));}}};function v(t,e=new WeakSet){if(t===null||typeof t!="object"||e.has(t))return t;e.add(t);let r=Object.getOwnPropertyNames(t);for(let n of r){let i=t[n];i&&(typeof i=="object"||Array.isArray(i))&&v(i,e);}return Object.freeze(t)}o(v,"deepFreeze");function f(t){return v({...t})}o(f,"vo");function de(t,e){return JSON.stringify(t)===JSON.stringify(e)}o(de,"voEquals");function ue(t,e,r){return e(t)?s(f(t)):a(r??`Validation failed for value object: ${JSON.stringify(t)}`)}o(ue,"voWithValidation");function pe(t,e,r){if(!e(t))throw new Error(r??`Validation failed for value object: ${JSON.stringify(t)}`);return f(t)}o(pe,"voWithValidationUnsafe");export{d as AggregateBase,u as AggregateEventSourced,p as CommandBus,g as EventBusImpl,l as QueryBus,T as aggregate,h as bump,b as copyMetadata,m as createDomainEvent,x as createDomainEventWithMetadata,re as entityIds,a as err,X as findEntityById,z as guard,Y as hasEntityId,w as isErr,_ as isOk,I as mergeMetadata,s as ok,Z as removeEntityById,te as replaceEntityById,R as sameAggregate,G as sameEntity,ee as updateEntityById,f as vo,de as voEquals,ue as voWithValidation,pe as voWithValidationUnsafe,N as withCommit,E as withEvent};//# sourceMappingURL=index.js.map
+var _=Object.defineProperty;var n=(t,e)=>_(t,"name",{value:e,configurable:true});function V(t,e=0){return {state:t,version:e,pendingEvents:[]}}n(V,"aggregate");function Q(t,e){return {...t,pendingEvents:[...t.pendingEvents,e]}}n(Q,"withEvent");function C(t){return {...t,version:t.version+1}}n(C,"bump");function A(t,e,r){return {type:t,payload:e,occurredAt:r?.occurredAt??new Date,version:r?.version??1,metadata:r?.metadata}}n(A,"createDomainEvent");function U(t,e,r,o){return A(t,e,{...o,metadata:r})}n(U,"createDomainEventWithMetadata");function O(t,e){return {...t.metadata??{},...e??{}}}n(O,"copyMetadata");function B(...t){return Object.assign({},...t.filter(Boolean))}n(B,"mergeMetadata");function M(t,e){return t.id===e.id&&t.version===e.version}n(M,"sameAggregate");var d=class{static{n(this,"AggregateBase");}id;version=0;_config;_autoVersionBump;get state(){return this._state}_state;constructor(e,r,o){this.id=e,this._state=r,this._config=o??{},this._autoVersionBump=this._config.autoVersionBump??false;}bumpVersion(){this.version=this.version+1;}setState(e,r){this._state=e,(r??this._autoVersionBump)&&this.bumpVersion();}createSnapshot(){return {state:{...this._state},version:this.version,snapshotAt:new Date}}restoreFromSnapshot(e){this._state=e.state,this.version=e.version;}};function a(t){return {ok:true,value:t}}n(a,"ok");function i(t){return {ok:false,error:t}}n(i,"err");function v(t){return t.ok===true}n(v,"isOk");function g(t){return t.ok===false}n(g,"isErr");function l(t,e){return t.ok?e(t.value):t}n(l,"andThen");function c(t,e){return t.ok?a(e(t.value)):t}n(c,"map");function E(t,e){return t.ok?t:i(e(t.error))}n(E,"mapErr");function h(t,e){return t.ok?t.value:e}n(h,"unwrapOr");function y(t,e){return t.ok?t.value:e(t.error)}n(y,"unwrapOrElse");function T(t,e,r){return typeof e=="function"?t.ok?e(t.value):r(t.error):t.ok?e.ok(t.value):e.err(t.error)}n(T,"match");async function m(t,e,r){return typeof e=="function"?t.ok?e(t.value):r(t.error):t.ok?e.ok(t.value):e.err(t.error)}n(m,"matchAsync");var u=class{static{n(this,"ResultBase");}_result;constructor(e){this._result=e;}unwrap(){if(this._result.ok)return this._result.value;throw this._result.error instanceof Error?this._result.error:new Error(String(this._result.error))}unwrapOr(e){return h(this._result,e)}unwrapOrElse(e){return y(this._result,e)}match(e,r){return typeof e=="function"?T(this._result,e,r):T(this._result,e)}async matchAsync(e,r){return typeof e=="function"?m(this._result,e,r):m(this._result,e)}isOk(){return v(this._result)}isErr(){return g(this._result)}get result(){return this._result}},f=class t extends u{static{n(this,"Success");}constructor(e){super(a(e));}static of(e){return new t(e)}andThen(e){let r=l(this._result,e);return r.ok?new t(r.value):new p(r.error)}map(e){let r=c(this._result,e);if(r.ok)return new t(r.value);throw new Error("Unexpected error in Success.map")}mapErr(e){return this}};var p=class t extends u{static{n(this,"Erroneous");}constructor(e){super(i(e));}static of(e){return new t(e)}andThen(e){return this}map(e){return this}mapErr(e){let r=E(this._result,e);if(!r.ok)return new t(r.error);throw new Error("Unexpected ok in Erroneous.mapErr")}};var x=class t extends u{static{n(this,"Outcome");}constructor(e){super(e);}static ok(e){return new f(e)}static err(e){return new p(e)}static from(e){return new t(e)}andThen(e){return t.from(l(this._result,e))}map(e){return t.from(c(this._result,e))}mapErr(e){return t.from(E(this._result,e))}};var R=class extends d{static{n(this,"AggregateEventSourced");}_eventConfig;_eventAutoVersionBump;_pendingEvents=[];constructor(e,r,o){super(e,r,o),this._eventConfig=o??{},this._eventAutoVersionBump=this._eventConfig.autoVersionBump??true;}get pendingEvents(){return this._pendingEvents}clearPendingEvents(){this._pendingEvents.length=0;}validateEvent(e){return a(true)}apply(e,r=true){let o=this.validateEvent(e);if(!o.ok)return i(`Event validation failed for ${e.type}: ${o.error}`);let s=this.handlers[e.type];return s?(this._state=s(this._state,e),r&&(this._pendingEvents.push(e),this._eventAutoVersionBump&&(this.version=this.version+1)),a()):i(`Missing handler for event type: ${e.type}`)}applyUnsafe(e,r=true){let o=this.validateEvent(e);if(!o.ok)throw new Error(`Event validation failed for ${e.type}: ${o.error}`);let s=this.handlers[e.type];if(!s)throw new Error(`Missing handler for event type: ${e.type}`);this._state=s(this._state,e),r&&(this._pendingEvents.push(e),this._eventAutoVersionBump&&(this.version=this.version+1));}bumpVersion(){this.version=this.version+1;}loadFromHistory(e){for(let r of e){let o=this.apply(r,false);if(!o.ok)return o}return this.version=e.length,a()}hasPendingEvents(){return this._pendingEvents.length>0}getEventCount(){return this._pendingEvents.length}getLatestEvent(){return this._pendingEvents[this._pendingEvents.length-1]}restoreFromSnapshotWithEvents(e,r){this._state=e.state,this.version=e.version;for(let o of r){let s=this.apply(o,false);if(!s.ok)return s}return this.version=e.version+r.length,a()}};var k=class{static{n(this,"CommandBus");}handlers=new Map;register(e,r){this.handlers.set(e,r);}async execute(e){let r=this.handlers.get(e.type);return r?r(e):i(`No handler registered for command type: ${e.type}`)}};function ne(t,e){return t.uow.transactional(async()=>{let{result:r,events:o}=await e();return await t.outbox.add(o),t.bus&&await t.bus.publish(o),r})}n(ne,"withCommit");var w=class{static{n(this,"QueryBus");}handlers=new Map;register(e,r){this.handlers.set(e,r);}async execute(e){let r=this.handlers.get(e.type);if(!r)return i(`No handler registered for query type: ${e.type}`);try{let o=await r(e);return a(o)}catch(o){return i(o instanceof Error?o.message:String(o))}}async executeUnsafe(e){let r=this.handlers.get(e.type);if(!r)throw new Error(`No handler registered for query type: ${e.type}`);return r(e)}};function de(t,e){return t?a(true):i(e)}n(de,"guard");function Ee(t,e){return t.id===e.id}n(Ee,"sameEntity");function Te(t,e){return t.find(r=>r.id===e)}n(Te,"findEntityById");function me(t,e){return t.some(r=>r.id===e)}n(me,"hasEntityId");function fe(t,e){return t.filter(r=>r.id!==e)}n(fe,"removeEntityById");function ve(t,e,r){return t.map(o=>o.id===e?r(o):o)}n(ve,"updateEntityById");function ge(t,e,r){return t.map(o=>o.id===e?r:o)}n(ge,"replaceEntityById");function he(t){return t.map(e=>e.id)}n(he,"entityIds");var S=class{static{n(this,"EventBusImpl");}handlers=new Map;subscribe(e,r){let o=e;this.handlers.has(o)||this.handlers.set(o,new Set);let s=this.handlers.get(o);return s.add(r),()=>{s.delete(r),s.size===0&&this.handlers.delete(o);}}async publish(e){for(let r of e){let o=this.handlers.get(r.type);o&&await Promise.all(Array.from(o).map(s=>s(r)));}}};function b(t,e=new WeakSet){if(t===null||typeof t!="object"||e.has(t))return t;e.add(t);let r=Object.getOwnPropertyNames(t);for(let o of r){let s=t[o];s&&(typeof s=="object"||Array.isArray(s))&&b(s,e);}return Object.freeze(t)}n(b,"deepFreeze");function I(t){return b({...t})}n(I,"vo");function Se(t,e){return JSON.stringify(t)===JSON.stringify(e)}n(Se,"voEquals");function be(t,e,r){return e(t)?a(I(t)):i(r??`Validation failed for value object: ${JSON.stringify(t)}`)}n(be,"voWithValidation");function Ie(t,e,r){if(!e(t))throw new Error(r??`Validation failed for value object: ${JSON.stringify(t)}`);return I(t)}n(Ie,"voWithValidationUnsafe");export{d as AggregateBase,R as AggregateEventSourced,k as CommandBus,p as Erroneous,S as EventBusImpl,x as Outcome,w as QueryBus,f as Success,V as aggregate,l as andThen,C as bump,O as copyMetadata,A as createDomainEvent,U as createDomainEventWithMetadata,he as entityIds,i as err,Te as findEntityById,de as guard,me as hasEntityId,g as isErr,v as isOk,c as map,E as mapErr,T as match,m as matchAsync,B as mergeMetadata,a as ok,fe as removeEntityById,ge as replaceEntityById,M as sameAggregate,Ee as sameEntity,h as unwrapOr,y as unwrapOrElse,ve as updateEntityById,I as vo,Se as voEquals,be as voWithValidation,Ie as voWithValidationUnsafe,ne as withCommit,Q as withEvent};//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map