@event-driven-io/emmett-sqlite 0.43.0-alpha.1 → 0.43.0-alpha.4

package/dist/index.js

@@ -76,6 +76,10 @@ var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends C
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
+var isExpectedVersionConflictError = (error2) => error2 instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
+  error2,
+  ExpectedVersionConflictError.Codes.ConcurrencyError
+);
 var isPrimitive = (value) => {
   const type = typeof value;
   return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
@@ -511,27 +515,142 @@ var sqliteRawSQLProjection = (options) => {
 };
 
 // src/eventStore/projections/sqliteProjectionSpec.ts
+import { dumbo } from "@event-driven-io/dumbo";
+import { v4 as uuid5 } from "uuid";
+var SQLiteProjectionSpec = {
+  for: (options) => {
+    {
+      const pool = options.pool ?? dumbo({
+        ...options.driver.mapToDumboOptions(options)
+      });
+      const projection2 = options.projection;
+      let wasInitialized = false;
+      return (givenEvents) => {
+        return {
+          when: (events, options2) => {
+            const allEvents = [];
+            const run = async (connection) => {
+              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()}`,
+                  messageId: uuid5()
+                };
+                allEvents.push({
+                  ...event,
+                  kind: "Event",
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? event.metadata ?? {} : {}
+                  }
+                });
+              }
+              if (!wasInitialized && projection2.init) {
+                await projection2.init({
+                  registrationType: "async",
+                  status: "active",
+                  context: { connection },
+                  version: projection2.version ?? 1
+                });
+                wasInitialized = true;
+              }
+              await connection.withTransaction(
+                () => handleProjections({
+                  events: allEvents,
+                  projections: [projection2],
+                  connection
+                })
+              );
+            };
+            return {
+              then: (assert, message) => pool.withConnection(async (connection) => {
+                await run(connection);
+                const succeeded = await assert({
+                  connection
+                });
+                if (succeeded !== void 0 && succeeded === false)
+                  assertFails(
+                    message ?? "Projection specification didn't match the criteria"
+                  );
+              }),
+              thenThrows: (...args) => pool.withConnection(async (connection) => {
+                try {
+                  await run(connection);
+                  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()}`
+                    );
+                  }
+                }
+              })
+            };
+          }
+        };
+      };
+    }
+  }
+};
+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 = (sql, rows) => async ({
+  connection
+}) => {
+  const result = await connection.execute.query(sql);
+  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
+};
+var expectSQL = {
+  query: (sql) => ({
+    resultRows: {
+      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
+    }
+  })
+};
+
+// src/eventStore/schema/appendToStream.ts
 import {
-  JSONSerializer as JSONSerializer2
+  BatchCommandNoChangesError,
+  DumboError,
+  singleOrNull,
+  SQL,
+  UniqueConstraintError
 } from "@event-driven-io/dumbo";
-import {
-  InMemorySQLiteDatabase as InMemorySQLiteDatabase2,
-  sqlite3Connection as sqlite3Connection2
-} from "@event-driven-io/dumbo/sqlite3";
 import { v4 as uuid6 } from "uuid";
 
-// src/eventStore/SQLiteEventStore.ts
-import {
-  InMemorySQLiteDatabase,
-  sqlite3Pool as sqlite3Pool2
-} from "@event-driven-io/dumbo/sqlite3";
-
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-import "@event-driven-io/dumbo/sqlite3";
-
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-import { SQL, singleOrNull } from "@event-driven-io/dumbo";
-
 // src/eventStore/schema/typing.ts
 var emmettPrefix2 = "emt";
 var globalTag = "global";
@@ -567,156 +686,8 @@ var projectionsTable = {
   name: `${emmettPrefix2}_projections`
 };
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var { identifier } = SQL;
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await singleOrNull(
-    execute.query(
-      SQL`
-         SELECT global_position
-         FROM ${identifier(messagesTable.name)}
-         WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE
-         ORDER BY global_position
-         LIMIT 1`
-    )
-  );
-  return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
-  };
-};
-
-// src/eventStore/schema/readMessagesBatch.ts
-import { SQL as SQL2 } from "@event-driven-io/dumbo";
-var { identifier: identifier2 } = SQL2;
-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 ? SQL2`AND global_position >= ${from}` : "";
-  const toCondition = "to" in options ? SQL2`AND global_position <= ${options.to}` : SQL2.EMPTY;
-  const limitCondition = "batchSize" in options ? SQL2`LIMIT ${options.batchSize}` : SQL2.EMPTY;
-  const events = (await execute.query(
-    SQL2`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${identifier2(messagesTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${fromCondition} ${toCondition}
-           ORDER BY global_position
-           ${limitCondition}`
-  )).rows.map((row) => {
-    const rawEvent = {
-      type: row.message_type,
-      data: JSONParser.parse(row.message_data),
-      metadata: JSONParser.parse(row.message_metadata)
-    };
-    const metadata = {
-      ..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
-      messageId: row.message_id,
-      streamName: row.stream_id,
-      streamPosition: BigInt(row.stream_position),
-      globalPosition: BigInt(row.global_position)
-    };
-    return {
-      ...rawEvent,
-      kind: "Event",
-      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/consumers/messageBatchProcessing/index.ts
-var DefaultSQLiteEventStoreProcessorBatchSize = 100;
-var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
-var sqliteEventStoreMessageBatchPuller = ({
-  pool,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs
-}) => {
-  let isRunning = false;
-  let start;
-  const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await pool.withConnection(
-      async ({ execute }) => readLastMessageGlobalPosition(execute)
-    )).currentGlobalPosition ?? 0n : options.startFrom.globalPosition;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await pool.withConnection(
-        ({ execute }) => readMessagesBatch(execute, 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 zipSQLiteEventStoreMessageBatchPullerStartFrom = (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/consumers/sqliteEventStoreConsumer.ts
-import {
-  sqlite3Pool
-} from "@event-driven-io/dumbo/sqlite3";
-
-// src/eventStore/consumers/sqliteProcessor.ts
-import { JSONSerializer } from "@event-driven-io/dumbo";
-import {
-  sqlite3Connection
-} from "@event-driven-io/dumbo/sqlite3";
-
 // src/eventStore/schema/appendToStream.ts
-import {
-  singleOrNull as singleOrNull2,
-  SQL as SQL3
-} from "@event-driven-io/dumbo";
-import {
-  isSQLiteError
-} from "@event-driven-io/dumbo/sqlite3";
-import { v4 as uuid5 } from "uuid";
-var { identifier: identifier3, merge } = SQL3;
+var { identifier, merge } = SQL;
 var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
@@ -728,29 +699,43 @@ var appendToStream = async (connection, streamName, streamType, messages, option
       kind: m.kind ?? "Event",
       metadata: {
         streamName,
-        messageId: uuid5(),
+        messageId: uuid6(),
         streamPosition: BigInt(i + 1),
         ..."metadata" in m ? m.metadata ?? {} : {}
       }
     })
   );
-  return await connection.withTransaction(
-    async (transaction) => {
-      const result = await appendToStreamRaw(
-        transaction.execute,
-        streamName,
-        streamType,
-        downcastRecordedMessages(messagesToAppend, options?.schema?.versioning),
-        {
-          expectedStreamVersion
-        }
-      );
-      if (options?.onBeforeCommit)
-        await options.onBeforeCommit(messagesToAppend, { connection });
-      return { success: true, result };
+  try {
+    return await connection.withTransaction(
+      async (transaction) => {
+        const result = await appendToStreamRaw(
+          transaction.execute,
+          streamName,
+          streamType,
+          downcastRecordedMessages(
+            messagesToAppend,
+            options?.schema?.versioning
+          ),
+          {
+            expectedStreamVersion
+          }
+        );
+        if (options?.onBeforeCommit)
+          await options.onBeforeCommit(messagesToAppend, { connection });
+        return { success: true, result };
+      }
+    );
+  } catch (err) {
+    if (isExpectedVersionConflictError(err) || DumboError.isInstanceOf(err, {
+      errorType: UniqueConstraintError.ErrorType
+    }) || DumboError.isInstanceOf(err, {
+      errorType: BatchCommandNoChangesError.ErrorType
+    })) {
+      return { success: false };
     }
-  );
-};
+    throw err;
+  }
+};
 var toExpectedVersion = (expected) => {
   if (expected === void 0) return null;
   if (expected === NO_CONCURRENCY_CHECK) return null;
@@ -759,22 +744,20 @@ var toExpectedVersion = (expected) => {
   return expected;
 };
 var appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
-  let streamPosition;
-  let globalPosition;
-  try {
-    let expectedStreamVersion = options?.expectedStreamVersion ?? null;
-    if (expectedStreamVersion == null) {
-      expectedStreamVersion = await getLastStreamPosition(
-        execute,
-        streamId,
-        expectedStreamVersion
-      );
-    }
-    let position;
-    if (expectedStreamVersion === 0n) {
-      position = await singleOrNull2(
-        execute.query(
-          SQL3`INSERT INTO ${identifier3(streamsTable.name)}
+  let expectedStreamVersion = options?.expectedStreamVersion ?? null;
+  const currentStreamVersion = await getLastStreamPosition(
+    execute,
+    streamId,
+    expectedStreamVersion
+  );
+  expectedStreamVersion ??= currentStreamVersion ?? 0n;
+  if (expectedStreamVersion !== currentStreamVersion) {
+    throw new ExpectedVersionConflictError(
+      currentStreamVersion,
+      expectedStreamVersion
+    );
+  }
+  const streamSQL = expectedStreamVersion === 0n ? SQL`INSERT INTO ${identifier(streamsTable.name)}
             (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
             VALUES  (
                 ${streamId},
@@ -785,68 +768,37 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
                 false
             )
             RETURNING stream_position;
-          `
-        )
-      );
-    } else {
-      position = await singleOrNull2(
-        execute.query(
-          SQL3`UPDATE ${identifier3(streamsTable.name)}
+          ` : SQL`UPDATE ${identifier(streamsTable.name)}
             SET stream_position = stream_position + ${messages.length}
             WHERE stream_id = ${streamId}
+            AND stream_position = ${expectedStreamVersion}
             AND partition = ${options?.partition ?? streamsTable.columns.partition}
             AND is_archived = false
             RETURNING stream_position;
-          `
-        )
-      );
-    }
-    if (position == null) {
-      throw new Error("Could not find stream position");
-    }
-    streamPosition = BigInt(position.stream_position);
-    if (expectedStreamVersion != null) {
-      const expectedStreamPositionAfterSave = BigInt(expectedStreamVersion) + BigInt(messages.length);
-      if (streamPosition !== expectedStreamPositionAfterSave) {
-        return {
-          success: false
-        };
-      }
-    }
-    const insertSQL = buildMessageInsertQuery(
-      messages,
-      expectedStreamVersion,
-      streamId,
-      options?.partition?.toString() ?? defaultTag2
-    );
-    const { rows: returningIds } = await execute.query(insertSQL);
-    if (returningIds.length === 0 || !returningIds[returningIds.length - 1]?.global_position) {
-      throw new Error("Could not find global position");
-    }
-    globalPosition = BigInt(
-      returningIds[returningIds.length - 1].global_position
-    );
-  } catch (err) {
-    if (isSQLiteError(err) && isOptimisticConcurrencyError(err)) {
-      return {
-        success: false
-      };
-    }
-    throw err;
-  }
+          `;
+  const insertSQL = buildMessageInsertQuery(
+    messages,
+    expectedStreamVersion,
+    streamId,
+    options?.partition?.toString() ?? defaultTag2
+  );
+  const results = await execute.batchCommand([streamSQL, insertSQL], { assertChanges: true });
+  const [streamResult, messagesResult] = results;
+  const streamPosition = streamResult?.rows[0]?.stream_position;
+  const globalPosition = messagesResult?.rows.at(-1)?.global_position;
+  if (!streamPosition)
+    throw new ExpectedVersionConflictError(0n, expectedStreamVersion ?? 0n);
+  if (!globalPosition) throw new Error("Could not find global position");
   return {
     success: true,
-    nextStreamPosition: streamPosition,
-    lastGlobalPosition: globalPosition
+    nextStreamPosition: BigInt(streamPosition),
+    lastGlobalPosition: BigInt(globalPosition)
   };
 };
-var isOptimisticConcurrencyError = (error) => {
-  return error?.errno !== void 0 && error.errno === 19;
-};
 async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
-  const result = await singleOrNull2(
+  const result = await singleOrNull(
     execute.query(
-      SQL3`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier3(streamsTable.name)} WHERE stream_id = ${streamId}`
+      SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier(streamsTable.name)} WHERE stream_id = ${streamId}`
     )
   );
   if (result?.stream_position == null) {
@@ -862,10 +814,10 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
       throw new Error("Stream position is required");
     }
     const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
-    return SQL3`(${streamId},${streamPosition ?? 0n},${partition ?? defaultTag2},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${expectedStreamVersion ?? 0n},${message.type},${message.metadata.messageId},${false})`;
+    return SQL`(${streamId},${streamPosition ?? 0n},${partition ?? defaultTag2},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${expectedStreamVersion ?? 0n},${message.type},${message.metadata.messageId},${false})`;
   });
-  return SQL3`
-      INSERT INTO ${identifier3(messagesTable.name)} (
+  return SQL`
+      INSERT INTO ${identifier(messagesTable.name)} (
           stream_id, 
           stream_position, 
           partition, 
@@ -883,157 +835,10 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
     `;
 };
 
-// src/eventStore/schema/readProcessorCheckpoint.ts
-import { SQL as SQL4, singleOrNull as singleOrNull3 } from "@event-driven-io/dumbo";
-var { identifier: identifier4 } = SQL4;
-var readProcessorCheckpoint = async (execute, options) => {
-  const result = await singleOrNull3(
-    execute.query(
-      SQL4`SELECT last_processed_checkpoint
-           FROM ${identifier4(processorsTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag2} AND processor_id = ${options.processorId}
-           LIMIT 1`
-    )
-  );
-  return {
-    lastProcessedPosition: result !== null ? BigInt(result.last_processed_checkpoint) : null
-  };
-};
-
-// src/eventStore/schema/readStream.ts
-import { SQL as SQL5 } from "@event-driven-io/dumbo";
-var { identifier: identifier5 } = SQL5;
-var readStream = async (execute, streamId, options) => {
-  const fromCondition = options?.from ? SQL5`AND stream_position >= ${options.from}` : SQL5.EMPTY;
-  const to = Number(
-    options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN)
-  );
-  const toCondition = !isNaN(to) ? SQL5`AND stream_position <= ${to}` : SQL5.EMPTY;
-  const { rows: results } = await execute.query(
-    SQL5`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-        FROM ${identifier5(messagesTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${fromCondition} ${toCondition}
-        ORDER BY stream_position ASC`
-  );
-  const messages = results.map((row) => {
-    const rawEvent = {
-      type: row.message_type,
-      data: JSONParser.parse(row.message_data),
-      metadata: JSONParser.parse(row.message_metadata)
-    };
-    const metadata = {
-      ..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
-      messageId: row.message_id,
-      streamName: streamId,
-      streamPosition: BigInt(row.stream_position),
-      globalPosition: BigInt(row.global_position)
-    };
-    const event = {
-      ...rawEvent,
-      kind: "Event",
-      metadata
-    };
-    return upcastRecordedMessage(event, options?.schema?.versioning);
-  });
-  return messages.length > 0 ? {
-    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
-    events: messages,
-    streamExists: true
-  } : {
-    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
-    events: [],
-    streamExists: false
-  };
-};
-
-// src/eventStore/schema/storeProcessorCheckpoint.ts
-import { singleOrNull as singleOrNull4, SQL as SQL6 } from "@event-driven-io/dumbo";
-import { isSQLiteError as isSQLiteError2 } from "@event-driven-io/dumbo/sqlite3";
-var { identifier: identifier6 } = SQL6;
-async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
-  processorInstanceId ??= unknownTag2;
-  if (checkPosition !== null) {
-    const updateResult = await execute.command(
-      SQL6`
-          UPDATE ${identifier6(processorsTable.name)}
-          SET 
-            last_processed_checkpoint = ${position},
-            processor_instance_id = ${processorInstanceId}
-          WHERE processor_id = ${processorId} 
-            AND last_processed_checkpoint = ${checkPosition} 
-            AND partition = ${partition}
-        `
-    );
-    if (updateResult.rowCount && updateResult.rowCount > 0) {
-      return 1;
-    }
-    const current_position = await singleOrNull4(
-      execute.query(
-        SQL6`
-          SELECT last_processed_checkpoint FROM ${identifier6(processorsTable.name)} 
-               WHERE processor_id = ${processorId} AND partition = ${partition}`
-      )
-    );
-    const currentPosition = current_position && current_position?.last_processed_checkpoint !== null ? BigInt(current_position.last_processed_checkpoint) : null;
-    if (currentPosition === position) {
-      return 0;
-    } else if (position !== null && currentPosition !== null && currentPosition > position) {
-      return 2;
-    } else {
-      return 2;
-    }
-  } else {
-    try {
-      await execute.command(
-        SQL6`INSERT INTO ${identifier6(processorsTable.name)} (processor_id, version, last_processed_checkpoint, partition, processor_instance_id) 
-        VALUES (${processorId}, ${version}, ${position}, ${partition}, ${processorInstanceId})`
-      );
-      return 1;
-    } catch (err) {
-      if (!(isSQLiteError2(err) && (err.errno === 19 || err.errno === 2067))) {
-        throw err;
-      }
-      const current = await singleOrNull4(
-        execute.query(
-          SQL6`
-            SELECT last_processed_checkpoint FROM ${identifier6(processorsTable.name)} 
-            WHERE processor_id = ${processorId} AND partition = ${partition}`
-        )
-      );
-      const currentPosition = current && current?.last_processed_checkpoint !== null ? BigInt(current.last_processed_checkpoint) : null;
-      if (currentPosition === position) {
-        return 0;
-      } else {
-        return 2;
-      }
-    }
-  }
-}
-async function storeProcessorCheckpoint(execute, options) {
-  try {
-    const result = await storeSubscriptionCheckpointSQLite(
-      execute,
-      options.processorId,
-      options.version ?? 1,
-      options.newPosition,
-      options.lastProcessedPosition,
-      options.partition ?? defaultTag2
-    );
-    return result === 1 ? { success: true, newPosition: options.newPosition } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
-  } catch (error) {
-    console.log(error);
-    throw error;
-  }
-}
-
-// src/eventStore/schema/tables.ts
-import { SQL as SQL10 } from "@event-driven-io/dumbo";
-import "@event-driven-io/dumbo/sqlite3";
-
 // src/eventStore/schema/migrations/0_41_0/0_41_0.snapshot.ts
-import { SQL as SQL7 } from "@event-driven-io/dumbo";
+import { SQL as SQL2 } from "@event-driven-io/dumbo";
 var schema_0_41_0 = [
-  SQL7`CREATE TABLE IF NOT EXISTS emt_streams(
+  SQL2`CREATE TABLE IF NOT EXISTS emt_streams(
     stream_id         TEXT                      NOT NULL,
     stream_position   BIGINT                    NOT NULL DEFAULT 0,
     partition         TEXT                      NOT NULL DEFAULT 'global',
@@ -1043,7 +848,7 @@ var schema_0_41_0 = [
     PRIMARY KEY (stream_id, partition, is_archived),
     UNIQUE (stream_id, partition, is_archived)
 )`,
-  SQL7`CREATE TABLE IF NOT EXISTS emt_messages(
+  SQL2`CREATE TABLE IF NOT EXISTS emt_messages(
     stream_id              TEXT                      NOT NULL,
     stream_position        BIGINT                    NOT NULL,
     partition              TEXT                      NOT NULL DEFAULT 'global',
@@ -1058,7 +863,7 @@ var schema_0_41_0 = [
     created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
     UNIQUE (stream_id, stream_position, partition, is_archived)
 )`,
-  SQL7`CREATE TABLE IF NOT EXISTS emt_subscriptions(
+  SQL2`CREATE TABLE IF NOT EXISTS emt_subscriptions(
     subscription_id                 TEXT                   NOT NULL,
     version                         INTEGER                NOT NULL DEFAULT 1,
     partition                       TEXT                   NOT NULL DEFAULT 'global',
@@ -1068,10 +873,10 @@ var schema_0_41_0 = [
 ];
 
 // src/eventStore/schema/migrations/0_42_0/0_42_0.migration.ts
-import { singleOrNull as singleOrNull5, SQL as SQL8 } from "@event-driven-io/dumbo";
-var { identifier: identifier7, plain } = SQL8;
+import { singleOrNull as singleOrNull2, SQL as SQL3 } from "@event-driven-io/dumbo";
+var { identifier: identifier2, plain } = SQL3;
 var migration_0_42_0_SQLs = [
-  SQL8`CREATE TABLE IF NOT EXISTS ${identifier7(processorsTable.name)}(
+  SQL3`CREATE TABLE IF NOT EXISTS ${identifier2(processorsTable.name)}(
     processor_id                 TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
@@ -1080,7 +885,7 @@ var migration_0_42_0_SQLs = [
     processor_instance_id        TEXT                  DEFAULT 'emt:unknown',
     PRIMARY KEY (processor_id, partition, version)
 )`,
-  SQL8`CREATE TABLE IF NOT EXISTS ${identifier7(projectionsTable.name)}(
+  SQL3`CREATE TABLE IF NOT EXISTS ${identifier2(projectionsTable.name)}(
     name                         TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT '${plain(globalTag)}',
@@ -1090,7 +895,7 @@ var migration_0_42_0_SQLs = [
     definition                   JSONB                 NOT NULL DEFAULT '{}',
     PRIMARY KEY (name, partition, version)
 )`,
-  SQL8`INSERT INTO ${identifier7(processorsTable.name)}
+  SQL3`INSERT INTO ${identifier2(processorsTable.name)}
     (processor_id, version, partition, status, last_processed_checkpoint, processor_instance_id)
   SELECT
     subscription_id,
@@ -1100,12 +905,12 @@ var migration_0_42_0_SQLs = [
     printf('%019d', last_processed_position),
     'emt:unknown'
   FROM emt_subscriptions`,
-  SQL8`DROP TABLE emt_subscriptions`
+  SQL3`DROP TABLE emt_subscriptions`
 ];
 var migration_0_42_0_FromSubscriptionsToProcessors = async (execute) => {
-  const tableExists = await singleOrNull5(
+  const tableExists = await singleOrNull2(
     execute.query(
-      SQL8`SELECT name FROM sqlite_master WHERE type='table' AND name='emt_subscriptions'`
+      SQL3`SELECT name FROM sqlite_master WHERE type='table' AND name='emt_subscriptions'`
     )
   );
   if (!tableExists) {
@@ -1115,9 +920,9 @@ var migration_0_42_0_FromSubscriptionsToProcessors = async (execute) => {
 };
 
 // src/eventStore/schema/migrations/0_42_0/0_42_0.snapshot.ts
-import { SQL as SQL9 } from "@event-driven-io/dumbo";
+import { SQL as SQL4 } from "@event-driven-io/dumbo";
 var schema_0_42_0 = [
-  SQL9`CREATE TABLE IF NOT EXISTS emt_streams(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_streams(
     stream_id         TEXT                      NOT NULL,
     stream_position   BIGINT                    NOT NULL DEFAULT 0,
     partition         TEXT                      NOT NULL DEFAULT 'global',
@@ -1127,7 +932,7 @@ var schema_0_42_0 = [
     PRIMARY KEY (stream_id, partition, is_archived),
     UNIQUE (stream_id, partition, is_archived)
 )`,
-  SQL9`CREATE TABLE IF NOT EXISTS emt_messages(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_messages(
     stream_id              TEXT                      NOT NULL,
     stream_position        BIGINT                    NOT NULL,
     partition              TEXT                      NOT NULL DEFAULT 'global',
@@ -1142,7 +947,7 @@ var schema_0_42_0 = [
     created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
     UNIQUE (stream_id, stream_position, partition, is_archived)
 )`,
-  SQL9`CREATE TABLE IF NOT EXISTS emt_processors(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_processors(
     processor_id                 TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT 'global',
@@ -1151,7 +956,7 @@ var schema_0_42_0 = [
     processor_instance_id        TEXT                  DEFAULT 'emt:unknown',
     PRIMARY KEY (processor_id, partition, version)
 )`,
-  SQL9`CREATE TABLE IF NOT EXISTS emt_projections(
+  SQL4`CREATE TABLE IF NOT EXISTS emt_projections(
     name                         TEXT                  NOT NULL,
     version                      INTEGER               NOT NULL DEFAULT 1,
     partition                    TEXT                  NOT NULL DEFAULT 'global',
@@ -1163,119 +968,199 @@ var schema_0_42_0 = [
 )`
 ];
 
-// src/eventStore/schema/tables.ts
-var { identifier: identifier8, plain: plain2 } = SQL10;
-var streamsTableSQL = SQL10`CREATE TABLE IF NOT EXISTS ${identifier8(streamsTable.name)}(
-      stream_id         TEXT                      NOT NULL,
-      stream_position   BIGINT                    NOT NULL DEFAULT 0,
-      partition         TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
-      stream_type       TEXT                      NOT NULL,
-      stream_metadata   JSONB                     NOT NULL,
-      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, partition, is_archived),
-      UNIQUE (stream_id, partition, is_archived)
-  );`;
-var messagesTableSQL = SQL10`CREATE TABLE IF NOT EXISTS ${identifier8(messagesTable.name)}(
-      stream_id              TEXT                      NOT NULL,
-      stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
-      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      message_schema_version TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
-      global_position        INTEGER                   PRIMARY KEY,
-      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE (stream_id, stream_position, partition, is_archived)
-  ); 
-`;
-var processorsTableSQL = SQL10`
-  CREATE TABLE IF NOT EXISTS ${SQL10.identifier(processorsTable.name)}(
-      processor_id                 TEXT                  NOT NULL,
-      version                      INTEGER               NOT NULL DEFAULT 1,
-      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
-      status                       TEXT                  NOT NULL DEFAULT 'stopped',
-      last_processed_checkpoint    TEXT                  NOT NULL,
-      processor_instance_id        TEXT                  DEFAULT '${plain2(unknownTag2)}',
-      PRIMARY KEY (processor_id, partition, version)
-  );
-`;
-var projectionsTableSQL = SQL10`
-  CREATE TABLE IF NOT EXISTS ${SQL10.identifier(projectionsTable.name)}(
-      name                         TEXT                  NOT NULL,
-      version                      INTEGER               NOT NULL DEFAULT 1,
-      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
-      type                         CHAR(1)               NOT NULL,
-      kind                         TEXT                  NOT NULL,
-      status                       TEXT                  NOT NULL,
-      definition                   JSONB                 NOT NULL DEFAULT '{}',
-      PRIMARY KEY (name, partition, version)
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+import { SQL as SQL5, singleOrNull as singleOrNull3 } from "@event-driven-io/dumbo";
+var { identifier: identifier3 } = SQL5;
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await singleOrNull3(
+    execute.query(
+      SQL5`
+         SELECT global_position
+         FROM ${identifier3(messagesTable.name)}
+         WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE
+         ORDER BY global_position
+         LIMIT 1`
+    )
   );
-`;
-var schemaSQL = [
-  streamsTableSQL,
-  messagesTableSQL,
-  processorsTableSQL,
-  projectionsTableSQL
-];
-var createEventStoreSchema = async (pool, hooks) => {
-  await pool.withTransaction(async (tx) => {
-    await migration_0_42_0_FromSubscriptionsToProcessors(tx.execute);
-    if (hooks?.onBeforeSchemaCreated) {
-      await hooks.onBeforeSchemaCreated({
-        connection: tx.connection
-      });
-    }
-    await tx.execute.batchCommand(schemaSQL);
-    if (hooks?.onAfterSchemaCreated) {
-      await hooks.onAfterSchemaCreated();
-    }
-  });
+  return {
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+  };
 };
 
-// src/eventStore/consumers/sqliteProcessor.ts
-var genericSQLiteProcessor = (options) => {
-  const { eachMessage } = options;
-  let isActive = true;
-  const getDb = (context) => {
-    const fileName = context.fileName ?? options.connectionOptions?.fileName;
-    if (!fileName)
-      throw new EmmettError(
-        `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
-      );
-    const connection = context.connection ?? options.connectionOptions?.connection ?? sqlite3Connection({ fileName, serializer: JSONSerializer });
-    return { connection, fileName };
-  };
-  return {
-    id: options.processorId,
-    start: async ({
-      execute
-    }) => {
-      isActive = true;
-      if (options.startFrom !== "CURRENT") return options.startFrom;
-      const { lastProcessedPosition } = await readProcessorCheckpoint(execute, {
-        processorId: options.processorId,
-        partition: options.partition
-      });
-      if (lastProcessedPosition === null) return "BEGINNING";
-      return { globalPosition: lastProcessedPosition };
-    },
-    get isActive() {
-      return isActive;
-    },
-    handle: async ({ messages }, context) => {
-      if (!isActive) return;
-      const { connection, fileName } = getDb(context);
+// src/eventStore/schema/readMessagesBatch.ts
+import { SQL as SQL6 } from "@event-driven-io/dumbo";
+var { identifier: identifier4 } = SQL6;
+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 ? SQL6`AND global_position >= ${from}` : "";
+  const toCondition = "to" in options ? SQL6`AND global_position <= ${options.to}` : SQL6.EMPTY;
+  const limitCondition = "batchSize" in options ? SQL6`LIMIT ${options.batchSize}` : SQL6.EMPTY;
+  const events = (await execute.query(
+    SQL6`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${identifier4(messagesTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${fromCondition} ${toCondition}
+           ORDER BY global_position
+           ${limitCondition}`
+  )).rows.map((row) => {
+    const rawEvent = {
+      type: row.message_type,
+      data: JSONParser.parse(row.message_data),
+      metadata: JSONParser.parse(row.message_metadata)
+    };
+    const metadata = {
+      ..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
+      messageId: row.message_id,
+      streamName: row.stream_id,
+      streamPosition: BigInt(row.stream_position),
+      globalPosition: BigInt(row.global_position)
+    };
+    return {
+      ...rawEvent,
+      kind: "Event",
+      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/readProcessorCheckpoint.ts
+import { SQL as SQL7, singleOrNull as singleOrNull4 } from "@event-driven-io/dumbo";
+var { identifier: identifier5 } = SQL7;
+var readProcessorCheckpoint = async (execute, options) => {
+  const result = await singleOrNull4(
+    execute.query(
+      SQL7`SELECT last_processed_checkpoint
+           FROM ${identifier5(processorsTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag2} AND processor_id = ${options.processorId}
+           LIMIT 1`
+    )
+  );
+  return {
+    lastProcessedPosition: result !== null ? BigInt(result.last_processed_checkpoint) : null
+  };
+};
+
+// src/eventStore/schema/readStream.ts
+import { SQL as SQL8 } from "@event-driven-io/dumbo";
+
+// src/eventStore/SQLiteEventStore.ts
+import { dumbo as dumbo3 } from "@event-driven-io/dumbo";
+
+// src/eventStore/consumers/messageBatchProcessing/index.ts
+var DefaultSQLiteEventStoreProcessorBatchSize = 100;
+var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
+var sqliteEventStoreMessageBatchPuller = ({
+  pool,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs
+}) => {
+  let isRunning = false;
+  let start;
+  const pullMessages = async (options) => {
+    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await pool.withConnection(
+      async ({ execute }) => readLastMessageGlobalPosition(execute)
+    )).currentGlobalPosition ?? 0n : options.startFrom.globalPosition;
+    const readMessagesOptions = {
+      after,
+      batchSize
+    };
+    let waitTime = 100;
+    do {
+      const { messages, currentGlobalPosition, areEventsLeft } = await pool.withConnection(
+        ({ execute }) => readMessagesBatch(execute, 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 zipSQLiteEventStoreMessageBatchPullerStartFrom = (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/consumers/sqliteEventStoreConsumer.ts
+import { dumbo as dumbo2 } from "@event-driven-io/dumbo";
+
+// src/eventStore/consumers/sqliteProcessor.ts
+var genericSQLiteProcessor = (options) => {
+  const { eachMessage } = options;
+  let isActive = true;
+  const mapToContext = (context) => {
+    const connection = context.connection ?? options.connectionOptions?.connection;
+    if (!connection)
+      throw new Error("Connection is required in context or options");
+    return { connection };
+  };
+  return {
+    id: options.processorId,
+    start: async ({
+      execute
+    }) => {
+      isActive = true;
+      if (options.startFrom !== "CURRENT") return options.startFrom;
+      const { lastProcessedPosition } = await readProcessorCheckpoint(execute, {
+        processorId: options.processorId,
+        partition: options.partition
+      });
+      if (lastProcessedPosition === null) return "BEGINNING";
+      return { globalPosition: lastProcessedPosition };
+    },
+    get isActive() {
+      return isActive;
+    },
+    handle: async ({ messages }, context) => {
+      if (!isActive) return;
+      const { connection } = mapToContext(context);
       return connection.withTransaction(async (tx) => {
         let result = void 0;
         let lastProcessedPosition = null;
         for (const message of messages) {
           const typedMessage = message;
           const messageProcessingResult = await eachMessage(typedMessage, {
-            connection: tx.connection,
-            fileName
+            connection: tx.connection
           });
           const newPosition = getCheckpoint(typedMessage);
           await storeProcessorCheckpoint(tx.execute, {
@@ -1329,9 +1214,12 @@ var sqliteEventStoreConsumer = (options) => {
   const processors = options.processors ?? [];
   let start;
   let currentMessagePuller;
-  const pool = options.pool ?? sqlite3Pool({
-    transactionOptions: { allowNestedTransactions: true },
-    ...options
+  const pool = options.pool ?? dumbo2({
+    ...options.driver.mapToDumboOptions(options),
+    transactionOptions: {
+      allowNestedTransactions: true,
+      mode: "session_based"
+    }
   });
   const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
     const activeProcessors = processors.filter((s) => s.isActive);
@@ -1343,8 +1231,7 @@ var sqliteEventStoreConsumer = (options) => {
     const result = await Promise.allSettled(
       activeProcessors.map((s) => {
         return s.handle(messagesBatch, {
-          connection,
-          fileName: options.fileName
+          connection
         });
       })
     );
@@ -1407,30 +1294,16 @@ var sqliteEventStoreConsumer = (options) => {
   };
 };
 
-// src/eventStore/schema/streamExists.ts
-import { exists, SQL as SQL11 } from "@event-driven-io/dumbo";
-var streamExists = (execute, streamId, options) => exists(
-  execute.query(
-    SQL11`SELECT EXISTS (
-        SELECT 1
-        from ${SQL11.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE) as exists
-      `
-  )
-);
-
 // src/eventStore/SQLiteEventStore.ts
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
   let autoGenerateSchema = false;
-  const fileName = options.fileName ?? InMemorySQLiteDatabase;
-  const poolOptions = {
-    fileName,
-    transactionOptions: { allowNestedTransactions: true }
-  };
-  const pool = options.pool ?? sqlite3Pool2({
-    ...poolOptions,
-    ...options.connectionOptions ? options.connectionOptions : {}
+  const pool = options.pool ?? dumbo3({
+    ...options.driver.mapToDumboOptions(options),
+    transactionOptions: {
+      allowNestedTransactions: true,
+      mode: "session_based"
+    }
   });
   let migrateSchema = void 0;
   const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
@@ -1533,9 +1406,9 @@ var getSQLiteEventStore = (options) => {
         ({ execute }) => streamExists(execute, streamName, options2)
       );
     },
-    consumer: (options2) => sqliteEventStoreConsumer({
-      ...options2 ?? {},
-      fileName,
+    consumer: (consumerOptions) => sqliteEventStoreConsumer({
+      ...options ?? {},
+      ...consumerOptions ?? {},
       pool
     }),
     close: () => pool.close(),
@@ -1547,134 +1420,220 @@ var getSQLiteEventStore = (options) => {
   };
 };
 
-// src/eventStore/projections/sqliteProjectionSpec.ts
-var SQLiteProjectionSpec = {
-  for: (options) => {
-    {
-      const connection = options.connection ?? sqlite3Connection2({
-        fileName: options.fileName ?? InMemorySQLiteDatabase2,
-        serializer: JSONSerializer2
-      });
-      const projection2 = options.projection;
-      let wasInitialized = false;
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (connection2) => {
-              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-${uuid6()}`,
-                  messageId: uuid6()
-                };
-                allEvents.push({
-                  ...event,
-                  kind: "Event",
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? event.metadata ?? {} : {}
-                  }
-                });
-              }
-              if (!wasInitialized && projection2.init) {
-                await projection2.init({
-                  registrationType: "async",
-                  status: "active",
-                  context: { connection: connection2 },
-                  version: projection2.version ?? 1
-                });
-                wasInitialized = true;
-              }
-              await connection2.withTransaction(
-                () => handleProjections({
-                  events: allEvents,
-                  projections: [projection2],
-                  connection: connection2
-                })
-              );
-            };
-            return {
-              then: async (assert, message) => {
-                try {
-                  await run(connection);
-                  const succeeded = await assert({
-                    connection
-                  });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      message ?? "Projection specification didn't match the criteria"
-                    );
-                } finally {
-                  await connection.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                try {
-                  await run(connection);
-                  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 connection.close();
-                }
-              }
-            };
-          }
-        };
-      };
+// src/eventStore/schema/readStream.ts
+var { identifier: identifier6 } = SQL8;
+var readStream = async (execute, streamId, options) => {
+  const fromCondition = options?.from ? SQL8`AND stream_position >= ${options.from}` : SQL8.EMPTY;
+  const to = Number(
+    options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN)
+  );
+  const toCondition = !isNaN(to) ? SQL8`AND stream_position <= ${to}` : SQL8.EMPTY;
+  const { rows: results } = await execute.query(
+    SQL8`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+        FROM ${identifier6(messagesTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE ${fromCondition} ${toCondition}
+        ORDER BY stream_position ASC`
+  );
+  const messages = results.map((row) => {
+    const rawEvent = {
+      type: row.message_type,
+      data: JSONParser.parse(row.message_data),
+      metadata: JSONParser.parse(row.message_metadata)
+    };
+    const metadata = {
+      ..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
+      messageId: row.message_id,
+      streamName: streamId,
+      streamPosition: BigInt(row.stream_position),
+      globalPosition: BigInt(row.global_position)
+    };
+    const event = {
+      ...rawEvent,
+      kind: "Event",
+      metadata
+    };
+    return upcastRecordedMessage(event, options?.schema?.versioning);
+  });
+  return messages.length > 0 ? {
+    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
+    events: messages,
+    streamExists: true
+  } : {
+    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
+    events: [],
+    streamExists: false
+  };
+};
+
+// src/eventStore/schema/storeProcessorCheckpoint.ts
+import {
+  DumboError as DumboError2,
+  singleOrNull as singleOrNull5,
+  SQL as SQL9,
+  UniqueConstraintError as UniqueConstraintError2
+} from "@event-driven-io/dumbo";
+var { identifier: identifier7 } = SQL9;
+async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
+  processorInstanceId ??= unknownTag2;
+  if (checkPosition !== null) {
+    const updateResult = await execute.command(
+      SQL9`
+          UPDATE ${identifier7(processorsTable.name)}
+          SET 
+            last_processed_checkpoint = ${position},
+            processor_instance_id = ${processorInstanceId}
+          WHERE processor_id = ${processorId} 
+            AND last_processed_checkpoint = ${checkPosition} 
+            AND partition = ${partition}
+        `
+    );
+    if (updateResult.rowCount && updateResult.rowCount > 0) {
+      return 1;
+    }
+    const current_position = await singleOrNull5(
+      execute.query(
+        SQL9`
+          SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
+               WHERE processor_id = ${processorId} AND partition = ${partition}`
+      )
+    );
+    const currentPosition = current_position && current_position?.last_processed_checkpoint !== null ? BigInt(current_position.last_processed_checkpoint) : null;
+    if (currentPosition === position) {
+      return 0;
+    } else if (position !== null && currentPosition !== null && currentPosition > position) {
+      return 2;
+    } else {
+      return 2;
+    }
+  } else {
+    try {
+      await execute.command(
+        SQL9`INSERT INTO ${identifier7(processorsTable.name)} (processor_id, version, last_processed_checkpoint, partition, processor_instance_id) 
+        VALUES (${processorId}, ${version}, ${position}, ${partition}, ${processorInstanceId})`
+      );
+      return 1;
+    } catch (err) {
+      if (!DumboError2.isInstanceOf(err, {
+        errorType: UniqueConstraintError2.ErrorType
+      })) {
+        throw err;
+      }
+      const current = await singleOrNull5(
+        execute.query(
+          SQL9`
+            SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
+            WHERE processor_id = ${processorId} AND partition = ${partition}`
+        )
+      );
+      const currentPosition = current && current?.last_processed_checkpoint !== null ? BigInt(current.last_processed_checkpoint) : null;
+      if (currentPosition === position) {
+        return 0;
+      } else {
+        return 2;
+      }
     }
   }
-};
-var eventInStream = (streamName, event) => {
-  return {
-    ...event,
-    metadata: {
-      ...event.metadata ?? {},
-      streamName: event.metadata?.streamName ?? streamName
+}
+async function storeProcessorCheckpoint(execute, options) {
+  try {
+    const result = await storeSubscriptionCheckpointSQLite(
+      execute,
+      options.processorId,
+      options.version ?? 1,
+      options.newPosition,
+      options.lastProcessedPosition,
+      options.partition ?? defaultTag2
+    );
+    return result === 1 ? { success: true, newPosition: options.newPosition } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}
+
+// src/eventStore/schema/streamExists.ts
+import { exists, SQL as SQL10 } from "@event-driven-io/dumbo";
+var streamExists = (execute, streamId, options) => exists(
+  execute.query(
+    SQL10`SELECT EXISTS (
+        SELECT 1
+        from ${SQL10.identifier(streamsTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag2} AND is_archived = FALSE) as exists
+      `
+  )
+);
+
+// src/eventStore/schema/tables.ts
+import { SQL as SQL11 } from "@event-driven-io/dumbo";
+var { identifier: identifier8, plain: plain2 } = SQL11;
+var streamsTableSQL = SQL11`CREATE TABLE IF NOT EXISTS ${identifier8(streamsTable.name)}(
+      stream_id         TEXT                      NOT NULL,
+      stream_position   BIGINT                    NOT NULL DEFAULT 0,
+      partition         TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
+      stream_type       TEXT                      NOT NULL,
+      stream_metadata   JSONB                     NOT NULL,
+      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
+      PRIMARY KEY (stream_id, partition, is_archived),
+      UNIQUE (stream_id, partition, is_archived)
+  );`;
+var messagesTableSQL = SQL11`CREATE TABLE IF NOT EXISTS ${identifier8(messagesTable.name)}(
+      stream_id              TEXT                      NOT NULL,
+      stream_position        BIGINT                    NOT NULL,
+      partition              TEXT                      NOT NULL DEFAULT '${plain2(globalTag)}',
+      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
+      message_data           JSONB                     NOT NULL,
+      message_metadata       JSONB                     NOT NULL,
+      message_schema_version TEXT                      NOT NULL,
+      message_type           TEXT                      NOT NULL,
+      message_id             TEXT                      NOT NULL,
+      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
+      global_position        INTEGER                   PRIMARY KEY,
+      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE (stream_id, stream_position, partition, is_archived)
+  ); 
+`;
+var processorsTableSQL = SQL11`
+  CREATE TABLE IF NOT EXISTS ${SQL11.identifier(processorsTable.name)}(
+      processor_id                 TEXT                  NOT NULL,
+      version                      INTEGER               NOT NULL DEFAULT 1,
+      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
+      status                       TEXT                  NOT NULL DEFAULT 'stopped',
+      last_processed_checkpoint    TEXT                  NOT NULL,
+      processor_instance_id        TEXT                  DEFAULT '${plain2(unknownTag2)}',
+      PRIMARY KEY (processor_id, partition, version)
+  );
+`;
+var projectionsTableSQL = SQL11`
+  CREATE TABLE IF NOT EXISTS ${SQL11.identifier(projectionsTable.name)}(
+      name                         TEXT                  NOT NULL,
+      version                      INTEGER               NOT NULL DEFAULT 1,
+      partition                    TEXT                  NOT NULL DEFAULT '${plain2(globalTag)}',
+      type                         CHAR(1)               NOT NULL,
+      kind                         TEXT                  NOT NULL,
+      status                       TEXT                  NOT NULL,
+      definition                   JSONB                 NOT NULL DEFAULT '{}',
+      PRIMARY KEY (name, partition, version)
+  );
+`;
+var schemaSQL = [
+  streamsTableSQL,
+  messagesTableSQL,
+  processorsTableSQL,
+  projectionsTableSQL
+];
+var createEventStoreSchema = async (pool, hooks) => {
+  await pool.withTransaction(async (tx) => {
+    await migration_0_42_0_FromSubscriptionsToProcessors(tx.execute);
+    if (hooks?.onBeforeSchemaCreated) {
+      await hooks.onBeforeSchemaCreated({
+        connection: tx.connection
+      });
     }
-  };
-};
-var eventsInStream = (streamName, events) => {
-  return events.map((e) => eventInStream(streamName, e));
-};
-var newEventsInStream = eventsInStream;
-var assertSQLQueryResultMatches = (sql, rows) => async ({
-  connection
-}) => {
-  const result = await connection.execute.query(sql);
-  assertThatArray(rows).containsExactlyInAnyOrder(result.rows);
-};
-var expectSQL = {
-  query: (sql) => ({
-    resultRows: {
-      toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows)
+    await tx.execute.batchCommand(schemaSQL);
+    if (hooks?.onAfterSchemaCreated) {
+      await hooks.onAfterSchemaCreated();
     }
-  })
+  });
 };
 export {
   SQLiteEventStoreDefaultStreamVersion,
@@ -1711,6 +1670,7 @@ export {
   sqliteRawBatchSQLProjection,
   sqliteRawSQLProjection,
   storeProcessorCheckpoint,
+  streamExists,
   streamsTable,
   streamsTableSQL,
   unknownTag2 as unknownTag