@event-driven-io/emmett-postgresql 0.35.0 → 0.37.0

package/dist/index.cjs

@@ -139,22 +139,6 @@ var deepEquals = (left, right) => {
 var isEquatable = (left) => {
   return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return _asyncretry2.default.call(void 0, 
-    async (bail) => {
-      try {
-        return await fn();
-      } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
-          bail(error2);
-        }
-        throw error2;
-      }
-    },
-    _nullishCoalesce(opts, () => ( { retries: 0 }))
-  );
-};
 var ParseError = class extends Error {
   constructor(text) {
     super(`Cannot parse! ${text}`);
@@ -163,19 +147,143 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _11 => _11.map]) ? options.map(value) : value,
+      _optionalChain([options, 'optionalAccess', _10 => _10.map]) ? options.map(value) : value,
       //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       (_, v) => typeof v === "bigint" ? v.toString() : v
     );
   },
   parse: (text, options) => {
-    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _12 => _12.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
+    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _11 => _11.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _12 => _12.typeCheck]) && !_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck, 'call', _14 => _14(parsed)]))
       throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _15 => _15.map]) ? options.map(parsed) : parsed;
   }
 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return _asyncretry2.default.call(void 0, 
+    async (bail) => {
+      try {
+        const result = await fn();
+        if (_optionalChain([opts, 'optionalAccess', _16 => _16.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONParser.stringify(result)}`
+          );
+        }
+        return result;
+      } catch (error2) {
+        if (_optionalChain([opts, 'optionalAccess', _17 => _17.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
+var MessageProcessorType = {
+  PROJECTOR: "projector",
+  REACTOR: "reactor"
+};
+var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+var reactor = (options) => {
+  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
+  let isActive = true;
+  const { checkpoints, processorId, partition } = options;
+  const processingScope = _nullishCoalesce(options.processingScope, () => ( defaultProcessingMessageProcessingScope));
+  return {
+    id: options.processorId,
+    type: _nullishCoalesce(options.type, () => ( MessageProcessorType.REACTOR)),
+    close: () => _optionalChain([options, 'access', _18 => _18.hooks, 'optionalAccess', _19 => _19.onClose]) ? _optionalChain([options, 'access', _20 => _20.hooks, 'optionalAccess', _21 => _21.onClose, 'call', _22 => _22()]) : Promise.resolve(),
+    start: async (startOptions) => {
+      isActive = true;
+      return await processingScope(async (context) => {
+        if (_optionalChain([options, 'access', _23 => _23.hooks, 'optionalAccess', _24 => _24.onStart])) {
+          await _optionalChain([options, 'access', _25 => _25.hooks, 'optionalAccess', _26 => _26.onStart, 'call', _27 => _27(context)]);
+        }
+        if (options.startFrom !== "CURRENT" && options.startFrom)
+          return options.startFrom;
+        let lastCheckpoint = null;
+        if (checkpoints) {
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _28 => _28.read, 'call', _29 => _29(
+            {
+              processorId,
+              partition
+            },
+            startOptions
+          )]);
+          lastCheckpoint = readResult.lastCheckpoint;
+        }
+        if (lastCheckpoint === null) return "BEGINNING";
+        return {
+          lastCheckpoint
+        };
+      }, startOptions);
+    },
+    get isActive() {
+      return isActive;
+    },
+    handle: async (messages, partialContext) => {
+      if (!isActive) return Promise.resolve();
+      return await processingScope(async (context) => {
+        let result = void 0;
+        let lastCheckpoint = null;
+        for (const message2 of messages) {
+          const messageProcessingResult = await eachMessage(message2, context);
+          if (checkpoints) {
+            const storeCheckpointResult = await checkpoints.store(
+              {
+                processorId: options.processorId,
+                version: options.version,
+                message: message2,
+                lastCheckpoint,
+                partition: options.partition
+              },
+              context
+            );
+            if (storeCheckpointResult && storeCheckpointResult.success) {
+              lastCheckpoint = storeCheckpointResult.newCheckpoint;
+            }
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+            isActive = false;
+            result = messageProcessingResult;
+            break;
+          }
+          if (options.stopAfter && options.stopAfter(message2)) {
+            isActive = false;
+            result = { type: "STOP", reason: "Stop condition reached" };
+            break;
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
+            continue;
+        }
+        return result;
+      }, partialContext);
+    }
+  };
+};
+var projector = (options) => {
+  const { projection: projection2, ...rest } = options;
+  return reactor({
+    ...rest,
+    type: MessageProcessorType.PROJECTOR,
+    processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
+    hooks: {
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _30 => _30.hooks, 'optionalAccess', _31 => _31.onStart]) ? async (context) => {
+        if (options.truncateOnStart && options.projection.truncate)
+          await options.projection.truncate(context);
+        if (_optionalChain([options, 'access', _32 => _32.hooks, 'optionalAccess', _33 => _33.onStart])) await _optionalChain([options, 'access', _34 => _34.hooks, 'optionalAccess', _35 => _35.onStart, 'call', _36 => _36(context)]);
+      } : void 0,
+      onClose: _optionalChain([options, 'access', _37 => _37.hooks, 'optionalAccess', _38 => _38.onClose])
+    },
+    eachMessage: async (event2, context) => {
+      if (!projection2.canHandle.includes(event2.type)) return;
+      await projection2.handle([event2], context);
+    }
+  });
+};
 var projection = (definition) => definition;
 var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
   transform(chunk, controller) {
@@ -485,7 +593,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
            WHERE partition = %L AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
            ORDER BY transaction_id, global_position
            LIMIT 1`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.partition]), () => ( defaultTag))
       )
     )
   );
@@ -502,7 +610,7 @@ var readMessagesBatch = async (execute, options) => {
   const fromCondition = from !== -0n ? `AND global_position >= ${from}` : "";
   const toCondition = "to" in options ? `AND global_position <= ${options.to}` : "";
   const limitCondition = "batchSize" in options ? `LIMIT ${options.batchSize}` : "";
-  const events = await _dumbo.mapRows.call(void 0, 
+  const messages = await _dumbo.mapRows.call(void 0, 
     execute.query(
       _dumbo.sql.call(void 0, 
         `SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
@@ -510,7 +618,7 @@ var readMessagesBatch = async (execute, options) => {
            WHERE partition = %L AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
            ORDER BY transaction_id, global_position
            ${limitCondition}`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
@@ -533,14 +641,14 @@ var readMessagesBatch = async (execute, options) => {
       };
     }
   );
-  return events.length > 0 ? {
-    currentGlobalPosition: events[events.length - 1].metadata.globalPosition,
-    messages: events,
-    areEventsLeft: events.length === batchSize
+  return messages.length > 0 ? {
+    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
+    messages,
+    areMessagesLeft: messages.length === batchSize
   } : {
     currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
     messages: [],
-    areEventsLeft: false
+    areMessagesLeft: false
   };
 };
 
@@ -551,21 +659,22 @@ var postgreSQLEventStoreMessageBatchPuller = ({
   executor,
   batchSize,
   eachBatch,
-  pullingFrequencyInMs
+  pullingFrequencyInMs,
+  stopWhen
 }) => {
   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.globalPosition;
+    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;
     do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await readMessagesBatch(executor, readMessagesOptions);
+      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
       if (messages.length > 0) {
-        const result = await eachBatch({ messages });
+        const result = await eachBatch(messages);
         if (result && result.type === "STOP") {
           isRunning = false;
           break;
@@ -573,7 +682,11 @@ var postgreSQLEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (!areEventsLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _41 => _41.noMessagesLeft]) === true && !areMessagesLeft) {
+        isRunning = false;
+        break;
+      }
+      if (!areMessagesLeft) {
         waitTime = Math.min(waitTime * 2, 1e3);
       } else {
         waitTime = pullingFrequencyInMs;
@@ -609,6 +722,7 @@ var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 
 
+
 // src/eventStore/consumers/postgreSQLProcessor.ts
 
 
@@ -719,7 +833,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
   let appendResult;
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _19 => _19.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _42 => _42.expectedStreamVersion])
     );
     const messagesToAppend = messages.map((e, i) => ({
       ...e,
@@ -740,7 +854,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _20 => _20.beforeCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _43 => _43.beforeCommitHook]))
       await options.beforeCommitHook(messagesToAppend, { transaction });
   } catch (error) {
     if (!isOptimisticConcurrencyError(error)) throw error;
@@ -798,8 +912,8 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
       messages.map((e) => _dumbo.sql.call(void 0, "%L", e.kind === "Event" ? "E" : "C")).join(","),
       streamId,
       streamType,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.expectedStreamVersion]), () => ( "NULL")),
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _44 => _44.expectedStreamVersion]), () => ( "NULL")),
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.partition]), () => ( defaultTag))
     )
   )
 );
@@ -866,7 +980,7 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 `);
-async function storeProcessorCheckpoint(execute, options) {
+var storeProcessorCheckpoint = async (execute, options) => {
   try {
     const { result } = await _dumbo.single.call(void 0, 
       execute.command(
@@ -885,7 +999,7 @@ async function storeProcessorCheckpoint(execute, options) {
     console.log(error);
     throw error;
   }
-}
+};
 
 // src/eventStore/schema/tables.ts
 
@@ -1243,7 +1357,7 @@ var readProcessorCheckpoint = async (execute, options) => {
            FROM ${subscriptionsTable.name}
            WHERE partition = %L AND subscription_id = %L
            LIMIT 1`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.partition]), () => ( defaultTag)),
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.partition]), () => ( defaultTag)),
         options.processorId
       )
     )
@@ -1268,7 +1382,7 @@ var readStream = async (execute, streamId, options) => {
            FROM ${messagesTable.name}
            WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
         streamId,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.partition]), () => ( defaultTag))
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
@@ -1324,120 +1438,114 @@ var createEventStoreSchema = async (pool) => {
 };
 
 // src/eventStore/consumers/postgreSQLProcessor.ts
-var PostgreSQLProcessor = {
-  result: {
-    skip: (options) => ({
-      type: "SKIP",
-      ..._nullishCoalesce(options, () => ( {}))
-    }),
-    stop: (options) => ({
-      type: "STOP",
-      ..._nullishCoalesce(options, () => ( {}))
-    })
+var postgreSQLCheckpointer = () => ({
+  read: async (options, context) => {
+    const result = await readProcessorCheckpoint(context.execute, options);
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _48 => _48.lastProcessedPosition]) };
+  },
+  store: async (options, context) => {
+    const result = await storeProcessorCheckpoint(context.execute, {
+      lastProcessedPosition: options.lastCheckpoint,
+      newPosition: options.message.metadata.globalPosition,
+      processorId: options.processorId,
+      partition: options.partition,
+      version: options.version
+    });
+    return result.success ? { success: true, newCheckpoint: result.newPosition } : result;
   }
-};
-var genericPostgreSQLProcessor = (options) => {
-  const { eachMessage } = options;
-  let isActive = true;
-  const poolOptions = {
-    ...options.connectionOptions ? options.connectionOptions : {}
-  };
-  const processorConnectionString = "connectionString" in poolOptions ? poolOptions.connectionString : null;
-  const processorPool = "dumbo" in poolOptions ? poolOptions.dumbo : processorConnectionString ? _dumbo.dumbo.call(void 0, {
-    connectionString: processorConnectionString,
-    ...poolOptions
-  }) : null;
-  const getPool = (context) => {
-    const connectionString = _nullishCoalesce(processorConnectionString, () => ( context.connectionString));
+});
+var postgreSQLProcessingScope = (options) => {
+  const processorConnectionString = options.connectionString;
+  const processorPool = options.pool;
+  const processingScope = async (handler, partialContext) => {
+    const connection = _optionalChain([partialContext, 'optionalAccess', _49 => _49.connection]);
+    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _50 => _50.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([context, 'optionalAccess', _25 => _25.pool]) : processorPool), () => ( processorPool));
+    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _51 => _51.pool]) : processorPool), () => ( processorPool));
     if (!pool)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
       );
-    return {
-      connectionString,
-      pool
-    };
-  };
-  return {
-    id: options.processorId,
-    start: async (execute) => {
-      isActive = true;
-      if (options.startFrom !== "CURRENT") return options.startFrom;
-      const { lastProcessedPosition } = await readProcessorCheckpoint(execute, {
-        processorId: options.processorId,
-        partition: options.partition
-      });
-      if (lastProcessedPosition === null) return "BEGINNING";
-      return { globalPosition: lastProcessedPosition };
-    },
-    get isActive() {
-      return isActive;
-    },
-    handle: async ({ messages }, context) => {
-      if (!isActive) return;
-      const { pool, connectionString } = getPool(context);
-      return pool.withTransaction(async (transaction) => {
-        let result = void 0;
-        let lastProcessedPosition = null;
-        for (const message of messages) {
-          const typedMessage = message;
-          const client = await transaction.connection.open();
-          const messageProcessingResult = await eachMessage(typedMessage, {
-            execute: transaction.execute,
-            connection: {
-              connectionString,
-              pool,
-              transaction,
-              client
-            }
-          });
-          await storeProcessorCheckpoint(transaction.execute, {
-            processorId: options.processorId,
-            version: options.version,
-            lastProcessedPosition,
-            newPosition: typedMessage.metadata.globalPosition,
-            partition: options.partition
-          });
-          lastProcessedPosition = typedMessage.metadata.globalPosition;
-          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-            isActive = false;
-            result = messageProcessingResult;
-            break;
-          }
-          if (options.stopAfter && options.stopAfter(typedMessage)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
+    return pool.withTransaction(async (transaction) => {
+      const client = await transaction.connection.open();
+      return handler({
+        execute: transaction.execute,
+        connection: {
+          connectionString,
+          pool,
+          client,
+          transaction
         }
-        return result;
       });
-    }
+    });
   };
+  return processingScope;
 };
-var postgreSQLProjectionProcessor = (options) => {
-  const projection2 = options.projection;
-  return genericPostgreSQLProcessor({
-    processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
-    eachMessage: async (event, context) => {
-      if (!projection2.canHandle.includes(event.type)) return;
-      await projection2.handle([event], context);
-    },
-    ...options
+var getProcessorPool = (options) => {
+  const poolOptions = {
+    ...options.connectionOptions ? options.connectionOptions : {}
+  };
+  const processorConnectionString = "connectionString" in poolOptions ? _nullishCoalesce(poolOptions.connectionString, () => ( null)) : null;
+  const processorPool = "dumbo" in poolOptions ? poolOptions.dumbo : processorConnectionString ? _dumbo.dumbo.call(void 0, {
+    connectionString: processorConnectionString,
+    ...poolOptions
+  }) : null;
+  return {
+    pool: processorPool,
+    connectionString: processorConnectionString,
+    close: processorPool != null && !("dumbo" in poolOptions) ? processorPool.close : void 0
+  };
+};
+var postgreSQLProjector = (options) => {
+  const { pool, connectionString, close } = getProcessorPool(options);
+  const hooks = {
+    onStart: _optionalChain([options, 'access', _52 => _52.hooks, 'optionalAccess', _53 => _53.onStart]),
+    onClose: _optionalChain([options, 'access', _54 => _54.hooks, 'optionalAccess', _55 => _55.onClose]) || close ? async () => {
+      if (_optionalChain([options, 'access', _56 => _56.hooks, 'optionalAccess', _57 => _57.onClose])) await _optionalChain([options, 'access', _58 => _58.hooks, 'optionalAccess', _59 => _59.onClose, 'call', _60 => _60()]);
+      if (close) await close();
+    } : void 0
+  };
+  return projector({
+    ...options,
+    hooks,
+    processingScope: postgreSQLProcessingScope({
+      pool,
+      connectionString,
+      processorId: _nullishCoalesce(options.processorId, () => ( `projection:${options.projection.name}`))
+    }),
+    checkpoints: postgreSQLCheckpointer()
   });
 };
-var postgreSQLProcessor = (options) => {
+var postgreSQLReactor = (options) => {
+  const { pool, connectionString, close } = getProcessorPool(options);
+  const hooks = {
+    onStart: _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onStart]),
+    onClose: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onClose]) || close ? async () => {
+      if (_optionalChain([options, 'access', _65 => _65.hooks, 'optionalAccess', _66 => _66.onClose])) await _optionalChain([options, 'access', _67 => _67.hooks, 'optionalAccess', _68 => _68.onClose, 'call', _69 => _69()]);
+      if (close) await close();
+    } : void 0
+  };
+  return reactor({
+    ...options,
+    hooks,
+    processingScope: postgreSQLProcessingScope({
+      pool,
+      connectionString,
+      processorId: options.processorId
+    }),
+    checkpoints: postgreSQLCheckpointer()
+  });
+};
+var postgreSQLMessageProcessor = (options) => {
   if ("projection" in options) {
-    return postgreSQLProjectionProcessor(options);
+    return postgreSQLProjector(
+      options
+    );
   }
-  return genericPostgreSQLProcessor(options);
+  return postgreSQLReactor(options);
 };
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
@@ -1458,22 +1566,25 @@ var postgreSQLEventStoreConsumer = (options) => {
     const result = await Promise.allSettled(
       activeProcessors.map((s) => {
         return s.handle(messagesBatch, {
-          pool,
-          connectionString: options.connectionString
+          connection: {
+            connectionString: options.connectionString,
+            pool
+          }
         });
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _26 => _26.value, 'optionalAccess', _27 => _27.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _70 => _70.value, 'optionalAccess', _71 => _71.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
   };
   const messagePooler = currentMessagePuller = postgreSQLEventStoreMessageBatchPuller({
+    stopWhen: options.stopWhen,
     executor: pool.execute,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _28 => _28.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _29 => _29.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _72 => _72.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _73 => _73.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -1483,15 +1594,20 @@ var postgreSQLEventStoreConsumer = (options) => {
       currentMessagePuller = void 0;
     }
     await start;
+    await Promise.all(processors.map((p) => p.close()));
   };
   return {
-    processors,
+    consumerId: _nullishCoalesce(options.consumerId, () => ( _uuid.v7.call(void 0, ))),
     get isRunning() {
       return isRunning;
     },
+    processors,
     processor: (options2) => {
-      const processor = postgreSQLProcessor(options2);
-      processors.push(processor);
+      const processor = postgreSQLMessageProcessor(options2);
+      processors.push(
+        // TODO: change that
+        processor
+      );
       return processor;
     },
     start: () => {
@@ -1505,7 +1621,18 @@ var postgreSQLEventStoreConsumer = (options) => {
           );
         isRunning = true;
         const startFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom(
-          await Promise.all(processors.map((o) => o.start(pool.execute)))
+          await Promise.all(
+            processors.map(async (o) => {
+              const result = await o.start({
+                execute: pool.execute,
+                connection: {
+                  connectionString: options.connectionString,
+                  pool
+                }
+              });
+              return result;
+            })
+          )
         );
         return messagePooler.start({ startFrom });
       })();
@@ -1519,14 +1646,110 @@ var postgreSQLEventStoreConsumer = (options) => {
   };
 };
 
-// src/eventStore/projections/index.ts
+// src/eventStore/consumers/rebuildPostgreSQLProjections.ts
+
+var rebuildPostgreSQLProjections = (options) => {
+  const consumer = postgreSQLEventStoreConsumer({
+    ...options,
+    stopWhen: { noMessagesLeft: true }
+  });
+  const projections = "projections" in options ? options.projections.map(
+    (p) => "projection" in p ? {
+      ...p,
+      processorId: `projection:${_nullishCoalesce(p.projection.name, () => ( _uuid.v7.call(void 0, )))}-rebuild`,
+      truncateOnStart: _nullishCoalesce(p.truncateOnStart, () => ( true))
+    } : {
+      projection: p,
+      processorId: `projection:${_nullishCoalesce(p.name, () => ( _uuid.v7.call(void 0, )))}-rebuild`,
+      truncateOnStart: true
+    }
+  ) : [options];
+  for (const projectionDefinition of projections) {
+    consumer.processor({
+      ...projectionDefinition,
+      processorId: _nullishCoalesce(projectionDefinition.processorId, () => ( `projection:${_nullishCoalesce(projectionDefinition.projection.name, () => ( _uuid.v7.call(void 0, )))}-rebuild`)),
+      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true))
+    });
+  }
+  return consumer;
+};
+
+// src/eventStore/projections/pongo/pongoProjections.ts
+
 
+var _pongo = require('@event-driven-io/pongo');
+var pongoProjection = ({
+  truncate,
+  handle,
+  canHandle
+}) => postgreSQLProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const {
+      connection: { connectionString, client, pool }
+    } = context;
+    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+      connectionOptions: { client, pool }
+    });
+    await handle(events, {
+      ...context,
+      pongo
+    });
+  },
+  truncate: truncate ? (context) => {
+    const {
+      connection: { connectionString, client, pool }
+    } = context;
+    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+      connectionOptions: { client, pool }
+    });
+    return truncate({
+      ...context,
+      pongo
+    });
+  } : void 0
+});
+var pongoMultiStreamProjection = (options) => {
+  const { collectionName, getDocumentId, canHandle } = options;
+  return pongoProjection({
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(collectionName);
+      for (const event of events) {
+        await collection.handle(getDocumentId(event), async (document) => {
+          return "initialState" in options ? await options.evolve(
+            _nullishCoalesce(document, () => ( options.initialState())),
+            event
+          ) : await options.evolve(
+            document,
+            event
+          );
+        });
+      }
+    },
+    canHandle,
+    truncate: async (context) => {
+      const {
+        connection: { connectionString, client, pool }
+      } = context;
+      const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+        connectionOptions: { client, pool }
+      });
+      await pongo.db().collection(collectionName).deleteMany();
+    }
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    getDocumentId: _nullishCoalesce(options.getDocumentId, () => ( ((event) => event.metadata.streamName)))
+  });
+};
 
 // src/eventStore/projections/pongo/pongoProjectionSpec.ts
 
 
 
-var _pongo = require('@event-driven-io/pongo');
+
 var withCollection = (handle, options) => {
   const { pool, connectionString, inDatabase, inCollection } = options;
   return pool.withConnection(async (connection) => {
@@ -1658,55 +1881,6 @@ var expectPongoDocuments = {
   }
 };
 
-// src/eventStore/projections/pongo/projections.ts
-
-
-
-var pongoProjection = ({
-  handle,
-  canHandle
-}) => postgreSQLProjection({
-  canHandle,
-  handle: async (events, context) => {
-    const {
-      connection: { connectionString, client }
-    } = context;
-    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
-      connectionOptions: { client }
-    });
-    await handle(events, {
-      ...context,
-      pongo
-    });
-  }
-});
-var pongoMultiStreamProjection = (options) => {
-  const { collectionName, getDocumentId, canHandle } = options;
-  return pongoProjection({
-    handle: async (events, { pongo }) => {
-      const collection = pongo.db().collection(collectionName);
-      for (const event of events) {
-        await collection.handle(getDocumentId(event), async (document) => {
-          return "initialState" in options ? await options.evolve(
-            _nullishCoalesce(document, () => ( options.initialState())),
-            event
-          ) : await options.evolve(
-            document,
-            event
-          );
-        });
-      }
-    },
-    canHandle
-  });
-};
-var pongoSingleStreamProjection = (options) => {
-  return pongoMultiStreamProjection({
-    ...options,
-    getDocumentId: _nullishCoalesce(options.getDocumentId, () => ( ((event) => event.metadata.streamName)))
-  });
-};
-
 // src/eventStore/projections/postgresProjectionSpec.ts
 
 
@@ -1723,7 +1897,7 @@ var PostgreSQLProjectionSpec = {
             const allEvents = [];
             const run = async (pool) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _30 => _30.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _74 => _74.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -1780,18 +1954,18 @@ var PostgreSQLProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _31 => _31.toString, 'call', _32 => _32()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _33 => _33.toString, 'call', _34 => _34()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _77 => _77.toString, 'call', _78 => _78()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _35 => _35.toString, 'call', _36 => _36()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _79 => _79.toString, 'call', _80 => _80()])}`
                     );
                   }
                 } finally {
@@ -1810,7 +1984,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _37 => _37.metadata, 'optionalAccess', _38 => _38.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _81 => _81.metadata, 'optionalAccess', _82 => _82.streamName]), () => ( streamName))
     }
   };
 };
@@ -1830,7 +2004,8 @@ var expectSQL = {
   })
 };
 
-// src/eventStore/projections/index.ts
+// src/eventStore/projections/postgreSQLProjection.ts
+
 var handleProjections = async (options) => {
   const {
     projections: allProjections,
@@ -1886,7 +2061,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
   const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
   let migrateSchema;
-  const autoGenerateSchema = _optionalChain([options, 'access', _39 => _39.schema, 'optionalAccess', _40 => _40.autoMigration]) === void 0 || _optionalChain([options, 'access', _41 => _41.schema, 'optionalAccess', _42 => _42.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _83 => _83.schema, 'optionalAccess', _84 => _84.autoMigration]) === void 0 || _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) !== "None";
   const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!migrateSchema) {
@@ -1916,7 +2091,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _43 => _43.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _87 => _87.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
@@ -1957,7 +2132,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _44 => _44.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _88 => _88.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -2051,5 +2226,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
 
 
 
-exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize; exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProcessor = PostgreSQLProcessor; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.addDefaultPartitionSQL = addDefaultPartitionSQL; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addPartitionSQL = addPartitionSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendToStream = appendToStream; exports.appendToStreamSQL = appendToStreamSQL; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migrationFromEventsToMessagesSQL = migrationFromEventsToMessagesSQL; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLProcessor = postgreSQLProcessor; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLProjectionProcessor = postgreSQLProjectionProcessor; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaSQL = schemaSQL; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.storeSubscriptionCheckpointSQL = storeSubscriptionCheckpointSQL; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.subscriptionsTable = subscriptionsTable; exports.subscriptionsTableSQL = subscriptionsTableSQL; exports.zipPostgreSQLEventStoreMessageBatchPullerStartFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom;
+
+
+exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize; exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.addDefaultPartitionSQL = addDefaultPartitionSQL; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addPartitionSQL = addPartitionSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendToStream = appendToStream; exports.appendToStreamSQL = appendToStreamSQL; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migrationFromEventsToMessagesSQL = migrationFromEventsToMessagesSQL; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLCheckpointer = postgreSQLCheckpointer; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLMessageProcessor = postgreSQLMessageProcessor; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLProjector = postgreSQLProjector; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.postgreSQLReactor = postgreSQLReactor; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.rebuildPostgreSQLProjections = rebuildPostgreSQLProjections; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaSQL = schemaSQL; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.storeSubscriptionCheckpointSQL = storeSubscriptionCheckpointSQL; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.subscriptionsTable = subscriptionsTable; exports.subscriptionsTableSQL = subscriptionsTableSQL; exports.zipPostgreSQLEventStoreMessageBatchPullerStartFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom;
 //# sourceMappingURL=index.cjs.map