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

package/dist/index.cjs

@@ -1,6 +1,5 @@
 "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 = class _EmmettError extends Error {
   static __initStatic() {this.Codes = {
@@ -35,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;
@@ -55,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`;
@@ -77,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);
   }
 };
@@ -282,45 +283,131 @@ var deepEquals = (left, right) => {
 var isEquatable = (left) => {
   return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+var toNormalizedString = (value) => value.toString().padStart(19, "0");
+var bigInt = {
+  toNormalizedString
+};
+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 }))
@@ -367,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;
 };
@@ -416,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) => {
@@ -495,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(
                 {
@@ -600,73 +687,20 @@ var getInMemoryDatabase = () => {
     }
   };
 };
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _24 => _24.downcast]))
-    return recordedMessage;
-  const downcasted = options.downcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: downcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in downcasted ? downcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _25 => _25.downcast]))
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _26 => _26.upcast]))
-    return recordedMessage;
-  const upcasted = options.upcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: upcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in upcasted ? upcasted.metadata : {}
-      }
-    } : {}
-  };
-};
 var getCheckpoint = (message2) => {
-  return "checkpoint" in message2.metadata ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.checkpoint
-  ) : "globalPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.globalPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.globalPosition
-  ) : "streamPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.streamPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.streamPosition
-  ) : null;
+  return message2.metadata.checkpoint;
 };
 var wasMessageHandled = (message2, checkpoint) => {
   const messageCheckpoint = getCheckpoint(message2);
-  const checkpointBigint = checkpoint;
-  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpointBigint !== null && checkpointBigint !== void 0 && messageCheckpoint <= checkpointBigint;
+  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
 };
 var MessageProcessorType = {
   PROJECTOR: "projector",
   REACTOR: "reactor"
 };
 var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+var bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
+var parseBigIntProcessorCheckpoint = (value) => BigInt(value);
 var defaultProcessorVersion = 1;
 var defaultProcessorPartition = defaultTag;
 var getProcessorInstanceId = (processorId) => `${processorId}:${_uuid.v7.call(void 0, )}`;
@@ -716,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
@@ -732,7 +767,7 @@ var reactor = (options) => {
         }
         if (startFrom && startFrom !== "CURRENT") return startFrom;
         if (checkpoints) {
-          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _27 => _27.read, 'call', _28 => _28(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _30 => _30.read, 'call', _31 => _31(
             {
               processorId,
               partition
@@ -760,7 +795,7 @@ var reactor = (options) => {
           const upcasted = upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
-            _optionalChain([options, 'access', _29 => _29.messageOptions, 'optionalAccess', _30 => _30.schema, 'optionalAccess', _31 => _31.versioning])
+            _optionalChain([options, 'access', _32 => _32.messageOptions, 'optionalAccess', _33 => _33.schema, 'optionalAccess', _34 => _34.versioning])
           );
           if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
             continue;
@@ -813,13 +848,13 @@ var projector = (options) => {
     processorId,
     messageOptions: options.projection.eventsOptions,
     hooks: {
-      onInit: _optionalChain([options, 'access', _32 => _32.hooks, 'optionalAccess', _33 => _33.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _34 => _34.hooks, 'optionalAccess', _35 => _35.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', _36 => _36.hooks, 'optionalAccess', _37 => _37.onStart])) await _optionalChain([options, 'access', _38 => _38.hooks, 'optionalAccess', _39 => _39.onStart, 'call', _40 => _40(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', _41 => _41.hooks, 'optionalAccess', _42 => _42.onClose])
+      onClose: _optionalChain([options, 'access', _44 => _44.hooks, 'optionalAccess', _45 => _45.onClose])
     },
     eachMessage: async (event2, context) => projection2.handle([event2], context)
   });
@@ -829,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', _43 => _43.lastCheckpoint]), () => ( null))
+        lastCheckpoint: _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _46 => _46.lastCheckpoint]), () => ( null))
       });
     },
     store: async (context, { database }) => {
@@ -840,7 +875,7 @@ var inMemoryCheckpointer = () => {
       const checkpoint = await checkpoints.findOne(
         (d) => d._id === processorId
       );
-      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _44 => _44.lastCheckpoint]), () => ( null));
+      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _47 => _47.lastCheckpoint]), () => ( null));
       const newCheckpoint = getCheckpoint(message2);
       if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
         return {
@@ -860,7 +895,7 @@ var inMemoryCheckpointer = () => {
 var inMemoryProcessingScope = (options) => {
   const processorDatabase = options.database;
   const processingScope = (handler, partialContext) => {
-    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _45 => _45.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`
@@ -870,12 +905,12 @@ var inMemoryProcessingScope = (options) => {
   return processingScope;
 };
 var inMemoryProjector = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _46 => _46.connectionOptions, 'optionalAccess', _47 => _47.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _49 => _49.connectionOptions, 'optionalAccess', _50 => _50.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    onInit: _optionalChain([options, 'access', _48 => _48.hooks, 'optionalAccess', _49 => _49.onInit]),
-    onStart: _optionalChain([options, 'access', _50 => _50.hooks, 'optionalAccess', _51 => _51.onStart]),
-    onClose: _optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onClose]) ? async (context) => {
-      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(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({
@@ -890,11 +925,11 @@ var inMemoryProjector = (options) => {
   return Object.assign(processor, { database });
 };
 var inMemoryReactor = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _59 => _59.connectionOptions, 'optionalAccess', _60 => _60.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _62 => _62.connectionOptions, 'optionalAccess', _63 => _63.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    onInit: _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onInit]),
-    onStart: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onStart]),
-    onClose: _optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.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,
@@ -907,6 +942,49 @@ var inMemoryReactor = (options) => {
   });
   return Object.assign(processor, { database });
 };
+var downcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _70 => _70.downcast]))
+    return recordedMessage;
+  const downcasted = options.downcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: downcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in downcasted ? downcasted.metadata : {}
+      }
+    } : {}
+  };
+};
+var downcastRecordedMessages = (recordedMessages, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _71 => _71.downcast]))
+    return recordedMessages;
+  return recordedMessages.map(
+    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
+  );
+};
+var upcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _72 => _72.upcast]))
+    return recordedMessage;
+  const upcasted = options.upcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: upcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in upcasted ? upcasted.metadata : {}
+      }
+    } : {}
+  };
+};
 
 // src/eventStore/consumers/eventStoreDBEventStoreConsumer.ts
 
@@ -942,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;
@@ -957,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,
@@ -1002,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;
@@ -1027,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,
@@ -1048,7 +1126,7 @@ var getEventStoreDBEventStore = (eventStore) => {
       } catch (error) {
         if (error instanceof _dbclient.WrongExpectedVersionError) {
           throw new ExpectedVersionConflictError(
-            error.actualVersion,
+            BigInt(error.actualVersion),
             toExpectedVersion(error.expectedVersion)
           );
         }
@@ -1077,8 +1155,8 @@ var getEventStoreDBEventStore = (eventStore) => {
     //streamEvents: streamEvents(eventStore),
   };
 };
-var getCheckpoint2 = (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));
+var getESDBCheckpoint = (resolvedEvent, from) => {
+  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;
@@ -1091,7 +1169,9 @@ var mapFromESDBEvent = (resolvedEvent, from) => {
       streamName: event.streamId,
       streamPosition: event.revision,
       globalPosition: event.position.commit,
-      checkpoint: getCheckpoint2(resolvedEvent, from)
+      checkpoint: bigIntProcessorCheckpoint(
+        getESDBCheckpoint(resolvedEvent, from)
+      )
     }
   };
 };
@@ -1114,12 +1194,12 @@ var toExpectedVersion = (expected) => {
 var DefaultEventStoreDBEventStoreProcessorBatchSize = 100;
 var DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = 50;
 var toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.START : startFrom === "END" ? _dbclient.END : {
-  prepare: startFrom.lastCheckpoint,
-  commit: startFrom.lastCheckpoint
+  prepare: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint),
+  commit: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint)
 };
-var toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.START : startFrom === "END" ? _dbclient.END : startFrom.lastCheckpoint;
+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, {
@@ -1178,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)
@@ -1200,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
           )}`
         );
@@ -1215,7 +1295,7 @@ var eventStoreDBSubscription = ({
         const handler = new class extends _stream.Writable {
           async _write(result, _encoding, done) {
             if (!isRunning) return;
-            if (isBigint(result)) {
+            if (isString(result)) {
               options.startFrom = {
                 lastCheckpoint: result
               };
@@ -1244,7 +1324,7 @@ var eventStoreDBSubscription = ({
                 return;
               }
               console.error(
-                `Received error: ${JSONParser.stringify(error)}.`
+                `Received error: ${JSONSerializer.serialize(error)}.`
               );
               reject(error);
             });
@@ -1301,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
@@ -1313,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 () => {