@shirudo/ddd-kit 0.16.0 → 1.0.0-rc.1

package/dist/index.js

@@ -1,2 +1,882 @@
-var F=Object.defineProperty;var o=(t,e)=>F(t,"name",{value:e,configurable:true});function Z(t,e=0){return {state:t,version:e,pendingEvents:[]}}o(Z,"aggregate");function ee(t,e){return {...t,pendingEvents:[...t.pendingEvents,e]}}o(ee,"withEvent");function te(t){return {...t,version:t.version+1}}o(te,"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 re(t,e,r,n){return M(t,e,{...n,metadata:r})}o(re,"createDomainEventWithMetadata");function ne(t,e){return {...t.metadata??{},...e??{}}}o(ne,"copyMetadata");function oe(...t){return Object.assign({},...t.filter(Boolean))}o(oe,"mergeMetadata");function se(t,e){return t.id===e.id&&t.version===e.version}o(se,"sameAggregate");function v(t,e){if(e.endsWith("Array]")||ArrayBuffer.isView(t)||e==="[object ArrayBuffer]"||e==="[object SharedArrayBuffer]")return  true;let r=t.constructor;if(r&&typeof r=="function"){let a=r.name;if(a&&typeof globalThis<"u"&&a in globalThis&&globalThis[a]===r){let s=Object.getPrototypeOf(t);if(s!==Object.prototype&&s!==null)return  true}}return new Set(["[object Date]","[object RegExp]","[object Map]","[object Set]","[object WeakMap]","[object WeakSet]","[object Promise]","[object Error]","[object Boolean]","[object Number]","[object String]"]).has(e)}o(v,"isBuiltInObject");var O=Object.prototype,b=O.toString,K=O.hasOwnProperty;function m(t,e){return h(t,e,new WeakMap)}o(m,"deepEqual");function h(t,e,r){if(t===e)return  true;let n=typeof t,a=typeof e;if(n!=="object"||t===null||a!=="object"||e===null)return n==="number"&&a==="number"?Number.isNaN(t)&&Number.isNaN(e):false;let s=t,i=e,g=r.get(s);if(g!==void 0)return g===i;if(r.set(s,i),ArrayBuffer.isView(s)||ArrayBuffer.isView(i)){if(!ArrayBuffer.isView(s)||!ArrayBuffer.isView(i))return  false;let c=b.call(s),l=b.call(i);if(c!==l)return  false;if(c==="[object DataView]"){let T=s,P=i;if(T.byteLength!==P.byteLength)return  false;let Q=T.byteLength;for(let R=0;R<Q;R++)if(T.getUint8(R)!==P.getUint8(R))return  false;return  true}let u=s,d=i,p=u.length;if(p!==d.length)return  false;for(let T=0;T<p;T++)if(u[T]!==d[T])return  false;return  true}let y=b.call(s),x=b.call(i);if(y!==x)return  false;switch(y){case "[object Array]":{let c=s,l=i,u=c.length;if(u!==l.length)return  false;for(let d=0;d<u;d++)if(!h(c[d],l[d],r))return  false;return  true}case "[object Map]":{let c=s,l=i;if(c.size!==l.size)return  false;for(let[u,d]of c){if(!l.has(u))return  false;let p=l.get(u);if(!h(d,p,r))return  false}return  true}case "[object Set]":{let c=s,l=i;if(c.size!==l.size)return  false;for(let u of c)if(!l.has(u))return  false;return  true}case "[object Date]":{let c=s.getTime(),l=i.getTime();return c===l}case "[object RegExp]":{let c=s,l=i;return c.source===l.source&&c.flags===l.flags}case "[object Boolean]":case "[object Number]":case "[object String]":return s.valueOf()===i.valueOf();default:{if(v(s,y)&&v(i,x))return s===i;let c=Object.keys(s),l=Object.keys(i),u=Object.getOwnPropertySymbols(s),d=Object.getOwnPropertySymbols(i);if(c.length!==l.length||u.length!==d.length)return  false;for(let p of c)if(!K.call(i,p))return  false;for(let p of u)if(!Object.getOwnPropertySymbols(i).includes(p))return  false;for(let p of c)if(!h(s[p],i[p],r))return  false;for(let p of u)if(!h(s[p],i[p],r))return  false;return  true}}}o(h,"deepEqualInner");var w=class{static{o(this,"Entity");}id;get state(){return this._state}_state;constructor(e,r){if(e==null)throw new Error("Entity ID cannot be null or undefined");this.id=e,this._state=r,this.validateState(this._state);}validateState(e){}setState(e){this.validateState(e),this._state=e;}};function Ee(t,e){return m(t.id,e.id)}o(Ee,"sameEntity");function me(t,e){return t.find(r=>m(r.id,e))}o(me,"findEntityById");function Te(t,e){return t.some(r=>m(r.id,e))}o(Te,"hasEntityId");function ye(t,e){return t.filter(r=>!m(r.id,e))}o(ye,"removeEntityById");function ge(t,e,r){return t.map(n=>m(n.id,e)?r(n):n)}o(ge,"updateEntityById");function ve(t,e,r){return t.map(n=>m(n.id,e)?r:n)}o(ve,"replaceEntityById");function he(t){return t.map(e=>e.id)}o(he,"entityIds");var k=class extends w{static{o(this,"AggregateRoot");}version=0;_config;_autoVersionBump;_domainEvents=[];get domainEvents(){return this._domainEvents}clearDomainEvents(){this._domainEvents=[];}constructor(e,r,n){super(e,r),this._config=n??{},this._autoVersionBump=this._config.autoVersionBump??false;}addDomainEvent(e){this._domainEvents.push(e);}bumpVersion(){this.version=this.version+1;}setState(e,r){super.setState(e),(r??this._autoVersionBump)&&this.bumpVersion();}createSnapshot(){return {state:{...this._state},version:this.version,snapshotAt:new Date}}restoreFromSnapshot(e){this.validateState(e.state),this._state=e.state,this.version=e.version;}};function E(t){return {ok:true,value:t}}o(E,"ok");function f(t){return {ok:false,error:t}}o(f,"err");var j=class extends k{static{o(this,"AggregateEventSourced");}_eventConfig;_eventAutoVersionBump;constructor(e,r,n){super(e,r,n),this._eventConfig=n??{},this._eventAutoVersionBump=this._eventConfig.autoVersionBump??true;}get pendingEvents(){return this.domainEvents}clearPendingEvents(){this.clearDomainEvents();}validateEvent(e){return E(true)}apply(e,r=true){let n=this.validateEvent(e);if(!n.ok)return f(`Event validation failed for ${e.type}: ${n.error}`);let a=this.handlers[e.type];return a?(this._state=a(this._state,e),r&&(this.addDomainEvent(e),this._eventAutoVersionBump&&(this.version=this.version+1)),E()):f(`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 a=this.handlers[e.type];if(!a)throw new Error(`Missing handler for event type: ${e.type}`);this._state=a(this._state,e),r&&(this.addDomainEvent(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,E()}hasPendingEvents(){return this.domainEvents.length>0}getEventCount(){return this.domainEvents.length}getLatestEvent(){let e=this.domainEvents;return e[e.length-1]}restoreFromSnapshotWithEvents(e,r){this._state=e.state,this.version=e.version;for(let n of r){let a=this.apply(n,false);if(!a.ok)return a}return this.version=e.version+r.length,E()}};var V=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);if(!r)return f(`No handler registered for command type: ${e.type}`);try{return await r(e)}catch(n){return f(n instanceof Error?n.message:String(n))}}};function Je(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(Je,"withCommit");var B=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 f(`No handler registered for query type: ${e.type}`);try{let n=await r(e);return E(n)}catch(n){return f(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 rt(t,e){return t?E(true):f(e)}o(rt,"guard");var D=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 a=this.handlers.get(n);return a.add(r),()=>{a.delete(r),a.size===0&&this.handlers.delete(n);}}once(e){return new Promise(r=>{let n=this.subscribe(e,a=>{n(),r(a);});})}async publish(e){let r=[];for(let n of e){let a=this.handlers.get(n.type);if(a){let s=await Promise.allSettled(Array.from(a).map(i=>i(n)));for(let i of s)i.status==="rejected"&&r.push(i.reason instanceof Error?i.reason:new Error(String(i.reason)));}}if(r.length===1)throw r[0];if(r.length>1)throw new AggregateError(r,"Multiple event handlers failed")}};function S(t,e){return I(t,e,[],new WeakMap)}o(S,"deepOmit");function I(t,e,r,n){if(t===null||typeof t!=="object")return t;let s=t,i=n.get(s);if(i!==void 0)return i;let g=Object.prototype.toString.call(s);if(g==="[object Array]"){let u=s,d=new Array(u.length);n.set(s,d);for(let p=0;p<u.length;p++)r.push(p),d[p]=I(u[p],e,r,n),r.pop();return d}if(v(s,g))return t;let y=Object.create(Object.getPrototypeOf(s));n.set(s,y);let x=Object.keys(s),c=Object.getOwnPropertySymbols(s),l=[...x,...c];for(let u of l)X(u,r,e)||(r.push(u),y[u]=I(s[u],e,r,n),r.pop());return y}o(I,"omitInternal");function X(t,e,r){return !!(r.ignoreKeys?.includes(t)||r.ignoreKeyPredicate?.(t,e))}o(X,"shouldIgnoreKey");function _(t,e,r){let n=S(t,r),a=S(e,r);return m(n,a)}o(_,"deepEqualExcept");function A(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 a=t[n];a&&(typeof a=="object"||Array.isArray(a))&&A(a,e);}return Object.freeze(t)}o(A,"deepFreeze");function C(t){return A({...t})}o(C,"vo");function yt(t,e){return m(t,e)}o(yt,"voEquals");function gt(t,e,r){return _(t,e,r)}o(gt,"voEqualsExcept");function vt(t,e,r){return e(t)?E(C(t)):f(r??`Validation failed for value object: ${JSON.stringify(t)}`)}o(vt,"voWithValidation");function ht(t,e,r){if(!e(t))throw new Error(r??`Validation failed for value object: ${JSON.stringify(t)}`);return C(t)}o(ht,"voWithValidationUnsafe");var U=class{static{o(this,"ValueObject");}props;constructor(e){this.validate(e),this.props=A({...e});}validate(e){}equals(e){return e==null||this.constructor!==e.constructor?false:m(this.props,e.props)}clone(e){let r=this.constructor;return new r({...this.props,...e||{}})}toJSON(){return this.props}};export{j as AggregateEventSourced,k as AggregateRoot,V as CommandBus,w as Entity,D as EventBusImpl,B as QueryBus,U as ValueObject,Z as aggregate,te as bump,ne as copyMetadata,M as createDomainEvent,re as createDomainEventWithMetadata,A as deepFreeze,he as entityIds,me as findEntityById,rt as guard,Te as hasEntityId,oe as mergeMetadata,ye as removeEntityById,ve as replaceEntityById,se as sameAggregate,Ee as sameEntity,ge as updateEntityById,C as vo,yt as voEquals,gt as voEqualsExcept,vt as voWithValidation,ht as voWithValidationUnsafe,Je as withCommit,ee as withEvent};//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/aggregate/domain-event.ts
+function createDomainEvent(type, payload, options) {
+  return {
+    type,
+    payload,
+    occurredAt: options?.occurredAt ?? /* @__PURE__ */ new Date(),
+    version: options?.version ?? 1,
+    metadata: options?.metadata
+  };
+}
+__name(createDomainEvent, "createDomainEvent");
+function createDomainEventWithMetadata(type, payload, metadata, options) {
+  return createDomainEvent(type, payload, {
+    ...options,
+    metadata
+  });
+}
+__name(createDomainEventWithMetadata, "createDomainEventWithMetadata");
+function copyMetadata(sourceEvent, additionalMetadata) {
+  return {
+    ...sourceEvent.metadata ?? {},
+    ...additionalMetadata ?? {}
+  };
+}
+__name(copyMetadata, "copyMetadata");
+function mergeMetadata(...metadataObjects) {
+  return Object.assign({}, ...metadataObjects.filter(Boolean));
+}
+__name(mergeMetadata, "mergeMetadata");
+
+// src/aggregate/aggregate.ts
+function aggregate(state, version = 0) {
+  return { state, version };
+}
+__name(aggregate, "aggregate");
+function bump(agg) {
+  return { ...agg, version: agg.version + 1 };
+}
+__name(bump, "bump");
+function sameVersion(a, b) {
+  return a.id === b.id && a.version === b.version;
+}
+__name(sameVersion, "sameVersion");
+
+// src/utils/array/is-built-in.ts
+function isBuiltInObject(obj, tag) {
+  if (tag.endsWith("Array]")) {
+    return true;
+  }
+  if (ArrayBuffer.isView(obj)) {
+    return true;
+  }
+  if (tag === "[object ArrayBuffer]" || tag === "[object SharedArrayBuffer]") {
+    return true;
+  }
+  const objConstructor = obj.constructor;
+  if (objConstructor && typeof objConstructor === "function") {
+    const constructorName = objConstructor.name;
+    if (constructorName && typeof globalThis !== "undefined" && constructorName in globalThis && globalThis[constructorName] === objConstructor) {
+      const proto = Object.getPrototypeOf(obj);
+      if (proto !== Object.prototype && proto !== null) {
+        return true;
+      }
+    }
+  }
+  const knownBuiltInTags = /* @__PURE__ */ new Set([
+    "[object Date]",
+    "[object RegExp]",
+    "[object Map]",
+    "[object Set]",
+    "[object WeakMap]",
+    "[object WeakSet]",
+    "[object Promise]",
+    "[object Error]",
+    "[object Boolean]",
+    "[object Number]",
+    "[object String]"
+  ]);
+  return knownBuiltInTags.has(tag);
+}
+__name(isBuiltInObject, "isBuiltInObject");
+
+// src/utils/array/deep-equal.ts
+var objProto = Object.prototype;
+var objToString = objProto.toString;
+var objHasOwn = objProto.hasOwnProperty;
+function deepEqual(a, b) {
+  return deepEqualInner(a, b, /* @__PURE__ */ new WeakMap());
+}
+__name(deepEqual, "deepEqual");
+function deepEqualInner(a, b, visited) {
+  if (a === b) return true;
+  const typeA = typeof a;
+  const typeB = typeof b;
+  if (typeA !== "object" || a === null || typeB !== "object" || b === null) {
+    if (typeA === "number" && typeB === "number") {
+      return Number.isNaN(a) && Number.isNaN(b);
+    }
+    return false;
+  }
+  const objA = a;
+  const objB = b;
+  const cached = visited.get(objA);
+  if (cached !== void 0) {
+    return cached === objB;
+  }
+  visited.set(objA, objB);
+  if (ArrayBuffer.isView(objA) || ArrayBuffer.isView(objB)) {
+    if (!ArrayBuffer.isView(objA) || !ArrayBuffer.isView(objB)) return false;
+    const tagA2 = objToString.call(objA);
+    const tagB2 = objToString.call(objB);
+    if (tagA2 !== tagB2) return false;
+    if (tagA2 === "[object DataView]") {
+      const viewA = objA;
+      const viewB = objB;
+      if (viewA.byteLength !== viewB.byteLength) return false;
+      const len2 = viewA.byteLength;
+      for (let i = 0; i < len2; i++) {
+        if (viewA.getUint8(i) !== viewB.getUint8(i)) return false;
+      }
+      return true;
+    }
+    const arrA = objA;
+    const arrB = objB;
+    const len = arrA.length;
+    if (len !== arrB.length) return false;
+    for (let i = 0; i < len; i++) {
+      if (arrA[i] !== arrB[i]) return false;
+    }
+    return true;
+  }
+  const tagA = objToString.call(objA);
+  const tagB = objToString.call(objB);
+  if (tagA !== tagB) return false;
+  switch (tagA) {
+    case "[object Array]": {
+      const arrA = objA;
+      const arrB = objB;
+      const len = arrA.length;
+      if (len !== arrB.length) return false;
+      for (let i = 0; i < len; i++) {
+        if (!deepEqualInner(arrA[i], arrB[i], visited)) return false;
+      }
+      return true;
+    }
+    case "[object Map]": {
+      const mapA = objA;
+      const mapB = objB;
+      if (mapA.size !== mapB.size) return false;
+      for (const [key, valA] of mapA) {
+        if (!mapB.has(key)) return false;
+        const valB = mapB.get(key);
+        if (!deepEqualInner(valA, valB, visited)) return false;
+      }
+      return true;
+    }
+    case "[object Set]": {
+      const setA = objA;
+      const setB = objB;
+      if (setA.size !== setB.size) return false;
+      for (const value of setA) {
+        if (!setB.has(value)) return false;
+      }
+      return true;
+    }
+    case "[object Date]": {
+      const timeA = objA.getTime();
+      const timeB = objB.getTime();
+      return timeA === timeB;
+    }
+    case "[object RegExp]": {
+      const regA = objA;
+      const regB = objB;
+      return regA.source === regB.source && regA.flags === regB.flags;
+    }
+    case "[object Boolean]":
+    case "[object Number]":
+    case "[object String]": {
+      return objA.valueOf() === objB.valueOf();
+    }
+    default: {
+      if (isBuiltInObject(objA, tagA) && isBuiltInObject(objB, tagB)) {
+        return objA === objB;
+      }
+      const stringKeysA = Object.keys(objA);
+      const stringKeysB = Object.keys(objB);
+      const symbolKeysA = Object.getOwnPropertySymbols(objA);
+      const symbolKeysB = Object.getOwnPropertySymbols(objB);
+      if (stringKeysA.length !== stringKeysB.length) return false;
+      if (symbolKeysA.length !== symbolKeysB.length) return false;
+      for (const key of stringKeysA) {
+        if (!objHasOwn.call(objB, key)) return false;
+      }
+      for (const key of symbolKeysA) {
+        if (!Object.getOwnPropertySymbols(objB).includes(key)) return false;
+      }
+      for (const key of stringKeysA) {
+        if (!deepEqualInner(objA[key], objB[key], visited)) {
+          return false;
+        }
+      }
+      for (const key of symbolKeysA) {
+        if (!deepEqualInner(objA[key], objB[key], visited)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+__name(deepEqualInner, "deepEqualInner");
+
+// src/entity/entity.ts
+var Entity = class {
+  static {
+    __name(this, "Entity");
+  }
+  id;
+  /**
+   * Returns the current state of the entity.
+   * State is readonly from outside to enforce encapsulation.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * The state is 'protected' so that only the subclass can modify it.
+   * Subclasses can mutate this directly or use helper methods.
+   */
+  _state;
+  constructor(id, initialState) {
+    if (id === null || id === void 0) {
+      throw new Error("Entity ID cannot be null or undefined");
+    }
+    this.id = id;
+    this._state = initialState;
+    this.validateState(this._state);
+  }
+  /**
+   * Optional validation hook to ensure state invariants.
+   * Called during construction and whenever helpful.
+   * Override this method to implement validation logic.
+   *
+   * @param state - The state to validate
+   * @throws Error if validation fails
+   */
+  validateState(_state) {
+  }
+  /**
+   * Sets the state of the entity.
+   * This is a convenience method for state mutations.
+   * Automatically validates the newState using `validateState()`.
+   *
+   * @param newState - The new state
+   */
+  setState(newState) {
+    this.validateState(newState);
+    this._state = newState;
+  }
+};
+function sameEntity(a, b) {
+  return deepEqual(a.id, b.id);
+}
+__name(sameEntity, "sameEntity");
+function findEntityById(entities, id) {
+  return entities.find((entity) => deepEqual(entity.id, id));
+}
+__name(findEntityById, "findEntityById");
+function hasEntityId(entities, id) {
+  return entities.some((entity) => deepEqual(entity.id, id));
+}
+__name(hasEntityId, "hasEntityId");
+function removeEntityById(entities, id) {
+  return entities.filter((entity) => !deepEqual(entity.id, id));
+}
+__name(removeEntityById, "removeEntityById");
+function updateEntityById(entities, id, updater) {
+  return entities.map((entity) => deepEqual(entity.id, id) ? updater(entity) : entity);
+}
+__name(updateEntityById, "updateEntityById");
+function replaceEntityById(entities, id, replacement) {
+  return entities.map((entity) => deepEqual(entity.id, id) ? replacement : entity);
+}
+__name(replaceEntityById, "replaceEntityById");
+function entityIds(entities) {
+  return entities.map((entity) => entity.id);
+}
+__name(entityIds, "entityIds");
+
+// src/aggregate/aggregate-root.ts
+var AggregateRoot = class extends Entity {
+  static {
+    __name(this, "AggregateRoot");
+  }
+  _version = 0;
+  get version() {
+    return this._version;
+  }
+  setVersion(version) {
+    this._version = version;
+  }
+  _config;
+  _autoVersionBump;
+  _domainEvents = [];
+  /**
+   * Returns a read-only list of domain events recorded by this aggregate.
+   * These events are side-effects of state changes.
+   */
+  get domainEvents() {
+    return this._domainEvents;
+  }
+  /**
+   * Clears the list of recorded domain events.
+   * Call this after dispatching the events.
+   */
+  clearDomainEvents() {
+    this._domainEvents = [];
+  }
+  constructor(id, initialState, config) {
+    super(id, initialState);
+    this._config = config ?? {};
+    this._autoVersionBump = this._config.autoVersionBump ?? false;
+  }
+  /**
+   * Adds a domain event to the aggregate's list of changes.
+   * Use this to record side-effects that should be published.
+   *
+   * @param event - The domain event to add
+   */
+  addDomainEvent(event) {
+    this._domainEvents.push(event);
+  }
+  /**
+   * Manually bumps the aggregate version.
+   * Call this after state changes for Optimistic Concurrency Control.
+   *
+   * If `autoVersionBump` is enabled, this is called automatically
+   * when using `setState()`.
+   */
+  bumpVersion() {
+    this.setVersion(this._version + 1);
+  }
+  /**
+   * Sets the state and optionally bumps the version automatically.
+   * This is a convenience method for state mutations.
+   * Automatically validates the newState using `validateState()`.
+   * Overrides Entity.setState to add version bumping.
+   *
+   * @param newState - The new state
+   * @param bumpVersion - Whether to bump the version (defaults to autoVersionBump config)
+   */
+  setState(newState, bumpVersion) {
+    super.setState(newState);
+    const shouldBump = bumpVersion ?? this._autoVersionBump;
+    if (shouldBump) {
+      this.bumpVersion();
+    }
+  }
+  /**
+   * Creates a snapshot of the current aggregate state.
+   * Useful for performance optimization, backup/restore, and audit trails.
+   *
+   * @returns A snapshot containing the current state and version
+   *
+   * @example
+   * ```typescript
+   * const snapshot = aggregate.createSnapshot();
+   * await snapshotRepository.save(aggregate.id, snapshot);
+   * ```
+   */
+  createSnapshot() {
+    return {
+      state: structuredClone(this._state),
+      version: this.version,
+      snapshotAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Restores the aggregate from a snapshot.
+   * This is useful for loading aggregates from snapshots instead of
+   * rebuilding them from scratch.
+   * Validates the restored state.
+   *
+   * @param snapshot - The snapshot to restore from
+   *
+   * @example
+   * ```typescript
+   * const snapshot = await snapshotRepository.getLatest(aggregateId);
+   * aggregate.restoreFromSnapshot(snapshot);
+   * ```
+   */
+  restoreFromSnapshot(snapshot) {
+    this.validateState(snapshot.state);
+    this._state = snapshot.state;
+    this.setVersion(snapshot.version);
+  }
+};
+
+// src/core/result/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+__name(ok, "ok");
+function err(error) {
+  return { ok: false, error };
+}
+__name(err, "err");
+
+// src/aggregate/event-sourced-aggregate.ts
+var EventSourcedAggregate = class extends Entity {
+  static {
+    __name(this, "EventSourcedAggregate");
+  }
+  // --- Version management (own, not inherited from AggregateRoot) ---
+  _version = 0;
+  get version() {
+    return this._version;
+  }
+  setVersion(version) {
+    this._version = version;
+  }
+  // --- Event tracking ---
+  _pendingEvents = [];
+  _autoVersionBump;
+  get pendingEvents() {
+    return this._pendingEvents;
+  }
+  clearPendingEvents() {
+    this._pendingEvents = [];
+  }
+  constructor(id, initialState, config) {
+    super(id, initialState);
+    this._autoVersionBump = config?.autoVersionBump ?? true;
+  }
+  // --- Event application ---
+  /**
+   * Validates an event before it is applied.
+   * Override this method to add custom validation logic.
+   * Return `ok(true)` if the event is valid, `err(message)` otherwise.
+   */
+  validateEvent(_event) {
+    return ok(true);
+  }
+  /**
+   * Applies an event to change the state and adds it to pending events.
+   * Returns a Result type instead of throwing an error.
+   *
+   * @param event - The domain event to apply
+   * @param isNew - Whether the event is new (needs persisting) or from history replay
+   */
+  apply(event, isNew = true) {
+    const validation = this.validateEvent(event);
+    if (!validation.ok) {
+      return err(
+        `Event validation failed for ${event.type}: ${validation.error}`
+      );
+    }
+    const handler = this.handlers[event.type];
+    if (!handler) {
+      return err(`Missing handler for event type: ${event.type}`);
+    }
+    this._state = handler(
+      this._state,
+      event
+    );
+    if (isNew) {
+      this._pendingEvents.push(event);
+      if (this._autoVersionBump) {
+        this.setVersion(this._version + 1);
+      }
+    }
+    return ok();
+  }
+  /**
+   * Applies an event to change the state and adds it to pending events.
+   * Throws an error if validation fails or handler is missing.
+   */
+  applyUnsafe(event, isNew = true) {
+    const validation = this.validateEvent(event);
+    if (!validation.ok) {
+      throw new Error(
+        `Event validation failed for ${event.type}: ${validation.error}`
+      );
+    }
+    const handler = this.handlers[event.type];
+    if (!handler) {
+      throw new Error(`Missing handler for event type: ${event.type}`);
+    }
+    this._state = handler(
+      this._state,
+      event
+    );
+    if (isNew) {
+      this._pendingEvents.push(event);
+      if (this._autoVersionBump) {
+        this.setVersion(this._version + 1);
+      }
+    }
+  }
+  /**
+   * Manually bumps the aggregate version.
+   * Only needed if `autoVersionBump` is disabled.
+   */
+  bumpVersion() {
+    this.setVersion(this._version + 1);
+  }
+  // --- History & Snapshots ---
+  /**
+   * Reconstitutes the aggregate from an event history.
+   * Sets the version to the number of events in the history.
+   */
+  loadFromHistory(history) {
+    for (const event of history) {
+      const result = this.apply(event, false);
+      if (!result.ok) {
+        return result;
+      }
+    }
+    this.setVersion(history.length);
+    return ok();
+  }
+  hasPendingEvents() {
+    return this._pendingEvents.length > 0;
+  }
+  getEventCount() {
+    return this._pendingEvents.length;
+  }
+  getLatestEvent() {
+    return this._pendingEvents[this._pendingEvents.length - 1];
+  }
+  /**
+   * Creates a snapshot of the current aggregate state.
+   */
+  createSnapshot() {
+    return {
+      state: structuredClone(this._state),
+      version: this._version,
+      snapshotAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Restores the aggregate from a snapshot and applies events that occurred after.
+   */
+  restoreFromSnapshotWithEvents(snapshot, eventsAfterSnapshot) {
+    this._state = snapshot.state;
+    this.setVersion(snapshot.version);
+    for (const event of eventsAfterSnapshot) {
+      const result = this.apply(event, false);
+      if (!result.ok) {
+        return result;
+      }
+    }
+    this.setVersion(snapshot.version + eventsAfterSnapshot.length);
+    return ok();
+  }
+};
+
+// src/app/command-bus.ts
+var CommandBus = class {
+  static {
+    __name(this, "CommandBus");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlers = /* @__PURE__ */ new Map();
+  register(commandType, handler) {
+    this.handlers.set(commandType, handler);
+  }
+  async execute(command) {
+    const handler = this.handlers.get(command.type);
+    if (!handler) {
+      return err(`No handler registered for command type: ${command.type}`);
+    }
+    try {
+      return await handler(command);
+    } catch (error) {
+      return err(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+};
+
+// src/app/handler.ts
+function withCommit(deps, fn) {
+  return deps.uow.transactional(async () => {
+    const { result, events } = await fn();
+    await deps.outbox.add(events);
+    if (deps.bus) await deps.bus.publish(events);
+    return result;
+  });
+}
+__name(withCommit, "withCommit");
+
+// src/app/query-bus.ts
+var QueryBus = class {
+  static {
+    __name(this, "QueryBus");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlers = /* @__PURE__ */ new Map();
+  register(queryType, handler) {
+    this.handlers.set(queryType, handler);
+  }
+  async execute(query) {
+    const handler = this.handlers.get(query.type);
+    if (!handler) {
+      return err(`No handler registered for query type: ${query.type}`);
+    }
+    try {
+      const result = await handler(query);
+      return ok(result);
+    } catch (error) {
+      return err(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  async executeUnsafe(query) {
+    const handler = this.handlers.get(query.type);
+    if (!handler) {
+      throw new Error(`No handler registered for query type: ${query.type}`);
+    }
+    return handler(query);
+  }
+};
+
+// src/core/guard.ts
+function guard(cond, error) {
+  return cond ? ok(true) : err(error);
+}
+__name(guard, "guard");
+
+// src/events/event-bus.ts
+var EventBusImpl = class {
+  static {
+    __name(this, "EventBusImpl");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlers = /* @__PURE__ */ new Map();
+  subscribe(eventType, handler) {
+    const type = eventType;
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    const handlersForType = this.handlers.get(type);
+    handlersForType.add(handler);
+    return () => {
+      handlersForType.delete(handler);
+      if (handlersForType.size === 0) {
+        this.handlers.delete(type);
+      }
+    };
+  }
+  once(eventType) {
+    return new Promise((resolve) => {
+      const unsubscribe = this.subscribe(eventType, (event) => {
+        unsubscribe();
+        resolve(event);
+      });
+    });
+  }
+  async publish(events) {
+    const errors = [];
+    for (const event of events) {
+      const handlersForType = this.handlers.get(event.type);
+      if (handlersForType) {
+        const results = await Promise.allSettled(
+          Array.from(handlersForType).map((handler) => handler(event))
+        );
+        for (const result of results) {
+          if (result.status === "rejected") {
+            errors.push(
+              result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+            );
+          }
+        }
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    }
+    if (errors.length > 1) {
+      throw new AggregateError(errors, "Multiple event handlers failed");
+    }
+  }
+};
+
+// src/utils/array/deep-omit.ts
+function deepOmit(value, options) {
+  const visited = /* @__PURE__ */ new WeakMap();
+  return omitInternal(value, options, [], visited);
+}
+__name(deepOmit, "deepOmit");
+function omitInternal(value, options, path, visited) {
+  if (value === null) return value;
+  const type = typeof value;
+  if (type !== "object") return value;
+  const obj = value;
+  const cached = visited.get(obj);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const tag = Object.prototype.toString.call(obj);
+  if (tag === "[object Array]") {
+    const arr = obj;
+    const clone2 = new Array(arr.length);
+    visited.set(obj, clone2);
+    for (let i = 0; i < arr.length; i++) {
+      path.push(i);
+      clone2[i] = omitInternal(arr[i], options, path, visited);
+      path.pop();
+    }
+    return clone2;
+  }
+  if (isBuiltInObject(obj, tag)) {
+    return value;
+  }
+  const clone = Object.create(Object.getPrototypeOf(obj));
+  visited.set(obj, clone);
+  const stringKeys = Object.keys(obj);
+  const symbolKeys = Object.getOwnPropertySymbols(obj);
+  const keys = [...stringKeys, ...symbolKeys];
+  for (const key of keys) {
+    if (shouldIgnoreKey(key, path, options)) continue;
+    path.push(key);
+    clone[key] = omitInternal(
+      obj[key],
+      options,
+      path,
+      visited
+    );
+    path.pop();
+  }
+  return clone;
+}
+__name(omitInternal, "omitInternal");
+function shouldIgnoreKey(key, path, options) {
+  if (options.ignoreKeys?.includes(key)) {
+    return true;
+  }
+  if (options.ignoreKeyPredicate?.(key, path)) {
+    return true;
+  }
+  return false;
+}
+__name(shouldIgnoreKey, "shouldIgnoreKey");
+
+// src/utils/array/deep-equal-except.ts
+function deepEqualExcept(a, b, options) {
+  const prunedA = deepOmit(a, options);
+  const prunedB = deepOmit(b, options);
+  return deepEqual(prunedA, prunedB);
+}
+__name(deepEqualExcept, "deepEqualExcept");
+
+// src/value-object/value-object.ts
+function deepFreeze(obj, visited = /* @__PURE__ */ new WeakSet()) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return obj;
+  }
+  visited.add(obj);
+  const propNames = Object.getOwnPropertyNames(obj);
+  for (const name of propNames) {
+    const value = obj[name];
+    if (value && (typeof value === "object" || Array.isArray(value))) {
+      deepFreeze(value, visited);
+    }
+  }
+  return Object.freeze(obj);
+}
+__name(deepFreeze, "deepFreeze");
+function vo(t) {
+  return deepFreeze({ ...t });
+}
+__name(vo, "vo");
+function voEquals(a, b) {
+  return deepEqual(a, b);
+}
+__name(voEquals, "voEquals");
+function voEqualsExcept(a, b, options) {
+  return deepEqualExcept(a, b, options);
+}
+__name(voEqualsExcept, "voEqualsExcept");
+function voWithValidation(t, validate, errorMessage) {
+  if (!validate(t)) {
+    return err(
+      errorMessage ?? `Validation failed for value object: ${JSON.stringify(t)}`
+    );
+  }
+  return ok(vo(t));
+}
+__name(voWithValidation, "voWithValidation");
+function voWithValidationUnsafe(t, validate, errorMessage) {
+  if (!validate(t)) {
+    throw new Error(
+      errorMessage ?? `Validation failed for value object: ${JSON.stringify(t)}`
+    );
+  }
+  return vo(t);
+}
+__name(voWithValidationUnsafe, "voWithValidationUnsafe");
+var ValueObject = class {
+  static {
+    __name(this, "ValueObject");
+  }
+  props;
+  /**
+   * Creates a new ValueObject.
+   * The properties are deeply frozen to ensure immutability.
+   *
+   * @param props - The properties of the value object
+   * @example
+   * ```ts
+   * class Money extends ValueObject<{ amount: number; currency: string }> {
+   *   constructor(props: { amount: number; currency: string }) {
+   *     super(props);
+   *   }
+   *
+   *   protected validate(props: { amount: number; currency: string }): void {
+   *     if (props.amount < 0) throw new Error("Amount cannot be negative");
+   *   }
+   * }
+   * ```
+   */
+  constructor(props) {
+    this.validate(props);
+    this.props = deepFreeze({ ...props });
+  }
+  /**
+   * Optional validation hook that can be overridden by subclasses.
+   * Should throw an error if validation fails.
+   *
+   * @param props - The properties to validate
+   * @throws Error if validation fails
+   */
+  validate(props) {
+  }
+  /**
+   * Checks if this value object is equal to another.
+   * Uses deep equality comparison on the properties and checks for constructor equality.
+   *
+   * @param other - The other value object to compare
+   * @returns true if the properties are deeply equal and constructors match
+   */
+  equals(other) {
+    if (other === null || other === void 0) {
+      return false;
+    }
+    if (this.constructor !== other.constructor) {
+      return false;
+    }
+    return deepEqual(this.props, other.props);
+  }
+  /**
+   * Creates a clone of the value object with optional property overrides.
+   *
+   * @param props - Optional properties to override
+   * @returns A new instance of the value object
+   */
+  clone(props) {
+    const Constructor = this.constructor;
+    return new Constructor({ ...this.props, ...props || {} });
+  }
+  /**
+   * Serializes the value object to its raw properties for JSON operations.
+   *
+   * @returns The raw properties object
+   */
+  toJSON() {
+    return this.props;
+  }
+};
+
+export { AggregateRoot, CommandBus, Entity, EventBusImpl, EventSourcedAggregate, QueryBus, ValueObject, aggregate, bump, copyMetadata, createDomainEvent, createDomainEventWithMetadata, deepFreeze, entityIds, findEntityById, guard, hasEntityId, mergeMetadata, removeEntityById, replaceEntityById, sameEntity, sameVersion, updateEntityById, vo, voEquals, voEqualsExcept, voWithValidation, voWithValidationUnsafe, withCommit };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map