@event-driven-io/emmett-mongodb 0.23.0 → 0.24.0

package/dist/index.cjs

@@ -47,6 +47,16 @@ var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefa
 
 
 
+async function tryPublishMessagesAfterCommit(messages, options, context) {
+  if (_optionalChain([options, 'optionalAccess', _4 => _4.onAfterCommit]) === void 0) return false;
+  try {
+    await _optionalChain([options, 'optionalAccess', _5 => _5.onAfterCommit, 'call', _6 => _6(messages, context)]);
+    return true;
+  } catch (error2) {
+    console.error(`Error in on after commit hook`, error2);
+    return false;
+  }
+}
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -63,7 +73,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', _7 => _7.toString, 'call', _8 => _8()]), _optionalChain([expected, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -77,9 +87,9 @@ var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfi
       }
     });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.streamId]), () => ( _uuid.v4.call(void 0, )));
     this.onNoActiveReaderCallback = onNoActiveReaderCallback;
-    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _12 => _12.intervalCheckInMs]), () => ( 20)));
   }
   __init() {this.checkInterval = null}
   
@@ -178,7 +188,7 @@ var asyncRetry = async (fn, opts) => {
       try {
         return await fn();
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _13 => _13.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
         }
         throw error2;
@@ -195,17 +205,17 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _11 => _11.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _14 => _14.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)]))
+    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)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _19 => _19.map]) ? options.map(parsed) : parsed;
   }
 };
 var filterProjections = (type, projections2) => {
@@ -507,18 +517,18 @@ var MongoDBInlineProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _17 => _17.toString, 'call', _18 => _18()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _19 => _19.toString, 'call', _20 => _20()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _21 => _21.toString, 'call', _22 => _22()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _24 => _24.toString, 'call', _25 => _25()])}`
                     );
                   }
                 } finally {
@@ -665,7 +675,9 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   __init5() {this.isClosed = false}
   
   
+  
   constructor(options) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);
+    this.options = options;
     this.client = "client" in options && options.client ? options.client : new (0, _mongodb.MongoClient)(options.connectionString, options.clientOptions);
     this.shouldManageClientLifetime = !("client" in options);
     this.storage = mongoDBEventStoreStorage({
@@ -686,7 +698,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async readStream(streamName, options) {
     const { streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _23 => _23.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const filter2 = {
       streamName: { $eq: streamName }
@@ -727,7 +739,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
   }
   async aggregateStream(streamName, options) {
-    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _24 => _24.read]));
+    const stream = await this.readStream(streamName, _optionalChain([options, 'optionalAccess', _27 => _27.read]));
     const state = stream.events.reduce(options.evolve, options.initialState());
     return {
       state,
@@ -737,7 +749,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
   }
   async appendToStream(streamName, events, options) {
     const { streamId, streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _25 => _25.expectedStreamVersion]);
+    const expectedStreamVersion = _optionalChain([options, 'optionalAccess', _28 => _28.expectedStreamVersion]);
     const collection = await this.storage.collectionFor(streamType);
     const stream = await collection.findOne(
       { streamName: { $eq: streamName } },
@@ -749,7 +761,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         }
       }
     );
-    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _26 => _26.metadata, 'access', _27 => _27.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
+    const currentStreamVersion = _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _29 => _29.metadata, 'access', _30 => _30.streamPosition]), () => ( MongoDBEventStoreDefaultStreamVersion));
     assertExpectedVersionMatchesCurrent(
       currentStreamVersion,
       expectedStreamVersion,
@@ -787,7 +799,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     };
     if (this.inlineProjections) {
       await handleInlineProjections({
-        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _28 => _28.projections]), () => ( {})),
+        readModels: _nullishCoalesce(_optionalChain([stream, 'optionalAccess', _31 => _31.projections]), () => ( {})),
         streamId,
         events: eventsToAppend,
         projections: this.inlineProjections,
@@ -807,9 +819,17 @@ var MongoDBEventStoreImplementation = (_class4 = class {
     if (!updatedStream) {
       throw new ExpectedVersionConflictError(
         currentStreamVersion,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.expectedStreamVersion]), () => ( 0n))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.expectedStreamVersion]), () => ( 0n))
       );
     }
+    await tryPublishMessagesAfterCommit(
+      // @ts-expect-error Issues with `globalPosition` not being present causing the type for metadata to expect `never`
+      eventsToAppend,
+      this.options.hooks
+      // {
+      // TODO: same context as InlineProjectionHandlerContext for mongodb?
+      // },
+    );
     return {
       nextExpectedStreamVersion: currentStreamVersion + BigInt(eventsToAppend.length),
       createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
@@ -851,7 +871,7 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _30 => _30.projections, 'optionalAccess', _31 => _31[projectionName]]), () => ( null));
+    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _33 => _33.projections, 'optionalAccess', _34 => _34[projectionName]]), () => ( null));
   }
   async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
     const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
@@ -876,13 +896,13 @@ var MongoDBEventStoreImplementation = (_class4 = class {
         projection: { [`projections.${projectionName}`]: 1 }
       }
     );
-    if (_optionalChain([queryOptions, 'optionalAccess', _32 => _32.skip])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _35 => _35.skip])) {
       query = query.skip(queryOptions.skip);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _33 => _33.limit])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _36 => _36.limit])) {
       query = query.limit(queryOptions.limit);
     }
-    if (_optionalChain([queryOptions, 'optionalAccess', _34 => _34.sort])) {
+    if (_optionalChain([queryOptions, 'optionalAccess', _37 => _37.sort])) {
       const sort = prependMongoFilterWithProjectionPrefix(
         queryOptions.sort,
         prefix