@event-driven-io/emmett-postgresql 0.28.0 → 0.30.0

package/dist/index.cjs

@@ -436,397 +436,190 @@ var assertThatArray = (array) => {
 // src/eventStore/postgreSQLEventStore.ts
 require('pg');
 
-// src/eventStore/projections/index.ts
-
+// src/eventStore/consumers/messageBatchProcessing/index.ts
 
-// src/eventStore/projections/pongo/pongoProjectionSpec.ts
 
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
 
 
-var _pongo = require('@event-driven-io/pongo');
-var withCollection = (handle, options) => {
-  const { pool, connectionString, inDatabase, inCollection } = options;
-  return pool.withConnection(async (connection) => {
-    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
-      connectionOptions: { connection }
-    });
-    try {
-      const collection = pongo.db(inDatabase).collection(inCollection);
-      return handle(collection);
-    } finally {
-      await pongo.close();
-    }
-  });
-};
-var withoutIdAndVersion = (doc) => {
-  const { _id, _version, ...without } = doc;
-  return without;
-};
-var assertDocumentsEqual = (actual, expected) => {
-  if ("_id" in expected)
-    assertEqual(
-      expected._id,
-      actual._id,
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`
-    );
-  return assertDeepEqual(
-    withoutIdAndVersion(actual),
-    withoutIdAndVersion(expected)
-  );
+// src/eventStore/schema/typing.ts
+var emmettPrefix = "emt";
+var globalTag = "global";
+var defaultTag = "emt:default";
+var globalNames = {
+  module: `${emmettPrefix}:module:${globalTag}`,
+  tenant: `${emmettPrefix}:tenant:${globalTag}`
 };
-var documentExists = (document, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.findOne(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertIsNotNull(result);
-    assertDocumentsEqual(result, document);
-  },
-  { ...options, ...assertOptions }
-);
-var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertEqual(
-      documents.length,
-      result.length,
-      "Different Documents Count than expected"
-    );
-    for (let i = 0; i < documents.length; i++) {
-      assertThatArray(result).contains(documents[i]);
-    }
-  },
-  { ...options, ...assertOptions }
-);
-var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertEqual(
-      expectedCount,
-      result.length,
-      "Different Documents Count than expected"
-    );
-  },
-  { ...options, ...assertOptions }
-);
-var documentMatchingExists = (options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.find(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertThatArray(result).isNotEmpty();
-  },
-  { ...options, ...assertOptions }
-);
-var documentDoesNotExist = (options) => (assertOptions) => withCollection(
-  async (collection) => {
-    const result = await collection.findOne(
-      "withId" in options ? { _id: options.withId } : options.matchingFilter
-    );
-    assertIsNotNull(result);
+var columns = {
+  partition: {
+    name: "partition"
   },
-  { ...options, ...assertOptions }
-);
-var expectPongoDocuments = {
-  fromCollection: (collectionName) => {
-    return {
-      withId: (id) => {
-        return {
-          toBeEqual: (document) => documentExists(document, {
-            withId: id,
-            inCollection: collectionName
-          }),
-          toExist: () => documentMatchingExists({
-            withId: id,
-            inCollection: collectionName
-          }),
-          notToExist: () => documentDoesNotExist({
-            withId: id,
-            inCollection: collectionName
-          })
-        };
-      },
-      matching: (filter2) => {
-        return {
-          toBeTheSame: (documents) => documentsAreTheSame(documents, {
-            matchingFilter: filter2,
-            inCollection: collectionName
-          }),
-          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
-            matchingFilter: filter2,
-            inCollection: collectionName
-          }),
-          toExist: () => documentMatchingExists({
-            matchingFilter: filter2,
-            inCollection: collectionName
-          }),
-          notToExist: () => documentDoesNotExist({
-            matchingFilter: filter2,
-            inCollection: collectionName
-          })
-        };
-      }
-    };
+  isArchived: { name: "is_archived" }
+};
+var streamsTable = {
+  name: `${emmettPrefix}_streams`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
   }
 };
-
-// src/eventStore/projections/pongo/projections.ts
-
-
-
-var pongoProjection = ({
-  handle,
-  canHandle
-}) => postgreSQLProjection({
-  canHandle,
-  handle: async (events, context) => {
-    const { connectionString, client } = context;
-    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
-      connectionOptions: { client }
-    });
-    await handle(events, {
-      ...context,
-      pongo
-    });
+var eventsTable = {
+  name: `${emmettPrefix}_events`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
   }
-});
-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)))
-  });
+var subscriptionsTable = {
+  name: `${emmettPrefix}_subscriptions`
 };
 
-// src/eventStore/projections/postgresProjectionSpec.ts
-
-
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await _dumbo.singleOrNull.call(void 0, 
+    execute.query(
+      _dumbo.sql.call(void 0, 
+        `SELECT global_position
+           FROM ${eventsTable.name}
+           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))
+      )
+    )
+  );
+  return {
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+  };
+};
 
+// src/eventStore/schema/readMessagesBatch.ts
 
-var PostgreSQLProjectionSpec = {
-  for: (options) => {
-    {
-      const { projection: projection2, ...dumoOptions } = options;
-      const { connectionString } = dumoOptions;
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (pool) => {
-              let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _17 => _17.numberOfTimes]), () => ( 1));
-              for (const event of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                const metadata = {
-                  globalPosition: ++globalPosition,
-                  streamPosition: globalPosition,
-                  streamName: `test-${_uuid.v4.call(void 0, )}`,
-                  eventId: _uuid.v4.call(void 0, )
-                };
-                allEvents.push({
-                  ...event,
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
-                  }
-                });
-              }
-              await pool.withTransaction(
-                (transaction) => handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  connection: {
-                    connectionString,
-                    transaction
-                  }
-                })
-              );
-            };
-            return {
-              then: async (assert, message) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
-                try {
-                  await run(pool);
-                  const succeeded = await assert({ pool, connectionString });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
-                    );
-                } finally {
-                  await pool.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
-                try {
-                  await run(pool);
-                  throw new AssertionError("Handler did not fail as expected");
-                } catch (error) {
-                  if (error instanceof AssertionError) throw error;
-                  if (args.length === 0) return;
-                  if (!isErrorConstructor(args[0])) {
-                    assertTrue(
-                      args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
-                    );
-                  }
-                } finally {
-                  await pool.close();
-                }
-              }
-            };
-          }
-        };
+var readMessagesBatch = async (execute, options) => {
+  const from = "from" in options ? options.from : "after" in options ? options.after + 1n : 0n;
+  const batchSize = options && "batchSize" in options ? options.batchSize : options.to - options.from;
+  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, 
+    execute.query(
+      _dumbo.sql.call(void 0, 
+        `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
+           FROM ${eventsTable.name}
+           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))
+      )
+    ),
+    (row) => {
+      const rawEvent = {
+        type: row.event_type,
+        data: row.event_data,
+        metadata: row.event_metadata
+      };
+      const metadata = {
+        ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
+        eventId: row.event_id,
+        streamName: row.stream_id,
+        streamPosition: BigInt(row.stream_position),
+        globalPosition: BigInt(row.global_position)
+      };
+      return {
+        ...rawEvent,
+        metadata
       };
     }
-  }
+  );
+  return events.length > 0 ? {
+    currentGlobalPosition: events[events.length - 1].metadata.globalPosition,
+    messages: events,
+    areEventsLeft: events.length === batchSize
+  } : {
+    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
+    messages: [],
+    areEventsLeft: false
+  };
 };
-var eventInStream = (streamName, event) => {
+
+// src/eventStore/consumers/messageBatchProcessing/index.ts
+var DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
+var DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
+var postgreSQLEventStoreMessageBatchPuller = ({
+  executor,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs
+}) => {
+  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 readMessagesOptions = {
+      after,
+      batchSize
+    };
+    let waitTime = 100;
+    do {
+      const { messages, currentGlobalPosition, areEventsLeft } = 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 (!areEventsLeft) {
+        waitTime = Math.min(waitTime * 2, 1e3);
+      } else {
+        waitTime = pullingFrequencyInMs;
+      }
+    } while (isRunning);
+  };
   return {
-    ...event,
-    metadata: {
-      ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => ( streamName))
+    get isRunning() {
+      return isRunning;
+    },
+    start: (options) => {
+      if (isRunning) return start;
+      start = (async () => {
+        isRunning = true;
+        return pullMessages(options);
+      })();
+      return start;
+    },
+    stop: async () => {
+      if (!isRunning) return;
+      isRunning = false;
+      await start;
     }
   };
 };
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
-var assertSQLQueryResultMatches = (sql7, rows) => async ({ pool: { execute } }) => {
-  const result = await execute.query(sql7);
-  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
-};
-var expectSQL = {
-  query: (sql7) => ({
-    resultRows: {
-      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql7, rows)
-    }
-  })
+var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
+  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
+    return "BEGINNING";
+  if (options.every((o) => o === "END")) return "END";
+  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
 };
 
-// src/eventStore/projections/index.ts
-var handleProjections = async (options) => {
-  const {
-    projections: allProjections,
-    events,
-    connection: { transaction, connectionString }
-  } = options;
-  const eventTypes = events.map((e) => e.type);
-  const projections = allProjections.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
-  );
-  const client = await transaction.connection.open();
-  for (const projection2 of projections) {
-    await projection2.handle(events, {
-      connectionString,
-      client,
-      transaction,
-      execute: transaction.execute
-    });
-  }
-};
-var postgreSQLProjection = (definition) => projection(definition);
-var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjection({
-  canHandle,
-  handle: async (events, context) => {
-    const sqls = await handle(events, context);
-    await context.execute.batchCommand(sqls);
-  }
-});
-var postgreSQLRawSQLProjection = (handle, ...canHandle) => postgreSQLRawBatchSQLProjection(
-  async (events, context) => {
-    const sqls = [];
-    for (const event of events) {
-      sqls.push(await handle(event, context));
-    }
-    return sqls;
-  },
-  ...canHandle
-);
+// src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 
-// src/eventStore/schema/index.ts
 
+// src/eventStore/consumers/postgreSQLProcessor.ts
 
-// src/eventStore/schema/appendToStream.ts
 
+// src/eventStore/schema/index.ts
 
 
+// src/eventStore/schema/appendToStream.ts
+
 
 
 
 
-// src/eventStore/schema/typing.ts
-var emmettPrefix = "emt";
-var globalTag = "global";
-var defaultTag = "emt:default";
-var globalNames = {
-  module: `${emmettPrefix}:module:${globalTag}`,
-  tenant: `${emmettPrefix}:tenant:${globalTag}`
-};
-var columns = {
-  partition: {
-    name: "partition"
-  },
-  isArchived: { name: "is_archived" }
-};
-var streamsTable = {
-  name: `${emmettPrefix}_streams`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var eventsTable = {
-  name: `${emmettPrefix}_events`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var subscriptionsTable = {
-  name: `${emmettPrefix}_subscriptions`
-};
 
-// src/eventStore/schema/appendToStream.ts
 var appendEventsSQL = _dumbo.rawSql.call(void 0, 
   `CREATE OR REPLACE FUNCTION emt_append_event(
       v_event_ids text[],
@@ -919,7 +712,7 @@ var appendToStream = (pool, streamName, streamType, events, options) => pool.wit
   let appendResult;
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _19 => _19.expectedStreamVersion])
     );
     const eventsToAppend = events.map((e, i) => ({
       ...e,
@@ -939,7 +732,7 @@ var appendToStream = (pool, streamName, streamType, events, options) => pool.wit
         expectedStreamVersion
       }
     );
-    if (_optionalChain([options, 'optionalAccess', _27 => _27.preCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _20 => _20.preCommitHook]))
       await options.preCommitHook(eventsToAppend, { transaction });
   } catch (error) {
     if (!isOptimisticConcurrencyError(error)) throw error;
@@ -995,13 +788,13 @@ var appendEventsRaw = (execute, streamId, streamType, events, options) => _dumbo
       events.map((e) => _dumbo.sql.call(void 0, "%L", e.type)).join(","),
       streamId,
       streamType,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.expectedStreamVersion]), () => ( "NULL")),
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.partition]), () => ( defaultTag))
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.expectedStreamVersion]), () => ( "NULL")),
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition]), () => ( defaultTag))
     )
   )
 );
 
-// src/eventStore/schema/storeSubscriptionCheckpoint.ts
+// src/eventStore/schema/storeProcessorCheckpoint.ts
 
 var storeSubscriptionCheckpointSQL = _dumbo.sql.call(void 0, `
 CREATE OR REPLACE FUNCTION store_subscription_checkpoint(
@@ -1063,13 +856,13 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 `);
-async function storeSubscriptionCheckpoint(execute, options) {
+async function storeProcessorCheckpoint(execute, options) {
   try {
     const { result } = await _dumbo.single.call(void 0, 
       execute.command(
         _dumbo.sql.call(void 0, 
           `SELECT store_subscription_checkpoint(%L, %s, %L, %L, pg_current_xact_id(), %L) as result;`,
-          options.subscriptionId,
+          options.processorId,
           _nullishCoalesce(options.version, () => ( 1)),
           options.newPosition,
           options.lastProcessedPosition,
@@ -1382,91 +1175,22 @@ var addDefaultPartition = _dumbo.rawSql.call(void 0,
   `SELECT emt_add_partition('${defaultTag}');`
 );
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
+// src/eventStore/schema/readStream.ts
 
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await _dumbo.singleOrNull.call(void 0, 
+var readStream = async (execute, streamId, options) => {
+  const fromCondition = options && "from" in options ? `AND stream_position >= ${options.from}` : "";
+  const to = Number(
+    options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : NaN
+  );
+  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
+  const events = await _dumbo.mapRows.call(void 0, 
     execute.query(
       _dumbo.sql.call(void 0, 
-        `SELECT global_position
+        `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
            FROM ${eventsTable.name}
-           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', _30 => _30.partition]), () => ( defaultTag))
-      )
-    )
-  );
-  return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
-  };
-};
-
-// src/eventStore/schema/readMessagesBatch.ts
-
-var readMessagesBatch = async (execute, options) => {
-  const from = "from" in options ? options.from : "after" in options ? options.after + 1n : 0n;
-  const batchSize = options && "batchSize" in options ? options.batchSize : options.to - options.from;
-  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, 
-    execute.query(
-      _dumbo.sql.call(void 0, 
-        `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
-           FROM ${eventsTable.name}
-           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', _31 => _31.partition]), () => ( defaultTag))
-      )
-    ),
-    (row) => {
-      const rawEvent = {
-        type: row.event_type,
-        data: row.event_data,
-        metadata: row.event_metadata
-      };
-      const metadata = {
-        ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
-        eventId: row.event_id,
-        streamName: row.stream_id,
-        streamPosition: BigInt(row.stream_position),
-        globalPosition: BigInt(row.global_position)
-      };
-      return {
-        ...rawEvent,
-        metadata
-      };
-    }
-  );
-  return events.length > 0 ? {
-    currentGlobalPosition: events[events.length - 1].metadata.globalPosition,
-    messages: events,
-    areEventsLeft: events.length === batchSize
-  } : {
-    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
-    messages: [],
-    areEventsLeft: false
-  };
-};
-
-// src/eventStore/schema/readStream.ts
-
-var readStream = async (execute, streamId, options) => {
-  const fromCondition = options && "from" in options ? `AND stream_position >= ${options.from}` : "";
-  const to = Number(
-    options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : NaN
-  );
-  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
-  const events = await _dumbo.mapRows.call(void 0, 
-    execute.query(
-      _dumbo.sql.call(void 0, 
-        `SELECT stream_id, stream_position, global_position, event_data, event_metadata, event_schema_version, event_type, event_id
-           FROM ${eventsTable.name}
-           WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
-        streamId,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.partition]), () => ( defaultTag))
+           WHERE stream_id = %L AND partition = %L AND is_archived = FALSE ${fromCondition} ${toCondition}`,
+        streamId,
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.partition]), () => ( defaultTag))
       )
     ),
     (row) => {
@@ -1499,9 +1223,9 @@ var readStream = async (execute, streamId, options) => {
   };
 };
 
-// src/eventStore/schema/readSubscriptionCheckpoint.ts
+// src/eventStore/schema/readProcessorCheckpoint.ts
 
-var readSubscriptionCheckpoint = async (execute, options) => {
+var readProcessorCheckpoint = async (execute, options) => {
   const result = await _dumbo.singleOrNull.call(void 0, 
     execute.query(
       _dumbo.sql.call(void 0, 
@@ -1509,35 +1233,524 @@ var readSubscriptionCheckpoint = async (execute, options) => {
            FROM ${subscriptionsTable.name}
            WHERE partition = %L AND subscription_id = %L
            LIMIT 1`,
-        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.partition]), () => ( defaultTag)),
-        options.subscriptionId
+        _nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.partition]), () => ( defaultTag)),
+        options.processorId
       )
     )
   );
   return {
-    lastProcessedPosition: result !== null ? BigInt(result.last_processed_position) : null
+    lastProcessedPosition: result !== null ? BigInt(result.last_processed_position) : null
+  };
+};
+
+// src/eventStore/schema/index.ts
+var schemaSQL = [
+  streamsTableSQL,
+  eventsTableSQL,
+  subscriptionsTableSQL,
+  sanitizeNameSQL,
+  addTablePartitions,
+  addEventsPartitions,
+  addModuleSQL,
+  addTenantSQL,
+  addModuleForAllTenantsSQL,
+  addTenantForAllModulesSQL,
+  appendEventsSQL,
+  addDefaultPartition,
+  storeSubscriptionCheckpointSQL
+];
+var createEventStoreSchema = async (pool) => {
+  await pool.withTransaction(({ execute }) => execute.batchCommand(schemaSQL));
+};
+
+// src/eventStore/consumers/postgreSQLProcessor.ts
+var PostgreSQLProcessor = {
+  result: {
+    skip: (options) => ({
+      type: "SKIP",
+      ..._nullishCoalesce(options, () => ( {}))
+    }),
+    stop: (options) => ({
+      type: "STOP",
+      ..._nullishCoalesce(options, () => ( {}))
+    })
+  }
+};
+var postgreSQLProcessor = (options) => {
+  const { eachMessage } = options;
+  let isActive = true;
+  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 }, { pool }) => {
+      if (!isActive) return;
+      return pool.withTransaction(async (tx) => {
+        let result = void 0;
+        let lastProcessedPosition = null;
+        for (const message of messages) {
+          const typedMessage = message;
+          const messageProcessingResult = await eachMessage(typedMessage);
+          await storeProcessorCheckpoint(tx.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 result;
+      });
+    }
+  };
+};
+
+// src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
+var postgreSQLEventStoreConsumer = (options) => {
+  let isRunning = false;
+  const { pulling } = options;
+  const processors = _nullishCoalesce(options.processors, () => ( []));
+  let start;
+  let currentMessagePuller;
+  const pool = "pool" in options ? options.pool : _dumbo.dumbo.call(void 0, { connectionString: options.connectionString });
+  const eachBatch = async (messagesBatch) => {
+    const activeProcessors = processors.filter((s) => s.isActive);
+    if (activeProcessors.length === 0)
+      return {
+        type: "STOP",
+        reason: "No active processors"
+      };
+    const result = await Promise.allSettled(
+      activeProcessors.map((s) => {
+        return s.handle(messagesBatch, { pool });
+      })
+    );
+    return result.some(
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _25 => _25.value, 'optionalAccess', _26 => _26.type]) !== "STOP"
+    ) ? void 0 : {
+      type: "STOP"
+    };
+  };
+  const messagePooler = currentMessagePuller = postgreSQLEventStoreMessageBatchPuller({
+    executor: pool.execute,
+    eachBatch,
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _27 => _27.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _28 => _28.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs))
+  });
+  const stop = async () => {
+    if (!isRunning) return;
+    isRunning = false;
+    if (currentMessagePuller) {
+      await currentMessagePuller.stop();
+      currentMessagePuller = void 0;
+    }
+    await start;
+  };
+  return {
+    processors,
+    get isRunning() {
+      return isRunning;
+    },
+    processor: (options2) => {
+      const processor = postgreSQLProcessor(options2);
+      processors.push(processor);
+      return processor;
+    },
+    start: () => {
+      if (isRunning) return start;
+      start = (async () => {
+        if (processors.length === 0)
+          return Promise.reject(
+            new EmmettError(
+              "Cannot start consumer without at least a single processor"
+            )
+          );
+        isRunning = true;
+        const startFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom(
+          await Promise.all(processors.map((o) => o.start(pool.execute)))
+        );
+        return messagePooler.start({ startFrom });
+      })();
+      return start;
+    },
+    stop,
+    close: async () => {
+      await stop();
+      await pool.close();
+    }
+  };
+};
+
+// src/eventStore/projections/index.ts
+
+
+// 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) => {
+    const pongo = _pongo.pongoClient.call(void 0, connectionString, {
+      connectionOptions: { connection }
+    });
+    try {
+      const collection = pongo.db(inDatabase).collection(inCollection);
+      return handle(collection);
+    } finally {
+      await pongo.close();
+    }
+  });
+};
+var withoutIdAndVersion = (doc) => {
+  const { _id, _version, ...without } = doc;
+  return without;
+};
+var assertDocumentsEqual = (actual, expected) => {
+  if ("_id" in expected)
+    assertEqual(
+      expected._id,
+      actual._id,
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`
+    );
+  return assertDeepEqual(
+    withoutIdAndVersion(actual),
+    withoutIdAndVersion(expected)
+  );
+};
+var documentExists = (document, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+    assertDocumentsEqual(result, document);
+  },
+  { ...options, ...assertOptions }
+);
+var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      documents.length,
+      result.length,
+      "Different Documents Count than expected"
+    );
+    for (let i = 0; i < documents.length; i++) {
+      assertThatArray(result).contains(documents[i]);
+    }
+  },
+  { ...options, ...assertOptions }
+);
+var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      expectedCount,
+      result.length,
+      "Different Documents Count than expected"
+    );
+  },
+  { ...options, ...assertOptions }
+);
+var documentMatchingExists = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertThatArray(result).isNotEmpty();
+  },
+  { ...options, ...assertOptions }
+);
+var documentDoesNotExist = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+  },
+  { ...options, ...assertOptions }
+);
+var expectPongoDocuments = {
+  fromCollection: (collectionName) => {
+    return {
+      withId: (id) => {
+        return {
+          toBeEqual: (document) => documentExists(document, {
+            withId: id,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            withId: id,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            withId: id,
+            inCollection: collectionName
+          })
+        };
+      },
+      matching: (filter2) => {
+        return {
+          toBeTheSame: (documents) => documentsAreTheSame(documents, {
+            matchingFilter: filter2,
+            inCollection: collectionName
+          }),
+          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
+            matchingFilter: filter2,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            matchingFilter: filter2,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            matchingFilter: filter2,
+            inCollection: collectionName
+          })
+        };
+      }
+    };
+  }
+};
+
+// src/eventStore/projections/pongo/projections.ts
+
+
+
+var pongoProjection = ({
+  handle,
+  canHandle
+}) => postgreSQLProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const { 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
+
+
+
+
+var PostgreSQLProjectionSpec = {
+  for: (options) => {
+    {
+      const { projection: projection2, ...dumoOptions } = options;
+      const { connectionString } = dumoOptions;
+      return (givenEvents) => {
+        return {
+          when: (events, options2) => {
+            const allEvents = [];
+            const run = async (pool) => {
+              let globalPosition = 0n;
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _29 => _29.numberOfTimes]), () => ( 1));
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  globalPosition: ++globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${_uuid.v4.call(void 0, )}`,
+                  eventId: _uuid.v4.call(void 0, )
+                };
+                allEvents.push({
+                  ...event,
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
+                  }
+                });
+              }
+              await pool.withTransaction(
+                (transaction) => handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  connection: {
+                    connectionString,
+                    transaction
+                  }
+                })
+              );
+            };
+            return {
+              then: async (assert, message) => {
+                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                try {
+                  await run(pool);
+                  const succeeded = await assert({ pool, connectionString });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      _nullishCoalesce(message, () => ( "Projection specification didn't match the criteria"))
+                    );
+                } finally {
+                  await pool.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                try {
+                  await run(pool);
+                  throw new AssertionError("Handler did not fail as expected");
+                } catch (error) {
+                  if (error instanceof AssertionError) throw error;
+                  if (args.length === 0) return;
+                  if (!isErrorConstructor(args[0])) {
+                    assertTrue(
+                      args[0](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()])}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _32 => _32.toString, 'call', _33 => _33()])}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _34 => _34.toString, 'call', _35 => _35()])}`
+                    );
+                  }
+                } finally {
+                  await pool.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ..._nullishCoalesce(event.metadata, () => ( {})),
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _36 => _36.metadata, 'optionalAccess', _37 => _37.streamName]), () => ( streamName))
+    }
   };
 };
+var eventsInStream = (streamName, events) => {
+  return events.map((e) => eventInStream(streamName, e));
+};
+var newEventsInStream = eventsInStream;
+var assertSQLQueryResultMatches = (sql7, rows) => async ({ pool: { execute } }) => {
+  const result = await execute.query(sql7);
+  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
+};
+var expectSQL = {
+  query: (sql7) => ({
+    resultRows: {
+      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql7, rows)
+    }
+  })
+};
 
-// src/eventStore/schema/index.ts
-var schemaSQL = [
-  streamsTableSQL,
-  eventsTableSQL,
-  subscriptionsTableSQL,
-  sanitizeNameSQL,
-  addTablePartitions,
-  addEventsPartitions,
-  addModuleSQL,
-  addTenantSQL,
-  addModuleForAllTenantsSQL,
-  addTenantForAllModulesSQL,
-  appendEventsSQL,
-  addDefaultPartition,
-  storeSubscriptionCheckpointSQL
-];
-var createEventStoreSchema = async (pool) => {
-  await pool.withTransaction(({ execute }) => execute.batchCommand(schemaSQL));
+// src/eventStore/projections/index.ts
+var handleProjections = async (options) => {
+  const {
+    projections: allProjections,
+    events,
+    connection: { transaction, connectionString }
+  } = options;
+  const eventTypes = events.map((e) => e.type);
+  const projections = allProjections.filter(
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+  );
+  const client = await transaction.connection.open();
+  for (const projection2 of projections) {
+    await projection2.handle(events, {
+      connectionString,
+      client,
+      transaction,
+      execute: transaction.execute
+    });
+  }
 };
+var postgreSQLProjection = (definition) => projection(definition);
+var postgreSQLRawBatchSQLProjection = (handle, ...canHandle) => postgreSQLProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const sqls = await handle(events, context);
+    await context.execute.batchCommand(sqls);
+  }
+});
+var postgreSQLRawSQLProjection = (handle, ...canHandle) => postgreSQLRawBatchSQLProjection(
+  async (events, context) => {
+    const sqls = [];
+    for (const event of events) {
+      sqls.push(await handle(event, context));
+    }
+    return sqls;
+  },
+  ...canHandle
+);
 
 // src/eventStore/postgreSQLEventStore.ts
 var defaultPostgreSQLOptions = {
@@ -1552,7 +1765,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', _34 => _34.schema, 'optionalAccess', _35 => _35.autoMigration]) === void 0 || _optionalChain([options, 'access', _36 => _36.schema, 'optionalAccess', _37 => _37.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _38 => _38.schema, 'optionalAccess', _39 => _39.autoMigration]) === void 0 || _optionalChain([options, 'access', _40 => _40.schema, 'optionalAccess', _41 => _41.autoMigration]) !== "None";
   const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
     if (!migrateSchema) {
@@ -1581,7 +1794,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _38 => _38.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _42 => _42.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(streamName, options2.read);
       const currentStreamVersion = result.currentStreamVersion;
@@ -1622,7 +1835,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _39 => _39.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _43 => _43.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1630,6 +1843,10 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
     },
+    consumer: (options2) => postgreSQLEventStoreConsumer({
+      ..._nullishCoalesce(options2, () => ( {})),
+      pool
+    }),
     close: () => pool.close(),
     async withSession(callback) {
       return await pool.withConnection(async (connection) => {
@@ -1652,219 +1869,6 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
   };
 };
 
-// src/eventStore/subscriptions/messageBatchProcessing/index.ts
-
-var DefaultPostgreSQLEventStoreSubscriptionBatchSize = 100;
-var DefaultPostgreSQLEventStoreSubscriptionPullingFrequencyInMs = 50;
-var postgreSQLEventStoreMessageBatchPuller = ({
-  executor,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs
-}) => {
-  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 readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    do {
-      const { messages, currentGlobalPosition, areEventsLeft } = 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 (!areEventsLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
-      } else {
-        waitTime = pullingFrequencyInMs;
-      }
-    } while (isRunning);
-  };
-  return {
-    get isRunning() {
-      return isRunning;
-    },
-    start: (options) => {
-      if (isRunning) return start;
-      start = (async () => {
-        isRunning = true;
-        return pullMessages(options);
-      })();
-      return start;
-    },
-    stop: async () => {
-      if (!isRunning) return;
-      isRunning = false;
-      await start;
-    }
-  };
-};
-var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
-  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
-    return "BEGINNING";
-  if (options.every((o) => o === "END")) return "END";
-  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
-};
-
-// src/eventStore/subscriptions/postgreSQLEventStoreConsumer.ts
-
-
-// src/eventStore/subscriptions/postgreSQLEventStoreSubscription.ts
-
-var PostgreSQLEventStoreSubscription = {
-  result: {
-    skip: (options) => ({
-      type: "SKIP",
-      ..._nullishCoalesce(options, () => ( {}))
-    }),
-    stop: (options) => ({
-      type: "STOP",
-      ..._nullishCoalesce(options, () => ( {}))
-    })
-  }
-};
-var postgreSQLEventStoreSubscription = (options) => {
-  const { eachMessage } = options;
-  let isActive = true;
-  return {
-    id: options.subscriptionId,
-    start: async (execute) => {
-      isActive = true;
-      if (options.startFrom !== "CURRENT") return options.startFrom;
-      const { lastProcessedPosition } = await readSubscriptionCheckpoint(
-        execute,
-        {
-          subscriptionId: options.subscriptionId,
-          partition: options.partition
-        }
-      );
-      if (lastProcessedPosition === null) return "BEGINNING";
-      return { globalPosition: lastProcessedPosition };
-    },
-    get isActive() {
-      return isActive;
-    },
-    handle: async ({ messages }, { pool }) => {
-      if (!isActive) return;
-      return pool.withTransaction(async (tx) => {
-        let result = void 0;
-        let lastProcessedPosition = null;
-        for (const message of messages) {
-          const typedMessage = message;
-          const messageProcessingResult = await eachMessage(typedMessage);
-          await storeSubscriptionCheckpoint(tx.execute, {
-            subscriptionId: options.subscriptionId,
-            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 result;
-      });
-    }
-  };
-};
-
-// src/eventStore/subscriptions/postgreSQLEventStoreConsumer.ts
-var postgreSQLEventStoreConsumer = (options) => {
-  let isRunning = false;
-  const { connectionString, pooling } = options;
-  const subscriptions = _nullishCoalesce(options.subscriptions, () => ( []));
-  let start;
-  let currentMessagePooler;
-  const pool = _dumbo.dumbo.call(void 0, { connectionString });
-  const eachBatch = async (messagesBatch) => {
-    const activeSubscriptions = subscriptions.filter((s) => s.isActive);
-    if (activeSubscriptions.length === 0)
-      return {
-        type: "STOP",
-        reason: "No active subscriptions"
-      };
-    const result = await Promise.allSettled(
-      activeSubscriptions.map((s) => {
-        return s.handle(messagesBatch, { pool });
-      })
-    );
-    return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _40 => _40.value, 'optionalAccess', _41 => _41.type]) !== "STOP"
-    ) ? void 0 : {
-      type: "STOP"
-    };
-  };
-  const messagePooler = currentMessagePooler = postgreSQLEventStoreMessageBatchPuller({
-    executor: pool.execute,
-    eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pooling, 'optionalAccess', _42 => _42.batchSize]), () => ( DefaultPostgreSQLEventStoreSubscriptionBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pooling, 'optionalAccess', _43 => _43.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreSubscriptionPullingFrequencyInMs))
-  });
-  const stop = async () => {
-    if (!isRunning) return;
-    isRunning = false;
-    if (currentMessagePooler) {
-      await currentMessagePooler.stop();
-      currentMessagePooler = void 0;
-    }
-    await start;
-  };
-  return {
-    connectionString,
-    subscriptions,
-    get isRunning() {
-      return isRunning;
-    },
-    subscribe: (options2) => {
-      const subscription = postgreSQLEventStoreSubscription(options2);
-      subscriptions.push(subscription);
-      return subscription;
-    },
-    start: () => {
-      if (isRunning) return start;
-      start = (async () => {
-        if (subscriptions.length === 0)
-          return Promise.reject(
-            new EmmettError(
-              "Cannot start consumer without at least a single subscription"
-            )
-          );
-        isRunning = true;
-        const startFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom(
-          await Promise.all(subscriptions.map((o) => o.start(pool.execute)))
-        );
-        return messagePooler.start({ startFrom });
-      })();
-      return start;
-    },
-    stop,
-    close: async () => {
-      await stop();
-      await pool.close();
-    }
-  };
-};
-
 
 
 
@@ -1922,5 +1926,5 @@ var postgreSQLEventStoreConsumer = (options) => {
 
 
 
-exports.DefaultPostgreSQLEventStoreSubscriptionBatchSize = DefaultPostgreSQLEventStoreSubscriptionBatchSize; exports.DefaultPostgreSQLEventStoreSubscriptionPullingFrequencyInMs = DefaultPostgreSQLEventStoreSubscriptionPullingFrequencyInMs; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLEventStoreSubscription = PostgreSQLEventStoreSubscription; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.addDefaultPartition = addDefaultPartition; exports.addEventsPartitions = addEventsPartitions; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendEventsSQL = appendEventsSQL; exports.appendToStream = appendToStream; 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.eventsTable = eventsTable; exports.eventsTableSQL = eventsTableSQL; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLEventStoreSubscription = postgreSQLEventStoreSubscription; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readStream = readStream; exports.readSubscriptionCheckpoint = readSubscriptionCheckpoint; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaSQL = schemaSQL; exports.storeSubscriptionCheckpoint = storeSubscriptionCheckpoint; 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.PostgreSQLProcessor = PostgreSQLProcessor; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.addDefaultPartition = addDefaultPartition; exports.addEventsPartitions = addEventsPartitions; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendEventsSQL = appendEventsSQL; exports.appendToStream = appendToStream; 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.eventsTable = eventsTable; exports.eventsTableSQL = eventsTableSQL; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; 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.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;
 //# sourceMappingURL=index.cjs.map