@event-driven-io/emmett-postgresql 0.27.0 → 0.29.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/eventStore/postgreSQLEventStore.ts
 import {
-  dumbo as dumbo2
+  dumbo as dumbo3
 } from "@event-driven-io/dumbo";
 
 // ../emmett/dist/chunk-4E7QLAH5.js
@@ -436,352 +436,179 @@ var assertThatArray = (array) => {
 // src/eventStore/postgreSQLEventStore.ts
 import "pg";
 
-// src/eventStore/projections/index.ts
+// src/eventStore/consumers/messageBatchProcessing/index.ts
 import "@event-driven-io/dumbo";
 
-// src/eventStore/projections/pongo/pongoProjectionSpec.ts
-import "@event-driven-io/dumbo";
-import {
-  pongoClient
-} from "@event-driven-io/pongo";
-var withCollection = (handle, options) => {
-  const { pool, connectionString, inDatabase, inCollection } = options;
-  return pool.withConnection(async (connection) => {
-    const pongo = pongoClient(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/readLastMessageGlobalPosition.ts
+import { singleOrNull, sql } from "@event-driven-io/dumbo";
+
+// 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
-import {
-  pongoClient as pongoClient2
-} from "@event-driven-io/pongo";
-var pongoProjection = ({
-  handle,
-  canHandle
-}) => postgreSQLProjection({
-  canHandle,
-  handle: async (events, context) => {
-    const { connectionString, client } = context;
-    const pongo = pongoClient2(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(
-            document ?? options.initialState(),
-            event
-          ) : await options.evolve(
-            document,
-            event
-          );
-        });
-      }
-    },
-    canHandle
-  });
 };
-var pongoSingleStreamProjection = (options) => {
-  return pongoMultiStreamProjection({
-    ...options,
-    getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
-  });
+var subscriptionsTable = {
+  name: `${emmettPrefix}_subscriptions`
 };
 
-// src/eventStore/projections/postgresProjectionSpec.ts
-import {
-  dumbo
-} from "@event-driven-io/dumbo";
-import { v4 as uuid4 } from "uuid";
-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 = options2?.numberOfTimes ?? 1;
-              for (const event of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                const metadata = {
-                  globalPosition: ++globalPosition,
-                  streamPosition: globalPosition,
-                  streamName: `test-${uuid4()}`,
-                  eventId: uuid4()
-                };
-                allEvents.push({
-                  ...event,
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? event.metadata ?? {} : {}
-                  }
-                });
-              }
-              await pool.withTransaction(
-                (transaction) => handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  connection: {
-                    connectionString,
-                    transaction
-                  }
-                })
-              );
-            };
-            return {
-              then: async (assert, message) => {
-                const pool = dumbo(dumoOptions);
-                try {
-                  await run(pool);
-                  const succeeded = await assert({ pool, connectionString });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      message ?? "Projection specification didn't match the criteria"
-                    );
-                } finally {
-                  await pool.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                const pool = dumbo(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: ${error?.toString()}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${error?.toString()}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${error?.toString()}`
-                    );
-                  }
-                } finally {
-                  await pool.close();
-                }
-              }
-            };
-          }
-        };
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await singleOrNull(
+    execute.query(
+      sql(
+        `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`,
+        options?.partition ?? defaultTag
+      )
+    )
+  );
+  return {
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+  };
+};
+
+// src/eventStore/schema/readMessagesBatch.ts
+import { mapRows, sql as sql2 } from "@event-driven-io/dumbo";
+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 mapRows(
+    execute.query(
+      sql2(
+        `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}`,
+        options?.partition ?? defaultTag
+      )
+    ),
+    (row) => {
+      const rawEvent = {
+        type: row.event_type,
+        data: row.event_data,
+        metadata: row.event_metadata
+      };
+      const metadata = {
+        ..."metadata" in rawEvent ? 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 readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 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: {
-      ...event.metadata ?? {},
-      streamName: event.metadata?.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
+import { dumbo } from "@event-driven-io/dumbo";
+
+// src/eventStore/consumers/postgreSQLProcessor.ts
+import "@event-driven-io/dumbo";
 
 // src/eventStore/schema/index.ts
 import "@event-driven-io/dumbo";
@@ -790,43 +617,9 @@ import "@event-driven-io/dumbo";
 import {
   rawSql,
   single,
-  sql
+  sql as sql3
 } from "@event-driven-io/dumbo";
-import { v4 as uuid5 } from "uuid";
-
-// 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
+import { v4 as uuid4 } from "uuid";
 var appendEventsSQL = rawSql(
   `CREATE OR REPLACE FUNCTION emt_append_event(
       v_event_ids text[],
@@ -925,7 +718,7 @@ var appendToStream = (pool, streamName, streamType, events, options) => pool.wit
       ...e,
       metadata: {
         streamName,
-        eventId: uuid5(),
+        eventId: uuid4(),
         streamPosition: BigInt(i),
         ..."metadata" in e ? e.metadata ?? {} : {}
       }
@@ -976,7 +769,7 @@ var toExpectedVersion = (expected) => {
 var isOptimisticConcurrencyError = (error) => error instanceof Error && "code" in error && error.code === "23505";
 var appendEventsRaw = (execute, streamId, streamType, events, options) => single(
   execute.command(
-    sql(
+    sql3(
       `SELECT * FROM emt_append_event(
                   ARRAY[%s]::text[],
                   ARRAY[%s]::jsonb[],
@@ -988,11 +781,11 @@ var appendEventsRaw = (execute, streamId, streamType, events, options) => single
                   %s::bigint,
                   %L::text
               )`,
-      events.map((e) => sql("%L", e.metadata.eventId)).join(","),
-      events.map((e) => sql("%L", JSONParser.stringify(e.data))).join(","),
-      events.map((e) => sql("%L", JSONParser.stringify(e.metadata ?? {}))).join(","),
+      events.map((e) => sql3("%L", e.metadata.eventId)).join(","),
+      events.map((e) => sql3("%L", JSONParser.stringify(e.data))).join(","),
+      events.map((e) => sql3("%L", JSONParser.stringify(e.metadata ?? {}))).join(","),
       events.map(() => `'1'`).join(","),
-      events.map((e) => sql("%L", e.type)).join(","),
+      events.map((e) => sql3("%L", e.type)).join(","),
       streamId,
       streamType,
       options?.expectedStreamVersion ?? "NULL",
@@ -1001,9 +794,9 @@ var appendEventsRaw = (execute, streamId, streamType, events, options) => single
   )
 );
 
-// src/eventStore/schema/storeSubscriptionCheckpoint.ts
-import { single as single2, sql as sql2 } from "@event-driven-io/dumbo";
-var storeSubscriptionCheckpointSQL = sql2(`
+// src/eventStore/schema/storeProcessorCheckpoint.ts
+import { single as single2, sql as sql4 } from "@event-driven-io/dumbo";
+var storeSubscriptionCheckpointSQL = sql4(`
 CREATE OR REPLACE FUNCTION store_subscription_checkpoint(
   p_subscription_id VARCHAR(100),
   p_version BIGINT,
@@ -1063,13 +856,13 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 `);
-async function storeSubscriptionCheckpoint(execute, options) {
+async function storeProcessorCheckpoint(execute, options) {
   try {
     const { result } = await single2(
       execute.command(
-        sql2(
+        sql4(
           `SELECT store_subscription_checkpoint(%L, %s, %L, %L, pg_current_xact_id(), %L) as result;`,
-          options.subscriptionId,
+          options.processorId,
           options.version ?? 1,
           options.newPosition,
           options.lastProcessedPosition,
@@ -1382,75 +1175,6 @@ var addDefaultPartition = rawSql2(
   `SELECT emt_add_partition('${defaultTag}');`
 );
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-import { singleOrNull, sql as sql3 } from "@event-driven-io/dumbo";
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await singleOrNull(
-    execute.query(
-      sql3(
-        `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`,
-        options?.partition ?? defaultTag
-      )
-    )
-  );
-  return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
-  };
-};
-
-// src/eventStore/schema/readMessagesBatch.ts
-import { mapRows, sql as sql4 } from "@event-driven-io/dumbo";
-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 mapRows(
-    execute.query(
-      sql4(
-        `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}`,
-        options?.partition ?? defaultTag
-      )
-    ),
-    (row) => {
-      const rawEvent = {
-        type: row.event_type,
-        data: row.event_data,
-        metadata: row.event_metadata
-      };
-      const metadata = {
-        ..."metadata" in rawEvent ? 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
 import { mapRows as mapRows2, sql as sql5 } from "@event-driven-io/dumbo";
 var readStream = async (execute, streamId, options) => {
@@ -1499,9 +1223,9 @@ var readStream = async (execute, streamId, options) => {
   };
 };
 
-// src/eventStore/schema/readSubscriptionCheckpoint.ts
+// src/eventStore/schema/readProcessorCheckpoint.ts
 import { singleOrNull as singleOrNull2, sql as sql6 } from "@event-driven-io/dumbo";
-var readSubscriptionCheckpoint = async (execute, options) => {
+var readProcessorCheckpoint = async (execute, options) => {
   const result = await singleOrNull2(
     execute.query(
       sql6(
@@ -1510,7 +1234,7 @@ var readSubscriptionCheckpoint = async (execute, options) => {
            WHERE partition = %L AND subscription_id = %L
            LIMIT 1`,
         options?.partition ?? defaultTag,
-        options.subscriptionId
+        options.processorId
       )
     )
   );
@@ -1539,188 +1263,8 @@ var createEventStoreSchema = async (pool) => {
   await pool.withTransaction(({ execute }) => execute.batchCommand(schemaSQL));
 };
 
-// src/eventStore/postgreSQLEventStore.ts
-var defaultPostgreSQLOptions = {
-  projections: [],
-  schema: { autoMigration: "CreateOrUpdate" }
-};
-var PostgreSQLEventStoreDefaultStreamVersion = 0n;
-var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
-  const poolOptions = {
-    connectionString,
-    ...options.connectionOptions ? options.connectionOptions : {}
-  };
-  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : dumbo2(poolOptions);
-  let migrateSchema;
-  const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
-  const ensureSchemaExists = () => {
-    if (!autoGenerateSchema) return Promise.resolve();
-    if (!migrateSchema) {
-      migrateSchema = createEventStoreSchema(pool);
-    }
-    return migrateSchema;
-  };
-  const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const preCommitHook = inlineProjections.length > 0 ? (events, { transaction }) => handleProjections({
-    projections: inlineProjections,
-    connection: {
-      connectionString,
-      transaction
-    },
-    // TODO: Add proper handling of global data
-    // Currently it's not available as append doesn't return array of global position but just the last one
-    events
-  }) : void 0;
-  return {
-    schema: {
-      sql: () => schemaSQL.join(""),
-      print: () => console.log(schemaSQL.join("")),
-      migrate: async () => {
-        await (migrateSchema = createEventStoreSchema(pool));
-      }
-    },
-    async aggregateStream(streamName, options2) {
-      const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = read?.expectedStreamVersion;
-      let state = initialState();
-      const result = await this.readStream(streamName, options2.read);
-      const currentStreamVersion = result.currentStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        expectedStreamVersion,
-        PostgreSQLEventStoreDefaultStreamVersion
-      );
-      for (const event of result.events) {
-        if (!event) continue;
-        state = evolve(state, event);
-      }
-      return {
-        currentStreamVersion,
-        state,
-        streamExists: result.streamExists
-      };
-    },
-    readStream: async (streamName, options2) => {
-      await ensureSchemaExists();
-      return readStream(pool.execute, streamName, options2);
-    },
-    appendToStream: async (streamName, events, options2) => {
-      await ensureSchemaExists();
-      const [firstPart, ...rest] = streamName.split("-");
-      const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
-      const appendResult = await appendToStream(
-        pool,
-        streamName,
-        streamType,
-        events,
-        {
-          ...options2,
-          preCommitHook
-        }
-      );
-      if (!appendResult.success)
-        throw new ExpectedVersionConflictError(
-          -1n,
-          //TODO: Return actual version in case of error
-          options2?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
-        );
-      return {
-        nextExpectedStreamVersion: appendResult.nextStreamPosition,
-        lastEventGlobalPosition: appendResult.lastGlobalPosition,
-        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
-      };
-    },
-    close: () => pool.close(),
-    async withSession(callback) {
-      return await pool.withConnection(async (connection) => {
-        const storeOptions = {
-          ...options,
-          connectionOptions: {
-            connection
-          }
-        };
-        const eventStore = getPostgreSQLEventStore(
-          connectionString,
-          storeOptions
-        );
-        return callback({
-          eventStore,
-          close: () => Promise.resolve()
-        });
-      });
-    }
-  };
-};
-
-// src/eventStore/subscriptions/messageBatchProcessing/index.ts
-import "@event-driven-io/dumbo";
-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 readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 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
-import { dumbo as dumbo3 } from "@event-driven-io/dumbo";
-
-// src/eventStore/subscriptions/postgreSQLEventStoreSubscription.ts
-import "@event-driven-io/dumbo";
-var PostgreSQLEventStoreSubscription = {
+// src/eventStore/consumers/postgreSQLProcessor.ts
+var PostgreSQLProcessor = {
   result: {
     skip: (options) => ({
       type: "SKIP",
@@ -1732,21 +1276,18 @@ var PostgreSQLEventStoreSubscription = {
     })
   }
 };
-var postgreSQLEventStoreSubscription = (options) => {
+var postgreSQLProcessor = (options) => {
   const { eachMessage } = options;
   let isActive = true;
   return {
-    id: options.subscriptionId,
+    id: options.processorId,
     start: async (execute) => {
       isActive = true;
       if (options.startFrom !== "CURRENT") return options.startFrom;
-      const { lastProcessedPosition } = await readSubscriptionCheckpoint(
-        execute,
-        {
-          subscriptionId: options.subscriptionId,
-          partition: options.partition
-        }
-      );
+      const { lastProcessedPosition } = await readProcessorCheckpoint(execute, {
+        processorId: options.processorId,
+        partition: options.partition
+      });
       if (lastProcessedPosition === null) return "BEGINNING";
       return { globalPosition: lastProcessedPosition };
     },
@@ -1761,8 +1302,8 @@ var postgreSQLEventStoreSubscription = (options) => {
         for (const message of messages) {
           const typedMessage = message;
           const messageProcessingResult = await eachMessage(typedMessage);
-          await storeSubscriptionCheckpoint(tx.execute, {
-            subscriptionId: options.subscriptionId,
+          await storeProcessorCheckpoint(tx.execute, {
+            processorId: options.processorId,
             version: options.version,
             lastProcessedPosition,
             newPosition: typedMessage.metadata.globalPosition,
@@ -1788,23 +1329,23 @@ var postgreSQLEventStoreSubscription = (options) => {
   };
 };
 
-// src/eventStore/subscriptions/postgreSQLEventStoreConsumer.ts
+// src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 var postgreSQLEventStoreConsumer = (options) => {
   let isRunning = false;
-  const { connectionString, pooling } = options;
-  const subscriptions = options.subscriptions ?? [];
+  const { pulling } = options;
+  const processors = options.processors ?? [];
   let start;
-  let currentMessagePooler;
-  const pool = dumbo3({ connectionString });
+  let currentMessagePuller;
+  const pool = "pool" in options ? options.pool : dumbo({ connectionString: options.connectionString });
   const eachBatch = async (messagesBatch) => {
-    const activeSubscriptions = subscriptions.filter((s) => s.isActive);
-    if (activeSubscriptions.length === 0)
+    const activeProcessors = processors.filter((s) => s.isActive);
+    if (activeProcessors.length === 0)
       return {
         type: "STOP",
-        reason: "No active subscriptions"
+        reason: "No active processors"
       };
     const result = await Promise.allSettled(
-      activeSubscriptions.map((s) => {
+      activeProcessors.map((s) => {
         return s.handle(messagesBatch, { pool });
       })
     );
@@ -1814,44 +1355,43 @@ var postgreSQLEventStoreConsumer = (options) => {
       type: "STOP"
     };
   };
-  const messagePooler = currentMessagePooler = postgreSQLEventStoreMessageBatchPuller({
+  const messagePooler = currentMessagePuller = postgreSQLEventStoreMessageBatchPuller({
     executor: pool.execute,
     eachBatch,
-    batchSize: pooling?.batchSize ?? DefaultPostgreSQLEventStoreSubscriptionBatchSize,
-    pullingFrequencyInMs: pooling?.pullingFrequencyInMs ?? DefaultPostgreSQLEventStoreSubscriptionPullingFrequencyInMs
+    batchSize: pulling?.batchSize ?? DefaultPostgreSQLEventStoreProcessorBatchSize,
+    pullingFrequencyInMs: pulling?.pullingFrequencyInMs ?? DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs
   });
   const stop = async () => {
     if (!isRunning) return;
     isRunning = false;
-    if (currentMessagePooler) {
-      await currentMessagePooler.stop();
-      currentMessagePooler = void 0;
+    if (currentMessagePuller) {
+      await currentMessagePuller.stop();
+      currentMessagePuller = void 0;
     }
     await start;
   };
   return {
-    connectionString,
-    subscriptions,
+    processors,
     get isRunning() {
       return isRunning;
     },
-    subscribe: (options2) => {
-      const subscription = postgreSQLEventStoreSubscription(options2);
-      subscriptions.push(subscription);
-      return subscription;
+    processor: (options2) => {
+      const processor = postgreSQLProcessor(options2);
+      processors.push(processor);
+      return processor;
     },
     start: () => {
       if (isRunning) return start;
       start = (async () => {
-        if (subscriptions.length === 0)
+        if (processors.length === 0)
           return Promise.reject(
             new EmmettError(
-              "Cannot start consumer without at least a single subscription"
+              "Cannot start consumer without at least a single processor"
             )
           );
         isRunning = true;
         const startFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom(
-          await Promise.all(subscriptions.map((o) => o.start(pool.execute)))
+          await Promise.all(processors.map((o) => o.start(pool.execute)))
         );
         return messagePooler.start({ startFrom });
       })();
@@ -1864,11 +1404,472 @@ var postgreSQLEventStoreConsumer = (options) => {
     }
   };
 };
+
+// src/eventStore/projections/index.ts
+import "@event-driven-io/dumbo";
+
+// src/eventStore/projections/pongo/pongoProjectionSpec.ts
+import "@event-driven-io/dumbo";
+import {
+  pongoClient
+} from "@event-driven-io/pongo";
+var withCollection = (handle, options) => {
+  const { pool, connectionString, inDatabase, inCollection } = options;
+  return pool.withConnection(async (connection) => {
+    const pongo = pongoClient(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
+import {
+  pongoClient as pongoClient2
+} from "@event-driven-io/pongo";
+var pongoProjection = ({
+  handle,
+  canHandle
+}) => postgreSQLProjection({
+  canHandle,
+  handle: async (events, context) => {
+    const { connectionString, client } = context;
+    const pongo = pongoClient2(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(
+            document ?? options.initialState(),
+            event
+          ) : await options.evolve(
+            document,
+            event
+          );
+        });
+      }
+    },
+    canHandle
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    getDocumentId: options.getDocumentId ?? ((event) => event.metadata.streamName)
+  });
+};
+
+// src/eventStore/projections/postgresProjectionSpec.ts
+import {
+  dumbo as dumbo2
+} from "@event-driven-io/dumbo";
+import { v4 as uuid5 } from "uuid";
+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 = options2?.numberOfTimes ?? 1;
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  globalPosition: ++globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${uuid5()}`,
+                  eventId: uuid5()
+                };
+                allEvents.push({
+                  ...event,
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? event.metadata ?? {} : {}
+                  }
+                });
+              }
+              await pool.withTransaction(
+                (transaction) => handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  connection: {
+                    connectionString,
+                    transaction
+                  }
+                })
+              );
+            };
+            return {
+              then: async (assert, message) => {
+                const pool = dumbo2(dumoOptions);
+                try {
+                  await run(pool);
+                  const succeeded = await assert({ pool, connectionString });
+                  if (succeeded !== void 0 && succeeded === false)
+                    assertFails(
+                      message ?? "Projection specification didn't match the criteria"
+                    );
+                } finally {
+                  await pool.close();
+                }
+              },
+              thenThrows: async (...args) => {
+                const pool = dumbo2(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: ${error?.toString()}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${error?.toString()}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${error?.toString()}`
+                    );
+                  }
+                } finally {
+                  await pool.close();
+                }
+              }
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ...event.metadata ?? {},
+      streamName: event.metadata?.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/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 = {
+  projections: [],
+  schema: { autoMigration: "CreateOrUpdate" }
+};
+var PostgreSQLEventStoreDefaultStreamVersion = 0n;
+var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
+  const poolOptions = {
+    connectionString,
+    ...options.connectionOptions ? options.connectionOptions : {}
+  };
+  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : dumbo3(poolOptions);
+  let migrateSchema;
+  const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
+  const ensureSchemaExists = () => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    if (!migrateSchema) {
+      migrateSchema = createEventStoreSchema(pool);
+    }
+    return migrateSchema;
+  };
+  const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
+  const preCommitHook = inlineProjections.length > 0 ? (events, { transaction }) => handleProjections({
+    projections: inlineProjections,
+    connection: {
+      connectionString,
+      transaction
+    },
+    // TODO: Add proper handling of global data
+    // Currently it's not available as append doesn't return array of global position but just the last one
+    events
+  }) : void 0;
+  return {
+    schema: {
+      sql: () => schemaSQL.join(""),
+      print: () => console.log(schemaSQL.join("")),
+      migrate: async () => {
+        await (migrateSchema = createEventStoreSchema(pool));
+      }
+    },
+    async aggregateStream(streamName, options2) {
+      const { evolve, initialState, read } = options2;
+      const expectedStreamVersion = read?.expectedStreamVersion;
+      let state = initialState();
+      const result = await this.readStream(streamName, options2.read);
+      const currentStreamVersion = result.currentStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        expectedStreamVersion,
+        PostgreSQLEventStoreDefaultStreamVersion
+      );
+      for (const event of result.events) {
+        if (!event) continue;
+        state = evolve(state, event);
+      }
+      return {
+        currentStreamVersion,
+        state,
+        streamExists: result.streamExists
+      };
+    },
+    readStream: async (streamName, options2) => {
+      await ensureSchemaExists();
+      return readStream(pool.execute, streamName, options2);
+    },
+    appendToStream: async (streamName, events, options2) => {
+      await ensureSchemaExists();
+      const [firstPart, ...rest] = streamName.split("-");
+      const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
+      const appendResult = await appendToStream(
+        pool,
+        streamName,
+        streamType,
+        events,
+        {
+          ...options2,
+          preCommitHook
+        }
+      );
+      if (!appendResult.success)
+        throw new ExpectedVersionConflictError(
+          -1n,
+          //TODO: Return actual version in case of error
+          options2?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+        );
+      return {
+        nextExpectedStreamVersion: appendResult.nextStreamPosition,
+        lastEventGlobalPosition: appendResult.lastGlobalPosition,
+        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
+      };
+    },
+    consumer: (options2) => postgreSQLEventStoreConsumer({ ...options2, pool }),
+    close: () => pool.close(),
+    async withSession(callback) {
+      return await pool.withConnection(async (connection) => {
+        const storeOptions = {
+          ...options,
+          connectionOptions: {
+            connection
+          }
+        };
+        const eventStore = getPostgreSQLEventStore(
+          connectionString,
+          storeOptions
+        );
+        return callback({
+          eventStore,
+          close: () => Promise.resolve()
+        });
+      });
+    }
+  };
+};
 export {
-  DefaultPostgreSQLEventStoreSubscriptionBatchSize,
-  DefaultPostgreSQLEventStoreSubscriptionPullingFrequencyInMs,
+  DefaultPostgreSQLEventStoreProcessorBatchSize,
+  DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs,
   PostgreSQLEventStoreDefaultStreamVersion,
-  PostgreSQLEventStoreSubscription,
+  PostgreSQLProcessor,
   PostgreSQLProjectionSpec,
   addDefaultPartition,
   addEventsPartitions,
@@ -1905,17 +1906,17 @@ export {
   pongoSingleStreamProjection,
   postgreSQLEventStoreConsumer,
   postgreSQLEventStoreMessageBatchPuller,
-  postgreSQLEventStoreSubscription,
+  postgreSQLProcessor,
   postgreSQLProjection,
   postgreSQLRawBatchSQLProjection,
   postgreSQLRawSQLProjection,
   readLastMessageGlobalPosition,
   readMessagesBatch,
+  readProcessorCheckpoint,
   readStream,
-  readSubscriptionCheckpoint,
   sanitizeNameSQL,
   schemaSQL,
-  storeSubscriptionCheckpoint,
+  storeProcessorCheckpoint,
   storeSubscriptionCheckpointSQL,
   streamsTable,
   streamsTableSQL,