@event-driven-io/emmett-sqlite 0.43.0-beta.11 → 0.43.0-beta.13

package/dist/index.js

@@ -1,130 +1,3 @@
-// src/eventStore/projections/pongo/pongoProjections.ts
-import {
-  pongoClient
-} from "@event-driven-io/pongo";
-var pongoProjection = ({
-  name,
-  kind,
-  version,
-  truncate,
-  handle,
-  canHandle,
-  eventsOptions
-}) => sqliteProjection({
-  name,
-  version,
-  kind: kind ?? "emt:projections:postgresql:pongo:generic",
-  canHandle,
-  eventsOptions,
-  handle: async (events, context) => {
-    const { connection } = context;
-    const driver = await pongoDriverRegistry.tryResolve(
-      context.driverType
-    );
-    const pongo = pongoClient({
-      driver,
-      connectionOptions: { connection }
-    });
-    try {
-      await handle(events, {
-        ...context,
-        pongo
-      });
-    } finally {
-      await pongo.close();
-    }
-  },
-  truncate: truncate ? async (context) => {
-    const { connection } = context;
-    const driver = await pongoDriverRegistry.tryResolve(
-      context.driverType
-    );
-    const pongo = pongoClient({
-      driver,
-      connectionOptions: { connection }
-    });
-    try {
-      await truncate({
-        ...context,
-        pongo
-      });
-    } finally {
-      await pongo.close();
-    }
-  } : void 0
-});
-var pongoMultiStreamProjection = (options) => {
-  const { collectionName, getDocumentId, canHandle } = options;
-  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
-  return pongoProjection({
-    name: collectionNameWithVersion,
-    version: options.version,
-    kind: options.kind ?? "emt:projections:postgresql:pongo:multi_stream",
-    eventsOptions: options.eventsOptions,
-    handle: async (events, { pongo }) => {
-      const collection = pongo.db().collection(
-        collectionNameWithVersion,
-        options.collectionOptions
-      );
-      for (const event of events) {
-        await collection.handle(getDocumentId(event), async (document) => {
-          return "initialState" in options ? await options.evolve(
-            document ?? options.initialState(),
-            event
-          ) : await options.evolve(
-            document,
-            event
-          );
-        });
-      }
-    },
-    canHandle,
-    truncate: async (context) => {
-      const { connection } = context;
-      const driver = await pongoDriverRegistry.tryResolve(
-        context.driverType
-      );
-      const pongo = pongoClient({
-        driver,
-        connectionOptions: { connection }
-      });
-      try {
-        await pongo.db().collection(
-          collectionNameWithVersion,
-          options.collectionOptions
-        ).deleteMany();
-      } finally {
-        await pongo.close();
-      }
-    },
-    init: async (context) => {
-      const { connection } = context;
-      const driver = await pongoDriverRegistry.tryResolve(
-        context.driverType
-      );
-      const pongo = pongoClient({
-        connectionOptions: { connection },
-        driver
-      });
-      try {
-        await pongo.db().collection(
-          collectionNameWithVersion,
-          options.collectionOptions
-        ).schema.migrate();
-      } finally {
-        await pongo.close();
-      }
-    }
-  });
-};
-var pongoSingleStreamProjection = (options) => {
-  return pongoMultiStreamProjection({
-    ...options,
-    kind: "emt:projections:postgresql:pongo:single_stream",
-    getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
-  });
-};
-
 // ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
@@ -218,6 +91,13 @@ var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersion
   error,
   ExpectedVersionConflictError.Codes.ConcurrencyError
 );
+async function reduceAsync(items, fn, initial) {
+  let accumulator = initial;
+  for (let i = 0; i < items.length; i++) {
+    accumulator = await fn(accumulator, items[i], i);
+  }
+  return accumulator;
+}
 var isPrimitive = (value) => {
   const type = typeof value;
   return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
@@ -609,7 +489,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;
@@ -647,10 +560,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);
@@ -679,46 +593,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,
             options.messageOptions?.schema?.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 = batchResult?.type === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+          type: "STOP",
+          reason: "Stop condition reached",
+          lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
+        } : batchResult;
+        const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
+        const checkpointMessage = messageProcessingResult?.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 (stopAfter && stopAfter(upcasted)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
+          if (storeCheckpointResult.success) {
+            lastCheckpoint = storeCheckpointResult.newCheckpoint;
           }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
         }
-        return result;
+        if (isStop) {
+          isActive = false;
+          return messageProcessingResult;
+        }
+        return void 0;
       }, partialContext);
     }
   };
@@ -746,7 +662,7 @@ var projector = (options) => {
       } : void 0,
       onClose: options.hooks?.onClose
     },
-    eachMessage: async (event2, context) => projection2.handle([event2], context)
+    eachBatch: async (events, context) => projection2.handle(events, context)
   });
 };
 var AssertionError = class extends Error {
@@ -1153,10 +1069,8 @@ var workflowProcessor = (options) => {
         return;
       }
       if (options.outputHandler?.canHandle.includes(messageType) === true) {
-        const handledOutputMessages = await options.outputHandler.handle(
-          message2,
-          context
-        );
+        const recordedMessage = message2;
+        const handledOutputMessages = options.outputHandler.eachBatch ? await options.outputHandler.eachBatch([recordedMessage], context) : await options.outputHandler.eachMessage(recordedMessage, context);
         if (handledOutputMessages instanceof EmmettError) {
           return {
             type: "STOP",
@@ -1187,6 +1101,146 @@ var workflowProcessor = (options) => {
   });
 };
 
+// src/eventStore/projections/pongo/pongoProjections.ts
+import {
+  pongoClient
+} from "@event-driven-io/pongo";
+var pongoProjection = ({
+  name,
+  kind,
+  version,
+  truncate,
+  handle,
+  canHandle,
+  eventsOptions
+}) => sqliteProjection({
+  name,
+  version,
+  kind: kind ?? "emt:projections:postgresql:pongo:generic",
+  canHandle,
+  eventsOptions,
+  handle: async (events, context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = pongoClient({
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await handle(events, {
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  },
+  truncate: truncate ? async (context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = pongoClient({
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await truncate({
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  } : void 0
+});
+var pongoMultiStreamProjection = (options) => {
+  const { collectionName, getDocumentId, canHandle } = options;
+  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
+  return pongoProjection({
+    name: collectionNameWithVersion,
+    version: options.version,
+    kind: options.kind ?? "emt:projections:postgresql:pongo:multi_stream",
+    eventsOptions: options.eventsOptions,
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(
+        collectionNameWithVersion,
+        options.collectionOptions
+      );
+      const eventsByDocumentId = events.map((event) => {
+        const documentId = getDocumentId(event);
+        return {
+          documentId,
+          event
+        };
+      }).reduce((acc, { documentId, event }) => {
+        if (!acc.has(documentId)) {
+          acc.set(documentId, []);
+        }
+        acc.get(documentId).push(event);
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      await collection.handle(
+        [...eventsByDocumentId.keys()],
+        (document, id) => {
+          const events2 = eventsByDocumentId.get(id);
+          return reduceAsync(
+            events2,
+            async (acc, event) => await options.evolve(acc, event),
+            document ?? ("initialState" in options ? options.initialState() : null)
+          );
+        }
+      );
+    },
+    canHandle,
+    truncate: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = pongoClient({
+        driver,
+        connectionOptions: { connection }
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).deleteMany();
+      } finally {
+        await pongo.close();
+      }
+    },
+    init: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = pongoClient({
+        connectionOptions: { connection },
+        driver
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).schema.migrate();
+      } finally {
+        await pongo.close();
+      }
+    }
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    kind: "emt:projections:postgresql:pongo:single_stream",
+    getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
+  });
+};
+
 // src/eventStore/projections/pongo/pongoProjectionSpec.ts
 import {
   pongoClient as pongoClient2