@event-driven-io/emmett-mongodb 0.36.0 → 0.37.0

package/dist/index.cjs

@@ -182,22 +182,6 @@ var deepEquals = (left, right) => {
 var isEquatable = (left) => {
   return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return _asyncretry2.default.call(void 0, 
-    async (bail) => {
-      try {
-        return await fn();
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _13 => _13.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
-        }
-        throw error2;
-      }
-    },
-    _nullishCoalesce(opts, () => ( { retries: 0 }))
-  );
-};
 var ParseError = class extends Error {
   constructor(text) {
     super(`Cannot parse! ${text}`);
@@ -206,19 +190,41 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _14 => _14.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _13 => _13.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', _15 => _15.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _16 => _16.typeCheck]) && !_optionalChain([options, 'optionalAccess', _17 => _17.typeCheck, 'call', _18 => _18(parsed)]))
+    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _14 => _14.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _15 => _15.typeCheck]) && !_optionalChain([options, 'optionalAccess', _16 => _16.typeCheck, 'call', _17 => _17(parsed)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _19 => _19.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _18 => _18.map]) ? options.map(parsed) : parsed;
   }
 };
+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', _19 => _19.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONParser.stringify(result)}`
+          );
+        }
+        return result;
+      } catch (error2) {
+        if (_optionalChain([opts, 'optionalAccess', _20 => _20.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
 var filterProjections = (type, projections2) => {
   const inlineProjections2 = projections2.filter((projection2) => projection2.type === type).map(({ projection: projection2 }) => projection2);
   const duplicateRegistrations = arrayUtils.getDuplicates(
@@ -524,18 +530,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', _21 => _21.toString, 'call', _22 => _22()])}`
                     );
                     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', _23 => _23.toString, 'call', _24 => _24()])}`
                   );
                   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', _25 => _25.toString, 'call', _26 => _26()])}`
                     );
                   }
                 } finally {
@@ -705,7 +711,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async readStream(streamName, options) {
     const { streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _27 => _27.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const filter2 = {
       streamName: { $eq: streamName }
@@ -746,7 +752,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
   }
   async aggregateStream(streamName, options) {
-    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _27 => _27.read]));
+    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _28 => _28.read]));
     const state = stream.events.reduce(options.evolve, options.initialState());
     return {
       state,
@@ -756,7 +762,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async appendToStream(streamName, events, options) {
     const { streamId, streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _28 => _28.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _29 => _29.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const stream = await collection.findOne(
       { streamName: { $eq: streamName } },
@@ -768,7 +774,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         }
       }
     );
-    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _29 => _29.metadata, 'access', _30 => _30.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
+    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _30 => _30.metadata, 'access', _31 => _31.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
     assertExpectedVersionMatchesCurrent(
       currentStreamVersion,
       expectedStreamVersion,
@@ -806,7 +812,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
     if (this.inlineProjections) {
       await handleInlineProjections({
-        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _31 => _31.projections]), () => ( {})),
+        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _32 => _32.projections]), () => ( {})),
         streamId,
         events: eventsToAppend,
         projections: this.inlineProjections,
@@ -826,7 +832,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     if (!updatedStream) {
       throw new ExpectedVersionConflictError(
         currentStreamVersion,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.expectedStreamVersion]), () => ( 0n))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.expectedStreamVersion]), () => ( 0n))
       );
     }
     await tryPublishMessagesAfterCommit(
@@ -877,7 +883,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _33 => _33.projections, 'optionalAccess', _34 => _34[projectionName]]), () => ( null));
+    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _34 => _34.projections, 'optionalAccess', _35 => _35[projectionName]]), () => ( null));
   }
   async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
     const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
@@ -902,13 +908,13 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    if (_optionalChain([queryOptions, 'optionalAccess', _35 => _35.skip])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _36 => _36.skip])) {
       query = query.skip(queryOptions.skip);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _36 => _36.limit])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _37 => _37.limit])) {
       query = query.limit(queryOptions.limit);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _37 => _37.sort])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _38 => _38.sort])) {
       const sort = prependMongoFilterWithProjectionPrefix(
         queryOptions.sort,
         prefix