@event-driven-io/emmett-esdb 0.20.2-alpha.1 → 0.20.2-alpha2

package/dist/index.js

@@ -1,2 +1,407 @@
-var v=e=>typeof e=="number"&&e===e,S=e=>typeof e=="string";var E=class y extends Error{errorCode;constructor(t){let r=t&&typeof t=="object"&&"errorCode"in t?t.errorCode:v(t)?t:500,n=t&&typeof t=="object"&&"message"in t?t.message:S(t)?t:`Error with status code '${r}' ocurred during Emmett processing`;super(n),this.errorCode=r,Object.setPrototypeOf(this,y.prototype)}},w=class T extends E{constructor(t,r,n){super({errorCode:412,message:n??`Expected version ${r.toString()} does not match current ${t?.toString()}`}),this.current=t,this.expected=r,Object.setPrototypeOf(this,T.prototype)}};import{v4 as Ce}from"uuid";import{TransformStream as Ae}from"web-streams-polyfill";import{v4 as xe}from"uuid";import{v4 as D}from"uuid";import{TransformStream as V}from"web-streams-polyfill";import U from"async-retry";import{ReadableStream as Pe}from"web-streams-polyfill";import"web-streams-polyfill";import{TransformStream as q}from"web-streams-polyfill";import{TransformStream as G}from"web-streams-polyfill";import{TransformStream as F}from"web-streams-polyfill";import{TransformStream as H}from"web-streams-polyfill";import{TransformStream as L}from"web-streams-polyfill";import{TransformStream as z}from"web-streams-polyfill";import{TransformStream as Q}from"web-streams-polyfill";import{TransformStream as te}from"web-streams-polyfill";import{TransformStream as ne}from"web-streams-polyfill";var m="STREAM_EXISTS",d="STREAM_DOES_NOT_EXIST",c="NO_CONCURRENCY_CHECK",k=(e,t,r)=>t===c?!0:t==d?e===r:t==m?e!==r:e===t,b=(e,t,r)=>{if(t??=c,!k(e,t,r))throw new f(e,t)},f=class C extends w{constructor(t,r){super(t?.toString(),r?.toString()),Object.setPrototypeOf(this,C.prototype)}};var B=(e,t={})=>new R(e,t),R=class extends V{constructor(e,t={}){super({cancel:r=>{console.log("Stream was canceled. Reason:",r),this.stopChecking()}}),this.onNoActiveReaderCallback=e,this.streamId=t?.streamId??D(),this.onNoActiveReaderCallback=e,this.startChecking(t?.intervalCheckInMs??20)}checkInterval=null;streamId;_isStopped=!1;get hasActiveSubscribers(){return!this._isStopped}startChecking(e){this.checkInterval=setInterval(()=>{this.checkNoActiveReader()},e)}stopChecking(){this.checkInterval&&(clearInterval(this.checkInterval),this.checkInterval=null,this._isStopped=!0,this.onNoActiveReaderCallback(this))}checkNoActiveReader(){!this.readable.locked&&!this._isStopped&&this.stopChecking()}};var j=async(e,t)=>t===void 0||t.retries===0?e():U(async r=>{try{return await e()}catch(n){throw t?.shouldRetryError&&!t.shouldRetryError(n)&&r(n),n}},t??{retries:0});var Y=e=>new q({transform(t,r){e(t)&&r.enqueue(t)}}),$=e=>new G({transform(t,r){r.enqueue(e(t))}}),W=(e,t)=>new A(e,t),A=class extends F{accumulator;reducer;constructor(e,t){super({transform:r=>{this.accumulator=this.reducer(this.accumulator,r)},flush:r=>{r.enqueue(this.accumulator),r.terminate()}}),this.accumulator=t,this.reducer=e}},J=(e,t,r={forever:!0,minTimeout:25})=>new H({start(n){j(()=>X(e,t,n),r).catch(a=>{n.error(a)})}}),X=async(e,t,r)=>{let a=e().getReader();try{let s;do{let o=await a.read();s=o.done,await t(o,r),s&&r.terminate()}while(!s)}finally{a.releaseLock()}},K=e=>new N(e),N=class extends L{count=0;skip;constructor(e){super({transform:(t,r)=>{this.count++,this.count>this.skip&&r.enqueue(t)}}),this.skip=e}},Z=e=>new z({transform(t,r){r.enqueue(t),e(t)&&r.terminate()}}),ee=e=>new Q({async transform(t,r){if(!e(t)){r.enqueue(t);return}await Promise.resolve(),r.terminate()}}),re=e=>new x(e),x=class extends te{count=0;limit;constructor(e){super({transform:(t,r)=>{this.count<this.limit?(this.count++,r.enqueue(t)):r.terminate()}}),this.limit=e}},ae=e=>new ne({start(t){let r=setTimeout(()=>{t.terminate()},e),n=t.terminate.bind(t);t.terminate=()=>{clearTimeout(r),n()}},transform(t,r){r.enqueue(t)}}),h={filter:Y,take:re,TakeTransformStream:x,skip:K,SkipTransformStream:N,map:$,notifyAboutNoActiveReadersStream:B,NotifyAboutNoActiveReadersStream:R,reduce:W,ReduceTransformStream:A,retry:J,stopAfter:Z,stopOn:ee,waitAtMost:ae},{retry:Fe}=h;import{ANY as g,STREAM_EXISTS as _,NO_STREAM as P,StreamNotFoundError as I,WrongExpectedVersionError as se,jsonEvent as oe}from"@eventstore/db-client";import{WritableStream as tt}from"node:stream/web";import{Readable as nt}from"stream";var{map:at}=h,O=e=>e?{fromRevision:"from"in e?e.from:void 0,maxCount:"maxCount"in e?e.maxCount:"to"in e?e.to:void 0}:void 0,p=-1n,st=e=>({async aggregateStream(t,r){let{evolve:n,initialState:a,read:s}=r,o=s?.expectedStreamVersion,u=a(),l=p;try{for await(let{event:i}of e.readStream(t,O(r.read)))i&&(u=n(u,M(i)),l=i.revision);return b(l,o,p),{currentStreamVersion:l,state:u,streamExists:!0}}catch(i){if(i instanceof I)return{currentStreamVersion:l,state:u,streamExists:!1};throw i}},readStream:async(t,r)=>{let n=[],a=p;try{for await(let{event:s}of e.readStream(t,O(r)))s&&(n.push(M(s)),a=s.revision);return{currentStreamVersion:a,events:n,streamExists:!0}}catch(s){if(s instanceof I)return{currentStreamVersion:a,events:[],streamExists:!1};throw s}},appendToStream:async(t,r,n)=>{try{let a=r.map(oe),s=ie(n?.expectedStreamVersion),o=await e.appendToStream(t,a,{expectedRevision:s});return{nextExpectedStreamVersion:o.nextExpectedRevision,createdNewStream:o.nextExpectedRevision>=BigInt(a.length)}}catch(a){throw a instanceof se?new f(a.actualVersion,ce(a.expectedVersion)):a}}}),M=e=>({type:e.type,data:e.data,metadata:{...e.metadata??{},eventId:e.id,streamName:e.streamId,streamPosition:e.revision,globalPosition:e.position.commit}}),ie=e=>e===void 0?g:e===c?g:e==d?P:e==m?_:e,ce=e=>e===void 0?c:e===g?c:e==P?d:e==_?m:e;export{p as EventStoreDBEventStoreDefaultStreamVersion,st as getEventStoreDBEventStore};
+// ../emmett/dist/chunk-AEEEXE2R.js
+var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var EmmettError = class _EmmettError extends Error {
+  errorCode;
+  constructor(options) {
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
+    super(message);
+    this.errorCode = errorCode;
+    Object.setPrototypeOf(this, _EmmettError.prototype);
+  }
+};
+var ConcurrencyError = class _ConcurrencyError extends EmmettError {
+  constructor(current, expected, message) {
+    super({
+      errorCode: 412,
+      message: message ?? `Expected version ${expected.toString()} does not match current ${current?.toString()}`
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+
+// ../emmett/dist/index.js
+import { v4 as uuid3 } from "uuid";
+import { TransformStream } from "web-streams-polyfill";
+import { v4 as uuid2 } from "uuid";
+import { v4 as uuid } from "uuid";
+import { TransformStream as TransformStream2 } from "web-streams-polyfill";
+import retry from "async-retry";
+import { ReadableStream } from "web-streams-polyfill";
+import "web-streams-polyfill";
+import { TransformStream as TransformStream3 } from "web-streams-polyfill";
+import { TransformStream as TransformStream4 } from "web-streams-polyfill";
+import { TransformStream as TransformStream5 } from "web-streams-polyfill";
+import {
+  TransformStream as TransformStream6
+} from "web-streams-polyfill";
+import { TransformStream as TransformStream7 } from "web-streams-polyfill";
+import { TransformStream as TransformStream8 } from "web-streams-polyfill";
+import { TransformStream as TransformStream9 } from "web-streams-polyfill";
+import { TransformStream as TransformStream10 } from "web-streams-polyfill";
+import { TransformStream as TransformStream11 } from "web-streams-polyfill";
+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 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();
+    }
+  }
+};
+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 }
+  );
+};
+var filter = (filter2) => new TransformStream3({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+var map = (map22) => new TransformStream4({
+  transform(chunk, controller) {
+    controller.enqueue(map22(chunk));
+  }
+});
+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;
+  }
+};
+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();
+  }
+};
+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;
+  }
+};
+var stopAfter = (stopCondition) => new TransformStream8({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+var stopOn = (stopCondition) => new TransformStream9({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+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;
+  }
+};
+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);
+  }
+});
+var streamTransformations = {
+  filter,
+  take,
+  TakeTransformStream,
+  skip,
+  SkipTransformStream,
+  map,
+  notifyAboutNoActiveReadersStream,
+  NotifyAboutNoActiveReadersStream,
+  reduce,
+  ReduceTransformStream,
+  retry: retryStream,
+  stopAfter,
+  stopOn,
+  waitAtMost
+};
+var { retry: retry2 } = streamTransformations;
+
+// src/eventStore/eventstoreDBEventStore.ts
+import {
+  ANY,
+  STREAM_EXISTS as ESDB_STREAM_EXISTS,
+  NO_STREAM,
+  StreamNotFoundError,
+  WrongExpectedVersionError,
+  jsonEvent
+} from "@eventstore/db-client";
+import { WritableStream } from "node:stream/web";
+import { Readable } from "stream";
+var { map: map2 } = streamTransformations;
+var toEventStoreDBReadOptions = (options) => {
+  return options ? {
+    fromRevision: "from" in options ? options.from : void 0,
+    maxCount: "maxCount" in options ? options.maxCount : "to" in options ? options.to : void 0
+  } : void 0;
+};
+var EventStoreDBEventStoreDefaultStreamVersion = -1n;
+var getEventStoreDBEventStore = (eventStore) => {
+  return {
+    async aggregateStream(streamName, options) {
+      const { evolve, initialState, read } = options;
+      const expectedStreamVersion = read?.expectedStreamVersion;
+      let state = initialState();
+      let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
+      try {
+        for await (const { event } of eventStore.readStream(
+          streamName,
+          toEventStoreDBReadOptions(options.read)
+        )) {
+          if (!event) continue;
+          state = evolve(state, mapFromESDBEvent(event));
+          currentStreamVersion = event.revision;
+        }
+        assertExpectedVersionMatchesCurrent(
+          currentStreamVersion,
+          expectedStreamVersion,
+          EventStoreDBEventStoreDefaultStreamVersion
+        );
+        return {
+          currentStreamVersion,
+          state,
+          streamExists: true
+        };
+      } catch (error) {
+        if (error instanceof StreamNotFoundError) {
+          return {
+            currentStreamVersion,
+            state,
+            streamExists: false
+          };
+        }
+        throw error;
+      }
+    },
+    readStream: async (streamName, options) => {
+      const events = [];
+      let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
+      try {
+        for await (const { event } of eventStore.readStream(
+          streamName,
+          toEventStoreDBReadOptions(options)
+        )) {
+          if (!event) continue;
+          events.push(mapFromESDBEvent(event));
+          currentStreamVersion = event.revision;
+        }
+        return {
+          currentStreamVersion,
+          events,
+          streamExists: true
+        };
+      } catch (error) {
+        if (error instanceof StreamNotFoundError) {
+          return {
+            currentStreamVersion,
+            events: [],
+            streamExists: false
+          };
+        }
+        throw error;
+      }
+    },
+    appendToStream: async (streamName, events, options) => {
+      try {
+        const serializedEvents = events.map(jsonEvent);
+        const expectedRevision = toExpectedRevision(
+          options?.expectedStreamVersion
+        );
+        const appendResult = await eventStore.appendToStream(
+          streamName,
+          serializedEvents,
+          {
+            expectedRevision
+          }
+        );
+        return {
+          nextExpectedStreamVersion: appendResult.nextExpectedRevision,
+          createdNewStream: appendResult.nextExpectedRevision >= BigInt(serializedEvents.length)
+        };
+      } catch (error) {
+        if (error instanceof WrongExpectedVersionError) {
+          throw new ExpectedVersionConflictError(
+            error.actualVersion,
+            toExpectedVersion(error.expectedVersion)
+          );
+        }
+        throw error;
+      }
+    }
+    //streamEvents: streamEvents(eventStore),
+  };
+};
+var mapFromESDBEvent = (event) => {
+  return {
+    type: event.type,
+    data: event.data,
+    metadata: {
+      ...event.metadata ?? {},
+      eventId: event.id,
+      streamName: event.streamId,
+      streamPosition: event.revision,
+      globalPosition: event.position.commit
+    }
+  };
+};
+var toExpectedRevision = (expected) => {
+  if (expected === void 0) return ANY;
+  if (expected === NO_CONCURRENCY_CHECK) return ANY;
+  if (expected == STREAM_DOES_NOT_EXIST) return NO_STREAM;
+  if (expected == STREAM_EXISTS) return ESDB_STREAM_EXISTS;
+  return expected;
+};
+var toExpectedVersion = (expected) => {
+  if (expected === void 0) return NO_CONCURRENCY_CHECK;
+  if (expected === ANY) return NO_CONCURRENCY_CHECK;
+  if (expected == NO_STREAM) return STREAM_DOES_NOT_EXIST;
+  if (expected == ESDB_STREAM_EXISTS) return STREAM_EXISTS;
+  return expected;
+};
+export {
+  EventStoreDBEventStoreDefaultStreamVersion,
+  getEventStoreDBEventStore
+};
 //# sourceMappingURL=index.js.map