@event-driven-io/emmett-postgresql 0.42.0-rc.2 → 0.42.1-alpha.1

package/dist/index.cjs

@@ -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 _optionalChain([checkpoints, 'optionalAccess', _20 => _20.read, 'call', _21 => _21(
             {
@@ -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,
-            _optionalChain([options, 'access', _22 => _22.messageOptions, 'optionalAccess', _23 => _23.schema, 'optionalAccess', _24 => _24.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,
+              _optionalChain([options, 'access', _22 => _22.messageOptions, 'optionalAccess', _23 => _23.schema, 'optionalAccess', _24 => _24.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 _asyncNullishCoalesce((await readLastMessageGlobalPosition(executor)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.lastCheckpoint;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _37 => _37.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 _asyncNullishCoalesce((await readLastMessageGlobalPosition(executor)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.lastCheckpoint;
+      const readMessagesOptions = {
+        after,
+        batchSize
+      };
+      let waitTime = 100;
+      while (isRunning && !_optionalChain([signal, 'optionalAccess', _37 => _37.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 (_optionalChain([stopWhen, 'optionalAccess', _38 => _38.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 (_optionalChain([stopWhen, 'optionalAccess', _38 => _38.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 {
@@ -886,16 +938,19 @@ var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
 
 
 
+
+
+
 // src/eventStore/consumers/postgreSQLProcessor.ts
 
 
 
 require('pg');
 
-// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
 
 
-// src/eventStore/schema/processors/processorsLocks.ts
+// src/eventStore/schema/projections/projectionsLocks.ts
 
 
 // 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) => _dumbo.sql.call(void 0, 
+  `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 _dumbo.single.call(void 0, 
+    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 = _nullishCoalesce(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
+
+
 // src/eventStore/schema/processors/processorsLocks.ts
+
 var tryAcquireProcessorLockSQL = createFunctionIfDoesNotExistSQL(
   "emt_try_acquire_processor_lock",
   `
@@ -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 = _nullishCoalesce(options.lockPolicy, () => ( DefaultPostgreSQLProcessorLockPolicy));
+  const policy = _nullishCoalesce(options.lockAcquisitionPolicy, () => ( DefaultPostgreSQLProcessorLockPolicy));
   if (policy.type === "retry") {
     return asyncRetry(() => tryAcquireProcessorLock(execute, options), {
       retries: policy.retries - 1,
@@ -1095,98 +1243,11 @@ var releaseProcessorLock = async (execute, options) => {
       })
     )
   );
-  return result;
-};
-
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-
-
-// 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) => _dumbo.sql.call(void 0, 
-  `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 _dumbo.single.call(void 0, 
-    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 = _nullishCoalesce(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 && _optionalChain([options, 'access', _45 => _45.lockPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
+      if (!result.acquired && _optionalChain([options, 'access', _45 => _45.lockAcquisitionPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
+        console.log(
+          `Failed to acquire lock for processor '${options.processorId}' with policy '${_optionalChain([options, 'access', _47 => _47.lockAcquisitionPolicy, 'optionalAccess', _48 => _48.type])}'.`
+        );
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1213,12 +1280,17 @@ 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,
         lockKey,
-        projectionName: _optionalChain([projection2, 'optionalAccess', _47 => _47.name])
+        projectionName: _optionalChain([projection2, 'optionalAccess', _49 => _49.name])
       });
       acquired = false;
     }
@@ -1889,7 +1961,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
     return { success: false, result: { success: false } };
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _48 => _48.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _50 => _50.expectedStreamVersion])
     );
     const messagesToAppend = messages.map((e) => ({
       ...e,
@@ -1929,7 +2001,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
         globalPosition
       };
     });
-    if (_optionalChain([options, 'optionalAccess', _49 => _49.beforeCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _51 => _51.beforeCommitHook]))
       await options.beforeCommitHook(messagesToAppend, { transaction });
     return {
       success: true,
@@ -1970,8 +2042,8 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
       messageKinds: messages.map((e) => _dumbo.sql.call(void 0, "%L", e.kind === "Event" ? "E" : "C")).join(","),
       streamId,
       streamType,
-      expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _50 => _50.expectedStreamVersion, 'optionalAccess', _51 => _51.toString, 'call', _52 => _52()]), () => ( "NULL")),
-      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.partition]), () => ( defaultTag))
+      expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.expectedStreamVersion, 'optionalAccess', _53 => _53.toString, 'call', _54 => _54()]), () => ( "NULL")),
+      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.partition]), () => ( defaultTag))
     })
   )
 );
@@ -2673,7 +2745,7 @@ BEGIN
 END $$;
 `);
 var migration_0_42_0_FromSubscriptionsToProcessors = _dumbo.sqlMigration.call(void 0, 
-  "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 = _dumbo.rawSql.call(void 0, `
@@ -2950,7 +3022,7 @@ END;
 $emt_deactivate_projection$;
 `);
 var migration_0_42_0_2_AddProcessorProjectionFunctions = _dumbo.sqlMigration.call(void 0, 
-  "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]
 );
 
@@ -4059,7 +4131,7 @@ var readProcessorCheckpoint = async (execute, options) => {
            FROM ${processorsTable.name}
            WHERE partition = %L AND processor_id = %L AND version = %s
            LIMIT 1`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.partition]), () => ( defaultTag)),
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.partition]), () => ( defaultTag)),
         options.processorId,
         _nullishCoalesce(options.version, () => ( 1))
       )
@@ -4073,9 +4145,9 @@ var readProcessorCheckpoint = async (execute, options) => {
 // src/eventStore/schema/readStream.ts
 
 var readStream = async (execute, streamId, options) => {
-  const fromCondition = _optionalChain([options, 'optionalAccess', _55 => _55.from]) ? `AND stream_position >= ${options.from}` : "";
+  const fromCondition = _optionalChain([options, 'optionalAccess', _57 => _57.from]) ? `AND stream_position >= ${options.from}` : "";
   const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.to]), () => ( (_optionalChain([options, 'optionalAccess', _57 => _57.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _58 => _58.to]), () => ( (_optionalChain([options, 'optionalAccess', _59 => _59.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
   );
   const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
   const events = await _dumbo.mapRows.call(void 0, 
@@ -4086,7 +4158,7 @@ var readStream = async (execute, streamId, options) => {
            WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}
            ORDER BY stream_position ASC`,
         streamId,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _58 => _58.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _60 => _60.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
@@ -4107,7 +4179,7 @@ var readStream = async (execute, streamId, options) => {
         kind: "Event",
         metadata
       };
-      return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _59 => _59.schema, 'optionalAccess', _60 => _60.versioning]));
+      return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _61 => _61.schema, 'optionalAccess', _62 => _62.versioning]));
     }
   );
   return events.length > 0 ? {
@@ -4132,10 +4204,10 @@ var streamExists = async (execute, streamId, options) => {
         WHERE stream_id = %L AND partition = %L AND is_archived = FALSE)
       `,
       streamId,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _61 => _61.partition]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _63 => _63.partition]), () => ( defaultTag))
     )
   );
-  return _nullishCoalesce(_optionalChain([queryResult, 'access', _62 => _62.rows, 'access', _63 => _63[0], 'optionalAccess', _64 => _64.exists]), () => ( false));
+  return _nullishCoalesce(_optionalChain([queryResult, 'access', _64 => _64.rows, 'access', _65 => _65[0], 'optionalAccess', _66 => _66.exists]), () => ( false));
 };
 
 // src/eventStore/schema/index.ts
@@ -4180,7 +4252,7 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
     };
     const nestedPool = _dumbo.dumbo.call(void 0, { connectionString, connection: tx.connection });
     try {
-      if (_optionalChain([hooks, 'optionalAccess', _65 => _65.onBeforeSchemaCreated])) {
+      if (_optionalChain([hooks, 'optionalAccess', _67 => _67.onBeforeSchemaCreated])) {
         await hooks.onBeforeSchemaCreated(context);
       }
       const result = await _dumbo.runPostgreSQLMigrations.call(void 0, 
@@ -4188,7 +4260,7 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
         eventStoreSchemaMigrations,
         options
       );
-      if (_optionalChain([hooks, 'optionalAccess', _66 => _66.onAfterSchemaCreated])) {
+      if (_optionalChain([hooks, 'optionalAccess', _68 => _68.onAfterSchemaCreated])) {
         await hooks.onAfterSchemaCreated(context);
       }
       return result;
@@ -4203,7 +4275,7 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
 var truncateTables = async (execute, options) => {
   await execute.command(
     _dumbo.rawSql.call(void 0, 
-      `TRUNCATE TABLE ${streamsTable.name}, ${messagesTable.name}, ${processorsTable.name}, ${projectionsTable.name} CASCADE${_optionalChain([options, 'optionalAccess', _67 => _67.resetSequences]) ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : ""};`
+      `TRUNCATE TABLE ${streamsTable.name}, ${messagesTable.name}, ${processorsTable.name}, ${projectionsTable.name} CASCADE${_optionalChain([options, 'optionalAccess', _69 => _69.resetSequences]) ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : ""};`
     )
   );
 };
@@ -4221,7 +4293,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
   let migrateSchema = void 0;
-  const autoGenerateSchema = _optionalChain([options, 'access', _68 => _68.schema, 'optionalAccess', _69 => _69.autoMigration]) === void 0 || _optionalChain([options, 'access', _70 => _70.schema, 'optionalAccess', _71 => _71.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _70 => _70.schema, 'optionalAccess', _71 => _71.autoMigration]) === void 0 || _optionalChain([options, 'access', _72 => _72.schema, 'optionalAccess', _73 => _73.autoMigration]) !== "None";
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const migrate = async (migrationOptions) => {
     if (!migrateSchema) {
@@ -4230,7 +4302,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         pool,
         {
           onBeforeSchemaCreated: async (context) => {
-            if (_optionalChain([options, 'access', _72 => _72.hooks, 'optionalAccess', _73 => _73.onBeforeSchemaCreated])) {
+            if (_optionalChain([options, 'access', _74 => _74.hooks, 'optionalAccess', _75 => _75.onBeforeSchemaCreated])) {
               await options.hooks.onBeforeSchemaCreated(context);
             }
           },
@@ -4245,7 +4317,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
                 });
               }
             }
-            if (_optionalChain([options, 'access', _74 => _74.hooks, 'optionalAccess', _75 => _75.onAfterSchemaCreated])) {
+            if (_optionalChain([options, 'access', _76 => _76.hooks, 'optionalAccess', _77 => _77.onAfterSchemaCreated])) {
               await options.hooks.onAfterSchemaCreated(context);
             }
           }
@@ -4279,13 +4351,13 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
           await ensureSchemaExists();
           await truncateTables(transaction.execute, truncateOptions);
-          if (_optionalChain([truncateOptions, 'optionalAccess', _76 => _76.truncateProjections])) {
+          if (_optionalChain([truncateOptions, 'optionalAccess', _78 => _78.truncateProjections])) {
             const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(
               connectionString,
               pool,
               transaction
             );
-            for (const projection2 of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _77 => _77.projections]), () => ( []))) {
+            for (const projection2 of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _79 => _79.projections]), () => ( []))) {
               if (projection2.projection.truncate)
                 await projection2.projection.truncate(projectionContext);
             }
@@ -4295,7 +4367,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _78 => _78.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _80 => _80.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(
         streamName,
@@ -4333,7 +4405,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         pool,
         streamName,
         streamType,
-        downcastRecordedMessages(events, _optionalChain([options2, 'optionalAccess', _79 => _79.schema, 'optionalAccess', _80 => _80.versioning])),
+        downcastRecordedMessages(events, _optionalChain([options2, 'optionalAccess', _81 => _81.schema, 'optionalAccess', _82 => _82.versioning])),
         {
           ...options2,
           beforeCommitHook
@@ -4343,7 +4415,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _81 => _81.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _83 => _83.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -4426,7 +4498,7 @@ var PostgreSQLProjectionSpec = {
             const allEvents = [];
             const run = async (pool) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _82 => _82.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _84 => _84.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -4484,18 +4556,18 @@ var PostgreSQLProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _83 => _83.toString, 'call', _84 => _84()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _85 => _85.toString, 'call', _86 => _86()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _85 => _85.toString, 'call', _86 => _86()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _87 => _87.toString, 'call', _88 => _88()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _87 => _87.toString, 'call', _88 => _88()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _89 => _89.toString, 'call', _90 => _90()])}`
                     );
                   }
                 } finally {
@@ -4514,7 +4586,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _89 => _89.metadata, 'optionalAccess', _90 => _90.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _91 => _91.metadata, 'optionalAccess', _92 => _92.streamName]), () => ( streamName))
     }
   };
 };
@@ -4643,7 +4715,7 @@ var postgreSQLRawSQLProjection = (options) => {
 var postgreSQLCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _91 => _91.lastProcessedCheckpoint]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _93 => _93.lastProcessedCheckpoint]) };
   },
   store: async (options, context) => {
     const newPosition = getCheckpoint(options.message);
@@ -4661,13 +4733,13 @@ var postgreSQLProcessingScope = (options) => {
   const processorConnectionString = options.connectionString;
   const processorPool = options.pool;
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _92 => _92.connection]);
-    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _93 => _93.connectionString])));
+    const connection = _optionalChain([partialContext, 'optionalAccess', _94 => _94.connection]);
+    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _95 => _95.connectionString])));
     if (!connectionString)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
       );
-    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _94 => _94.pool]) : processorPool), () => ( processorPool));
+    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _96 => _96.pool]) : processorPool), () => ( processorPool));
     if (!pool)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
@@ -4708,11 +4780,11 @@ var wrapHooksWithProcessorLocks = (hooks, processorLock) => ({
   ..._nullishCoalesce(hooks, () => ( {})),
   onStart: async (context) => {
     await processorLock.tryAcquire({ execute: context.execute });
-    if (_optionalChain([hooks, 'optionalAccess', _95 => _95.onStart])) await hooks.onStart(context);
+    if (_optionalChain([hooks, 'optionalAccess', _97 => _97.onStart])) await hooks.onStart(context);
   },
-  onClose: _optionalChain([hooks, 'optionalAccess', _96 => _96.onClose]) || processorLock ? async (context) => {
+  onClose: _optionalChain([hooks, 'optionalAccess', _98 => _98.onClose]) || processorLock ? async (context) => {
     await processorLock.release({ execute: context.execute });
-    if (_optionalChain([hooks, 'optionalAccess', _97 => _97.onClose])) await hooks.onClose(context);
+    if (_optionalChain([hooks, 'optionalAccess', _99 => _99.onClose])) await hooks.onClose(context);
   } : void 0
 });
 var postgreSQLProjector = (options) => {
@@ -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,13 +4809,13 @@ var postgreSQLProjector = (options) => {
       version: _nullishCoalesce(options.projection.version, () => ( version)),
       handlingType: "async"
     } : void 0,
-    lockPolicy,
-    lockTimeoutSeconds
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _100 => _100.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _101 => _101.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
-      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _98 => _98.hooks, 'optionalAccess', _99 => _99.onInit]) ? async (context) => {
+      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onInit]) ? async (context) => {
         if (options.projection.init)
           await options.projection.init({
             version: _nullishCoalesce(options.projection.version, () => ( version)),
@@ -4755,16 +4826,16 @@ var postgreSQLProjector = (options) => {
               migrationOptions: options.migrationOptions
             }
           });
-        if (_optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.onInit]))
+        if (_optionalChain([options, 'access', _104 => _104.hooks, 'optionalAccess', _105 => _105.onInit]))
           await options.hooks.onInit({
             ...context,
             migrationOptions: options.migrationOptions
           });
-      } : _optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onInit]),
+      } : _optionalChain([options, 'access', _106 => _106.hooks, 'optionalAccess', _107 => _107.onInit]),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _104 => _104.hooks, 'optionalAccess', _105 => _105.onClose])) await _optionalChain([options, 'access', _106 => _106.hooks, 'optionalAccess', _107 => _107.onClose, 'call', _108 => _108(context)]);
+        if (_optionalChain([options, 'access', _108 => _108.hooks, 'optionalAccess', _109 => _109.onClose])) await _optionalChain([options, 'access', _110 => _110.hooks, 'optionalAccess', _111 => _111.onClose, 'call', _112 => _112(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _109 => _109.hooks, 'optionalAccess', _110 => _110.onClose])
+      } : _optionalChain([options, 'access', _113 => _113.hooks, 'optionalAccess', _114 => _114.onClose])
     },
     processorLock
   );
@@ -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,15 +4871,16 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockPolicy
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _115 => _115.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _116 => _116.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _111 => _111.hooks, 'optionalAccess', _112 => _112.onClose])) await _optionalChain([options, 'access', _113 => _113.hooks, 'optionalAccess', _114 => _114.onClose, 'call', _115 => _115(context)]);
+        if (_optionalChain([options, 'access', _117 => _117.hooks, 'optionalAccess', _118 => _118.onClose])) await _optionalChain([options, 'access', _119 => _119.hooks, 'optionalAccess', _120 => _120.onClose, 'call', _121 => _121(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _116 => _116.hooks, 'optionalAccess', _117 => _117.onClose])
+      } : _optionalChain([options, 'access', _122 => _122.hooks, 'optionalAccess', _123 => _123.onClose])
     },
     processorLock
   );
@@ -4856,16 +4928,24 @@ 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(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _118 => _118.value, 'optionalAccess', _119 => _119.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _124 => _124.value, 'optionalAccess', _125 => _125.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -4884,7 +4964,7 @@ var postgreSQLEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _120 => _120.abort, 'call', _121 => _121()]);
+      _optionalChain([abortController, 'optionalAccess', _126 => _126.abort, 'call', _127 => _127()]);
       await messagePuller.stop();
       messagePuller = void 0;
       abortController = null;
@@ -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,40 +5023,63 @@ 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({
         stopWhen: options.stopWhen,
         executor: pool.execute,
         eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _122 => _122.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _123 => _123.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _128 => _128.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _129 => _129.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       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: ${_dumbo.JSONSerializer.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: _nullishCoalesce(p.projection.name, () => ( unknownTag2))
@@ -4999,14 +5119,14 @@ var rebuildPostgreSQLProjections = (options) => {
       processorId: getProjectorId({
         projectionName: _nullishCoalesce(p.name, () => ( unknownTag2))
       }),
-      truncateOnStart: true,
-      lockPolicy: defaultRebuildLockPolicy
+      truncateOnStart: true
     }
   ) : [options];
   for (const projectionDefinition of projections) {
     consumer.projector({
       ...projectionDefinition,
-      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true))
+      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true)),
+      lock
     });
   }
   return consumer;