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

package/dist/index.cjs

@@ -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,25 +515,140 @@ var sqliteRawSQLProjection = (options) => {
 };
 
 // src/eventStore/projections/sqliteProjectionSpec.ts
-
-
 var _dumbo = require('@event-driven-io/dumbo');
 
+var SQLiteProjectionSpec = {
+  for: (options) => {
+    {
+      const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
+        ...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 = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _17 => _17.numberOfTimes]), () => ( 1));
+              for (const event of [
+                ...givenEvents,
+                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
+              ]) {
+                const metadata = {
+                  globalPosition: ++globalPosition,
+                  streamPosition: globalPosition,
+                  streamName: `test-${_uuid.v4.call(void 0, )}`,
+                  messageId: _uuid.v4.call(void 0, )
+                };
+                allEvents.push({
+                  ...event,
+                  kind: "Event",
+                  metadata: {
+                    ...metadata,
+                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
+                  }
+                });
+              }
+              if (!wasInitialized && projection2.init) {
+                await projection2.init({
+                  registrationType: "async",
+                  status: "active",
+                  context: { connection },
+                  version: _nullishCoalesce(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(
+                    _nullishCoalesce(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: ${_optionalChain([error, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`
+                    );
+                    return;
+                  }
+                  assertTrue(
+                    error instanceof args[0],
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _20 => _20.toString, 'call', _21 => _21()])}`
+                  );
+                  if (args[1]) {
+                    assertTrue(
+                      args[1](error),
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
+                    );
+                  }
+                }
+              })
+            };
+          }
+        };
+      };
+    }
+  }
+};
+var eventInStream = (streamName, event) => {
+  return {
+    ...event,
+    metadata: {
+      ..._nullishCoalesce(event.metadata, () => ( {})),
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.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)
+    }
+  })
+};
 
-
-var _sqlite3 = require('@event-driven-io/dumbo/sqlite3');
-
-
-// src/eventStore/SQLiteEventStore.ts
+// src/eventStore/schema/appendToStream.ts
 
 
 
 
 
-// src/eventStore/consumers/messageBatchProcessing/index.ts
 
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
 
 
 // src/eventStore/schema/typing.ts
@@ -567,160 +686,12 @@ var projectionsTable = {
   name: `${emmettPrefix2}_projections`
 };
 
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var { identifier } = _dumbo.SQL;
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`
-         SELECT global_position
-         FROM ${identifier(messagesTable.name)}
-         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.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
-
-var { identifier: identifier2 } = _dumbo.SQL;
-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 ? _dumbo.SQL`AND global_position >= ${from}` : "";
-  const toCondition = "to" in options ? _dumbo.SQL`AND global_position <= ${options.to}` : _dumbo.SQL.EMPTY;
-  const limitCondition = "batchSize" in options ? _dumbo.SQL`LIMIT ${options.batchSize}` : _dumbo.SQL.EMPTY;
-  const events = (await execute.query(
-    _dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${identifier2(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.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 ? _nullishCoalesce(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 _asyncNullishCoalesce((await pool.withConnection(
-      async ({ execute }) => readLastMessageGlobalPosition(execute)
-    )).currentGlobalPosition, async () => ( 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
-
-
-
-
-// src/eventStore/consumers/sqliteProcessor.ts
-
-
-
-
-
 // src/eventStore/schema/appendToStream.ts
-
-
-
-
-
-
-
-
-var { identifier: identifier3, merge } = _dumbo.SQL;
+var { identifier, merge } = _dumbo.SQL;
 var appendToStream = async (connection, streamName, streamType, messages, options) => {
   if (messages.length === 0) return { success: false };
   const expectedStreamVersion = toExpectedVersion(
-    _optionalChain([options, 'optionalAccess', _19 => _19.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _26 => _26.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -734,22 +705,36 @@ var appendToStream = async (connection, streamName, streamType, messages, option
       }
     })
   );
-  return await connection.withTransaction(
-    async (transaction) => {
-      const result = await appendToStreamRaw(
-        transaction.execute,
-        streamName,
-        streamType,
-        downcastRecordedMessages(messagesToAppend, _optionalChain([options, 'optionalAccess', _20 => _20.schema, 'optionalAccess', _21 => _21.versioning])),
-        {
-          expectedStreamVersion
-        }
-      );
-      if (_optionalChain([options, 'optionalAccess', _22 => _22.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,
+            _optionalChain([options, 'optionalAccess', _27 => _27.schema, 'optionalAccess', _28 => _28.versioning])
+          ),
+          {
+            expectedStreamVersion
+          }
+        );
+        if (_optionalChain([options, 'optionalAccess', _29 => _29.onBeforeCommit]))
+          await options.onBeforeCommit(messagesToAppend, { connection });
+        return { success: true, result };
+      }
+    );
+  } catch (err) {
+    if (isExpectedVersionConflictError(err) || _dumbo.DumboError.isInstanceOf(err, {
+      errorType: _dumbo.UniqueConstraintError.ErrorType
+    }) || _dumbo.DumboError.isInstanceOf(err, {
+      errorType: _dumbo.BatchCommandNoChangesError.ErrorType
+    })) {
+      return { success: false };
+    }
+    throw err;
+  }
 };
 var toExpectedVersion = (expected) => {
   if (expected === void 0) return null;
@@ -759,97 +744,64 @@ var toExpectedVersion = (expected) => {
   return expected;
 };
 var appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
-  let streamPosition;
-  let globalPosition;
-  try {
-    let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.expectedStreamVersion]), () => ( null));
-    if (expectedStreamVersion == null) {
-      expectedStreamVersion = await getLastStreamPosition(
-        execute,
-        streamId,
-        expectedStreamVersion
-      );
-    }
-    let position;
-    if (expectedStreamVersion === 0n) {
-      position = await _dumbo.singleOrNull.call(void 0, 
-        execute.query(
-          _dumbo.SQL`INSERT INTO ${identifier3(streamsTable.name)}
+  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _30 => _30.expectedStreamVersion]), () => ( null));
+  const currentStreamVersion = await getLastStreamPosition(
+    execute,
+    streamId,
+    expectedStreamVersion
+  );
+  expectedStreamVersion ??= _nullishCoalesce(currentStreamVersion, () => ( 0n));
+  if (expectedStreamVersion !== currentStreamVersion) {
+    throw new ExpectedVersionConflictError(
+      currentStreamVersion,
+      expectedStreamVersion
+    );
+  }
+  const streamSQL = expectedStreamVersion === 0n ? _dumbo.SQL`INSERT INTO ${identifier(streamsTable.name)}
             (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
             VALUES  (
                 ${streamId},
                 ${messages.length},
-                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.partition]), () => ( streamsTable.columns.partition))},
+                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _31 => _31.partition]), () => ( streamsTable.columns.partition))},
                 ${streamType},
                 '[]',
                 false
             )
             RETURNING stream_position;
-          `
-        )
-      );
-    } else {
-      position = await _dumbo.singleOrNull.call(void 0, 
-        execute.query(
-          _dumbo.SQL`UPDATE ${identifier3(streamsTable.name)}
+          ` : _dumbo.SQL`UPDATE ${identifier(streamsTable.name)}
             SET stream_position = stream_position + ${messages.length}
             WHERE stream_id = ${streamId}
-            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _25 => _25.partition]), () => ( streamsTable.columns.partition))}
+            AND stream_position = ${expectedStreamVersion}
+            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.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,
-      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _26 => _26.partition, 'optionalAccess', _27 => _27.toString, 'call', _28 => _28()]), () => ( defaultTag2))
-    );
-    const { rows: returningIds } = await execute.query(insertSQL);
-    if (returningIds.length === 0 || !_optionalChain([returningIds, 'access', _29 => _29[returningIds.length - 1], 'optionalAccess', _30 => _30.global_position])) {
-      throw new Error("Could not find global position");
-    }
-    globalPosition = BigInt(
-      returningIds[returningIds.length - 1].global_position
-    );
-  } catch (err) {
-    if (_sqlite3.isSQLiteError.call(void 0, err) && isOptimisticConcurrencyError(err)) {
-      return {
-        success: false
-      };
-    }
-    throw err;
-  }
+          `;
+  const insertSQL = buildMessageInsertQuery(
+    messages,
+    expectedStreamVersion,
+    streamId,
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.partition, 'optionalAccess', _34 => _34.toString, 'call', _35 => _35()]), () => ( defaultTag2))
+  );
+  const results = await execute.batchCommand([streamSQL, insertSQL], { assertChanges: true });
+  const [streamResult, messagesResult] = results;
+  const streamPosition = _optionalChain([streamResult, 'optionalAccess', _36 => _36.rows, 'access', _37 => _37[0], 'optionalAccess', _38 => _38.stream_position]);
+  const globalPosition = _optionalChain([messagesResult, 'optionalAccess', _39 => _39.rows, 'access', _40 => _40.at, 'call', _41 => _41(-1), 'optionalAccess', _42 => _42.global_position]);
+  if (!streamPosition)
+    throw new ExpectedVersionConflictError(0n, _nullishCoalesce(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 _optionalChain([error, 'optionalAccess', _31 => _31.errno]) !== void 0 && error.errno === 19;
-};
 async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
   const result = await _dumbo.singleOrNull.call(void 0, 
     execute.query(
-      _dumbo.SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier3(streamsTable.name)} WHERE stream_id = ${streamId}`
+      _dumbo.SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier(streamsTable.name)} WHERE stream_id = ${streamId}`
     )
   );
-  if (_optionalChain([result, 'optionalAccess', _32 => _32.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _43 => _43.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -858,14 +810,14 @@ async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
 }
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const values = messages.map((message) => {
-    if (_optionalChain([message, 'access', _33 => _33.metadata, 'optionalAccess', _34 => _34.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+    if (_optionalChain([message, 'access', _44 => _44.metadata, 'optionalAccess', _45 => _45.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
       throw new Error("Stream position is required");
     }
     const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
     return _dumbo.SQL`(${streamId},${_nullishCoalesce(streamPosition, () => ( 0n))},${_nullishCoalesce(partition, () => ( defaultTag2))},${message.kind === "Event" ? "E" : "C"},${message.data},${message.metadata},${_nullishCoalesce(expectedStreamVersion, () => ( 0n))},${message.type},${message.metadata.messageId},${false})`;
   });
   return _dumbo.SQL`
-      INSERT INTO ${identifier3(messagesTable.name)} (
+      INSERT INTO ${identifier(messagesTable.name)} (
           stream_id, 
           stream_position, 
           partition, 
@@ -883,153 +835,6 @@ var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partit
     `;
 };
 
-// src/eventStore/schema/readProcessorCheckpoint.ts
-
-var { identifier: identifier4 } = _dumbo.SQL;
-var readProcessorCheckpoint = async (execute, options) => {
-  const result = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`SELECT last_processed_checkpoint
-           FROM ${identifier4(processorsTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
-           LIMIT 1`
-    )
-  );
-  return {
-    lastProcessedPosition: result !== null ? BigInt(result.last_processed_checkpoint) : null
-  };
-};
-
-// src/eventStore/schema/readStream.ts
-
-var { identifier: identifier5 } = _dumbo.SQL;
-var readStream = async (execute, streamId, options) => {
-  const fromCondition = _optionalChain([options, 'optionalAccess', _36 => _36.from]) ? _dumbo.SQL`AND stream_position >= ${options.from}` : _dumbo.SQL.EMPTY;
-  const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _37 => _37.to]), () => ( (_optionalChain([options, 'optionalAccess', _38 => _38.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
-  );
-  const toCondition = !isNaN(to) ? _dumbo.SQL`AND stream_position <= ${to}` : _dumbo.SQL.EMPTY;
-  const { rows: results } = await execute.query(
-    _dumbo.SQL`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 = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.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 ? _nullishCoalesce(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, _optionalChain([options, 'optionalAccess', _40 => _40.schema, 'optionalAccess', _41 => _41.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
-
-
-var { identifier: identifier6 } = _dumbo.SQL;
-async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
-  processorInstanceId ??= unknownTag2;
-  if (checkPosition !== null) {
-    const updateResult = await execute.command(
-      _dumbo.SQL`
-          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 _dumbo.singleOrNull.call(void 0, 
-      execute.query(
-        _dumbo.SQL`
-          SELECT last_processed_checkpoint FROM ${identifier6(processorsTable.name)} 
-               WHERE processor_id = ${processorId} AND partition = ${partition}`
-      )
-    );
-    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _42 => _42.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(
-        _dumbo.SQL`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 (!(_sqlite3.isSQLiteError.call(void 0, err) && (err.errno === 19 || err.errno === 2067))) {
-        throw err;
-      }
-      const current = await _dumbo.singleOrNull.call(void 0, 
-        execute.query(
-          _dumbo.SQL`
-            SELECT last_processed_checkpoint FROM ${identifier6(processorsTable.name)} 
-            WHERE processor_id = ${processorId} AND partition = ${partition}`
-        )
-      );
-      const currentPosition = current && _optionalChain([current, 'optionalAccess', _43 => _43.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,
-      _nullishCoalesce(options.version, () => ( 1)),
-      options.newPosition,
-      options.lastProcessedPosition,
-      _nullishCoalesce(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
-
-
-
 // src/eventStore/schema/migrations/0_41_0/0_41_0.snapshot.ts
 
 var schema_0_41_0 = [
@@ -1069,9 +874,9 @@ var schema_0_41_0 = [
 
 // src/eventStore/schema/migrations/0_42_0/0_42_0.migration.ts
 
-var { identifier: identifier7, plain } = _dumbo.SQL;
+var { identifier: identifier2, plain } = _dumbo.SQL;
 var migration_0_42_0_SQLs = [
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier7(processorsTable.name)}(
+  _dumbo.SQL`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)
 )`,
-  _dumbo.SQL`CREATE TABLE IF NOT EXISTS ${identifier7(projectionsTable.name)}(
+  _dumbo.SQL`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)
 )`,
-  _dumbo.SQL`INSERT INTO ${identifier7(processorsTable.name)}
+  _dumbo.SQL`INSERT INTO ${identifier2(processorsTable.name)}
     (processor_id, version, partition, status, last_processed_checkpoint, processor_instance_id)
   SELECT
     subscription_id,
@@ -1163,90 +968,171 @@ var schema_0_42_0 = [
 )`
 ];
 
-// src/eventStore/schema/tables.ts
-var { identifier: identifier8, plain: plain2 } = _dumbo.SQL;
-var streamsTableSQL = _dumbo.SQL`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 = _dumbo.SQL`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 = _dumbo.SQL`
-  CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.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 = _dumbo.SQL`
-  CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.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
+
+var { identifier: identifier3 } = _dumbo.SQL;
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await _dumbo.singleOrNull.call(void 0, 
+    execute.query(
+      _dumbo.SQL`
+         SELECT global_position
+         FROM ${identifier3(messagesTable.name)}
+         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.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 (_optionalChain([hooks, 'optionalAccess', _44 => _44.onBeforeSchemaCreated])) {
-      await hooks.onBeforeSchemaCreated({
-        connection: tx.connection
-      });
-    }
-    await tx.execute.batchCommand(schemaSQL);
-    if (_optionalChain([hooks, 'optionalAccess', _45 => _45.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 = _nullishCoalesce(context.fileName, () => ( _optionalChain([options, 'access', _46 => _46.connectionOptions, 'optionalAccess', _47 => _47.fileName])));
-    if (!fileName)
-      throw new EmmettError(
-        `SQLite processor '${options.processorId}' is missing file name. Ensure that you passed it through options`
+// src/eventStore/schema/readMessagesBatch.ts
+
+var { identifier: identifier4 } = _dumbo.SQL;
+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 ? _dumbo.SQL`AND global_position >= ${from}` : "";
+  const toCondition = "to" in options ? _dumbo.SQL`AND global_position <= ${options.to}` : _dumbo.SQL.EMPTY;
+  const limitCondition = "batchSize" in options ? _dumbo.SQL`LIMIT ${options.batchSize}` : _dumbo.SQL.EMPTY;
+  const events = (await execute.query(
+    _dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${identifier4(messagesTable.name)}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.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 ? _nullishCoalesce(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
+
+var { identifier: identifier5 } = _dumbo.SQL;
+var readProcessorCheckpoint = async (execute, options) => {
+  const result = await _dumbo.singleOrNull.call(void 0, 
+    execute.query(
+      _dumbo.SQL`SELECT last_processed_checkpoint
+           FROM ${identifier5(processorsTable.name)}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _48 => _48.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
+           LIMIT 1`
+    )
+  );
+  return {
+    lastProcessedPosition: result !== null ? BigInt(result.last_processed_checkpoint) : null
+  };
+};
+
+// src/eventStore/schema/readStream.ts
+
+
+// src/eventStore/SQLiteEventStore.ts
+
+
+// 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 _asyncNullishCoalesce((await pool.withConnection(
+      async ({ execute }) => readLastMessageGlobalPosition(execute)
+    )).currentGlobalPosition, async () => ( 0n)) : options.startFrom.globalPosition;
+    const readMessagesOptions = {
+      after,
+      batchSize
+    };
+    let waitTime = 100;
+    do {
+      const { messages, currentGlobalPosition, areEventsLeft } = await pool.withConnection(
+        ({ execute }) => readMessagesBatch(execute, readMessagesOptions)
       );
-    const connection = _nullishCoalesce(_nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _48 => _48.connectionOptions, 'optionalAccess', _49 => _49.connection]))), () => ( _sqlite3.sqlite3Connection.call(void 0, { fileName, serializer: _dumbo.JSONSerializer })));
-    return { connection, fileName };
+      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
+
+
+// src/eventStore/consumers/sqliteProcessor.ts
+var genericSQLiteProcessor = (options) => {
+  const { eachMessage } = options;
+  let isActive = true;
+  const mapToContext = (context) => {
+    const connection = _nullishCoalesce(context.connection, () => ( _optionalChain([options, 'access', _49 => _49.connectionOptions, 'optionalAccess', _50 => _50.connection])));
+    if (!connection)
+      throw new Error("Connection is required in context or options");
+    return { connection };
   };
   return {
     id: options.processorId,
@@ -1267,15 +1153,14 @@ var genericSQLiteProcessor = (options) => {
     },
     handle: async ({ messages }, context) => {
       if (!isActive) return;
-      const { connection, fileName } = getDb(context);
+      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 = _nullishCoalesce(options.processors, () => ( []));
   let start;
   let currentMessagePuller;
-  const pool = _nullishCoalesce(options.pool, () => ( _sqlite3.sqlite3Pool.call(void 0, {
-    transactionOptions: { allowNestedTransactions: true },
-    ...options
+  const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
+    ...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,13 +1231,12 @@ var sqliteEventStoreConsumer = (options) => {
     const result = await Promise.allSettled(
       activeProcessors.map((s) => {
         return s.handle(messagesBatch, {
-          connection,
-          fileName: options.fileName
+          connection
         });
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _50 => _50.value, 'optionalAccess', _51 => _51.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _51 => _51.value, 'optionalAccess', _52 => _52.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -1357,8 +1244,8 @@ var sqliteEventStoreConsumer = (options) => {
   const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
     pool,
     eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _52 => _52.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _53 => _53.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
+    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _53 => _53.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _54 => _54.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
   });
   const stop = async () => {
     if (!isRunning) return;
@@ -1407,30 +1294,16 @@ var sqliteEventStoreConsumer = (options) => {
   };
 };
 
-// src/eventStore/schema/streamExists.ts
-
-var streamExists = (execute, streamId, options) => _dumbo.exists.call(void 0, 
-  execute.query(
-    _dumbo.SQL`SELECT EXISTS (
-        SELECT 1
-        from ${_dumbo.SQL.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
-      `
-  )
-);
-
 // src/eventStore/SQLiteEventStore.ts
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
   let autoGenerateSchema = false;
-  const fileName = _nullishCoalesce(options.fileName, () => ( _sqlite3.InMemorySQLiteDatabase));
-  const poolOptions = {
-    fileName,
-    transactionOptions: { allowNestedTransactions: true }
-  };
-  const pool = _nullishCoalesce(options.pool, () => ( _sqlite3.sqlite3Pool.call(void 0, {
-    ...poolOptions,
-    ...options.connectionOptions ? options.connectionOptions : {}
+  const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
+    ...options.driver.mapToDumboOptions(options),
+    transactionOptions: {
+      allowNestedTransactions: true,
+      mode: "session_based"
+    }
   })));
   let migrateSchema = void 0;
   const inlineProjections = (_nullishCoalesce(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({
-      ..._nullishCoalesce(options2, () => ( {})),
-      fileName,
+    consumer: (consumerOptions) => sqliteEventStoreConsumer({
+      ..._nullishCoalesce(options, () => ( {})),
+      ..._nullishCoalesce(consumerOptions, () => ( {})),
       pool
     }),
     close: () => pool.close(),
@@ -1547,134 +1420,220 @@ var getSQLiteEventStore = (options) => {
   };
 };
 
-// src/eventStore/projections/sqliteProjectionSpec.ts
-var SQLiteProjectionSpec = {
-  for: (options) => {
-    {
-      const connection = _nullishCoalesce(options.connection, () => ( _sqlite3.sqlite3Connection.call(void 0, {
-        fileName: _nullishCoalesce(options.fileName, () => ( _sqlite3.InMemorySQLiteDatabase)),
-        serializer: _dumbo.JSONSerializer
-      })));
-      const projection2 = options.projection;
-      let wasInitialized = false;
-      return (givenEvents) => {
-        return {
-          when: (events, options2) => {
-            const allEvents = [];
-            const run = async (connection2) => {
-              let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _67 => _67.numberOfTimes]), () => ( 1));
-              for (const event of [
-                ...givenEvents,
-                ...Array.from({ length: numberOfTimes }).flatMap(() => events)
-              ]) {
-                const metadata = {
-                  globalPosition: ++globalPosition,
-                  streamPosition: globalPosition,
-                  streamName: `test-${_uuid.v4.call(void 0, )}`,
-                  messageId: _uuid.v4.call(void 0, )
-                };
-                allEvents.push({
-                  ...event,
-                  kind: "Event",
-                  metadata: {
-                    ...metadata,
-                    ..."metadata" in event ? _nullishCoalesce(event.metadata, () => ( {})) : {}
-                  }
-                });
-              }
-              if (!wasInitialized && projection2.init) {
-                await projection2.init({
-                  registrationType: "async",
-                  status: "active",
-                  context: { connection: connection2 },
-                  version: _nullishCoalesce(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(
-                      _nullishCoalesce(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: ${_optionalChain([error, 'optionalAccess', _68 => _68.toString, 'call', _69 => _69()])}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _70 => _70.toString, 'call', _71 => _71()])}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _72 => _72.toString, 'call', _73 => _73()])}`
-                    );
-                  }
-                } finally {
-                  await connection.close();
-                }
-              }
-            };
-          }
-        };
-      };
+// src/eventStore/schema/readStream.ts
+var { identifier: identifier6 } = _dumbo.SQL;
+var readStream = async (execute, streamId, options) => {
+  const fromCondition = _optionalChain([options, 'optionalAccess', _67 => _67.from]) ? _dumbo.SQL`AND stream_position >= ${options.from}` : _dumbo.SQL.EMPTY;
+  const to = Number(
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _68 => _68.to]), () => ( (_optionalChain([options, 'optionalAccess', _69 => _69.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
+  );
+  const toCondition = !isNaN(to) ? _dumbo.SQL`AND stream_position <= ${to}` : _dumbo.SQL.EMPTY;
+  const { rows: results } = await execute.query(
+    _dumbo.SQL`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 = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.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 ? _nullishCoalesce(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, _optionalChain([options, 'optionalAccess', _71 => _71.schema, 'optionalAccess', _72 => _72.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
+
+
+
+
+
+
+var { identifier: identifier7 } = _dumbo.SQL;
+async function storeSubscriptionCheckpointSQLite(execute, processorId, version, position, checkPosition, partition, processorInstanceId) {
+  processorInstanceId ??= unknownTag2;
+  if (checkPosition !== null) {
+    const updateResult = await execute.command(
+      _dumbo.SQL`
+          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 _dumbo.singleOrNull.call(void 0, 
+      execute.query(
+        _dumbo.SQL`
+          SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
+               WHERE processor_id = ${processorId} AND partition = ${partition}`
+      )
+    );
+    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _73 => _73.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(
+        _dumbo.SQL`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 (!_dumbo.DumboError.isInstanceOf(err, {
+        errorType: _dumbo.UniqueConstraintError.ErrorType
+      })) {
+        throw err;
+      }
+      const current = await _dumbo.singleOrNull.call(void 0, 
+        execute.query(
+          _dumbo.SQL`
+            SELECT last_processed_checkpoint FROM ${identifier7(processorsTable.name)} 
+            WHERE processor_id = ${processorId} AND partition = ${partition}`
+        )
+      );
+      const currentPosition = current && _optionalChain([current, 'optionalAccess', _74 => _74.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: {
-      ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _74 => _74.metadata, 'optionalAccess', _75 => _75.streamName]), () => ( streamName))
+}
+async function storeProcessorCheckpoint(execute, options) {
+  try {
+    const result = await storeSubscriptionCheckpointSQLite(
+      execute,
+      options.processorId,
+      _nullishCoalesce(options.version, () => ( 1)),
+      options.newPosition,
+      options.lastProcessedPosition,
+      _nullishCoalesce(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
+
+var streamExists = (execute, streamId, options) => _dumbo.exists.call(void 0, 
+  execute.query(
+    _dumbo.SQL`SELECT EXISTS (
+        SELECT 1
+        from ${_dumbo.SQL.identifier(streamsTable.name)}
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
+      `
+  )
+);
+
+// src/eventStore/schema/tables.ts
+
+var { identifier: identifier8, plain: plain2 } = _dumbo.SQL;
+var streamsTableSQL = _dumbo.SQL`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 = _dumbo.SQL`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 = _dumbo.SQL`
+  CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.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 = _dumbo.SQL`
+  CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.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 (_optionalChain([hooks, 'optionalAccess', _76 => _76.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 (_optionalChain([hooks, 'optionalAccess', _77 => _77.onAfterSchemaCreated])) {
+      await hooks.onAfterSchemaCreated();
     }
-  })
+  });
 };
 
 
@@ -1714,5 +1673,6 @@ var expectSQL = {
 
 
 
-exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
+
+exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
 //# sourceMappingURL=index.cjs.map