@event-driven-io/emmett-esdb 0.38.7 → 0.39.1

package/dist/index.cjs

@@ -1,30 +1,40 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// ../emmett/dist/chunk-O2VMBOV4.js
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isBigint = (val) => typeof val === "bigint" && val === val;
 var isString = (val) => typeof val === "string";
-var EmmettError = class _EmmettError extends Error {
+var EmmettError = (_class = class _EmmettError extends Error {
+  static __initStatic() {this.Codes = {
+    ValidationError: 400,
+    IllegalStateError: 403,
+    NotFoundError: 404,
+    ConcurrencyError: 412,
+    InternalServerError: 500
+  }}
   
   constructor(options) {
-    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : _EmmettError.Codes.InternalServerError;
     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);
   }
   static mapFrom(error) {
-    if (error instanceof _EmmettError) {
+    if (_EmmettError.isInstanceOf(error)) {
       return error;
     }
     return new _EmmettError({
-      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : 500,
+      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : _EmmettError.Codes.InternalServerError,
       message: _nullishCoalesce(error.message, () => ( "An unknown error occurred"))
     });
   }
-};
+  static isInstanceOf(error, errorCode) {
+    return typeof error === "object" && error !== null && "errorCode" in error && isNumber(error.errorCode) && (errorCode === void 0 || error.errorCode === errorCode);
+  }
+}, _class.__initStatic(), _class);
 var ConcurrencyError = class _ConcurrencyError extends EmmettError {
   constructor(current, expected, message) {
     super({
-      errorCode: 412,
+      errorCode: EmmettError.Codes.ConcurrencyError,
       message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
     });
     this.current = current;
@@ -35,7 +45,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 var ConcurrencyInMemoryDatabaseError = class _ConcurrencyInMemoryDatabaseError extends EmmettError {
   constructor(message) {
     super({
-      errorCode: 412,
+      errorCode: EmmettError.Codes.ConcurrencyError,
       message: _nullishCoalesce(message, () => ( `Expected document state does not match current one!`))
     });
     Object.setPrototypeOf(this, _ConcurrencyInMemoryDatabaseError.prototype);
@@ -47,23 +57,6 @@ var _uuid = require('uuid');
 
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
-var _webstreamspolyfill = require('web-streams-polyfill');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -576,44 +569,6 @@ var getInMemoryDatabase = () => {
     }
   };
 };
-var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
-var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfill.TransformStream {
-  constructor(onNoActiveReaderCallback, options = {}) {
-    super({
-      cancel: (reason) => {
-        console.log("Stream was canceled. Reason:", reason);
-        this.stopChecking();
-      }
-    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.streamId]), () => ( _uuid.v4.call(void 0, )));
-    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _25 => _25.intervalCheckInMs]), () => ( 20)));
-  }
-  __init() {this.checkInterval = null}
-  
-  __init2() {this._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();
-    }
-  }
-}, _class);
 var getCheckpoint = (message2) => {
   return "checkpoint" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   isBigint(message2.metadata.checkpoint) ? (
@@ -648,7 +603,7 @@ var reactor = (options) => {
   return {
     id: options.processorId,
     type: _nullishCoalesce(options.type, () => ( MessageProcessorType.REACTOR)),
-    close: () => _optionalChain([options, 'access', _26 => _26.hooks, 'optionalAccess', _27 => _27.onClose]) ? _optionalChain([options, 'access', _28 => _28.hooks, 'optionalAccess', _29 => _29.onClose, 'call', _30 => _30()]) : Promise.resolve(),
+    close: () => _optionalChain([options, 'access', _24 => _24.hooks, 'optionalAccess', _25 => _25.onClose]) ? _optionalChain([options, 'access', _26 => _26.hooks, 'optionalAccess', _27 => _27.onClose, 'call', _28 => _28()]) : Promise.resolve(),
     start: async (startOptions) => {
       isActive = true;
       if (lastCheckpoint !== null)
@@ -656,13 +611,13 @@ var reactor = (options) => {
           lastCheckpoint
         };
       return await processingScope(async (context) => {
-        if (_optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart])) {
-          await _optionalChain([options, 'access', _33 => _33.hooks, 'optionalAccess', _34 => _34.onStart, 'call', _35 => _35(context)]);
+        if (_optionalChain([options, 'access', _29 => _29.hooks, 'optionalAccess', _30 => _30.onStart])) {
+          await _optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart, 'call', _33 => _33(context)]);
         }
         if (options.startFrom !== "CURRENT" && options.startFrom)
           return options.startFrom;
         if (checkpoints) {
-          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _36 => _36.read, 'call', _37 => _37(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _34 => _34.read, 'call', _35 => _35(
             {
               processorId,
               partition
@@ -727,12 +682,12 @@ var projector = (options) => {
     type: MessageProcessorType.PROJECTOR,
     processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
     hooks: {
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _38 => _38.hooks, 'optionalAccess', _39 => _39.onStart]) ? async (context) => {
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _36 => _36.hooks, 'optionalAccess', _37 => _37.onStart]) ? async (context) => {
         if (options.truncateOnStart && options.projection.truncate)
           await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _40 => _40.hooks, 'optionalAccess', _41 => _41.onStart])) await _optionalChain([options, 'access', _42 => _42.hooks, 'optionalAccess', _43 => _43.onStart, 'call', _44 => _44(context)]);
+        if (_optionalChain([options, 'access', _38 => _38.hooks, 'optionalAccess', _39 => _39.onStart])) await _optionalChain([options, 'access', _40 => _40.hooks, 'optionalAccess', _41 => _41.onStart, 'call', _42 => _42(context)]);
       } : void 0,
-      onClose: _optionalChain([options, 'access', _45 => _45.hooks, 'optionalAccess', _46 => _46.onClose])
+      onClose: _optionalChain([options, 'access', _43 => _43.hooks, 'optionalAccess', _44 => _44.onClose])
     },
     eachMessage: async (event2, context) => {
       if (!projection2.canHandle.includes(event2.type)) return;
@@ -745,7 +700,7 @@ var inMemoryCheckpointer = () => {
     read: async ({ processorId }, { database }) => {
       const checkpoint = await database.collection("emt_processor_checkpoints").findOne((d) => d._id === processorId);
       return Promise.resolve({
-        lastCheckpoint: _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _47 => _47.lastCheckpoint]), () => ( null))
+        lastCheckpoint: _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _45 => _45.lastCheckpoint]), () => ( null))
       });
     },
     store: async (context, { database }) => {
@@ -756,7 +711,7 @@ var inMemoryCheckpointer = () => {
       const checkpoint = await checkpoints.findOne(
         (d) => d._id === processorId
       );
-      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _48 => _48.lastCheckpoint]), () => ( null));
+      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _46 => _46.lastCheckpoint]), () => ( null));
       const newCheckpoint = getCheckpoint(message2);
       if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
         return {
@@ -776,7 +731,7 @@ var inMemoryCheckpointer = () => {
 var inMemoryProcessingScope = (options) => {
   const processorDatabase = options.database;
   const processingScope = (handler, partialContext) => {
-    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _49 => _49.database])));
+    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _47 => _47.database])));
     if (!database)
       throw new EmmettError(
         `InMemory processor '${options.processorId}' is missing database. Ensure that you passed it through options`
@@ -786,11 +741,11 @@ var inMemoryProcessingScope = (options) => {
   return processingScope;
 };
 var inMemoryProjector = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _50 => _50.connectionOptions, 'optionalAccess', _51 => _51.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _48 => _48.connectionOptions, 'optionalAccess', _49 => _49.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    onStart: _optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onStart]),
-    onClose: _optionalChain([options, 'access', _54 => _54.hooks, 'optionalAccess', _55 => _55.onClose]) ? async () => {
-      if (_optionalChain([options, 'access', _56 => _56.hooks, 'optionalAccess', _57 => _57.onClose])) await _optionalChain([options, 'access', _58 => _58.hooks, 'optionalAccess', _59 => _59.onClose, 'call', _60 => _60()]);
+    onStart: _optionalChain([options, 'access', _50 => _50.hooks, 'optionalAccess', _51 => _51.onStart]),
+    onClose: _optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onClose]) ? async () => {
+      if (_optionalChain([options, 'access', _54 => _54.hooks, 'optionalAccess', _55 => _55.onClose])) await _optionalChain([options, 'access', _56 => _56.hooks, 'optionalAccess', _57 => _57.onClose, 'call', _58 => _58()]);
     } : void 0
   };
   return {
@@ -807,11 +762,11 @@ var inMemoryProjector = (options) => {
   };
 };
 var inMemoryReactor = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _61 => _61.connectionOptions, 'optionalAccess', _62 => _62.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _59 => _59.connectionOptions, 'optionalAccess', _60 => _60.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    onStart: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onStart]),
-    onClose: _optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.onClose]) ? async () => {
-      if (_optionalChain([options, 'access', _67 => _67.hooks, 'optionalAccess', _68 => _68.onClose])) await _optionalChain([options, 'access', _69 => _69.hooks, 'optionalAccess', _70 => _70.onClose, 'call', _71 => _71()]);
+    onStart: _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onStart]),
+    onClose: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onClose]) ? async () => {
+      if (_optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.onClose])) await _optionalChain([options, 'access', _67 => _67.hooks, 'optionalAccess', _68 => _68.onClose, 'call', _69 => _69()]);
     } : void 0
   };
   return {
@@ -827,147 +782,6 @@ var inMemoryReactor = (options) => {
     database
   };
 };
-var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
-  transform(chunk, controller) {
-    if (filter2(chunk)) {
-      controller.enqueue(chunk);
-    }
-  }
-});
-var map = (map2) => new (0, _webstreamspolyfill.TransformStream)({
-  transform(chunk, controller) {
-    controller.enqueue(map2(chunk));
-  }
-});
-var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
-var ReduceTransformStream = class extends _webstreamspolyfill.TransformStream {
-  
-  
-  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 (0, _webstreamspolyfill.TransformStream)({
-  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 = (_class2 = class extends _webstreamspolyfill.TransformStream {
-  __init3() {this.count = 0}
-  
-  constructor(skip2) {
-    super({
-      transform: (chunk, controller) => {
-        this.count++;
-        if (this.count > this.skip) {
-          controller.enqueue(chunk);
-        }
-      }
-    });_class2.prototype.__init3.call(this);;
-    this.skip = skip2;
-  }
-}, _class2);
-var stopAfter = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
-  transform(chunk, controller) {
-    controller.enqueue(chunk);
-    if (stopCondition(chunk)) {
-      controller.terminate();
-    }
-  }
-});
-var stopOn = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
-  async transform(chunk, controller) {
-    if (!stopCondition(chunk)) {
-      controller.enqueue(chunk);
-      return;
-    }
-    await Promise.resolve();
-    controller.terminate();
-  }
-});
-var take = (limit) => new TakeTransformStream(limit);
-var TakeTransformStream = (_class3 = class extends _webstreamspolyfill.TransformStream {
-  __init4() {this.count = 0}
-  
-  constructor(limit) {
-    super({
-      transform: (chunk, controller) => {
-        if (this.count < this.limit) {
-          this.count++;
-          controller.enqueue(chunk);
-        } else {
-          controller.terminate();
-        }
-      }
-    });_class3.prototype.__init4.call(this);;
-    this.limit = limit;
-  }
-}, _class3);
-var waitAtMost = (waitTimeInMs) => new (0, _webstreamspolyfill.TransformStream)({
-  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/consumers/eventStoreDBEventStoreConsumer.ts
 
@@ -1003,7 +817,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   return {
     async aggregateStream(streamName, options) {
       const { evolve, initialState, read } = options;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _72 => _72.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _70 => _70.expectedStreamVersion]);
       let state = initialState();
       let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
       let lastEventGlobalPosition = void 0;
@@ -1016,7 +830,7 @@ var getEventStoreDBEventStore = (eventStore) => {
           if (!event) continue;
           state = evolve(state, mapFromESDBEvent(resolvedEvent));
           currentStreamVersion = event.revision;
-          lastEventGlobalPosition = _optionalChain([event, 'access', _73 => _73.position, 'optionalAccess', _74 => _74.commit]);
+          lastEventGlobalPosition = _optionalChain([event, 'access', _71 => _71.position, 'optionalAccess', _72 => _72.commit]);
         }
         assertExpectedVersionMatchesCurrent(
           currentStreamVersion,
@@ -1077,7 +891,7 @@ var getEventStoreDBEventStore = (eventStore) => {
       try {
         const serializedEvents = events.map(_dbclient.jsonEvent);
         const expectedRevision = toExpectedRevision(
-          _optionalChain([options, 'optionalAccess', _75 => _75.expectedStreamVersion])
+          _optionalChain([options, 'optionalAccess', _73 => _73.expectedStreamVersion])
         );
         const appendResult = await eventStore.appendToStream(
           streamName,
@@ -1109,7 +923,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   };
 };
 var getCheckpoint2 = (resolvedEvent, from) => {
-  return !from || _optionalChain([from, 'optionalAccess', _76 => _76.stream]) === $all ? _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _77 => _77.link, 'optionalAccess', _78 => _78.position, 'optionalAccess', _79 => _79.commit]), () => ( _optionalChain([resolvedEvent, 'access', _80 => _80.event, 'optionalAccess', _81 => _81.position, 'optionalAccess', _82 => _82.commit]))) : _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _83 => _83.link, 'optionalAccess', _84 => _84.revision]), () => ( resolvedEvent.event.revision));
+  return !from || _optionalChain([from, 'optionalAccess', _74 => _74.stream]) === $all ? _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _75 => _75.link, 'optionalAccess', _76 => _76.position, 'optionalAccess', _77 => _77.commit]), () => ( _optionalChain([resolvedEvent, 'access', _78 => _78.event, 'optionalAccess', _79 => _79.position, 'optionalAccess', _80 => _80.commit]))) : _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _81 => _81.link, 'optionalAccess', _82 => _82.revision]), () => ( resolvedEvent.event.revision));
 };
 var mapFromESDBEvent = (resolvedEvent, from) => {
   const event = resolvedEvent.event;
@@ -1150,7 +964,7 @@ var toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.STAR
 };
 var toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.START : startFrom === "END" ? _dbclient.END : startFrom.lastCheckpoint;
 var subscribe = (client, from, options) => from == void 0 || from.stream == $all ? client.subscribeToAll({
-  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _85 => _85.options]), () => ( {})),
+  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _83 => _83.options]), () => ( {})),
   fromPosition: toGlobalPosition(options.startFrom),
   filter: _dbclient.excludeSystemEvents.call(void 0, )
 }) : client.subscribeToStream(from.stream, {
@@ -1209,7 +1023,7 @@ var eventStoreDBSubscription = ({
   let start;
   let processor;
   let subscription;
-  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _86 => _86.resubscribeOptions]), () => ( {
+  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _84 => _84.resubscribeOptions]), () => ( {
     ...EventStoreDBResubscribeDefaultOptions,
     shouldRetryResult: () => isRunning,
     shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
@@ -1223,11 +1037,11 @@ var eventStoreDBSubscription = ({
     }))));
   };
   const pipeMessages = (options) => {
-    let retry3 = 0;
+    let retry2 = 0;
     return asyncRetry(
       () => new Promise((resolve, reject) => {
         console.info(
-          `Starting subscription. ${retry3++} retries. From: ${JSONParser.stringify(_nullishCoalesce(from, () => ( "$all")))}, Start from: ${JSONParser.stringify(
+          `Starting subscription. ${retry2++} retries. From: ${JSONParser.stringify(_nullishCoalesce(from, () => ( "$all")))}, Start from: ${JSONParser.stringify(
             options.startFrom
           )}`
         );
@@ -1324,13 +1138,13 @@ var eventStoreDBEventStoreConsumer = (options) => {
         reason: "No active processors"
       };
     const result = await Promise.allSettled(
-      activeProcessors.map((s) => {
-        return s.handle(messagesBatch, { client });
+      activeProcessors.map(async (s) => {
+        return await s.handle(messagesBatch, { client });
       })
     );
-    const error = _optionalChain([result, 'access', _87 => _87.find, 'call', _88 => _88((r) => r.status === "rejected"), 'optionalAccess', _89 => _89.reason]);
+    const error = _optionalChain([result, 'access', _85 => _85.find, 'call', _86 => _86((r) => r.status === "rejected"), 'optionalAccess', _87 => _87.reason]);
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _90 => _90.value, 'optionalAccess', _91 => _91.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _88 => _88.value, 'optionalAccess', _89 => _89.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP",
       error: error ? EmmettError.mapFrom(error) : void 0
@@ -1340,7 +1154,7 @@ var eventStoreDBEventStoreConsumer = (options) => {
     client,
     from: options.from,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _92 => _92.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _90 => _90.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
     resilience: options.resilience
   });
   const stop = async () => {