@event-driven-io/emmett-postgresql 0.42.0-rc.2 → 0.42.1-alpha.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
@@ -892,10 +947,10 @@ import {
 } from "@event-driven-io/dumbo";
 import "pg";
 
-// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
 import { single } from "@event-driven-io/dumbo";
 
-// src/eventStore/schema/processors/processorsLocks.ts
+// src/eventStore/schema/projections/projectionsLocks.ts
 import { sql as sql3 } from "@event-driven-io/dumbo";
 
 // src/eventStore/schema/createFunctionIfDoesNotExist.ts
@@ -911,7 +966,97 @@ END $$;
 `
 );
 
+// src/eventStore/schema/projections/projectionsLocks.ts
+var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
+  "emt_try_acquire_projection_lock",
+  `
+CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
+    p_lock_key   BIGINT,
+    p_partition  TEXT,
+    p_name       TEXT,
+    p_version    INT
+)
+RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
+LANGUAGE plpgsql
+AS $emt_try_acquire_projection_lock$
+BEGIN
+    RETURN QUERY
+    WITH lock_check AS (
+        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
+    ),
+    status_check AS (
+        SELECT status = 'active' AS is_active
+        FROM ${projectionsTable.name}
+        WHERE partition = p_partition AND name = p_name AND version = p_version
+    )
+    SELECT
+        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
+        COALESCE((SELECT sc.is_active FROM status_check sc), true);
+END;
+$emt_try_acquire_projection_lock$;
+`
+);
+var callTryAcquireProjectionLock = (params) => sql3(
+  `SELECT * FROM emt_try_acquire_projection_lock(%s::BIGINT, %L, %L, %s);`,
+  params.lockKey,
+  params.partition,
+  params.name,
+  params.version
+);
+
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
+var tryAcquireProjectionLock = async (execute, {
+  lockKey,
+  projectionName,
+  partition,
+  version
+}) => {
+  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
+  const { acquired, is_active } = await single(
+    execute.query(
+      callTryAcquireProjectionLock({
+        lockKey: lockKeyBigInt.toString(),
+        partition,
+        name: projectionName,
+        version
+      })
+    )
+  );
+  return acquired === true && is_active === true;
+};
+
+// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
+var postgreSQLProjectionLock = (options) => {
+  let acquired = false;
+  const lockKey = options.lockKey ?? toProjectionLockKey(options);
+  return {
+    tryAcquire: async (context) => {
+      if (acquired) {
+        return true;
+      }
+      acquired = await tryAcquireProjectionLock(context.execute, {
+        ...options,
+        lockKey
+      });
+      return acquired;
+    },
+    release: (_context) => {
+      if (!acquired) return;
+      acquired = false;
+    }
+  };
+};
+var toProjectionLockKey = ({
+  projectionName,
+  partition,
+  version
+}) => `${partition}:${projectionName}:${version}`;
+
+// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+import { single as single2 } from "@event-driven-io/dumbo";
+
 // src/eventStore/schema/processors/processorsLocks.ts
+import { sql as sql4 } from "@event-driven-io/dumbo";
 var tryAcquireProcessorLockSQL = createFunctionIfDoesNotExistSQL(
   "emt_try_acquire_processor_lock",
   `
@@ -1026,7 +1171,7 @@ END;
 $emt_release_processor_lock$;
 `
 );
-var callTryAcquireProcessorLock = (params) => sql3(
+var callTryAcquireProcessorLock = (params) => sql4(
   `SELECT * FROM emt_try_acquire_processor_lock(%s::BIGINT, %L, %s, %L, %L, %L, %L, %L, %s);`,
   params.lockKey,
   params.processorId,
@@ -1038,7 +1183,7 @@ var callTryAcquireProcessorLock = (params) => sql3(
   params.projectionKind,
   params.lockTimeoutSeconds
 );
-var callReleaseProcessorLock = (params) => sql3(
+var callReleaseProcessorLock = (params) => sql4(
   `SELECT emt_release_processor_lock(%s::BIGINT, %L, %L, %s, %L, %L) as result;`,
   params.lockKey,
   params.processorId,
@@ -1052,7 +1197,7 @@ var callReleaseProcessorLock = (params) => sql3(
 var PROCESSOR_LOCK_DEFAULT_TIMEOUT_SECONDS = 300;
 var tryAcquireProcessorLock = async (execute, options) => {
   const lockKeyBigInt = isBigint(options.lockKey) ? options.lockKey : await hashText(options.lockKey);
-  const { acquired, checkpoint } = await single(
+  const { acquired, checkpoint } = await single2(
     execute.command(
       callTryAcquireProcessorLock({
         lockKey: lockKeyBigInt.toString(),
@@ -1067,10 +1212,13 @@ 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) => {
-  const policy = options.lockPolicy ?? DefaultPostgreSQLProcessorLockPolicy;
+  const policy = options.lockAcquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy;
   if (policy.type === "retry") {
     return asyncRetry(() => tryAcquireProcessorLock(execute, options), {
       retries: policy.retries - 1,
@@ -1083,7 +1231,7 @@ var tryAcquireProcessorLockWithRetry = async (execute, options) => {
 };
 var releaseProcessorLock = async (execute, options) => {
   const lockKeyBigInt = isBigint(options.lockKey) ? options.lockKey : await hashText(options.lockKey);
-  const { result } = await single(
+  const { result } = await single2(
     execute.command(
       callReleaseProcessorLock({
         lockKey: lockKeyBigInt.toString(),
@@ -1095,98 +1243,11 @@ var releaseProcessorLock = async (execute, options) => {
       })
     )
   );
-  return result;
-};
-
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-import { single as single2 } from "@event-driven-io/dumbo";
-
-// src/eventStore/schema/projections/projectionsLocks.ts
-import { sql as sql4 } from "@event-driven-io/dumbo";
-var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
-  "emt_try_acquire_projection_lock",
-  `
-CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
-    p_lock_key   BIGINT,
-    p_partition  TEXT,
-    p_name       TEXT,
-    p_version    INT
-)
-RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
-LANGUAGE plpgsql
-AS $emt_try_acquire_projection_lock$
-BEGIN
-    RETURN QUERY
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
-    ),
-    status_check AS (
-        SELECT status = 'active' AS is_active
-        FROM ${projectionsTable.name}
-        WHERE partition = p_partition AND name = p_name AND version = p_version
-    )
-    SELECT
-        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
-        COALESCE((SELECT sc.is_active FROM status_check sc), true);
-END;
-$emt_try_acquire_projection_lock$;
-`
-);
-var callTryAcquireProjectionLock = (params) => sql4(
-  `SELECT * FROM emt_try_acquire_projection_lock(%s::BIGINT, %L, %L, %s);`,
-  params.lockKey,
-  params.partition,
-  params.name,
-  params.version
-);
-
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-var tryAcquireProjectionLock = async (execute, {
-  lockKey,
-  projectionName,
-  partition,
-  version
-}) => {
-  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
-  const { acquired, is_active } = await single2(
-    execute.query(
-      callTryAcquireProjectionLock({
-        lockKey: lockKeyBigInt.toString(),
-        partition,
-        name: projectionName,
-        version
-      })
-    )
+  console.log(
+    `Lock for processor '${options.processorId}' with processor instance '${options.processorInstanceId}' and lock '${options.lockKey}' released: ${result}`
   );
-  return acquired === true && is_active === true;
-};
-
-// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
-var postgreSQLProjectionLock = (options) => {
-  let acquired = false;
-  const lockKey = options.lockKey ?? toProjectionLockKey(options);
-  return {
-    tryAcquire: async (context) => {
-      if (acquired) {
-        return true;
-      }
-      acquired = await tryAcquireProjectionLock(context.execute, {
-        ...options,
-        lockKey
-      });
-      return acquired;
-    },
-    release: (_context) => {
-      if (!acquired) return;
-      acquired = false;
-    }
-  };
+  return result;
 };
-var toProjectionLockKey = ({
-  projectionName,
-  partition,
-  version
-}) => `${partition}:${projectionName}:${version}`;
 
 // src/eventStore/projections/locks/postgreSQLProcessorLock.ts
 var DefaultPostgreSQLProcessorLockPolicy = {
@@ -1198,13 +1259,19 @@ 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, {
         ...options,
         lockKey
       });
-      if (!result.acquired && options.lockPolicy?.type !== "skip") {
+      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,
@@ -2673,7 +2745,7 @@ BEGIN
 END $$;
 `);
 var migration_0_42_0_FromSubscriptionsToProcessors = sqlMigration2(
-  "emt:postgresql:eventstore:0.42.0:from-subscriptions-to-processors",
+  "emt:postgresql:eventstore:0.42.1-alpha.1:from-subscriptions-to-processors",
   [migration_0_42_0_FromSubscriptionsToProcessorsSQL]
 );
 var migration_0_42_0_2_AddProcessorProjectionFunctionsSQL = rawSql3(`
@@ -2950,7 +3022,7 @@ END;
 $emt_deactivate_projection$;
 `);
 var migration_0_42_0_2_AddProcessorProjectionFunctions = sqlMigration2(
-  "emt:postgresql:eventstore:0.42.0-2:add-processor-projection-functions",
+  "emt:postgresql:eventstore:0.42.1-alpha.1-2:add-processor-projection-functions",
   [migration_0_42_0_2_AddProcessorProjectionFunctionsSQL]
 );
 
@@ -4723,8 +4795,7 @@ var postgreSQLProjector = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy,
-    lockTimeoutSeconds
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4738,8 +4809,8 @@ var postgreSQLProjector = (options) => {
       version: options.projection.version ?? version,
       handlingType: "async"
     } : void 0,
-    lockPolicy,
-    lockTimeoutSeconds
+    lockAcquisitionPolicy: lock?.acquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy,
+    lockTimeoutSeconds: lock?.timeoutSeconds
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
@@ -4791,7 +4862,7 @@ var postgreSQLReactor = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4800,7 +4871,8 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockPolicy
+    lockAcquisitionPolicy: lock?.acquisitionPolicy ?? DefaultPostgreSQLProcessorLockPolicy,
+    lockTimeoutSeconds: lock?.timeoutSeconds
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
@@ -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;
@@ -4986,9 +5106,9 @@ var rebuildPostgreSQLProjections = (options) => {
     ...options,
     stopWhen: { noMessagesLeft: true }
   });
+  const lock = { acquisitionPolicy: defaultRebuildLockPolicy, ...options.lock };
   const projections = "projections" in options ? options.projections.map(
     (p) => "projection" in p ? {
-      lockPolicy: defaultRebuildLockPolicy,
       truncateOnStart: true,
       processorId: getProjectorId({
         projectionName: p.projection.name ?? unknownTag2
@@ -4999,14 +5119,14 @@ var rebuildPostgreSQLProjections = (options) => {
       processorId: getProjectorId({
         projectionName: p.name ?? unknownTag2
       }),
-      truncateOnStart: true,
-      lockPolicy: defaultRebuildLockPolicy
+      truncateOnStart: true
     }
   ) : [options];
   for (const projectionDefinition of projections) {
     consumer.projector({
       ...projectionDefinition,
-      truncateOnStart: projectionDefinition.truncateOnStart ?? true
+      truncateOnStart: projectionDefinition.truncateOnStart ?? true,
+      lock
     });
   }
   return consumer;