@event-driven-io/emmett-postgresql 0.42.0 → 0.42.1

package/dist/index.js

@@ -657,19 +657,39 @@ var reactor = (options) => {
     type,
     init,
     start: async (startOptions) => {
-      if (isActive) return;
+      if (isActive) {
+        console.log(
+          `Processor ${processorId} with instance id ${instanceId} is already active. Start request ignored.`
+        );
+        return;
+      }
+      console.log(
+        `Starting processor ${processorId} with instance id ${instanceId}`
+      );
       await init(startOptions);
       isActive = true;
       closeSignal = onShutdown(() => close({}));
-      if (lastCheckpoint !== null)
+      if (lastCheckpoint !== null) {
+        console.log(
+          `Processor ${processorId} started with instance id ${instanceId}, checkpoint: ${JSONParser.stringify(lastCheckpoint)}`
+        );
         return {
           lastCheckpoint
         };
+      }
       return await processingScope(async (context) => {
         if (hooks.onStart) {
+          console.log(
+            `Executing onStart hook for processor ${processorId} with instance id ${instanceId}`
+          );
           await hooks.onStart(context);
         }
-        if (startFrom && startFrom !== "CURRENT") return startFrom;
+        if (startFrom && startFrom !== "CURRENT") {
+          console.log(
+            `Processor ${processorId} with instance id ${instanceId} starting from: ${JSONParser.stringify(startFrom)}`
+          );
+          return startFrom;
+        }
         if (checkpoints) {
           const readResult = await checkpoints?.read(
             {
@@ -680,7 +700,15 @@ var reactor = (options) => {
           );
           lastCheckpoint = readResult.lastCheckpoint;
         }
-        if (lastCheckpoint === null) return "BEGINNING";
+        if (lastCheckpoint === null) {
+          console.log(
+            `Processor ${processorId} with instance id ${instanceId} starting from: BEGINNING`
+          );
+          return "BEGINNING";
+        }
+        console.log(
+          `Checkpoint read for processor ${processorId} with instance id ${instanceId}: ${JSONParser.stringify(lastCheckpoint)}`
+        );
         return {
           lastCheckpoint
         };
@@ -692,48 +720,64 @@ 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(
-            // TODO: Make it smarter
-            message2,
-            options.messageOptions?.schema?.versioning
-          );
-          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
-              },
+      try {
+        return await processingScope(async (context) => {
+          let result = void 0;
+          for (const message2 of messages) {
+            if (wasMessageHandled(message2, lastCheckpoint)) continue;
+            const upcasted = upcastRecordedMessage(
+              // TODO: Make it smarter
+              message2,
+              options.messageOptions?.schema?.versioning
+            );
+            if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
+              continue;
+            const messageProcessingResult = await eachMessage(
+              upcasted,
               context
             );
-            if (storeCheckpointResult.success) {
-              lastCheckpoint = storeCheckpointResult.newCheckpoint;
+            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 (messageProcessingResult && messageProcessingResult.type === "SKIP")
+              continue;
           }
-          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 (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
-        }
-        return result;
-      }, partialContext);
+          return result;
+        }, partialContext);
+      } catch (error2) {
+        console.log(
+          `Error during message processing for processor ${processorId} with instance id ${instanceId}. Stopping the processor.`,
+          error2
+        );
+        isActive = false;
+        return {
+          type: "STOP",
+          error: error2,
+          reason: "Error during message processing"
+        };
+      }
     }
   };
 };
@@ -828,32 +872,40 @@ var postgreSQLEventStoreMessageBatchPuller = ({
   let isRunning = false;
   let start;
   const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : options.startFrom.lastCheckpoint;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    while (isRunning && !signal?.aborted) {
-      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
-      if (messages.length > 0) {
-        const result = await eachBatch(messages);
-        if (result && result.type === "STOP") {
+    try {
+      const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : options.startFrom.lastCheckpoint;
+      const readMessagesOptions = {
+        after,
+        batchSize
+      };
+      let waitTime = 100;
+      while (isRunning && !signal?.aborted) {
+        const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
+        if (messages.length > 0) {
+          const result = await eachBatch(messages);
+          if (result && result.type === "STOP") {
+            isRunning = false;
+            break;
+          }
+        }
+        readMessagesOptions.after = currentGlobalPosition;
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
+          console.log(
+            `No messages left to process after reaching global position ${currentGlobalPosition}. Stopping the puller.`
+          );
           isRunning = false;
           break;
         }
+        if (!areMessagesLeft) {
+          waitTime = Math.min(waitTime * 2, 1e3);
+        } else {
+          waitTime = pullingFrequencyInMs;
+        }
       }
-      readMessagesOptions.after = currentGlobalPosition;
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
-        isRunning = false;
-        break;
-      }
-      if (!areMessagesLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
-      } else {
-        waitTime = pullingFrequencyInMs;
-      }
+    } catch (error) {
+      console.log("Error occurred during message pulling:", error);
+      throw error;
     }
   };
   return {
@@ -883,7 +935,10 @@ var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
 };
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
-import { dumbo as dumbo6 } from "@event-driven-io/dumbo";
+import {
+  dumbo as dumbo6,
+  JSONSerializer as JSONSerializer2
+} from "@event-driven-io/dumbo";
 import { v7 as uuid7 } from "uuid";
 
 // src/eventStore/consumers/postgreSQLProcessor.ts
@@ -1157,6 +1212,9 @@ var tryAcquireProcessorLock = async (execute, options) => {
       })
     )
   );
+  console.log(
+    `Lock acquisition attempt for processor '${options.processorId}' with processor instance '${options.processorInstanceId}' and lock '${options.lockKey}' resulted in: ${acquired}`
+  );
   return acquired ? { acquired: true, checkpoint } : { acquired: false };
 };
 var tryAcquireProcessorLockWithRetry = async (execute, options) => {
@@ -1185,6 +1243,9 @@ var releaseProcessorLock = async (execute, options) => {
       })
     )
   );
+  console.log(
+    `Lock for processor '${options.processorId}' with processor instance '${options.processorInstanceId}' and lock '${options.lockKey}' released: ${result}`
+  );
   return result;
 };
 
@@ -1198,6 +1259,9 @@ var postgreSQLProcessorLock = (options) => {
   return {
     tryAcquire: async (context) => {
       if (acquired) {
+        console.log(
+          `Lock for processor '${options.processorId}' is already acquired by this instance. Reusing the lock.`
+        );
         return true;
       }
       const result = await tryAcquireProcessorLockWithRetry(context.execute, {
@@ -1205,6 +1269,9 @@ var postgreSQLProcessorLock = (options) => {
         lockKey
       });
       if (!result.acquired && options.lockAcquisitionPolicy?.type !== "skip") {
+        console.log(
+          `Failed to acquire lock for processor '${options.processorId}' with policy '${options.lockAcquisitionPolicy?.type}'.`
+        );
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1213,7 +1280,12 @@ var postgreSQLProcessorLock = (options) => {
       return acquired;
     },
     release: async (context) => {
-      if (!acquired) return;
+      if (!acquired) {
+        console.log(
+          `Lock for processor '${options.processorId}' is not acquired by this instance. Skipping release.`
+        );
+        return;
+      }
       const { projection: projection2, ...releaseOptions } = options;
       await releaseProcessorLock(context.execute, {
         ...releaseOptions,
@@ -4856,12 +4928,20 @@ var postgreSQLEventStoreConsumer = (options) => {
       };
     const result = await Promise.allSettled(
       activeProcessors.map(async (s) => {
-        return await s.handle(messagesBatch, {
-          connection: {
-            connectionString: options.connectionString,
-            pool
-          }
-        });
+        try {
+          return await s.handle(messagesBatch, {
+            connection: {
+              connectionString: options.connectionString,
+              pool
+            }
+          });
+        } catch (error) {
+          console.log(
+            `Error during message batch processing for processor: ${s.id}`,
+            error
+          );
+          throw error;
+        }
       })
     );
     return result.some(
@@ -4897,7 +4977,24 @@ var postgreSQLEventStoreConsumer = (options) => {
     const postgresProcessors = processors;
     for (const processor of postgresProcessors) {
       if (processor.init) {
-        await processor.init(processorContext);
+        try {
+          await processor.init(processorContext);
+        } catch (error) {
+          console.log(
+            `Error during processor initialization for processor: ${processor.id}. Stopping it.`,
+            error
+          );
+          await processor.close(processorContext).catch((closeError) => {
+            console.log(
+              `Error during processor cleanup after failed initialization for processor: ${processor.id}`,
+              closeError
+            );
+          });
+          console.log(
+            `Processor ${processor.id} stopped successfully after failed initialization.`
+          );
+          throw error;
+        }
       }
     }
     isInitialized = true;
@@ -4926,11 +5023,20 @@ var postgreSQLEventStoreConsumer = (options) => {
       return processor;
     },
     start: () => {
-      if (isRunning) return start;
-      if (processors.length === 0)
+      if (isRunning) {
+        console.log(
+          "Consumer is already running. Returning the existing start promise."
+        );
+        return start;
+      }
+      if (processors.length === 0) {
+        console.log(
+          "Cannot start consumer without at least a single processor"
+        );
         throw new EmmettError(
           "Cannot start consumer without at least a single processor"
         );
+      }
       isRunning = true;
       abortController = new AbortController();
       messagePuller = postgreSQLEventStoreMessageBatchPuller({
@@ -4944,22 +5050,36 @@ var postgreSQLEventStoreConsumer = (options) => {
       start = (async () => {
         if (!isRunning) return;
         if (!isInitialized) {
+          console.log("Initializing consumer before starting message pulling.");
           await init();
         }
         const startFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom(
           await Promise.all(
             processors.map(async (o) => {
-              const result = await o.start({
-                execute: pool.execute,
-                connection: {
-                  connectionString: options.connectionString,
-                  pool
-                }
-              });
-              return result;
+              try {
+                const result = await o.start({
+                  execute: pool.execute,
+                  connection: {
+                    connectionString: options.connectionString,
+                    pool
+                  }
+                });
+                return result;
+              } catch (error) {
+                console.log(
+                  `Error during processor start position retrieval for processor: ${o.id}. Stopping it.`,
+                  error
+                );
+                throw error;
+              }
             })
           )
         );
+        console.log(
+          `Starting message pulling with start position: ${JSONSerializer2.serialize(
+            startFrom
+          )}. Waiting for messages...`
+        );
         await messagePuller.start({ startFrom });
         await stopProcessors();
         isRunning = false;