@event-driven-io/emmett 0.20.1-alpha.5 → 0.20.2-alpha.1

package/dist/index.js

@@ -1,17 +1,1333 @@
-import{a as Ye,b as ze,c as Qe,d as Ze,e as et,f as tt,g as rt,h as nt,i as ot,j as $,k as I,l as J,m as at,n as st,o as it,p as mt}from"./chunk-6TXKRKDJ.js";var K=t=>"withSession"in t,X=t=>({withSession:e=>e({eventStore:t,close:()=>Promise.resolve()})});var pt=(t,e,r)=>({type:t,data:e,metadata:r});var L=(t,e,r)=>({type:t,data:e,metadata:r});var ut=t=>({kind:"Reply",message:t}),ft=t=>({kind:"Send",message:t}),yt=t=>({kind:"Publish",message:t}),vt=(t,e)=>({kind:"Schedule",message:t,when:e}),Et=()=>({kind:"Complete"}),St=t=>({kind:"Ignore",reason:t}),Tt=t=>({kind:"Error",reason:t}),xt=()=>({kind:"Accept"});var H="__emt:GlobalStreamCaughtUp",Y=t=>t.type===H,Mt=t=>e=>e.type===H&&e.metadata?.globalPosition>=t,j=t=>L(H,t,{globalPosition:t.globalPosition}),Vt=t=>Y(t),Pt=t=>!Y(t);var xe="STREAM_EXISTS",F="STREAM_DOES_NOT_EXIST",D="NO_CONCURRENCY_CHECK",ge=(t,e,r)=>e===D?!0:e==F?t===r:e==xe?t!==r:t===e,N=(t,e,r)=>{if(e??=D,!ge(t,e,r))throw new b(t,e)},b=class t extends J{constructor(e,r){super(e?.toString(),r?.toString()),Object.setPrototypeOf(this,t.prototype)}},z=t=>t instanceof b;import{v4 as De}from"uuid";import{TransformStream as he}from"web-streams-polyfill";var Q=t=>new _(t),_=class extends he{_currentPosition;_logPosition;constructor(e){super({start:r=>{let n=0n;for(let o of e)r.enqueue(o),n=o.metadata.globalPosition;r.enqueue(j({globalPosition:n}))},transform:(r,n)=>{this._currentPosition=r.metadata.globalPosition,n.enqueue(r),!(this._currentPosition<this._logPosition)&&n.enqueue(j({globalPosition:this._currentPosition}))}}),this._currentPosition=this._logPosition=e.length>0?e[e.length-1].metadata.globalPosition:0n}set logPosition(e){this._logPosition=e}};import{v4 as be}from"uuid";import{v4 as Ce}from"uuid";import{TransformStream as Re}from"web-streams-polyfill";var O=(t,e={})=>new S(t,e),S=class extends Re{constructor(r,n={}){super({cancel:o=>{console.log("Stream was canceled. Reason:",o),this.stopChecking()}});this.onNoActiveReaderCallback=r;this.streamId=n?.streamId??Ce(),this.onNoActiveReaderCallback=r,this.startChecking(n?.intervalCheckInMs??20)}checkInterval=null;streamId;_isStopped=!1;get hasActiveSubscribers(){return!this._isStopped}startChecking(r){this.checkInterval=setInterval(()=>{this.checkNoActiveReader()},r)}stopChecking(){this.checkInterval&&(clearInterval(this.checkInterval),this.checkInterval=null,this._isStopped=!0,this.onNoActiveReaderCallback(this))}checkNoActiveReader(){!this.readable.locked&&!this._isStopped&&this.stopChecking()}};var Z=async(t,e)=>{if(t.writable.locked)return!1;let r=t.writable.getWriter();if(await r.ready,!t.readable.locked)return!1;try{for(let n of e)await r.write(n)}catch(n){console.log(n)}finally{await r.close()}return!0};var ee=()=>{let t=[],e=new Map;return{notify:async r=>{if(r.length!==0){t.push(...r);for(let n of e.values())n.logPosition=r[r.length-1].metadata.globalPosition,await Z(n,r)}},stream:()=>{let r=be(),n=Q(t);return e.set(r,n),n.readable.pipeThrough(O(o=>{e.has(o.streamId)&&e.delete(o.streamId)},{streamId:r}))}}};var T=0n,ir=()=>{let t=new Map,e=ee(),r=()=>Array.from(t.values()).map(n=>n.length).reduce((n,o)=>n+o,0);return{async aggregateStream(n,o){let{evolve:a,initialState:i,read:m}=o,l=await this.readStream(n,m),y=l?.events??[];return{currentStreamVersion:BigInt(y.length),state:y.reduce(a,i()),streamExists:l.streamExists}},readStream:(n,o)=>{let a=t.get(n),i=a?BigInt(a.length):T;N(i,o?.expectedStreamVersion,T);let m=Number(o&&"from"in o?o.from:0),l=Number(o&&"to"in o?o.to:o&&"maxCount"in o&&o.maxCount?o.from+o.maxCount:a?.length??1),y=a!==void 0&&a.length>0?a.map(f=>f).slice(m,l):[],E={currentStreamVersion:i,events:y,streamExists:a!==void 0&&a.length>0};return Promise.resolve(E)},appendToStream:async(n,o,a)=>{let i=t.get(n)??[],m=i.length>0?BigInt(i.length):T;N(m,a?.expectedStreamVersion,T);let l=o.map((f,v)=>({...f,metadata:{...f.metadata??{},streamName:n,eventId:De(),streamPosition:BigInt(i.length+v+1),globalPosition:BigInt(r()+v+1)}})),y=BigInt(l.slice(-1)[0].metadata.streamPosition);return t.set(n,[...i,...l]),await e.notify(l),{nextExpectedStreamVersion:y,createdNewStream:m===T}}}};var d=(t,e)=>{if(Oe(t))return t.equals(e);if(Array.isArray(t))return Array.isArray(e)&&t.length===e.length&&t.every((o,a)=>d(o,e[a]));if(typeof t!="object"||typeof e!="object"||t===null||e===null)return t===e;if(Array.isArray(e))return!1;let r=Object.keys(t),n=Object.keys(e);if(r.length!==n.length||!r.every(o=>n.includes(o)))return!1;for(let o in t){if(t[o]instanceof Function&&e[o]instanceof Function)continue;if(!d(t[o],e[o]))return!1}return!0},Oe=t=>t&&typeof t=="object"&&"equals"in t&&typeof t.equals=="function";var vr=t=>{let e,r,n=0;do({value:e,done:r}=t.next()),n+=e||0;while(!r);return n};var Sr=(t,e,r,n,o=()=>{})=>{let a=!1,i=t.map(m=>r(m)?(a=!0,n(m)):m).filter(m=>m!==void 0).map(m=>{if(!m)throw Error("That should not happen");return m});return!a&&o()!==void 0?[...t,e]:i};import we from"async-retry";var te={retries:0},w=async(t,e)=>e===void 0||e.retries===0?t():we(async r=>{try{return await t()}catch(n){throw e?.shouldRetryError&&!e.shouldRetryError(n)&&r(n),n}},e??{retries:0});var re={retries:3,minTimeout:100,factor:1.5,shouldRetryError:z},Me=t=>t===void 0?te:"onVersionConflict"in t?typeof t.onVersionConflict=="boolean"?re:typeof t.onVersionConflict=="number"?{...re,retries:t.onVersionConflict}:t.onVersionConflict:t,ne=t=>async(e,r,n,o)=>w(async()=>await Ve(e,async({eventStore:i})=>{let{evolve:m,initialState:l}=t,E=(t.mapToStreamId??(Te=>Te))(r),f=await i.aggregateStream(E,{evolve:m,initialState:l,read:{expectedStreamVersion:o?.expectedStreamVersion??D}}),v=f.state,B=f.currentStreamVersion,A=await n(v),R=Array.isArray(A)?A:[A];if(R.length===0)return{newEvents:[],newState:v,nextExpectedStreamVersion:B,createdNewStream:!1};let Se=o?.expectedStreamVersion??(f.streamExists?B:F);return{...await i.appendToStream(E,R,{...o,expectedStreamVersion:Se}),newEvents:R,newState:R.reduce(m,v)}}),Me(o&&"retry"in o?o.retry:t.retry)),Ve=(t,e)=>(K(t)?t:X(t)).withSession(e);var Pr=t=>async(e,r,n,o)=>{let{decide:a,...i}=t;return ne(i)(e,r,m=>a(n,m),o)};var Nr=()=>{let t=new Map,e=[];return{send:async r=>{let n=t.get(r.type);if(n===void 0||n.length===0)throw new I(`No handler registered for command ${r.type}!`);let o=n[0];await o(r)},publish:async r=>{let n=t.get(r.type)??[];for(let o of n)await o(r)},schedule:(r,n)=>{e=[...e,{message:r,options:n}]},handle:(r,...n)=>{let o=[...t.keys()].filter(a=>n.includes(a));if(o.length>0)throw new I(`Cannot register handler for commands ${o.join(", ")} as they're already registered!`);for(let a of n)t.set(a,[r])},subscribe(r,...n){for(let o of n)t.has(o)||t.set(o,[]),t.set(o,[...t.get(o)??[],r])},dequeue:()=>{let r=e;return e=[],r}}};var Wr=t=>t,Pe=t=>t.map(e=>({type:"inline",projection:e})),ke=t=>t.map(e=>({type:"async",projection:e})),Gr={inline:Pe,async:ke};var W=class extends Error{constructor(e){super(`Cannot parse! ${e}`)}},c={stringify:(t,e)=>JSON.stringify(e?.map?e.map(t):t,(r,n)=>typeof n=="bigint"?n.toString():n),parse:(t,e)=>{let r=JSON.parse(t,e?.reviver);if(e?.typeCheck&&!e?.typeCheck(r))throw new W(t);return e?.map?e.map(r):r}};var G=t=>{let e=t.reduce((o,a)=>o+a.length,0),r=new Uint8Array(e),n=0;for(let o of t)r.set(o,n),n+=o.length;return r};var Lr=async t=>{let e=[];for await(let r of t)e.push(r);return e};var M=class{buffer=[];addToBuffer(e){this.buffer.push(e)}clearBuffer(){this.buffer=[]}hasCompleteMessage(){let e=G(this.buffer);return new TextDecoder().decode(e).includes(`
-`)}decode(){if(!this.hasCompleteMessage())return null;let e=G(this.buffer),r=new TextDecoder().decode(e),n=r.indexOf(`
-`);if(n===-1)return null;let o=r.slice(0,n),a=new Uint8Array(e.buffer,n+1);return this.buffer=a.byteLength>0?[a]:[],JSON.parse(o)}};var V=class{constructor(e){this.transform=e;this.transform=e}buffer=[];addToBuffer(e){this.buffer.push(e)}clearBuffer(){this.buffer=[]}hasCompleteMessage(){return this.buffer.some(e=>e.includes(`
-`))}decode(){let e=this.buffer.join("");if(!this.hasCompleteMessage()){if(e.trim().length>0)throw new Error("Unterminated string in JSON at position");return null}let r=e.indexOf(`
-`),n=e.slice(0,r).trim();return this.buffer=[e.slice(r+1)],this.transform(n)}};var P=class extends V{constructor(){super(e=>JSON.parse(e))}};var k=class{buffer=null;addToBuffer(e){this.buffer=e}clearBuffer(){this.buffer=null}hasCompleteMessage(){return this.buffer!==null}decode(){if(!this.hasCompleteMessage()||!this.buffer)return null;let e=this.buffer;return this.clearBuffer(),e}};var q=class{constructor(e){this.decoders=e}decoderFor(e){let r=this.decoders.find(n=>n[0](e));return r?r[1]:null}addToBuffer(e){this.decoderFor(e)?.addToBuffer(e)}clearBuffer(){for(let e of this.decoders.map(r=>r[1]))e.clearBuffer()}hasCompleteMessage(){return this.decoders.some(e=>e[1].hasCompleteMessage())}decode(){return this.decoders.map(r=>r[1]).find(r=>r.hasCompleteMessage())?.decode()??null}},x=class extends q{constructor(){super([[e=>typeof e=="string",new P],[e=>e instanceof Uint8Array,new M],[e=>typeof e=="object",new k]])}};import{ReadableStream as Ae}from"web-streams-polyfill";var oe=t=>new Ae({start(e){for(let r of t)e.enqueue(r);e.close()}});var En={fromArray:oe};import"web-streams-polyfill";import{TransformStream as Ie}from"web-streams-polyfill";var ae=t=>new Ie({transform(e,r){t(e)&&r.enqueue(e)}});import{TransformStream as He}from"web-streams-polyfill";var se=t=>new He({transform(e,r){r.enqueue(t(e))}});import{TransformStream as je}from"web-streams-polyfill";var ie=(t,e)=>new g(t,e),g=class extends je{accumulator;reducer;constructor(e,r){super({transform:n=>{this.accumulator=this.reducer(this.accumulator,n)},flush:n=>{n.enqueue(this.accumulator),n.terminate()}}),this.accumulator=r,this.reducer=e}};import{TransformStream as Fe}from"web-streams-polyfill";var me=(t,e,r={forever:!0,minTimeout:25})=>new Fe({start(n){w(()=>Ne(t,e,n),r).catch(o=>{n.error(o)})}}),Ne=async(t,e,r)=>{let o=t().getReader();try{let a;do{let i=await o.read();a=i.done,await e(i,r),a&&r.terminate()}while(!a)}finally{o.releaseLock()}};import{TransformStream as _e}from"web-streams-polyfill";var de=t=>new h(t),h=class extends _e{count=0;skip;constructor(e){super({transform:(r,n)=>{this.count++,this.count>this.skip&&n.enqueue(r)}}),this.skip=e}};import{TransformStream as We}from"web-streams-polyfill";var pe=t=>new We({transform(e,r){r.enqueue(e),t(e)&&r.terminate()}});import{TransformStream as Ge}from"web-streams-polyfill";var le=t=>new Ge({async transform(e,r){if(!t(e)){r.enqueue(e);return}await Promise.resolve(),r.terminate()}});import{TransformStream as qe}from"web-streams-polyfill";var ce=t=>new C(t),C=class extends qe{count=0;limit;constructor(e){super({transform:(r,n)=>{this.count<this.limit?(this.count++,n.enqueue(r)):n.terminate()}}),this.limit=e}};import{TransformStream as Ue}from"web-streams-polyfill";var ue=t=>new Ue({start(e){let r=setTimeout(()=>{e.terminate()},t),n=e.terminate.bind(e);e.terminate=()=>{clearTimeout(r),n()}},transform(e,r){r.enqueue(e)}});var fe={filter:ae,take:ce,TakeTransformStream:C,skip:de,SkipTransformStream:h,map:se,notifyAboutNoActiveReadersStream:O,NotifyAboutNoActiveReadersStream:S,reduce:ie,ReduceTransformStream:g,retry:me,stopAfter:pe,stopOn:le,waitAtMost:ue};var{retry:Be}=fe,Qn=(t,e=o=>o,r={forever:!0,minTimeout:25},n=new x)=>Be(t,$e(e,n),r).readable,$e=(t=r=>r,e=new x)=>(r,n)=>{let{done:o,value:a}=r;a&&e.addToBuffer(a),!(!o&&!e.hasCompleteMessage())&&Je(e,t,n)},Je=(t,e,r)=>{try{let n=t.decode();if(!n)return;let o=e(n);r.enqueue(o)}catch(n){r.error(new Error(`Decoding error: ${n?.toString()}`))}};var p=class extends Error{constructor(e){super(e)}},ye=(t,e)=>{let r=t,n=e;return U(r),U(n),Object.keys(n).every(o=>typeof n[o]=="object"?ye(r[o],n[o]):n[o]===r[o])},po=t=>{throw new p(t??"That should not ever happened, right?")},lo=async(t,e)=>{try{throw await t(),new p("Function didn't throw expected error")}catch(r){let n=r;return e&&s(e(n)),n}},co=(t,e)=>{try{throw t(),new p("Function didn't throw expected error")}catch(r){let n=r;return e&&s(e(n)),n}},uo=async(t,e)=>{try{throw await t,new p("Function didn't throw expected error")}catch(r){if(!e)return;e instanceof Error?Ke(r,e):s(e(r))}},ve=(t,e,r)=>{if(!ye(t,e))throw new p(r??`subObj:
-${c.stringify(e)}
+import {
+  ConcurrencyError,
+  EmmettError,
+  IllegalStateError,
+  NotFoundError,
+  ValidationError,
+  ValidationErrors,
+  assertNotEmptyString,
+  assertPositiveNumber,
+  assertUnsignedBigInt,
+  formatDateToUtcYYYYMMDD,
+  isErrorConstructor,
+  isNumber,
+  isPluginConfig,
+  isString,
+  isValidYYYYMMDD,
+  parseDateFromUtcYYYYMMDD
+} from "./chunk-AEEEXE2R.js";
+
+// src/eventStore/eventStore.ts
+var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+var nulloSessionFactory = (eventStore) => ({
+  withSession: (callback) => {
+    const nulloSession = {
+      eventStore,
+      close: () => Promise.resolve()
+    };
+    return callback(nulloSession);
+  }
+});
+
+// src/typing/command.ts
+var command = (type, data, metadata) => {
+  return {
+    type,
+    data,
+    metadata
+  };
+};
+
+// src/typing/event.ts
+var event = (type, data, metadata) => {
+  return {
+    type,
+    data,
+    metadata
+  };
+};
+
+// src/typing/workflow.ts
+var reply = (message) => {
+  return {
+    kind: "Reply",
+    message
+  };
+};
+var send = (message) => {
+  return {
+    kind: "Send",
+    message
+  };
+};
+var publish = (message) => {
+  return {
+    kind: "Publish",
+    message
+  };
+};
+var schedule = (message, when) => {
+  return {
+    kind: "Schedule",
+    message,
+    when
+  };
+};
+var complete = () => {
+  return {
+    kind: "Complete"
+  };
+};
+var ignore = (reason) => {
+  return {
+    kind: "Ignore",
+    reason
+  };
+};
+var error = (reason) => {
+  return {
+    kind: "Error",
+    reason
+  };
+};
+var accept = () => {
+  return { kind: "Accept" };
+};
+
+// src/eventStore/events/index.ts
+var GlobalStreamCaughtUpType = "__emt:GlobalStreamCaughtUp";
+var isGlobalStreamCaughtUp = (event2) => event2.type === GlobalStreamCaughtUpType;
+var caughtUpEventFrom = (position) => (event2) => event2.type === GlobalStreamCaughtUpType && event2.metadata?.globalPosition >= position;
+var globalStreamCaughtUp = (data) => event(GlobalStreamCaughtUpType, data, {
+  globalPosition: data.globalPosition
+});
+var isSubscriptionEvent = (event2) => isGlobalStreamCaughtUp(event2);
+var isNotInternalEvent = (event2) => !isGlobalStreamCaughtUp(event2);
+
+// src/eventStore/expectedVersion.ts
+var STREAM_EXISTS = "STREAM_EXISTS";
+var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var matchesExpectedVersion = (current, expected, defaultVersion) => {
+  if (expected === NO_CONCURRENCY_CHECK) return true;
+  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
+  if (expected == STREAM_EXISTS) return current !== defaultVersion;
+  return current === expected;
+};
+var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+  expected ??= NO_CONCURRENCY_CHECK;
+  if (!matchesExpectedVersion(current, expected, defaultVersion))
+    throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
+  constructor(current, expected) {
+    super(current?.toString(), expected?.toString());
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
+  }
+};
+var isExpectedVersionConflictError = (error2) => error2 instanceof ExpectedVersionConflictError;
+
+// src/eventStore/inMemoryEventStore.ts
+import { v4 as uuid3 } from "uuid";
+
+// src/eventStore/subscriptions/caughtUpTransformStream.ts
+import { TransformStream } from "web-streams-polyfill";
+var streamTrackingGlobalPosition = (currentEvents) => new CaughtUpTransformStream(currentEvents);
+var CaughtUpTransformStream = class extends TransformStream {
+  _currentPosition;
+  _logPosition;
+  constructor(events) {
+    super({
+      start: (controller) => {
+        let globalPosition = 0n;
+        for (const event2 of events) {
+          controller.enqueue(event2);
+          globalPosition = event2.metadata.globalPosition;
+        }
+        controller.enqueue(globalStreamCaughtUp({ globalPosition }));
+      },
+      transform: (event2, controller) => {
+        this._currentPosition = event2.metadata.globalPosition;
+        controller.enqueue(event2);
+        if (this._currentPosition < this._logPosition) return;
+        controller.enqueue(
+          globalStreamCaughtUp({ globalPosition: this._currentPosition })
+        );
+      }
+    });
+    this._currentPosition = this._logPosition = events.length > 0 ? events[events.length - 1].metadata.globalPosition : 0n;
+  }
+  set logPosition(value) {
+    this._logPosition = value;
+  }
+};
+
+// src/eventStore/subscriptions/streamingCoordinator.ts
+import { v4 as uuid2 } from "uuid";
+
+// src/streaming/transformations/notifyAboutNoActiveReaders.ts
+import { v4 as uuid } from "uuid";
+import { TransformStream as TransformStream2 } from "web-streams-polyfill";
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = class extends TransformStream2 {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = options?.streamId ?? uuid();
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(options?.intervalCheckInMs ?? 20);
+  }
+  checkInterval = null;
+  streamId;
+  _isStopped = false;
+  get hasActiveSubscribers() {
+    return !this._isStopped;
+  }
+  startChecking(interval) {
+    this.checkInterval = setInterval(() => {
+      this.checkNoActiveReader();
+    }, interval);
+  }
+  stopChecking() {
+    if (!this.checkInterval) return;
+    clearInterval(this.checkInterval);
+    this.checkInterval = null;
+    this._isStopped = true;
+    this.onNoActiveReaderCallback(this);
+  }
+  checkNoActiveReader() {
+    if (!this.readable.locked && !this._isStopped) {
+      this.stopChecking();
+    }
+  }
+};
+
+// src/streaming/writers/writeToStream.ts
+var writeToStream = async (stream, items) => {
+  if (stream.writable.locked) return false;
+  const writer = stream.writable.getWriter();
+  await writer.ready;
+  if (!stream.readable.locked) return false;
+  try {
+    for (const item of items) {
+      await writer.write(item);
+    }
+  } catch (error2) {
+    console.log(error2);
+  } finally {
+    await writer.close();
+  }
+  return true;
+};
+
+// src/eventStore/subscriptions/streamingCoordinator.ts
+var StreamingCoordinator = () => {
+  const allEvents = [];
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    notify: async (events) => {
+      if (events.length === 0) return;
+      allEvents.push(...events);
+      for (const listener of listeners.values()) {
+        listener.logPosition = events[events.length - 1].metadata.globalPosition;
+        await writeToStream(listener, events);
+      }
+    },
+    stream: () => {
+      const streamId = uuid2();
+      const transformStream = streamTrackingGlobalPosition(allEvents);
+      listeners.set(streamId, transformStream);
+      return transformStream.readable.pipeThrough(
+        notifyAboutNoActiveReadersStream(
+          (stream) => {
+            if (listeners.has(stream.streamId))
+              listeners.delete(stream.streamId);
+          },
+          { streamId }
+        )
+      );
+    }
+  };
+};
+
+// src/eventStore/inMemoryEventStore.ts
+var InMemoryEventStoreDefaultStreamVersion = 0n;
+var getInMemoryEventStore = () => {
+  const streams = /* @__PURE__ */ new Map();
+  const streamingCoordinator = StreamingCoordinator();
+  const getAllEventsCount = () => {
+    return Array.from(streams.values()).map((s) => s.length).reduce((p, c) => p + c, 0);
+  };
+  return {
+    async aggregateStream(streamName, options) {
+      const { evolve, initialState, read } = options;
+      const result = await this.readStream(streamName, read);
+      const events = result?.events ?? [];
+      return {
+        currentStreamVersion: BigInt(events.length),
+        state: events.reduce(evolve, initialState()),
+        streamExists: result.streamExists
+      };
+    },
+    readStream: (streamName, options) => {
+      const events = streams.get(streamName);
+      const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        options?.expectedStreamVersion,
+        InMemoryEventStoreDefaultStreamVersion
+      );
+      const from = Number(options && "from" in options ? options.from : 0);
+      const to = Number(
+        options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : events?.length ?? 1
+      );
+      const resultEvents = events !== void 0 && events.length > 0 ? events.map(
+        (e) => e
+      ).slice(from, to) : [];
+      const result = {
+        currentStreamVersion,
+        events: resultEvents,
+        streamExists: events !== void 0 && events.length > 0
+      };
+      return Promise.resolve(result);
+    },
+    appendToStream: async (streamName, events, options) => {
+      const currentEvents = streams.get(streamName) ?? [];
+      const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        options?.expectedStreamVersion,
+        InMemoryEventStoreDefaultStreamVersion
+      );
+      const newEvents = events.map((event2, index) => {
+        return {
+          ...event2,
+          metadata: {
+            ...event2.metadata ?? {},
+            streamName,
+            eventId: uuid3(),
+            streamPosition: BigInt(currentEvents.length + index + 1),
+            globalPosition: BigInt(getAllEventsCount() + index + 1)
+          }
+        };
+      });
+      const positionOfLastEventInTheStream = BigInt(
+        newEvents.slice(-1)[0].metadata.streamPosition
+      );
+      streams.set(streamName, [...currentEvents, ...newEvents]);
+      await streamingCoordinator.notify(newEvents);
+      const result = {
+        nextExpectedStreamVersion: positionOfLastEventInTheStream,
+        createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
+      };
+      return result;
+    }
+    //streamEvents: streamingCoordinator.stream,
+  };
+};
+
+// src/utils/deepEquals.ts
+var deepEquals = (left, right) => {
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return left === right;
+  }
+  if (Array.isArray(right)) return false;
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+    return false;
+  for (const key in left) {
+    if (left[key] instanceof Function && right[key] instanceof Function)
+      continue;
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var isEquatable = (left) => {
+  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+
+// src/utils/iterators.ts
+var sum = (iterator) => {
+  let value, done, sum2 = 0;
+  do {
+    ({ value, done } = iterator.next());
+    sum2 += value || 0;
+  } while (!done);
+  return sum2;
+};
+
+// src/utils/merge.ts
+var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
+  let wasFound = false;
+  const result = array.map((p) => {
+    if (!where(p)) return p;
+    wasFound = true;
+    return onExisting(p);
+  }).filter((p) => p !== void 0).map((p) => {
+    if (!p) throw Error("That should not happen");
+    return p;
+  });
+  if (!wasFound) {
+    const result2 = onNotFound();
+    if (result2 !== void 0) return [...array, item];
+  }
+  return result;
+};
+
+// src/utils/retry.ts
+import retry from "async-retry";
+var NoRetries = { retries: 0 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return retry(
+    async (bail) => {
+      try {
+        return await fn();
+      } catch (error2) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    opts ?? { retries: 0 }
+  );
+};
+
+// src/commandHandling/handleCommand.ts
+var CommandHandlerStreamVersionConflictRetryOptions = {
+  retries: 3,
+  minTimeout: 100,
+  factor: 1.5,
+  shouldRetryError: isExpectedVersionConflictError
+};
+var fromCommandHandlerRetryOptions = (retryOptions) => {
+  if (retryOptions === void 0) return NoRetries;
+  if ("onVersionConflict" in retryOptions) {
+    if (typeof retryOptions.onVersionConflict === "boolean")
+      return CommandHandlerStreamVersionConflictRetryOptions;
+    else if (typeof retryOptions.onVersionConflict === "number")
+      return {
+        ...CommandHandlerStreamVersionConflictRetryOptions,
+        retries: retryOptions.onVersionConflict
+      };
+    else return retryOptions.onVersionConflict;
+  }
+  return retryOptions;
+};
+var CommandHandler = (options) => async (store, id, handle, handleOptions) => asyncRetry(
+  async () => {
+    const result = await withSession(store, async ({ eventStore }) => {
+      const { evolve, initialState } = options;
+      const mapToStreamId = options.mapToStreamId ?? ((id2) => id2);
+      const streamName = mapToStreamId(id);
+      const aggregationResult = await eventStore.aggregateStream(streamName, {
+        evolve,
+        initialState,
+        read: {
+          // expected stream version is passed to fail fast
+          // if stream is in the wrong state
+          expectedStreamVersion: handleOptions?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+        }
+      });
+      const state = aggregationResult.state;
+      const currentStreamVersion = aggregationResult.currentStreamVersion;
+      const result2 = await handle(state);
+      const newEvents = Array.isArray(result2) ? result2 : [result2];
+      if (newEvents.length === 0) {
+        return {
+          newEvents: [],
+          newState: state,
+          nextExpectedStreamVersion: currentStreamVersion,
+          createdNewStream: false
+        };
+      }
+      const expectedStreamVersion = handleOptions?.expectedStreamVersion ?? (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST);
+      const appendResult = await eventStore.appendToStream(
+        streamName,
+        newEvents,
+        {
+          ...handleOptions,
+          expectedStreamVersion
+        }
+      );
+      return {
+        ...appendResult,
+        newEvents,
+        newState: newEvents.reduce(evolve, state)
+      };
+    });
+    return result;
+  },
+  fromCommandHandlerRetryOptions(
+    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
+  )
+);
+var withSession = (eventStore, callback) => {
+  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
+  return sessionFactory.withSession(callback);
+};
+
+// src/commandHandling/handleCommandWithDecider.ts
+var DeciderCommandHandler = (options) => async (eventStore, id, command2, handleOptions) => {
+  const { decide, ...rest } = options;
+  return CommandHandler(rest)(
+    eventStore,
+    id,
+    (state) => decide(command2, state),
+    handleOptions
+  );
+};
+
+// src/messageBus/index.ts
+var getInMemoryMessageBus = () => {
+  const allHandlers = /* @__PURE__ */ new Map();
+  let pendingMessages = [];
+  return {
+    send: async (command2) => {
+      const handlers = allHandlers.get(command2.type);
+      if (handlers === void 0 || handlers.length === 0)
+        throw new EmmettError(
+          `No handler registered for command ${command2.type}!`
+        );
+      const commandHandler = handlers[0];
+      await commandHandler(command2);
+    },
+    publish: async (event2) => {
+      const handlers = allHandlers.get(event2.type) ?? [];
+      for (const handler of handlers) {
+        const eventHandler = handler;
+        await eventHandler(event2);
+      }
+    },
+    schedule: (message, when) => {
+      pendingMessages = [...pendingMessages, { message, options: when }];
+    },
+    handle: (commandHandler, ...commandTypes) => {
+      const alreadyRegistered = [...allHandlers.keys()].filter(
+        (registered) => commandTypes.includes(registered)
+      );
+      if (alreadyRegistered.length > 0)
+        throw new EmmettError(
+          `Cannot register handler for commands ${alreadyRegistered.join(", ")} as they're already registered!`
+        );
+      for (const commandType of commandTypes) {
+        allHandlers.set(commandType, [commandHandler]);
+      }
+    },
+    subscribe(eventHandler, ...eventTypes) {
+      for (const eventType of eventTypes) {
+        if (!allHandlers.has(eventType)) allHandlers.set(eventType, []);
+        allHandlers.set(eventType, [
+          ...allHandlers.get(eventType) ?? [],
+          eventHandler
+        ]);
+      }
+    },
+    dequeue: () => {
+      const pending = pendingMessages;
+      pendingMessages = [];
+      return pending;
+    }
+  };
+};
+
+// src/projections/index.ts
+var projection = (definition) => definition;
+var inlineProjections = (definitions) => definitions.map((projection2) => ({ type: "inline", projection: projection2 }));
+var asyncProjections = (definitions) => definitions.map((projection2) => ({ type: "async", projection: projection2 }));
+var projections = {
+  inline: inlineProjections,
+  async: asyncProjections
+};
+
+// src/serialization/json/JSONParser.ts
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      options?.map ? options.map(value) : value,
+      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+  },
+  parse: (text, options) => {
+    const parsed = JSON.parse(text, options?.reviver);
+    if (options?.typeCheck && !options?.typeCheck(parsed))
+      throw new ParseError(text);
+    return options?.map ? options.map(parsed) : parsed;
+  }
+};
+
+// src/streaming/binaryArrays.ts
+var concatUint8Arrays = (chunks) => {
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+};
+
+// src/streaming/collectors/collect.ts
+var collect = async (stream) => {
+  const results = [];
+  for await (const value of stream) {
+    results.push(value);
+  }
+  return results;
+};
+
+// src/streaming/decoders/binary.ts
+var BinaryJsonDecoder = class {
+  buffer = [];
+  addToBuffer(data) {
+    this.buffer.push(data);
+  }
+  clearBuffer() {
+    this.buffer = [];
+  }
+  hasCompleteMessage() {
+    const combined = concatUint8Arrays(this.buffer);
+    const text = new TextDecoder().decode(combined);
+    return text.includes("\n");
+  }
+  decode() {
+    if (!this.hasCompleteMessage()) {
+      return null;
+    }
+    const combined = concatUint8Arrays(this.buffer);
+    const text = new TextDecoder().decode(combined);
+    const delimiterIndex = text.indexOf("\n");
+    if (delimiterIndex === -1) {
+      return null;
+    }
+    const jsonString = text.slice(0, delimiterIndex);
+    const remaining = new Uint8Array(combined.buffer, delimiterIndex + 1);
+    this.buffer = remaining.byteLength > 0 ? [remaining] : [];
+    return JSON.parse(jsonString);
+  }
+};
+
+// src/streaming/decoders/string.ts
+var StringDecoder = class {
+  constructor(transform) {
+    this.transform = transform;
+    this.transform = transform;
+  }
+  buffer = [];
+  addToBuffer(data) {
+    this.buffer.push(data);
+  }
+  clearBuffer() {
+    this.buffer = [];
+  }
+  hasCompleteMessage() {
+    return this.buffer.some((chunk) => chunk.includes("\n"));
+  }
+  decode() {
+    const completeString = this.buffer.join("");
+    if (!this.hasCompleteMessage()) {
+      if (completeString.trim().length > 0) {
+        throw new Error("Unterminated string in JSON at position");
+      }
+      return null;
+    }
+    const delimiterIndex = completeString.indexOf("\n");
+    const message = completeString.slice(0, delimiterIndex).trim();
+    this.buffer = [completeString.slice(delimiterIndex + 1)];
+    return this.transform(message);
+  }
+};
+
+// src/streaming/decoders/json.ts
+var JsonDecoder = class extends StringDecoder {
+  constructor() {
+    super((jsonString) => JSON.parse(jsonString));
+  }
+};
+
+// src/streaming/decoders/object.ts
+var ObjectDecoder = class {
+  buffer = null;
+  addToBuffer(data) {
+    this.buffer = data;
+  }
+  clearBuffer() {
+    this.buffer = null;
+  }
+  hasCompleteMessage() {
+    return this.buffer !== null;
+  }
+  decode() {
+    if (!this.hasCompleteMessage() || !this.buffer) {
+      return null;
+    }
+    const data = this.buffer;
+    this.clearBuffer();
+    return data;
+  }
+};
+
+// src/streaming/decoders/composite.ts
+var CompositeDecoder = class {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  decoderFor(data) {
+    const decoder = this.decoders.find((d) => d[0](data));
+    if (!decoder) return null;
+    return decoder[1];
+  }
+  addToBuffer(data) {
+    this.decoderFor(data)?.addToBuffer(data);
+  }
+  clearBuffer() {
+    for (const decoder of this.decoders.map((d) => d[1])) {
+      decoder.clearBuffer();
+    }
+  }
+  hasCompleteMessage() {
+    return this.decoders.some((d) => d[1].hasCompleteMessage());
+  }
+  decode() {
+    const decoder = this.decoders.map((d) => d[1]).find((d) => d.hasCompleteMessage());
+    return decoder?.decode() ?? null;
+  }
+};
+var DefaultDecoder = class extends CompositeDecoder {
+  constructor() {
+    super([
+      [(data) => typeof data === "string", new JsonDecoder()],
+      [(data) => data instanceof Uint8Array, new BinaryJsonDecoder()],
+      [(data) => typeof data === "object", new ObjectDecoder()]
+    ]);
+  }
+};
+
+// src/streaming/generators/fromArray.ts
+import { ReadableStream } from "web-streams-polyfill";
+var fromArray = (chunks) => new ReadableStream({
+  start(controller) {
+    for (const chunk of chunks) controller.enqueue(chunk);
+    controller.close();
+  }
+});
+
+// src/streaming/generators/index.ts
+var streamGenerators = { fromArray };
+
+// src/streaming/restream.ts
+import "web-streams-polyfill";
+
+// src/streaming/transformations/filter.ts
+import { TransformStream as TransformStream3 } from "web-streams-polyfill";
+var filter = (filter2) => new TransformStream3({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+
+// src/streaming/transformations/map.ts
+import { TransformStream as TransformStream4 } from "web-streams-polyfill";
+var map = (map2) => new TransformStream4({
+  transform(chunk, controller) {
+    controller.enqueue(map2(chunk));
+  }
+});
+
+// src/streaming/transformations/reduce.ts
+import { TransformStream as TransformStream5 } from "web-streams-polyfill";
+var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
+var ReduceTransformStream = class extends TransformStream5 {
+  accumulator;
+  reducer;
+  constructor(reducer, initialValue) {
+    super({
+      transform: (chunk) => {
+        this.accumulator = this.reducer(this.accumulator, chunk);
+      },
+      flush: (controller) => {
+        controller.enqueue(this.accumulator);
+        controller.terminate();
+      }
+    });
+    this.accumulator = initialValue;
+    this.reducer = reducer;
+  }
+};
+
+// src/streaming/transformations/retry.ts
+import {
+  TransformStream as TransformStream6
+} from "web-streams-polyfill";
+var retryStream = (createSourceStream, handleChunk2, retryOptions = { forever: true, minTimeout: 25 }) => new TransformStream6({
+  start(controller) {
+    asyncRetry(
+      () => onRestream(createSourceStream, handleChunk2, controller),
+      retryOptions
+    ).catch((error2) => {
+      controller.error(error2);
+    });
+  }
+});
+var onRestream = async (createSourceStream, handleChunk2, controller) => {
+  const sourceStream = createSourceStream();
+  const reader = sourceStream.getReader();
+  try {
+    let done;
+    do {
+      const result = await reader.read();
+      done = result.done;
+      await handleChunk2(result, controller);
+      if (done) {
+        controller.terminate();
+      }
+    } while (!done);
+  } finally {
+    reader.releaseLock();
+  }
+};
+
+// src/streaming/transformations/skip.ts
+import { TransformStream as TransformStream7 } from "web-streams-polyfill";
+var skip = (limit) => new SkipTransformStream(limit);
+var SkipTransformStream = class extends TransformStream7 {
+  count = 0;
+  skip;
+  constructor(skip2) {
+    super({
+      transform: (chunk, controller) => {
+        this.count++;
+        if (this.count > this.skip) {
+          controller.enqueue(chunk);
+        }
+      }
+    });
+    this.skip = skip2;
+  }
+};
+
+// src/streaming/transformations/stopAfter.ts
+import { TransformStream as TransformStream8 } from "web-streams-polyfill";
+var stopAfter = (stopCondition) => new TransformStream8({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+
+// src/streaming/transformations/stopOn.ts
+import { TransformStream as TransformStream9 } from "web-streams-polyfill";
+var stopOn = (stopCondition) => new TransformStream9({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+
+// src/streaming/transformations/take.ts
+import { TransformStream as TransformStream10 } from "web-streams-polyfill";
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = class extends TransformStream10 {
+  count = 0;
+  limit;
+  constructor(limit) {
+    super({
+      transform: (chunk, controller) => {
+        if (this.count < this.limit) {
+          this.count++;
+          controller.enqueue(chunk);
+        } else {
+          controller.terminate();
+        }
+      }
+    });
+    this.limit = limit;
+  }
+};
+
+// src/streaming/transformations/waitAtMost.ts
+import { TransformStream as TransformStream11 } from "web-streams-polyfill";
+var waitAtMost = (waitTimeInMs) => new TransformStream11({
+  start(controller) {
+    const timeoutId = setTimeout(() => {
+      controller.terminate();
+    }, waitTimeInMs);
+    const originalTerminate = controller.terminate.bind(controller);
+    controller.terminate = () => {
+      clearTimeout(timeoutId);
+      originalTerminate();
+    };
+  },
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+  }
+});
+
+// src/streaming/transformations/index.ts
+var streamTransformations = {
+  filter,
+  take,
+  TakeTransformStream,
+  skip,
+  SkipTransformStream,
+  map,
+  notifyAboutNoActiveReadersStream,
+  NotifyAboutNoActiveReadersStream,
+  reduce,
+  ReduceTransformStream,
+  retry: retryStream,
+  stopAfter,
+  stopOn,
+  waitAtMost
+};
+
+// src/streaming/restream.ts
+var { retry: retry2 } = streamTransformations;
+var restream = (createSourceStream, transform = (source) => source, retryOptions = { forever: true, minTimeout: 25 }, decoder = new DefaultDecoder()) => retry2(createSourceStream, handleChunk(transform, decoder), retryOptions).readable;
+var handleChunk = (transform = (source) => source, decoder = new DefaultDecoder()) => (readResult, controller) => {
+  const { done: isDone, value } = readResult;
+  if (value) decoder.addToBuffer(value);
+  if (!isDone && !decoder.hasCompleteMessage()) return;
+  decodeAndTransform(decoder, transform, controller);
+};
+var decodeAndTransform = (decoder, transform, controller) => {
+  try {
+    const decoded = decoder.decode();
+    if (!decoded) return;
+    const transformed = transform(decoded);
+    controller.enqueue(transformed);
+  } catch (error2) {
+    controller.error(new Error(`Decoding error: ${error2?.toString()}`));
+  }
+};
+
+// src/testing/assertions.ts
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+var assertFails = (message) => {
+  throw new AssertionError(message ?? "That should not ever happened, right?");
+};
+var assertThrowsAsync = async (fun, errorCheck) => {
+  try {
+    await fun();
+    throw new AssertionError("Function didn't throw expected error");
+  } catch (error2) {
+    const typedError = error2;
+    if (errorCheck) assertTrue(errorCheck(typedError));
+    return typedError;
+  }
+};
+var assertThrows = (fun, errorCheck) => {
+  try {
+    fun();
+    throw new AssertionError("Function didn't throw expected error");
+  } catch (error2) {
+    const typedError = error2;
+    if (errorCheck) assertTrue(errorCheck(typedError));
+    return typedError;
+  }
+};
+var assertRejects = async (promise, errorCheck) => {
+  try {
+    await promise;
+    throw new AssertionError("Function didn't throw expected error");
+  } catch (error2) {
+    if (!errorCheck) return;
+    if (errorCheck instanceof Error) assertDeepEqual(error2, errorCheck);
+    else assertTrue(errorCheck(error2));
+  }
+};
+var assertMatches = (actual, expected, message) => {
+  if (!isSubset(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is not subset of
-${c.stringify(t)}`)},Ke=(t,e,r)=>{if(!d(t,e))throw new p(r??`subObj:
-${c.stringify(e)}
+${JSONParser.stringify(actual)}`
+    );
+};
+var assertDeepEqual = (actual, expected, message) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is not equal to
-${c.stringify(t)}`)},fo=(t,e,r)=>{if(d(t,e))throw new p(r??`subObj:
-${c.stringify(e)}
+${JSONParser.stringify(actual)}`
+    );
+};
+var assertNotDeepEqual = (actual, expected, message) => {
+  if (deepEquals(actual, expected))
+    throw new AssertionError(
+      message ?? `subObj:
+${JSONParser.stringify(expected)}
 is equals to
-${c.stringify(t)}`)},yo=t=>({isEqualTo:e=>s(d(t,e))});function Xe(t,e){if(t)throw new p(e??"Condition is false")}function s(t,e){if(!t)throw new p(e??"Condition is false")}function U(t,e){if(!t)throw new p(e??"Condition is not truthy")}function u(t,e,r){if(t!==e)throw new p(`${r??"Objects are not equal"}:
-Expected: ${c.stringify(t)}
-Actual:${c.stringify(e)}`)}function Ee(t,e,r){if(t===e)throw new p(r??`Objects are equal: ${c.stringify(t)}`)}function vo(t){Ee(t,null),U(t)}function Eo(t){u(t,null)}var So=t=>e=>d(e,t),To=t=>e=>t(e);function xo(t){return{calledTimes:e=>{u(t.mock?.calls?.length,e)},notCalled:()=>{u(t?.mock?.calls?.length,0)},called:()=>{s(t.mock?.calls.length!==void 0&&t.mock.calls.length>0)},calledWith:(...e)=>{s(t.mock?.calls.length!==void 0&&t.mock.calls.length>=1&&t.mock.calls.some(r=>d(r.arguments,e)))},calledOnceWith:(...e)=>{s(t.mock?.calls.length!==void 0&&t.mock.calls.length===1&&t.mock.calls.some(r=>d(r.arguments,e)))},calledWithArgumentMatching:(...e)=>{s(t.mock?.calls.length!==void 0&&t.mock.calls.length>=1),s(t.mock?.calls.length!==void 0&&t.mock.calls.length>=1&&t.mock.calls.some(r=>r.arguments&&r.arguments.length>=e.length&&e.every((n,o)=>n(r.arguments[o]))))},notCalledWithArgumentMatching:(...e)=>{Xe(t.mock?.calls.length!==void 0&&t.mock.calls.length>=1&&t.mock.calls[0].arguments&&t.mock.calls[0].arguments.length>=e.length&&e.every((r,n)=>r(t.mock.calls[0].arguments[n])))}}}var go=t=>({isEmpty:()=>u(t.length,0),isNotEmpty:()=>Ee(t.length,0),hasSize:e=>u(t.length,e),containsElements:(...e)=>{s(e.every(r=>e.some(n=>d(r,n))))},containsExactlyInAnyOrder:(...e)=>{u(t.length,e.length),s(t.every(r=>e.some(n=>d(r,n))))},containsExactlyInAnyOrderElementsOf:e=>{u(t.length,e.length),s(t.every(r=>e.some(n=>d(r,n))))},containsExactlyElementsOf:e=>{u(t.length,e.length);for(let r=0;r<t.length;r++)s(d(t[r],e[r]))},containsExactly:e=>{u(t.length,1),s(d(t[0],e))},contains:e=>{s(t.some(r=>d(r,e)))},containsOnlyOnceElementsOf:e=>{s(e.map(r=>t.filter(n=>d(n,r)).length).filter(r=>r===1).length===e.length)},containsAnyOf:(...e)=>{s(t.some(r=>e.some(n=>d(r,n))))},allMatch:e=>{s(t.every(e))},anyMatches:e=>{s(t.some(e))},allMatchAsync:async e=>{for(let r of t)s(await e(r))}});var bo={for:t=>e=>({when:r=>{let n=()=>{let a=(Array.isArray(e)?e:[e]).reduce(t.evolve,t.initialState());return t.decide(r,a)};return{then:o=>{let a=n(),i=Array.isArray(a)?a:[a],m=Array.isArray(o)?o:[o];ve(i,m)},thenThrows:(...o)=>{try{throw n(),new p("Handler did not fail as expected")}catch(a){if(a instanceof p)throw a;if(o.length===0)return;if(!$(o[0])){s(o[0](a),`Error didn't match the error condition: ${a?.toString()}`);return}s(a instanceof o[0],`Caught error is not an instance of the expected type: ${a?.toString()}`),o[1]&&s(o[1](a),`Error didn't match the error condition: ${a?.toString()}`)}}}}})};var wo=t=>{let e=new Map;return{async aggregateStream(r,n){return t.aggregateStream(r,n)},readStream(r,n){return t.readStream(r,n)},appendToStream:async(r,n,o)=>{let a=await t.appendToStream(r,n,o),i=e.get(r)??[r,[]];return e.set(r,[r,[...i[1],...n]]),a},appendedEvents:e,setup:async(r,n)=>t.appendToStream(r,n)}};export{p as AssertionError,M as BinaryJsonDecoder,_ as CaughtUpTransformStream,ne as CommandHandler,re as CommandHandlerStreamVersionConflictRetryOptions,q as CompositeDecoder,J as ConcurrencyError,Pr as DeciderCommandHandler,bo as DeciderSpecification,x as DefaultDecoder,I as EmmettError,b as ExpectedVersionConflictError,H as GlobalStreamCaughtUpType,st as IllegalStateError,T as InMemoryEventStoreDefaultStreamVersion,c as JSONParser,P as JsonDecoder,D as NO_CONCURRENCY_CHECK,te as NoRetries,it as NotFoundError,k as ObjectDecoder,W as ParseError,F as STREAM_DOES_NOT_EXIST,xe as STREAM_EXISTS,ee as StreamingCoordinator,V as StringDecoder,at as ValidationError,Ze as ValidationErrors,wo as WrapEventStore,xt as accept,To as argMatches,So as argValue,Ke as assertDeepEqual,u as assertEqual,N as assertExpectedVersionMatchesCurrent,po as assertFails,Xe as assertFalse,vo as assertIsNotNull,Eo as assertIsNull,ve as assertMatches,fo as assertNotDeepEqual,rt as assertNotEmptyString,Ee as assertNotEqual,U as assertOk,nt as assertPositiveNumber,uo as assertRejects,yo as assertThat,go as assertThatArray,co as assertThrows,lo as assertThrowsAsync,s as assertTrue,ot as assertUnsignedBigInt,ke as asyncProjections,w as asyncRetry,K as canCreateEventStoreSession,Mt as caughtUpEventFrom,Lr as collect,pt as command,Et as complete,G as concatUint8Arrays,d as deepEquals,Tt as error,L as event,Ye as formatDateToUtcYYYYMMDD,ir as getInMemoryEventStore,Nr as getInMemoryMessageBus,j as globalStreamCaughtUp,St as ignore,Pe as inlineProjections,Oe as isEquatable,$ as isErrorConstructor,z as isExpectedVersionConflictError,Y as isGlobalStreamCaughtUp,Pt as isNotInternalEvent,et as isNumber,mt as isPluginConfig,tt as isString,Vt as isSubscriptionEvent,ye as isSubset,ze as isValidYYYYMMDD,ge as matchesExpectedVersion,Sr as merge,X as nulloSessionFactory,Qe as parseDateFromUtcYYYYMMDD,Wr as projection,Gr as projections,yt as publish,ut as reply,Qn as restream,vt as schedule,ft as send,En as streamGenerators,Q as streamTrackingGlobalPosition,fe as streamTransformations,vr as sum,xo as verifyThat};
+${JSONParser.stringify(actual)}`
+    );
+};
+var assertThat = (item) => {
+  return {
+    isEqualTo: (other) => assertTrue(deepEquals(item, other))
+  };
+};
+function assertFalse(condition, message) {
+  if (condition) throw new AssertionError(message ?? `Condition is false`);
+}
+function assertTrue(condition, message) {
+  if (!condition) throw new AssertionError(message ?? `Condition is false`);
+}
+function assertOk(obj, message) {
+  if (!obj) throw new AssertionError(message ?? `Condition is not truthy`);
+}
+function assertEqual(expected, actual, message) {
+  if (expected !== actual)
+    throw new AssertionError(
+      `${message ?? "Objects are not equal"}:
+Expected: ${JSONParser.stringify(expected)}
+Actual:${JSONParser.stringify(actual)}`
+    );
+}
+function assertNotEqual(obj, other, message) {
+  if (obj === other)
+    throw new AssertionError(
+      message ?? `Objects are equal: ${JSONParser.stringify(obj)}`
+    );
+}
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+function assertIsNull(result) {
+  assertEqual(result, null);
+}
+var argValue = (value) => (arg) => deepEquals(arg, value);
+var argMatches = (matches) => (arg) => matches(arg);
+function verifyThat(fn) {
+  return {
+    calledTimes: (times) => {
+      assertEqual(fn.mock?.calls?.length, times);
+    },
+    notCalled: () => {
+      assertEqual(fn?.mock?.calls?.length, 0);
+    },
+    called: () => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length > 0
+      );
+    },
+    calledWith: (...args) => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
+      );
+    },
+    calledOnceWith: (...args) => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length === 1 && fn.mock.calls.some((call) => deepEquals(call.arguments, args))
+      );
+    },
+    calledWithArgumentMatching: (...matches) => {
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1
+      );
+      assertTrue(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls.some(
+          (call) => call.arguments && call.arguments.length >= matches.length && matches.every((match, index) => match(call.arguments[index]))
+        )
+      );
+    },
+    notCalledWithArgumentMatching: (...matches) => {
+      assertFalse(
+        fn.mock?.calls.length !== void 0 && fn.mock.calls.length >= 1 && fn.mock.calls[0].arguments && fn.mock.calls[0].arguments.length >= matches.length && matches.every(
+          (match, index) => match(fn.mock.calls[0].arguments[index])
+        )
+      );
+    }
+  };
+}
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(array.length, 0),
+    isNotEmpty: () => assertNotEqual(array.length, 0),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (...other) => {
+      assertTrue(other.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrder: (...other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrderElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      for (let i = 0; i < array.length; i++) {
+        assertTrue(deepEquals(array[i], other[i]));
+      }
+    },
+    containsExactly: (elem) => {
+      assertEqual(array.length, 1);
+      assertTrue(deepEquals(array[0], elem));
+    },
+    contains: (elem) => {
+      assertTrue(array.some((a) => deepEquals(a, elem)));
+    },
+    containsOnlyOnceElementsOf: (other) => {
+      assertTrue(
+        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
+      );
+    },
+    containsAnyOf: (...other) => {
+      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+    },
+    allMatch: (matches) => {
+      assertTrue(array.every(matches));
+    },
+    anyMatches: (matches) => {
+      assertTrue(array.some(matches));
+    },
+    allMatchAsync: async (matches) => {
+      for (const item of array) {
+        assertTrue(await matches(item));
+      }
+    }
+  };
+};
+
+// src/testing/deciderSpecification.ts
+var DeciderSpecification = {
+  for: (decider) => {
+    {
+      return (givenEvents) => {
+        return {
+          when: (command2) => {
+            const handle = () => {
+              const existingEvents = Array.isArray(givenEvents) ? givenEvents : [givenEvents];
+              const currentState = existingEvents.reduce(
+                decider.evolve,
+                decider.initialState()
+              );
+              return decider.decide(command2, currentState);
+            };
+            return {
+              then: (expectedEvents) => {
+                const resultEvents = handle();
+                const resultEventsArray = Array.isArray(resultEvents) ? resultEvents : [resultEvents];
+                const expectedEventsArray = Array.isArray(expectedEvents) ? expectedEvents : [expectedEvents];
+                assertMatches(resultEventsArray, expectedEventsArray);
+              },
+              thenThrows: (...args) => {
+                try {
+                  handle();
+                  throw new AssertionError("Handler did not fail as expected");
+                } catch (error2) {
+                  if (error2 instanceof AssertionError) throw error2;
+                  if (args.length === 0) return;
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
+                      args[0](error2),
+                      `Error didn't match the error condition: ${error2?.toString()}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error2 instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${error2?.toString()}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error2),
+                      `Error didn't match the error condition: ${error2?.toString()}`
+                    );
+                  }
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+
+// src/testing/wrapEventStore.ts
+var WrapEventStore = (eventStore) => {
+  const appendedEvents = /* @__PURE__ */ new Map();
+  return {
+    async aggregateStream(streamName, options) {
+      return eventStore.aggregateStream(streamName, options);
+    },
+    readStream(streamName, options) {
+      return eventStore.readStream(streamName, options);
+    },
+    appendToStream: async (streamName, events, options) => {
+      const result = await eventStore.appendToStream(
+        streamName,
+        events,
+        options
+      );
+      const currentStream = appendedEvents.get(streamName) ?? [streamName, []];
+      appendedEvents.set(streamName, [
+        streamName,
+        [...currentStream[1], ...events]
+      ]);
+      return result;
+    },
+    appendedEvents,
+    setup: async (streamName, events) => {
+      return eventStore.appendToStream(streamName, events);
+    }
+    // streamEvents: (): ReadableStream<
+    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
+    // > => {
+    //   return eventStore.streamEvents();
+    // },
+  };
+};
+export {
+  AssertionError,
+  BinaryJsonDecoder,
+  CaughtUpTransformStream,
+  CommandHandler,
+  CommandHandlerStreamVersionConflictRetryOptions,
+  CompositeDecoder,
+  ConcurrencyError,
+  DeciderCommandHandler,
+  DeciderSpecification,
+  DefaultDecoder,
+  EmmettError,
+  ExpectedVersionConflictError,
+  GlobalStreamCaughtUpType,
+  IllegalStateError,
+  InMemoryEventStoreDefaultStreamVersion,
+  JSONParser,
+  JsonDecoder,
+  NO_CONCURRENCY_CHECK,
+  NoRetries,
+  NotFoundError,
+  ObjectDecoder,
+  ParseError,
+  STREAM_DOES_NOT_EXIST,
+  STREAM_EXISTS,
+  StreamingCoordinator,
+  StringDecoder,
+  ValidationError,
+  ValidationErrors,
+  WrapEventStore,
+  accept,
+  argMatches,
+  argValue,
+  assertDeepEqual,
+  assertEqual,
+  assertExpectedVersionMatchesCurrent,
+  assertFails,
+  assertFalse,
+  assertIsNotNull,
+  assertIsNull,
+  assertMatches,
+  assertNotDeepEqual,
+  assertNotEmptyString,
+  assertNotEqual,
+  assertOk,
+  assertPositiveNumber,
+  assertRejects,
+  assertThat,
+  assertThatArray,
+  assertThrows,
+  assertThrowsAsync,
+  assertTrue,
+  assertUnsignedBigInt,
+  asyncProjections,
+  asyncRetry,
+  canCreateEventStoreSession,
+  caughtUpEventFrom,
+  collect,
+  command,
+  complete,
+  concatUint8Arrays,
+  deepEquals,
+  error,
+  event,
+  formatDateToUtcYYYYMMDD,
+  getInMemoryEventStore,
+  getInMemoryMessageBus,
+  globalStreamCaughtUp,
+  ignore,
+  inlineProjections,
+  isEquatable,
+  isErrorConstructor,
+  isExpectedVersionConflictError,
+  isGlobalStreamCaughtUp,
+  isNotInternalEvent,
+  isNumber,
+  isPluginConfig,
+  isString,
+  isSubscriptionEvent,
+  isSubset,
+  isValidYYYYMMDD,
+  matchesExpectedVersion,
+  merge,
+  nulloSessionFactory,
+  parseDateFromUtcYYYYMMDD,
+  projection,
+  projections,
+  publish,
+  reply,
+  restream,
+  schedule,
+  send,
+  streamGenerators,
+  streamTrackingGlobalPosition,
+  streamTransformations,
+  sum,
+  verifyThat
+};
 //# sourceMappingURL=index.js.map