@event-driven-io/emmett-esdb 0.43.0-beta.1 → 0.43.0-beta.10

package/dist/index.cjs

@@ -34,7 +34,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
   constructor(current, expected, message) {
     super({
       errorCode: EmmettError.Codes.ConcurrencyError,
-      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
     });
     this.current = current;
     this.expected = expected;
@@ -54,9 +54,11 @@ var ConcurrencyInMemoryDatabaseError = class _ConcurrencyInMemoryDatabaseError e
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
+
 var emmettPrefix = "emt";
 var defaultTag = `${emmettPrefix}:default`;
 var unknownTag = `${emmettPrefix}:unknown`;
@@ -76,7 +78,7 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
+    super(_optionalChain([current, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([expected, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -285,45 +287,127 @@ var toNormalizedString = (value) => value.toString().padStart(19, "0");
 var bigInt = {
   toNormalizedString
 };
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+var bigIntReplacer = (_key, value) => {
+  return typeof value === "bigint" ? value.toString() : value;
+};
+var dateReplacer = (_key, value) => {
+  return value instanceof Date ? value.toISOString() : value;
+};
+var isFirstLetterNumeric = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57;
+};
+var isFirstLetterNumericOrMinus = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57 || c === 45;
+};
+var bigIntReviver = (_key, value, context) => {
+  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    try {
+      return BigInt(_nullishCoalesce(_optionalChain([context, 'optionalAccess', _7 => _7.source]), () => ( value.toString())));
+    } catch (e) {
+      return value;
+    }
   }
+  if (typeof value === "string" && value.length > 15) {
+    if (isFirstLetterNumericOrMinus(value)) {
+      const num = Number(value);
+      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
+        try {
+          return BigInt(value);
+        } catch (e2) {
+        }
+      }
+    }
+  }
+  return value;
 };
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _8 => _8.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, _optionalChain([options, 'optionalAccess', _9 => _9.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _10 => _10.typeCheck]) && !_optionalChain([options, 'optionalAccess', _11 => _11.typeCheck, 'call', _12 => _12(parsed)]))
-      throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
+var dateReviver = (_key, value) => {
+  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
   }
+  return value;
 };
+var composeJSONReplacers = (...replacers) => {
+  const filteredReplacers = replacers.filter((r) => r !== void 0);
+  if (filteredReplacers.length === 0) return void 0;
+  return (key, value) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredReplacers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, replacer) => replacer(key, accValue),
+      value
+    )
+  );
+};
+var composeJSONRevivers = (...revivers) => {
+  const filteredRevivers = revivers.filter((r) => r !== void 0);
+  if (filteredRevivers.length === 0) return void 0;
+  return (key, value, context) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredRevivers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, reviver) => reviver(key, accValue, context),
+      value
+    )
+  );
+};
+var JSONReplacer = (opts) => composeJSONReplacers(
+  _optionalChain([opts, 'optionalAccess', _8 => _8.replacer]),
+  _optionalChain([opts, 'optionalAccess', _9 => _9.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _10 => _10.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  _optionalChain([opts, 'optionalAccess', _11 => _11.reviver]),
+  _optionalChain([opts, 'optionalAccess', _12 => _12.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _13 => _13.parseDates]) === true ? JSONRevivers.date : void 0
+);
+var JSONReplacers = {
+  bigInt: bigIntReplacer,
+  date: dateReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, serializerOptions) => JSON.stringify(
+      object,
+      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
+    ),
+    deserialize: (payload, deserializerOptions) => JSON.parse(
+      payload,
+      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
+    )
+  };
+};
+var JSONSerializer = Object.assign(jsonSerializer(), {
+  from: (options) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.serialization, 'optionalAccess', _15 => _15.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _16 => _16.serialization, 'optionalAccess', _17 => _17.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _18 => _18.serialization, 'optionalAccess', _19 => _19.options])) : JSONSerializer)))
+});
 var asyncRetry = async (fn, opts) => {
   if (opts === void 0 || opts.retries === 0) return fn();
   return _asyncretry2.default.call(void 0, 
     async (bail) => {
       try {
         const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _14 => _14.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+        if (_optionalChain([opts, 'optionalAccess', _20 => _20.shouldRetryResult]) && opts.shouldRetryResult(result)) {
           throw new EmmettError(
-            `Retrying because of result: ${JSONParser.stringify(result)}`
+            `Retrying because of result: ${JSONSerializer.serialize(result)}`
           );
         }
         return result;
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
+      } catch (error) {
+        if (_optionalChain([opts, 'optionalAccess', _21 => _21.shouldRetryError]) && !opts.shouldRetryError(error)) {
+          bail(error);
           return void 0;
         }
-        throw error2;
+        throw error;
       }
     },
     _nullishCoalesce(opts, () => ( { retries: 0 }))
@@ -370,11 +454,11 @@ var operationResult = (result, options) => {
       const { operationName, collectionName } = options;
       if (!successful)
         throw new ConcurrencyInMemoryDatabaseError(
-          _nullishCoalesce(errorMessage, () => ( `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONParser.stringify(result)}!`))
+          _nullishCoalesce(errorMessage, () => ( `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`))
         );
     }
   };
-  if (_optionalChain([options, 'access', _16 => _16.errors, 'optionalAccess', _17 => _17.throwOnOperationFailures]))
+  if (_optionalChain([options, 'access', _22 => _22.errors, 'optionalAccess', _23 => _23.throwOnOperationFailures]))
     operationResult2.assertSuccessful();
   return operationResult2;
 };
@@ -419,14 +503,14 @@ var getInMemoryDatabase = () => {
         findOne: (predicate) => {
           ensureCollectionCreated();
           const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _18 => _18.filter, 'call', _19 => _19((doc) => predicate(doc))]) : documentsInCollection;
-          const firstOne = _nullishCoalesce(_optionalChain([filteredDocuments, 'optionalAccess', _20 => _20[0]]), () => ( null));
+          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _24 => _24.filter, 'call', _25 => _25((doc) => predicate(doc))]) : documentsInCollection;
+          const firstOne = _nullishCoalesce(_optionalChain([filteredDocuments, 'optionalAccess', _26 => _26[0]]), () => ( null));
           return Promise.resolve(firstOne);
         },
         find: (predicate) => {
           ensureCollectionCreated();
           const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _21 => _21.filter, 'call', _22 => _22((doc) => predicate(doc))]) : documentsInCollection;
+          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _27 => _27.filter, 'call', _28 => _28((doc) => predicate(doc))]) : documentsInCollection;
           return Promise.resolve(filteredDocuments);
         },
         deleteOne: (predicate) => {
@@ -498,7 +582,7 @@ var getInMemoryDatabase = () => {
             );
           }
           const existing = documentsInCollection[firstIndex];
-          if (typeof _optionalChain([options, 'optionalAccess', _23 => _23.expectedVersion]) === "bigint" && existing._version !== options.expectedVersion) {
+          if (typeof _optionalChain([options, 'optionalAccess', _29 => _29.expectedVersion]) === "bigint" && existing._version !== options.expectedVersion) {
             return Promise.resolve(
               operationResult(
                 {
@@ -666,12 +750,13 @@ var reactor = (options) => {
     id: processorId,
     instanceId,
     type,
+    canHandle,
     init,
     start: async (startOptions) => {
       if (isActive) return;
       await init(startOptions);
       isActive = true;
-      closeSignal = onShutdown(() => close({}));
+      closeSignal = onShutdown(() => close(startOptions));
       if (lastCheckpoint !== null)
         return {
           lastCheckpoint
@@ -682,7 +767,7 @@ var reactor = (options) => {
         }
         if (startFrom && startFrom !== "CURRENT") return startFrom;
         if (checkpoints) {
-          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _24 => _24.read, 'call', _25 => _25(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _30 => _30.read, 'call', _31 => _31(
             {
               processorId,
               partition
@@ -710,7 +795,7 @@ var reactor = (options) => {
           const upcasted = upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
-            _optionalChain([options, 'access', _26 => _26.messageOptions, 'optionalAccess', _27 => _27.schema, 'optionalAccess', _28 => _28.versioning])
+            _optionalChain([options, 'access', _32 => _32.messageOptions, 'optionalAccess', _33 => _33.schema, 'optionalAccess', _34 => _34.versioning])
           );
           if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
             continue;
@@ -763,13 +848,13 @@ var projector = (options) => {
     processorId,
     messageOptions: options.projection.eventsOptions,
     hooks: {
-      onInit: _optionalChain([options, 'access', _29 => _29.hooks, 'optionalAccess', _30 => _30.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart]) ? async (context) => {
+      onInit: _optionalChain([options, 'access', _35 => _35.hooks, 'optionalAccess', _36 => _36.onInit]),
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _37 => _37.hooks, 'optionalAccess', _38 => _38.onStart]) ? async (context) => {
         if (options.truncateOnStart && options.projection.truncate)
           await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _33 => _33.hooks, 'optionalAccess', _34 => _34.onStart])) await _optionalChain([options, 'access', _35 => _35.hooks, 'optionalAccess', _36 => _36.onStart, 'call', _37 => _37(context)]);
+        if (_optionalChain([options, 'access', _39 => _39.hooks, 'optionalAccess', _40 => _40.onStart])) await _optionalChain([options, 'access', _41 => _41.hooks, 'optionalAccess', _42 => _42.onStart, 'call', _43 => _43(context)]);
       } : void 0,
-      onClose: _optionalChain([options, 'access', _38 => _38.hooks, 'optionalAccess', _39 => _39.onClose])
+      onClose: _optionalChain([options, 'access', _44 => _44.hooks, 'optionalAccess', _45 => _45.onClose])
     },
     eachMessage: async (event2, context) => projection2.handle([event2], context)
   });
@@ -779,7 +864,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', _40 => _40.lastCheckpoint]), () => ( null))
+        lastCheckpoint: _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _46 => _46.lastCheckpoint]), () => ( null))
       });
     },
     store: async (context, { database }) => {
@@ -790,7 +875,7 @@ var inMemoryCheckpointer = () => {
       const checkpoint = await checkpoints.findOne(
         (d) => d._id === processorId
       );
-      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _41 => _41.lastCheckpoint]), () => ( null));
+      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _47 => _47.lastCheckpoint]), () => ( null));
       const newCheckpoint = getCheckpoint(message2);
       if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
         return {
@@ -810,7 +895,7 @@ var inMemoryCheckpointer = () => {
 var inMemoryProcessingScope = (options) => {
   const processorDatabase = options.database;
   const processingScope = (handler, partialContext) => {
-    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _42 => _42.database])));
+    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _48 => _48.database])));
     if (!database)
       throw new EmmettError(
         `InMemory processor '${options.processorId}' is missing database. Ensure that you passed it through options`
@@ -820,12 +905,12 @@ var inMemoryProcessingScope = (options) => {
   return processingScope;
 };
 var inMemoryProjector = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _43 => _43.connectionOptions, 'optionalAccess', _44 => _44.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _49 => _49.connectionOptions, 'optionalAccess', _50 => _50.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    onInit: _optionalChain([options, 'access', _45 => _45.hooks, 'optionalAccess', _46 => _46.onInit]),
-    onStart: _optionalChain([options, 'access', _47 => _47.hooks, 'optionalAccess', _48 => _48.onStart]),
-    onClose: _optionalChain([options, 'access', _49 => _49.hooks, 'optionalAccess', _50 => _50.onClose]) ? async (context) => {
-      if (_optionalChain([options, 'access', _51 => _51.hooks, 'optionalAccess', _52 => _52.onClose])) await _optionalChain([options, 'access', _53 => _53.hooks, 'optionalAccess', _54 => _54.onClose, 'call', _55 => _55(context)]);
+    onInit: _optionalChain([options, 'access', _51 => _51.hooks, 'optionalAccess', _52 => _52.onInit]),
+    onStart: _optionalChain([options, 'access', _53 => _53.hooks, 'optionalAccess', _54 => _54.onStart]),
+    onClose: _optionalChain([options, 'access', _55 => _55.hooks, 'optionalAccess', _56 => _56.onClose]) ? async (context) => {
+      if (_optionalChain([options, 'access', _57 => _57.hooks, 'optionalAccess', _58 => _58.onClose])) await _optionalChain([options, 'access', _59 => _59.hooks, 'optionalAccess', _60 => _60.onClose, 'call', _61 => _61(context)]);
     } : void 0
   };
   const processor = projector({
@@ -840,11 +925,11 @@ var inMemoryProjector = (options) => {
   return Object.assign(processor, { database });
 };
 var inMemoryReactor = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _56 => _56.connectionOptions, 'optionalAccess', _57 => _57.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _62 => _62.connectionOptions, 'optionalAccess', _63 => _63.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    onInit: _optionalChain([options, 'access', _58 => _58.hooks, 'optionalAccess', _59 => _59.onInit]),
-    onStart: _optionalChain([options, 'access', _60 => _60.hooks, 'optionalAccess', _61 => _61.onStart]),
-    onClose: _optionalChain([options, 'access', _62 => _62.hooks, 'optionalAccess', _63 => _63.onClose])
+    onInit: _optionalChain([options, 'access', _64 => _64.hooks, 'optionalAccess', _65 => _65.onInit]),
+    onStart: _optionalChain([options, 'access', _66 => _66.hooks, 'optionalAccess', _67 => _67.onStart]),
+    onClose: _optionalChain([options, 'access', _68 => _68.hooks, 'optionalAccess', _69 => _69.onClose])
   };
   const processor = reactor({
     ...options,
@@ -858,7 +943,7 @@ var inMemoryReactor = (options) => {
   return Object.assign(processor, { database });
 };
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _64 => _64.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _70 => _70.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -876,14 +961,14 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _65 => _65.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _71 => _71.downcast]))
     return recordedMessages;
   return recordedMessages.map(
     (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
   );
 };
 var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _66 => _66.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _72 => _72.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -935,7 +1020,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   return {
     async aggregateStream(streamName, options) {
       const { evolve, initialState, read } = options;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _67 => _67.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _73 => _73.expectedStreamVersion]);
       let state = initialState();
       let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
       let lastEventGlobalPosition = void 0;
@@ -950,11 +1035,11 @@ var getEventStoreDBEventStore = (eventStore) => {
             state,
             upcastRecordedMessage(
               mapFromESDBEvent(resolvedEvent),
-              _optionalChain([options, 'optionalAccess', _68 => _68.read, 'optionalAccess', _69 => _69.schema, 'optionalAccess', _70 => _70.versioning])
+              _optionalChain([options, 'optionalAccess', _74 => _74.read, 'optionalAccess', _75 => _75.schema, 'optionalAccess', _76 => _76.versioning])
             )
           );
           currentStreamVersion = event.revision;
-          lastEventGlobalPosition = _optionalChain([event, 'access', _71 => _71.position, 'optionalAccess', _72 => _72.commit]);
+          lastEventGlobalPosition = _optionalChain([event, 'access', _77 => _77.position, 'optionalAccess', _78 => _78.commit]);
         }
         assertExpectedVersionMatchesCurrent(
           currentStreamVersion,
@@ -995,7 +1080,7 @@ var getEventStoreDBEventStore = (eventStore) => {
           events.push(
             upcastRecordedMessage(
               mapFromESDBEvent(resolvedEvent),
-              _optionalChain([options, 'optionalAccess', _73 => _73.schema, 'optionalAccess', _74 => _74.versioning])
+              _optionalChain([options, 'optionalAccess', _79 => _79.schema, 'optionalAccess', _80 => _80.versioning])
             )
           );
           currentStreamVersion = event.revision;
@@ -1020,11 +1105,11 @@ var getEventStoreDBEventStore = (eventStore) => {
       try {
         const eventsToStore = downcastRecordedMessages(
           events,
-          _optionalChain([options, 'optionalAccess', _75 => _75.schema, 'optionalAccess', _76 => _76.versioning])
+          _optionalChain([options, 'optionalAccess', _81 => _81.schema, 'optionalAccess', _82 => _82.versioning])
         );
         const serializedEvents = eventsToStore.map(_dbclient.jsonEvent);
         const expectedRevision = toExpectedRevision(
-          _optionalChain([options, 'optionalAccess', _77 => _77.expectedStreamVersion])
+          _optionalChain([options, 'optionalAccess', _83 => _83.expectedStreamVersion])
         );
         const appendResult = await eventStore.appendToStream(
           streamName,
@@ -1071,7 +1156,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   };
 };
 var getESDBCheckpoint = (resolvedEvent, from) => {
-  return !from || _optionalChain([from, 'optionalAccess', _78 => _78.stream]) === $all ? _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _79 => _79.link, 'optionalAccess', _80 => _80.position, 'optionalAccess', _81 => _81.commit]), () => ( _optionalChain([resolvedEvent, 'access', _82 => _82.event, 'optionalAccess', _83 => _83.position, 'optionalAccess', _84 => _84.commit]))) : _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _85 => _85.link, 'optionalAccess', _86 => _86.revision]), () => ( resolvedEvent.event.revision));
+  return !from || _optionalChain([from, 'optionalAccess', _84 => _84.stream]) === $all ? _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _85 => _85.link, 'optionalAccess', _86 => _86.position, 'optionalAccess', _87 => _87.commit]), () => ( _optionalChain([resolvedEvent, 'access', _88 => _88.event, 'optionalAccess', _89 => _89.position, 'optionalAccess', _90 => _90.commit]))) : _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _91 => _91.link, 'optionalAccess', _92 => _92.revision]), () => ( resolvedEvent.event.revision));
 };
 var mapFromESDBEvent = (resolvedEvent, from) => {
   const event = resolvedEvent.event;
@@ -1114,7 +1199,7 @@ var toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.STAR
 };
 var toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.START : startFrom === "END" ? _dbclient.END : parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint);
 var subscribe = (client, from, options) => from == void 0 || from.stream == $all ? client.subscribeToAll({
-  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _87 => _87.options]), () => ( {})),
+  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _93 => _93.options]), () => ( {})),
   fromPosition: toGlobalPosition(options.startFrom),
   filter: _dbclient.excludeSystemEvents.call(void 0, )
 }) : client.subscribeToStream(from.stream, {
@@ -1173,7 +1258,7 @@ var eventStoreDBSubscription = ({
   let start;
   let processor;
   let subscription;
-  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _88 => _88.resubscribeOptions]), () => ( {
+  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _94 => _94.resubscribeOptions]), () => ( {
     ...EventStoreDBResubscribeDefaultOptions,
     shouldRetryResult: () => isRunning,
     shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
@@ -1195,7 +1280,7 @@ var eventStoreDBSubscription = ({
           return;
         }
         console.info(
-          `Starting subscription. ${retry2++} retries. From: ${JSONParser.stringify(_nullishCoalesce(from, () => ( "$all")))}, Start from: ${JSONParser.stringify(
+          `Starting subscription. ${retry2++} retries. From: ${JSONSerializer.serialize(_nullishCoalesce(from, () => ( "$all")))}, Start from: ${JSONSerializer.serialize(
             options.startFrom
           )}`
         );
@@ -1239,7 +1324,7 @@ var eventStoreDBSubscription = ({
                 return;
               }
               console.error(
-                `Received error: ${JSONParser.stringify(error)}.`
+                `Received error: ${JSONSerializer.serialize(error)}.`
               );
               reject(error);
             });
@@ -1296,9 +1381,9 @@ var eventStoreDBEventStoreConsumer = (options) => {
         return await s.handle(messagesBatch, { client });
       })
     );
-    const error = _optionalChain([result, 'access', _89 => _89.find, 'call', _90 => _90((r) => r.status === "rejected"), 'optionalAccess', _91 => _91.reason]);
+    const error = _optionalChain([result, 'access', _95 => _95.find, 'call', _96 => _96((r) => r.status === "rejected"), 'optionalAccess', _97 => _97.reason]);
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _92 => _92.value, 'optionalAccess', _93 => _93.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _98 => _98.value, 'optionalAccess', _99 => _99.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP",
       error: error ? EmmettError.mapFrom(error) : void 0
@@ -1308,7 +1393,7 @@ var eventStoreDBEventStoreConsumer = (options) => {
     client,
     from: options.from,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _94 => _94.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _100 => _100.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
     resilience: options.resilience
   });
   const stop = async () => {