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

package/dist/index.cjs

@@ -38,7 +38,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;
@@ -49,16 +49,18 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
+
 async function tryPublishMessagesAfterCommit(messages, options, context) {
-  if (_optionalChain([options, 'optionalAccess', _4 => _4.onAfterCommit]) === void 0) return false;
+  if (_optionalChain([options, 'optionalAccess', _3 => _3.onAfterCommit]) === void 0) return false;
   try {
-    await _optionalChain([options, 'optionalAccess', _5 => _5.onAfterCommit, 'call', _6 => _6(messages, context)]);
+    await _optionalChain([options, 'optionalAccess', _4 => _4.onAfterCommit, 'call', _5 => _5(messages, context)]);
     return true;
-  } catch (error2) {
-    console.error(`Error in on after commit hook`, error2);
+  } catch (error) {
+    console.error(`Error in on after commit hook`, error);
     return false;
   }
 }
@@ -81,7 +83,7 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _7 => _7.toString, 'call', _8 => _8()]), _optionalChain([expected, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10()]));
+    super(_optionalChain([current, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]), _optionalChain([expected, 'optionalAccess', _8 => _8.toString, 'call', _9 => _9()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -324,27 +326,109 @@ 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 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', _10 => _10.source]), () => ( value.toString())));
+    } catch (e2) {
+      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 (e3) {
+        }
+      }
+    }
+  }
+  return value;
 };
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _11 => _11.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', _12 => _12.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
-      throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _16 => _16.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', _11 => _11.replacer]),
+  _optionalChain([opts, 'optionalAccess', _12 => _12.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _13 => _13.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  _optionalChain([opts, 'optionalAccess', _14 => _14.reviver]),
+  _optionalChain([opts, 'optionalAccess', _15 => _15.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _16 => _16.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', _17 => _17.serialization, 'optionalAccess', _18 => _18.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _19 => _19.serialization, 'optionalAccess', _20 => _20.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _21 => _21.serialization, 'optionalAccess', _22 => _22.options])) : JSONSerializer)))
+});
 var textEncoder = new TextEncoder();
 var AssertionError = class extends Error {
   constructor(message2) {
@@ -374,7 +458,7 @@ function assertOk(obj, message2) {
   if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
 }
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _17 => _17.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _23 => _23.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -392,7 +476,7 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _18 => _18.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _24 => _24.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -410,7 +494,7 @@ var upcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var upcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _19 => _19.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _25 => _25.upcast]))
     return recordedMessages;
   return recordedMessages.map(
     (recordedMessage) => upcastRecordedMessage(recordedMessage, options)
@@ -425,7 +509,7 @@ var filterProjections = (type, projections2) => {
   if (duplicateRegistrations.length > 0) {
     throw new EmmettError(`You cannot register multiple projections with the same name (or without the name).
       Ensure that:
-      ${JSONParser.stringify(duplicateRegistrations)}
+      ${JSONSerializer.serialize(duplicateRegistrations)}
       have different names`);
   }
   return inlineProjections2;
@@ -553,18 +637,18 @@ var MongoDBInlineProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _26 => _26.toString, 'call', _27 => _27()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _28 => _28.toString, 'call', _29 => _29()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _24 => _24.toString, 'call', _25 => _25()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()])}`
                     );
                   }
                 } finally {
@@ -734,7 +818,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
   }
   async readStream(streamName, options) {
     const { streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _32 => _32.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const filter = {
       streamName: { $eq: streamName }
@@ -770,7 +854,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
     );
     const events = upcastRecordedMessages(
       stream.messages,
-      _optionalChain([options, 'optionalAccess', _27 => _27.schema, 'optionalAccess', _28 => _28.versioning])
+      _optionalChain([options, 'optionalAccess', _33 => _33.schema, 'optionalAccess', _34 => _34.versioning])
     );
     return {
       events,
@@ -781,7 +865,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
   async aggregateStream(streamName, options) {
     const stream = await this.readStream(
       streamName,
-      _optionalChain([options, 'optionalAccess', _29 => _29.read])
+      _optionalChain([options, 'optionalAccess', _35 => _35.read])
     );
     const { evolve, initialState } = options;
     const state = stream.events.reduce(evolve, initialState());
@@ -793,7 +877,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
   }
   async appendToStream(streamName, events, options) {
     const { streamId, streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _30 => _30.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _36 => _36.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const stream = await collection.findOne(
       { streamName: { $eq: streamName } },
@@ -805,7 +889,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
         }
       }
     );
-    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _31 => _31.metadata, 'access', _32 => _32.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
+    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _37 => _37.metadata, 'access', _38 => _38.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
     assertExpectedVersionMatchesCurrent(
       currentStreamVersion,
       expectedStreamVersion,
@@ -827,7 +911,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
             ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
           }
         },
-        _optionalChain([options, 'optionalAccess', _33 => _33.schema, 'optionalAccess', _34 => _34.versioning])
+        _optionalChain([options, 'optionalAccess', _39 => _39.schema, 'optionalAccess', _40 => _40.versioning])
       );
     });
     const now = /* @__PURE__ */ new Date();
@@ -846,7 +930,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
     };
     if (this.inlineProjections) {
       await handleInlineProjections({
-        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _35 => _35.projections]), () => ( {})),
+        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _41 => _41.projections]), () => ( {})),
         streamId,
         events: eventsToAppend,
         projections: this.inlineProjections,
@@ -866,7 +950,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
     if (!updatedStream) {
       throw new ExpectedVersionConflictError(
         currentStreamVersion,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.expectedStreamVersion]), () => ( 0n))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _42 => _42.expectedStreamVersion]), () => ( 0n))
       );
     }
     await tryPublishMessagesAfterCommit(
@@ -929,7 +1013,7 @@ var MongoDBEventStoreImplementation = (_class2 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _37 => _37.projections, 'optionalAccess', _38 => _38[projectionName]]), () => ( null));
+    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _43 => _43.projections, 'optionalAccess', _44 => _44[projectionName]]), () => ( null));
   }
   async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
     const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
@@ -954,13 +1038,13 @@ var MongoDBEventStoreImplementation = (_class2 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    if (_optionalChain([queryOptions, 'optionalAccess', _39 => _39.skip])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _45 => _45.skip])) {
       query = query.skip(queryOptions.skip);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _40 => _40.limit])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _46 => _46.limit])) {
       query = query.limit(queryOptions.limit);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _41 => _41.sort])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _47 => _47.sort])) {
       const sort = prependMongoFilterWithProjectionPrefix(
         queryOptions.sort,
         prefix