@event-driven-io/emmett-esdb 0.43.0-beta.12 → 0.43.0-beta.13

package/dist/index.cjs

@@ -719,7 +719,40 @@ var reactor = (options) => {
     canHandle,
     stopAfter
   } = options;
-  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
+  const isCustomBatch = "eachBatch" in options && !!options.eachBatch;
+  const eachBatch = isCustomBatch ? options.eachBatch : async (messages, context) => {
+    let result = void 0;
+    for (let i = 0; i < messages.length; i++) {
+      const message2 = messages[i];
+      const messageProcessingResult = await options.eachMessage(
+        message2,
+        context
+      );
+      if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+        result = {
+          ...messageProcessingResult,
+          lastSuccessfulMessage: messageProcessingResult.error ? messages[i - 1] : message2
+        };
+        break;
+      }
+      if (stopAfter && stopAfter(message2)) {
+        result = {
+          type: "STOP",
+          reason: "Stop condition reached",
+          lastSuccessfulMessage: message2
+        };
+        break;
+      }
+      if (messageProcessingResult && messageProcessingResult.type === "SKIP") {
+        result = {
+          ...messageProcessingResult,
+          lastSuccessfulMessage: message2
+        };
+        continue;
+      }
+    }
+    return result;
+  };
   let isInitiated = false;
   let isActive = false;
   let lastCheckpoint = null;
@@ -757,10 +790,11 @@ var reactor = (options) => {
       await init(startOptions);
       isActive = true;
       closeSignal = onShutdown(() => close(startOptions));
-      if (lastCheckpoint !== null)
+      if (lastCheckpoint !== null) {
         return {
           lastCheckpoint
         };
+      }
       return await processingScope(async (context) => {
         if (hooks.onStart) {
           await hooks.onStart(context);
@@ -789,46 +823,48 @@ var reactor = (options) => {
     handle: async (messages, partialContext) => {
       if (!isActive) return Promise.resolve();
       return await processingScope(async (context) => {
-        let result = void 0;
-        for (const message2 of messages) {
-          if (wasMessageHandled(message2, lastCheckpoint)) continue;
-          const upcasted = upcastRecordedMessage(
+        const messagesAboveCheckpoint = messages.filter(
+          (message2) => !wasMessageHandled(message2, lastCheckpoint)
+        );
+        const upcastedMessages = messagesAboveCheckpoint.map(
+          (message2) => upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
             _optionalChain([options, 'access', _32 => _32.messageOptions, 'optionalAccess', _33 => _33.schema, 'optionalAccess', _34 => _34.versioning])
+          )
+        ).filter(
+          (upcasted) => !canHandle || canHandle.includes(upcasted.type)
+        );
+        const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
+        const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
+        const batchResult = await eachBatch(unhandledMessages, context);
+        const messageProcessingResult = _optionalChain([batchResult, 'optionalAccess', _35 => _35.type]) === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+          type: "STOP",
+          reason: "Stop condition reached",
+          lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
+        } : batchResult;
+        const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
+        const checkpointMessage = _optionalChain([messageProcessingResult, 'optionalAccess', _36 => _36.type]) === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
+        if (checkpointMessage && checkpoints) {
+          const storeCheckpointResult = await checkpoints.store(
+            {
+              processorId,
+              version,
+              message: checkpointMessage,
+              lastCheckpoint,
+              partition
+            },
+            context
           );
-          if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
-            continue;
-          const messageProcessingResult = await eachMessage(upcasted, context);
-          if (checkpoints) {
-            const storeCheckpointResult = await checkpoints.store(
-              {
-                processorId,
-                version,
-                message: upcasted,
-                lastCheckpoint,
-                partition
-              },
-              context
-            );
-            if (storeCheckpointResult.success) {
-              lastCheckpoint = storeCheckpointResult.newCheckpoint;
-            }
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-            isActive = false;
-            result = messageProcessingResult;
-            break;
+          if (storeCheckpointResult.success) {
+            lastCheckpoint = storeCheckpointResult.newCheckpoint;
           }
-          if (stopAfter && stopAfter(upcasted)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
         }
-        return result;
+        if (isStop) {
+          isActive = false;
+          return messageProcessingResult;
+        }
+        return void 0;
       }, partialContext);
     }
   };
@@ -848,15 +884,15 @@ var projector = (options) => {
     processorId,
     messageOptions: options.projection.eventsOptions,
     hooks: {
-      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) => {
+      onInit: _optionalChain([options, 'access', _37 => _37.hooks, 'optionalAccess', _38 => _38.onInit]),
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _39 => _39.hooks, 'optionalAccess', _40 => _40.onStart]) ? async (context) => {
         if (options.truncateOnStart && options.projection.truncate)
           await options.projection.truncate(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)]);
+        if (_optionalChain([options, 'access', _41 => _41.hooks, 'optionalAccess', _42 => _42.onStart])) await _optionalChain([options, 'access', _43 => _43.hooks, 'optionalAccess', _44 => _44.onStart, 'call', _45 => _45(context)]);
       } : void 0,
-      onClose: _optionalChain([options, 'access', _44 => _44.hooks, 'optionalAccess', _45 => _45.onClose])
+      onClose: _optionalChain([options, 'access', _46 => _46.hooks, 'optionalAccess', _47 => _47.onClose])
     },
-    eachMessage: async (event2, context) => projection2.handle([event2], context)
+    eachBatch: async (events, context) => projection2.handle(events, context)
   });
 };
 var inMemoryCheckpointer = () => {
@@ -864,7 +900,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', _46 => _46.lastCheckpoint]), () => ( null))
+        lastCheckpoint: _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _48 => _48.lastCheckpoint]), () => ( null))
       });
     },
     store: async (context, { database }) => {
@@ -875,7 +911,7 @@ var inMemoryCheckpointer = () => {
       const checkpoint = await checkpoints.findOne(
         (d) => d._id === processorId
       );
-      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _47 => _47.lastCheckpoint]), () => ( null));
+      const currentPosition = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _49 => _49.lastCheckpoint]), () => ( null));
       const newCheckpoint = getCheckpoint(message2);
       if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
         return {
@@ -895,7 +931,7 @@ var inMemoryCheckpointer = () => {
 var inMemoryProcessingScope = (options) => {
   const processorDatabase = options.database;
   const processingScope = (handler, partialContext) => {
-    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _48 => _48.database])));
+    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _50 => _50.database])));
     if (!database)
       throw new EmmettError(
         `InMemory processor '${options.processorId}' is missing database. Ensure that you passed it through options`
@@ -905,12 +941,12 @@ var inMemoryProcessingScope = (options) => {
   return processingScope;
 };
 var inMemoryProjector = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _49 => _49.connectionOptions, 'optionalAccess', _50 => _50.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _51 => _51.connectionOptions, 'optionalAccess', _52 => _52.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    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)]);
+    onInit: _optionalChain([options, 'access', _53 => _53.hooks, 'optionalAccess', _54 => _54.onInit]),
+    onStart: _optionalChain([options, 'access', _55 => _55.hooks, 'optionalAccess', _56 => _56.onStart]),
+    onClose: _optionalChain([options, 'access', _57 => _57.hooks, 'optionalAccess', _58 => _58.onClose]) ? async (context) => {
+      if (_optionalChain([options, 'access', _59 => _59.hooks, 'optionalAccess', _60 => _60.onClose])) await _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onClose, 'call', _63 => _63(context)]);
     } : void 0
   };
   const processor = projector({
@@ -925,11 +961,11 @@ var inMemoryProjector = (options) => {
   return Object.assign(processor, { database });
 };
 var inMemoryReactor = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _62 => _62.connectionOptions, 'optionalAccess', _63 => _63.database]), () => ( getInMemoryDatabase()));
+  const database = _nullishCoalesce(_optionalChain([options, 'access', _64 => _64.connectionOptions, 'optionalAccess', _65 => _65.database]), () => ( getInMemoryDatabase()));
   const hooks = {
-    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])
+    onInit: _optionalChain([options, 'access', _66 => _66.hooks, 'optionalAccess', _67 => _67.onInit]),
+    onStart: _optionalChain([options, 'access', _68 => _68.hooks, 'optionalAccess', _69 => _69.onStart]),
+    onClose: _optionalChain([options, 'access', _70 => _70.hooks, 'optionalAccess', _71 => _71.onClose])
   };
   const processor = reactor({
     ...options,
@@ -943,7 +979,7 @@ var inMemoryReactor = (options) => {
   return Object.assign(processor, { database });
 };
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _70 => _70.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _72 => _72.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -961,14 +997,14 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _71 => _71.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _73 => _73.downcast]))
     return recordedMessages;
   return recordedMessages.map(
     (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
   );
 };
 var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _72 => _72.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _74 => _74.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -1020,7 +1056,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   return {
     async aggregateStream(streamName, options) {
       const { evolve, initialState, read } = options;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _73 => _73.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _75 => _75.expectedStreamVersion]);
       let state = initialState();
       let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
       let lastEventGlobalPosition = void 0;
@@ -1035,11 +1071,11 @@ var getEventStoreDBEventStore = (eventStore) => {
             state,
             upcastRecordedMessage(
               mapFromESDBEvent(resolvedEvent),
-              _optionalChain([options, 'optionalAccess', _74 => _74.read, 'optionalAccess', _75 => _75.schema, 'optionalAccess', _76 => _76.versioning])
+              _optionalChain([options, 'optionalAccess', _76 => _76.read, 'optionalAccess', _77 => _77.schema, 'optionalAccess', _78 => _78.versioning])
             )
           );
           currentStreamVersion = event.revision;
-          lastEventGlobalPosition = _optionalChain([event, 'access', _77 => _77.position, 'optionalAccess', _78 => _78.commit]);
+          lastEventGlobalPosition = _optionalChain([event, 'access', _79 => _79.position, 'optionalAccess', _80 => _80.commit]);
         }
         assertExpectedVersionMatchesCurrent(
           currentStreamVersion,
@@ -1080,7 +1116,7 @@ var getEventStoreDBEventStore = (eventStore) => {
           events.push(
             upcastRecordedMessage(
               mapFromESDBEvent(resolvedEvent),
-              _optionalChain([options, 'optionalAccess', _79 => _79.schema, 'optionalAccess', _80 => _80.versioning])
+              _optionalChain([options, 'optionalAccess', _81 => _81.schema, 'optionalAccess', _82 => _82.versioning])
             )
           );
           currentStreamVersion = event.revision;
@@ -1105,11 +1141,11 @@ var getEventStoreDBEventStore = (eventStore) => {
       try {
         const eventsToStore = downcastRecordedMessages(
           events,
-          _optionalChain([options, 'optionalAccess', _81 => _81.schema, 'optionalAccess', _82 => _82.versioning])
+          _optionalChain([options, 'optionalAccess', _83 => _83.schema, 'optionalAccess', _84 => _84.versioning])
         );
         const serializedEvents = eventsToStore.map(_dbclient.jsonEvent);
         const expectedRevision = toExpectedRevision(
-          _optionalChain([options, 'optionalAccess', _83 => _83.expectedStreamVersion])
+          _optionalChain([options, 'optionalAccess', _85 => _85.expectedStreamVersion])
         );
         const appendResult = await eventStore.appendToStream(
           streamName,
@@ -1156,7 +1192,7 @@ var getEventStoreDBEventStore = (eventStore) => {
   };
 };
 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));
+  return !from || _optionalChain([from, 'optionalAccess', _86 => _86.stream]) === $all ? _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _87 => _87.link, 'optionalAccess', _88 => _88.position, 'optionalAccess', _89 => _89.commit]), () => ( _optionalChain([resolvedEvent, 'access', _90 => _90.event, 'optionalAccess', _91 => _91.position, 'optionalAccess', _92 => _92.commit]))) : _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _93 => _93.link, 'optionalAccess', _94 => _94.revision]), () => ( resolvedEvent.event.revision));
 };
 var mapFromESDBEvent = (resolvedEvent, from) => {
   const event = resolvedEvent.event;
@@ -1199,7 +1235,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', _93 => _93.options]), () => ( {})),
+  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _95 => _95.options]), () => ( {})),
   fromPosition: toGlobalPosition(options.startFrom),
   filter: _dbclient.excludeSystemEvents.call(void 0, )
 }) : client.subscribeToStream(from.stream, {
@@ -1258,7 +1294,7 @@ var eventStoreDBSubscription = ({
   let start;
   let processor;
   let subscription;
-  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _94 => _94.resubscribeOptions]), () => ( {
+  const resubscribeOptions = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _96 => _96.resubscribeOptions]), () => ( {
     ...EventStoreDBResubscribeDefaultOptions,
     shouldRetryResult: () => isRunning,
     shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
@@ -1381,9 +1417,9 @@ var eventStoreDBEventStoreConsumer = (options) => {
         return await s.handle(messagesBatch, { client });
       })
     );
-    const error = _optionalChain([result, 'access', _95 => _95.find, 'call', _96 => _96((r) => r.status === "rejected"), 'optionalAccess', _97 => _97.reason]);
+    const error = _optionalChain([result, 'access', _97 => _97.find, 'call', _98 => _98((r) => r.status === "rejected"), 'optionalAccess', _99 => _99.reason]);
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _98 => _98.value, 'optionalAccess', _99 => _99.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _100 => _100.value, 'optionalAccess', _101 => _101.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP",
       error: error ? EmmettError.mapFrom(error) : void 0
@@ -1393,7 +1429,7 @@ var eventStoreDBEventStoreConsumer = (options) => {
     client,
     from: options.from,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _100 => _100.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _102 => _102.batchSize]), () => ( DefaultEventStoreDBEventStoreProcessorBatchSize)),
     resilience: options.resilience
   });
   const stop = async () => {