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

package/dist/index.cjs

@@ -1,6 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
-var isBigint = (val) => typeof val === "bigint" && val === val;
 var isString = (val) => typeof val === "string";
 var isErrorConstructor = (expect) => {
   return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -281,6 +280,10 @@ var deepEquals = (left, right) => {
 var isEquatable = (left) => {
   return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
+var toNormalizedString = (value) => value.toString().padStart(19, "0");
+var bigInt = {
+  toNormalizedString
+};
 var ParseError = class extends Error {
   constructor(text) {
     super(`Cannot parse! ${text}`);
@@ -302,7 +305,204 @@ var JSONParser = {
     return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
   }
 };
+var onShutdown = (handler) => {
+  const signals = ["SIGTERM", "SIGINT"];
+  if (typeof process !== "undefined" && typeof process.on === "function") {
+    for (const signal of signals) {
+      process.on(signal, handler);
+    }
+    return () => {
+      for (const signal of signals) {
+        process.off(signal, handler);
+      }
+    };
+  }
+  const deno = globalThis.Deno;
+  if (deno && typeof deno.addSignalListener === "function") {
+    for (const signal of signals) {
+      deno.addSignalListener(signal, handler);
+    }
+    return () => {
+      for (const signal of signals) {
+        deno.removeSignalListener(signal, handler);
+      }
+    };
+  }
+  return () => {
+  };
+};
 var textEncoder = new TextEncoder();
+var getCheckpoint = (message2) => {
+  return message2.metadata.checkpoint;
+};
+var wasMessageHandled = (message2, checkpoint) => {
+  const messageCheckpoint = getCheckpoint(message2);
+  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
+};
+var MessageProcessorType = {
+  PROJECTOR: "projector",
+  REACTOR: "reactor"
+};
+var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+var bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
+var parseBigIntProcessorCheckpoint = (value) => BigInt(value);
+var defaultProcessorVersion = 1;
+var defaultProcessorPartition = defaultTag;
+var getProcessorInstanceId = (processorId) => `${processorId}:${_uuid.v7.call(void 0, )}`;
+var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
+var reactor = (options) => {
+  const {
+    checkpoints,
+    processorId,
+    processorInstanceId: instanceId = getProcessorInstanceId(processorId),
+    type = MessageProcessorType.REACTOR,
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition,
+    hooks = {},
+    processingScope = defaultProcessingMessageProcessingScope,
+    startFrom,
+    canHandle,
+    stopAfter
+  } = options;
+  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
+  let isInitiated = false;
+  let isActive = false;
+  let lastCheckpoint = null;
+  let closeSignal = null;
+  const init = async (initOptions) => {
+    if (isInitiated) return;
+    if (hooks.onInit === void 0) {
+      isInitiated = true;
+      return;
+    }
+    return await processingScope(async (context) => {
+      await hooks.onInit(context);
+      isInitiated = true;
+    }, initOptions);
+  };
+  const close = async (closeOptions) => {
+    isActive = false;
+    if (closeSignal) {
+      closeSignal();
+      closeSignal = null;
+    }
+    if (hooks.onClose) {
+      await processingScope(hooks.onClose, closeOptions);
+    }
+  };
+  return {
+    // TODO: Consider whether not make it optional or add URN prefix
+    id: processorId,
+    instanceId,
+    type,
+    init,
+    start: async (startOptions) => {
+      if (isActive) return;
+      await init(startOptions);
+      isActive = true;
+      closeSignal = onShutdown(() => close({}));
+      if (lastCheckpoint !== null)
+        return {
+          lastCheckpoint
+        };
+      return await processingScope(async (context) => {
+        if (hooks.onStart) {
+          await hooks.onStart(context);
+        }
+        if (startFrom && startFrom !== "CURRENT") return startFrom;
+        if (checkpoints) {
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _14 => _14.read, 'call', _15 => _15(
+            {
+              processorId,
+              partition
+            },
+            { ...startOptions, ...context }
+          )]);
+          lastCheckpoint = readResult.lastCheckpoint;
+        }
+        if (lastCheckpoint === null) return "BEGINNING";
+        return {
+          lastCheckpoint
+        };
+      }, startOptions);
+    },
+    close,
+    get isActive() {
+      return isActive;
+    },
+    handle: async (messages, partialContext) => {
+      if (!isActive) return Promise.resolve();
+      return await processingScope(async (context) => {
+        let result = void 0;
+        for (const message2 of messages) {
+          if (wasMessageHandled(message2, lastCheckpoint)) continue;
+          const upcasted = upcastRecordedMessage(
+            // TODO: Make it smarter
+            message2,
+            _optionalChain([options, 'access', _16 => _16.messageOptions, 'optionalAccess', _17 => _17.schema, 'optionalAccess', _18 => _18.versioning])
+          );
+          if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
+            continue;
+          const messageProcessingResult = await eachMessage(upcasted, context);
+          if (checkpoints) {
+            const storeCheckpointResult = await checkpoints.store(
+              {
+                processorId,
+                version,
+                message: upcasted,
+                lastCheckpoint,
+                partition
+              },
+              context
+            );
+            if (storeCheckpointResult.success) {
+              lastCheckpoint = storeCheckpointResult.newCheckpoint;
+            }
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+            isActive = false;
+            result = messageProcessingResult;
+            break;
+          }
+          if (stopAfter && stopAfter(upcasted)) {
+            isActive = false;
+            result = { type: "STOP", reason: "Stop condition reached" };
+            break;
+          }
+          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
+            continue;
+        }
+        return result;
+      }, partialContext);
+    }
+  };
+};
+var projector = (options) => {
+  const {
+    projection: projection2,
+    processorId = getProjectorId({
+      projectionName: _nullishCoalesce(projection2.name, () => ( "unknown"))
+    }),
+    ...rest
+  } = options;
+  return reactor({
+    ...rest,
+    type: MessageProcessorType.PROJECTOR,
+    canHandle: projection2.canHandle,
+    processorId,
+    messageOptions: options.projection.eventsOptions,
+    hooks: {
+      onInit: _optionalChain([options, 'access', _19 => _19.hooks, 'optionalAccess', _20 => _20.onInit]),
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _21 => _21.hooks, 'optionalAccess', _22 => _22.onStart]) ? async (context) => {
+        if (options.truncateOnStart && options.projection.truncate)
+          await options.projection.truncate(context);
+        if (_optionalChain([options, 'access', _23 => _23.hooks, 'optionalAccess', _24 => _24.onStart])) await _optionalChain([options, 'access', _25 => _25.hooks, 'optionalAccess', _26 => _26.onStart, 'call', _27 => _27(context)]);
+      } : void 0,
+      onClose: _optionalChain([options, 'access', _28 => _28.hooks, 'optionalAccess', _29 => _29.onClose])
+    },
+    eachMessage: async (event2, context) => projection2.handle([event2], context)
+  });
+};
 var AssertionError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -314,7 +514,7 @@ var isSubset = (superObj, subObj) => {
   assertOk(sup);
   assertOk(sub);
   return Object.keys(sub).every((ele) => {
-    if (typeof sub[ele] == "object") {
+    if (sub[ele] !== null && typeof sub[ele] == "object") {
       return isSubset(sup[ele], sub[ele]);
     }
     return sub[ele] === sup[ele];
@@ -406,7 +606,7 @@ var assertThatArray = (array) => {
   };
 };
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _14 => _14.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _30 => _30.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -424,14 +624,14 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _15 => _15.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _31 => _31.downcast]))
     return recordedMessages;
   return recordedMessages.map(
     (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
   );
 };
 var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _16 => _16.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _32 => _32.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -448,56 +648,55 @@ var upcastRecordedMessage = (recordedMessage, options) => {
     } : {}
   };
 };
-var getCheckpoint = (message2) => {
-  return "checkpoint" in message2.metadata ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.checkpoint
-  ) : "globalPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.globalPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.globalPosition
-  ) : "streamPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.streamPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.streamPosition
-  ) : null;
-};
 var projection = (definition) => definition;
 
 // src/eventStore/projections/sqliteProjection.ts
 var handleProjections = async (options) => {
-  const { projections: allProjections, events, connection } = options;
+  const {
+    projections: allProjections,
+    events,
+    connection,
+    execute,
+    driverType
+  } = options;
   const eventTypes = events.map((e) => e.type);
   for (const projection2 of allProjections) {
     if (!projection2.canHandle.some((type) => eventTypes.includes(type))) {
       continue;
     }
     await projection2.handle(events, {
-      connection
+      connection,
+      execute,
+      driverType
     });
   }
 };
 var sqliteProjection = (definition) => projection(definition);
 var sqliteRawBatchSQLProjection = (options) => sqliteProjection({
+  name: options.name,
+  kind: _nullishCoalesce(options.kind, () => ( "emt:projections:sqlite:raw_sql:batch")),
+  version: options.version,
   canHandle: options.canHandle,
+  eventsOptions: options.eventsOptions,
   handle: async (events, context) => {
     const sqls = await options.evolve(events, context);
-    for (const sql of sqls) await context.connection.execute.command(sql);
+    await context.execute.batchCommand(sqls);
   },
   init: async (initOptions) => {
-    if (options.init) {
-      await options.init(initOptions);
-    }
-    if (options.initSQL) {
-      const initSQLs = Array.isArray(options.initSQL) ? options.initSQL : [options.initSQL];
-      for (const sql of initSQLs)
-        await initOptions.context.connection.execute.command(sql);
+    const initSQL = options.init ? await options.init(initOptions) : void 0;
+    if (initSQL) {
+      if (Array.isArray(initSQL)) {
+        await initOptions.context.execute.batchCommand(initSQL);
+      } else {
+        await initOptions.context.execute.command(initSQL);
+      }
     }
   }
 });
 var sqliteRawSQLProjection = (options) => {
-  const { evolve, ...rest } = options;
+  const { evolve, kind, ...rest } = options;
   return sqliteRawBatchSQLProjection({
+    kind: _nullishCoalesce(kind, () => ( "emt:projections:sqlite:raw:_sql:single")),
     ...rest,
     evolve: async (events, context) => {
       const sqls = [];
@@ -520,6 +719,7 @@ var _dumbo = require('@event-driven-io/dumbo');
 var SQLiteProjectionSpec = {
   for: (options) => {
     {
+      const driverType = options.driver.driverType;
       const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
         ...options.driver.mapToDumboOptions(options)
       })));
@@ -531,13 +731,14 @@ var SQLiteProjectionSpec = {
             const allEvents = [];
             const run = async (connection) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _17 => _17.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _33 => _33.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
               ]) {
                 const metadata = {
-                  globalPosition: ++globalPosition,
+                  checkpoint: bigIntProcessorCheckpoint(++globalPosition),
+                  globalPosition,
                   streamPosition: globalPosition,
                   streamName: `test-${_uuid.v4.call(void 0, )}`,
                   messageId: _uuid.v4.call(void 0, )
@@ -555,7 +756,11 @@ var SQLiteProjectionSpec = {
                 await projection2.init({
                   registrationType: "async",
                   status: "active",
-                  context: { connection },
+                  context: {
+                    execute: connection.execute,
+                    connection,
+                    driverType
+                  },
                   version: _nullishCoalesce(projection2.version, () => ( 1))
                 });
                 wasInitialized = true;
@@ -564,7 +769,9 @@ var SQLiteProjectionSpec = {
                 () => handleProjections({
                   events: allEvents,
                   projections: [projection2],
-                  connection
+                  execute: connection.execute,
+                  connection,
+                  driverType
                 })
               );
             };
@@ -591,18 +798,18 @@ var SQLiteProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _18 => _18.toString, 'call', _19 => _19()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _34 => _34.toString, 'call', _35 => _35()])}`
                     );
                     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()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _36 => _36.toString, 'call', _37 => _37()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _22 => _22.toString, 'call', _23 => _23()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _38 => _38.toString, 'call', _39 => _39()])}`
                     );
                   }
                 }
@@ -619,7 +826,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _24 => _24.metadata, 'optionalAccess', _25 => _25.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _40 => _40.metadata, 'optionalAccess', _41 => _41.streamName]), () => ( streamName))
     }
   };
 };
@@ -691,7 +898,7 @@ 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', _26 => _26.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _42 => _42.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -714,13 +921,13 @@ var appendToStream = async (connection, streamName, streamType, messages, option
           streamType,
           downcastRecordedMessages(
             messagesToAppend,
-            _optionalChain([options, 'optionalAccess', _27 => _27.schema, 'optionalAccess', _28 => _28.versioning])
+            _optionalChain([options, 'optionalAccess', _43 => _43.schema, 'optionalAccess', _44 => _44.versioning])
           ),
           {
             expectedStreamVersion
           }
         );
-        if (_optionalChain([options, 'optionalAccess', _29 => _29.onBeforeCommit]))
+        if (_optionalChain([options, 'optionalAccess', _45 => _45.onBeforeCommit]))
           await options.onBeforeCommit(messagesToAppend, { connection });
         return { success: true, result };
       }
@@ -744,7 +951,7 @@ var toExpectedVersion = (expected) => {
   return expected;
 };
 var appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
-  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _30 => _30.expectedStreamVersion]), () => ( null));
+  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.expectedStreamVersion]), () => ( null));
   const currentStreamVersion = await getLastStreamPosition(
     execute,
     streamId,
@@ -762,7 +969,7 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
             VALUES  (
                 ${streamId},
                 ${messages.length},
-                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _31 => _31.partition]), () => ( streamsTable.columns.partition))},
+                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.partition]), () => ( streamsTable.columns.partition))},
                 ${streamType},
                 '[]',
                 false
@@ -772,7 +979,7 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
             SET stream_position = stream_position + ${messages.length}
             WHERE stream_id = ${streamId}
             AND stream_position = ${expectedStreamVersion}
-            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _32 => _32.partition]), () => ( streamsTable.columns.partition))}
+            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _48 => _48.partition]), () => ( streamsTable.columns.partition))}
             AND is_archived = false
             RETURNING stream_position;
           `;
@@ -780,12 +987,12 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
     messages,
     expectedStreamVersion,
     streamId,
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.partition, 'optionalAccess', _34 => _34.toString, 'call', _35 => _35()]), () => ( defaultTag2))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.partition, 'optionalAccess', _50 => _50.toString, 'call', _51 => _51()]), () => ( 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]);
+  const streamPosition = _optionalChain([streamResult, 'optionalAccess', _52 => _52.rows, 'access', _53 => _53[0], 'optionalAccess', _54 => _54.stream_position]);
+  const globalPosition = _optionalChain([messagesResult, 'optionalAccess', _55 => _55.rows, 'access', _56 => _56.at, 'call', _57 => _57(-1), 'optionalAccess', _58 => _58.global_position]);
   if (!streamPosition)
     throw new ExpectedVersionConflictError(0n, _nullishCoalesce(expectedStreamVersion, () => ( 0n)));
   if (!globalPosition) throw new Error("Could not find global position");
@@ -801,7 +1008,7 @@ async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
       _dumbo.SQL`SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${identifier(streamsTable.name)} WHERE stream_id = ${streamId}`
     )
   );
-  if (_optionalChain([result, 'optionalAccess', _43 => _43.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _59 => _59.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -810,7 +1017,7 @@ async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
 }
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const values = messages.map((message) => {
-    if (_optionalChain([message, 'access', _44 => _44.metadata, 'optionalAccess', _45 => _45.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+    if (_optionalChain([message, 'access', _60 => _60.metadata, 'optionalAccess', _61 => _61.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
       throw new Error("Stream position is required");
     }
     const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -977,7 +1184,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
       _dumbo.SQL`
          SELECT global_position
          FROM ${identifier3(messagesTable.name)}
-         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.partition]), () => ( defaultTag2))} AND is_archived = FALSE
+         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.partition]), () => ( defaultTag2))} AND is_archived = FALSE
          ORDER BY global_position
          LIMIT 1`
     )
@@ -991,44 +1198,49 @@ var readLastMessageGlobalPosition = async (execute, options) => {
 
 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 from = "from" in options ? options.from : void 0;
+  const after = "after" in options ? options.after : void 0;
+  const batchSize = "batchSize" in options ? options.batchSize : options.to - options.from;
+  const fromCondition = from !== void 0 ? _dumbo.SQL`AND global_position >= ${from}` : after !== void 0 ? _dumbo.SQL`AND global_position > ${after}` : _dumbo.SQL.EMPTY;
   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
+  const messages = await _dumbo.mapRows.call(void 0, 
+    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}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _63 => _63.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
+    ),
+    (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),
+        checkpoint: bigIntProcessorCheckpoint(BigInt(row.global_position))
+      };
+      return {
+        ...rawEvent,
+        kind: "Event",
+        metadata
+      };
+    }
+  );
+  return messages.length > 0 ? {
+    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
+    messages,
+    areMessagesLeft: messages.length === batchSize
   } : {
     currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
     messages: [],
-    areEventsLeft: false
+    areMessagesLeft: false
   };
 };
 
@@ -1040,12 +1252,12 @@ var readProcessorCheckpoint = async (execute, options) => {
     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}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _64 => _64.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
            LIMIT 1`
     )
   );
   return {
-    lastProcessedPosition: result !== null ? BigInt(result.last_processed_checkpoint) : null
+    lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null
   };
 };
 
@@ -1059,28 +1271,26 @@ var readProcessorCheckpoint = async (execute, options) => {
 var DefaultSQLiteEventStoreProcessorBatchSize = 100;
 var DefaultSQLiteEventStoreProcessorPullingFrequencyInMs = 50;
 var sqliteEventStoreMessageBatchPuller = ({
-  pool,
+  executor,
   batchSize,
   eachBatch,
-  pullingFrequencyInMs
+  pullingFrequencyInMs,
+  stopWhen,
+  signal
 }) => {
   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 after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(executor)).currentGlobalPosition, async () => ( 0n)) : parseBigIntProcessorCheckpoint(options.startFrom.lastCheckpoint);
     const readMessagesOptions = {
       after,
       batchSize
     };
     let waitTime = 100;
-    do {
-      const { messages, currentGlobalPosition, areEventsLeft } = await pool.withConnection(
-        ({ execute }) => readMessagesBatch(execute, readMessagesOptions)
-      );
+    while (isRunning && !_optionalChain([signal, 'optionalAccess', _65 => _65.aborted])) {
+      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
       if (messages.length > 0) {
-        const result = await eachBatch({ messages });
+        const result = await eachBatch(messages);
         if (result && result.type === "STOP") {
           isRunning = false;
           break;
@@ -1088,12 +1298,16 @@ var sqliteEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (!areEventsLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _66 => _66.noMessagesLeft]) === true && !areMessagesLeft) {
+        isRunning = false;
+        break;
+      }
+      if (!areMessagesLeft) {
         waitTime = Math.min(waitTime * 2, 1e3);
       } else {
         waitTime = pullingFrequencyInMs;
       }
-    } while (isRunning);
+    }
   };
   return {
     get isRunning() {
@@ -1101,8 +1315,8 @@ var sqliteEventStoreMessageBatchPuller = ({
     },
     start: (options) => {
       if (isRunning) return start;
+      isRunning = true;
       start = (async () => {
-        isRunning = true;
         return pullMessages(options);
       })();
       return start;
@@ -1124,96 +1338,115 @@ var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
 // src/eventStore/consumers/sqliteEventStoreConsumer.ts
 
 
+
+// src/eventStore/consumers/sqliteCheckpointer.ts
+var sqliteCheckpointer = () => ({
+  read: async (options, context) => {
+    const result = await readProcessorCheckpoint(context.execute, options);
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _67 => _67.lastProcessedCheckpoint]) };
+  },
+  store: async (options, context) => {
+    const newCheckpoint = getCheckpoint(options.message);
+    const result = await storeProcessorCheckpoint(context.execute, {
+      lastProcessedCheckpoint: options.lastCheckpoint,
+      newCheckpoint,
+      processorId: options.processorId,
+      partition: options.partition,
+      version: options.version
+    });
+    return result.success ? { success: true, newCheckpoint: result.newCheckpoint } : result;
+  }
+});
+
 // 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])));
+var sqliteProcessingScope = () => {
+  const processingScope = async (handler, partialContext) => {
+    const connection = _optionalChain([partialContext, 'optionalAccess', _68 => _68.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
-          });
-          const newPosition = getCheckpoint(typedMessage);
-          await storeProcessorCheckpoint(tx.execute, {
-            processorId: options.processorId,
-            version: options.version,
-            lastProcessedPosition,
-            newPosition,
-            partition: options.partition
-          });
-          lastProcessedPosition = typedMessage.metadata.globalPosition;
-          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-            isActive = false;
-            result = messageProcessingResult;
-            break;
-          }
-          if (options.stopAfter && options.stopAfter(typedMessage)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
-        }
-        return result;
-      });
-    }
+      throw new EmmettError("Connection is required in context or options");
+    return connection.withTransaction(
+      async (transaction) => {
+        return handler({
+          ...partialContext,
+          connection,
+          execute: transaction.execute
+        });
+      }
+    );
   };
+  return processingScope;
 };
-var sqliteProjectionProcessor = (options) => {
-  const projection2 = options.projection;
-  return genericSQLiteProcessor({
-    processorId: _nullishCoalesce(options.processorId, () => ( `projection:${projection2.name}`)),
-    eachMessage: async (event, context) => {
-      if (!projection2.canHandle.includes(event.type)) return;
-      await projection2.handle([event], { connection: context.connection });
-    },
-    ...options
+var sqliteReactor = (options) => {
+  const {
+    processorId = options.processorId,
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition,
+    hooks
+  } = options;
+  return reactor({
+    ...options,
+    processorId,
+    processorInstanceId,
+    version,
+    partition,
+    hooks,
+    processingScope: sqliteProcessingScope(),
+    checkpoints: sqliteCheckpointer()
   });
 };
-var sqliteProcessor = (options) => {
-  if ("projection" in options) {
-    return sqliteProjectionProcessor(options);
-  }
-  return genericSQLiteProcessor(options);
+var sqliteProjector = (options) => {
+  const {
+    processorId = getProjectorId({
+      projectionName: _nullishCoalesce(options.projection.name, () => ( "unknown"))
+    }),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition
+  } = options;
+  const hooks = {
+    ..._nullishCoalesce(options.hooks, () => ( {})),
+    onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _69 => _69.hooks, 'optionalAccess', _70 => _70.onInit]) ? async (context) => {
+      if (options.projection.init)
+        await options.projection.init({
+          version: _nullishCoalesce(options.projection.version, () => ( version)),
+          status: "active",
+          registrationType: "async",
+          context: {
+            ...context,
+            migrationOptions: options.migrationOptions
+          }
+        });
+      if (_optionalChain([options, 'access', _71 => _71.hooks, 'optionalAccess', _72 => _72.onInit]))
+        await options.hooks.onInit({
+          ...context,
+          migrationOptions: options.migrationOptions
+        });
+    } : _optionalChain([options, 'access', _73 => _73.hooks, 'optionalAccess', _74 => _74.onInit]),
+    onClose: _optionalChain([options, 'access', _75 => _75.hooks, 'optionalAccess', _76 => _76.onClose])
+  };
+  const processor = projector({
+    ...options,
+    processorId,
+    processorInstanceId,
+    version,
+    partition,
+    hooks,
+    processingScope: sqliteProcessingScope(),
+    checkpoints: sqliteCheckpointer()
+  });
+  return processor;
 };
 
 // src/eventStore/consumers/sqliteEventStoreConsumer.ts
 var sqliteEventStoreConsumer = (options) => {
   let isRunning = false;
+  let isInitialized = false;
   const { pulling } = options;
   const processors = _nullishCoalesce(options.processors, () => ( []));
+  let abortController = null;
   let start;
-  let currentMessagePuller;
+  let messagePuller;
   const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
     ...options.driver.mapToDumboOptions(options),
     transactionOptions: {
@@ -1229,59 +1462,112 @@ var sqliteEventStoreConsumer = (options) => {
         reason: "No active processors"
       };
     const result = await Promise.allSettled(
-      activeProcessors.map((s) => {
-        return s.handle(messagesBatch, {
-          connection
+      activeProcessors.map(async (s) => {
+        return await s.handle(messagesBatch, {
+          connection,
+          execute: connection.execute
         });
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _51 => _51.value, 'optionalAccess', _52 => _52.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _77 => _77.value, 'optionalAccess', _78 => _78.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
   });
-  const messagePooler = currentMessagePuller = sqliteEventStoreMessageBatchPuller({
-    pool,
-    eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _53 => _53.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-    pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _54 => _54.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs))
-  });
+  const processorContext = {
+    execute: void 0,
+    connection: void 0
+  };
+  const stopProcessors = () => Promise.all(processors.map((p) => p.close(processorContext)));
   const stop = async () => {
     if (!isRunning) return;
     isRunning = false;
-    if (currentMessagePuller) {
-      await currentMessagePuller.stop();
-      currentMessagePuller = void 0;
+    if (messagePuller) {
+      _optionalChain([abortController, 'optionalAccess', _79 => _79.abort, 'call', _80 => _80()]);
+      await messagePuller.stop();
+      messagePuller = void 0;
+      abortController = null;
     }
     await start;
+    await stopProcessors();
+  };
+  const init = async () => {
+    if (isInitialized) return;
+    const sqliteProcessors = processors;
+    await pool.withConnection(async (connection) => {
+      for (const processor of sqliteProcessors) {
+        if (processor.init) {
+          await processor.init({
+            ...processorContext,
+            connection,
+            execute: connection.execute
+          });
+        }
+      }
+    });
+    isInitialized = true;
   };
   return {
-    processors,
+    consumerId: _nullishCoalesce(options.consumerId, () => ( _uuid.v7.call(void 0, ))),
     get isRunning() {
       return isRunning;
     },
-    processor: (options2) => {
-      const processor = sqliteProcessor(options2);
-      processors.push(processor);
+    processors,
+    init,
+    reactor: (options2) => {
+      const processor = sqliteReactor(options2);
+      processors.push(
+        // TODO: change that
+        processor
+      );
+      return processor;
+    },
+    projector: (options2) => {
+      const processor = sqliteProjector(options2);
+      processors.push(
+        // TODO: change that
+        processor
+      );
       return processor;
     },
     start: () => {
       if (isRunning) return start;
+      if (processors.length === 0)
+        throw new EmmettError(
+          "Cannot start consumer without at least a single processor"
+        );
+      isRunning = true;
+      abortController = new AbortController();
+      messagePuller = sqliteEventStoreMessageBatchPuller({
+        stopWhen: options.stopWhen,
+        executor: pool.execute,
+        eachBatch,
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _81 => _81.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _82 => _82.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs)),
+        signal: abortController.signal
+      });
       start = (async () => {
-        if (processors.length === 0)
-          return Promise.reject(
-            new EmmettError(
-              "Cannot start consumer without at least a single processor"
+        if (!isRunning) return;
+        if (!isInitialized) {
+          await init();
+        }
+        const startFrom = await pool.withConnection(
+          async (connection) => zipSQLiteEventStoreMessageBatchPullerStartFrom(
+            await Promise.all(
+              processors.map(async (o) => {
+                const result = await o.start({
+                  execute: connection.execute,
+                  connection
+                });
+                return result;
+              })
             )
-          );
-        isRunning = true;
-        const startFrom = zipSQLiteEventStoreMessageBatchPullerStartFrom(
-          await pool.withConnection(
-            (connection) => Promise.all(processors.map((o) => o.start(connection)))
           )
         );
-        return messagePooler.start({ startFrom });
+        await messagePuller.start({ startFrom });
+        await stopProcessors();
+        isRunning = false;
       })();
       return start;
     },
@@ -1289,7 +1575,6 @@ var sqliteEventStoreConsumer = (options) => {
     close: async () => {
       await stop();
       await pool.close();
-      await new Promise((resolve) => setTimeout(resolve, 250));
     }
   };
 };
@@ -1307,13 +1592,13 @@ var getSQLiteEventStore = (options) => {
   })));
   let migrateSchema = void 0;
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const onBeforeCommitHook = _optionalChain([options, 'access', _55 => _55.hooks, 'optionalAccess', _56 => _56.onBeforeCommit]);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _83 => _83.hooks, 'optionalAccess', _84 => _84.onBeforeCommit]);
   const withConnection = async (handler) => pool.withConnection(async (connection) => {
     await ensureSchemaExists(connection);
     return await handler(connection);
   });
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _57 => _57.schema, 'optionalAccess', _58 => _58.autoMigration]) === void 0 || _optionalChain([options, 'access', _59 => _59.schema, 'optionalAccess', _60 => _60.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) === void 0 || _optionalChain([options, 'access', _87 => _87.schema, 'optionalAccess', _88 => _88.autoMigration]) !== "None";
   }
   const migrate = (connection) => {
     if (!migrateSchema) {
@@ -1325,15 +1610,19 @@ var getSQLiteEventStore = (options) => {
                 version: _nullishCoalesce(projection2.version, () => ( 1)),
                 registrationType: "async",
                 status: "active",
-                context
+                context: {
+                  execute: context.connection.execute,
+                  connection: context.connection,
+                  driverType: options.driver.driverType
+                }
               });
             }
           }
-          if (_optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onBeforeSchemaCreated])) {
+          if (_optionalChain([options, 'access', _89 => _89.hooks, 'optionalAccess', _90 => _90.onBeforeSchemaCreated])) {
             await options.hooks.onBeforeSchemaCreated(context);
           }
         },
-        onAfterSchemaCreated: _optionalChain([options, 'access', _63 => _63.hooks, 'optionalAccess', _64 => _64.onAfterSchemaCreated])
+        onAfterSchemaCreated: _optionalChain([options, 'access', _91 => _91.hooks, 'optionalAccess', _92 => _92.onAfterSchemaCreated])
       });
     }
     return migrateSchema;
@@ -1345,7 +1634,7 @@ var getSQLiteEventStore = (options) => {
   return {
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _65 => _65.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _93 => _93.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
@@ -1372,18 +1661,20 @@ var getSQLiteEventStore = (options) => {
     readStream: async (streamName, options2) => withConnection(
       ({ execute }) => readStream(execute, streamName, options2)
     ),
-    appendToStream: async (streamName, events, options2) => {
+    appendToStream: async (streamName, events, appendOptions) => {
       const [firstPart, ...rest] = streamName.split("-");
       const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
       const appendResult = await withConnection(
         (connection) => appendToStream(connection, streamName, streamType, events, {
-          ...options2,
+          ...appendOptions,
           onBeforeCommit: async (messages, context) => {
             if (inlineProjections.length > 0)
               await handleProjections({
                 projections: inlineProjections,
                 events: messages,
-                ...context
+                execute: context.connection.execute,
+                connection: context.connection,
+                driverType: options.driver.driverType
               });
             if (onBeforeCommitHook) await onBeforeCommitHook(messages, context);
           }
@@ -1393,7 +1684,7 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _66 => _66.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _94 => _94.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1423,15 +1714,15 @@ var getSQLiteEventStore = (options) => {
 // 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 fromCondition = _optionalChain([options, 'optionalAccess', _95 => _95.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)))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _96 => _96.to]), () => ( (_optionalChain([options, 'optionalAccess', _97 => _97.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}
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _98 => _98.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
         ORDER BY stream_position ASC`
   );
   const messages = results.map((row) => {
@@ -1445,14 +1736,15 @@ var readStream = async (execute, streamId, options) => {
       messageId: row.message_id,
       streamName: streamId,
       streamPosition: BigInt(row.stream_position),
-      globalPosition: BigInt(row.global_position)
+      globalPosition: BigInt(row.global_position),
+      checkpoint: bigIntProcessorCheckpoint(BigInt(row.global_position))
     };
     const event = {
       ...rawEvent,
       kind: "Event",
       metadata
     };
-    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _71 => _71.schema, 'optionalAccess', _72 => _72.versioning]));
+    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _99 => _99.schema, 'optionalAccess', _100 => _100.versioning]));
   });
   return messages.length > 0 ? {
     currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
@@ -1497,7 +1789,7 @@ async function storeSubscriptionCheckpointSQLite(execute, processorId, version,
                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;
+    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _101 => _101.last_processed_checkpoint]) !== null ? current_position.last_processed_checkpoint : null;
     if (currentPosition === position) {
       return 0;
     } else if (position !== null && currentPosition !== null && currentPosition > position) {
@@ -1525,7 +1817,7 @@ async function storeSubscriptionCheckpointSQLite(execute, processorId, version,
             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;
+      const currentPosition = current && _optionalChain([current, 'optionalAccess', _102 => _102.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
       if (currentPosition === position) {
         return 0;
       } else {
@@ -1540,11 +1832,11 @@ async function storeProcessorCheckpoint(execute, options) {
       execute,
       options.processorId,
       _nullishCoalesce(options.version, () => ( 1)),
-      options.newPosition,
-      options.lastProcessedPosition,
+      options.newCheckpoint,
+      options.lastProcessedCheckpoint,
       _nullishCoalesce(options.partition, () => ( defaultTag2))
     );
-    return result === 1 ? { success: true, newPosition: options.newPosition } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
+    return result === 1 ? { success: true, newCheckpoint: options.newCheckpoint } : { success: false, reason: result === 0 ? "IGNORED" : "MISMATCH" };
   } catch (error) {
     console.log(error);
     throw error;
@@ -1558,7 +1850,7 @@ var streamExists = (execute, streamId, options) => _dumbo.exists.call(void 0,
     _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
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _103 => _103.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
       `
   )
 );
@@ -1624,13 +1916,13 @@ var schemaSQL = [
 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])) {
+    if (_optionalChain([hooks, 'optionalAccess', _104 => _104.onBeforeSchemaCreated])) {
       await hooks.onBeforeSchemaCreated({
         connection: tx.connection
       });
     }
     await tx.execute.batchCommand(schemaSQL);
-    if (_optionalChain([hooks, 'optionalAccess', _77 => _77.onAfterSchemaCreated])) {
+    if (_optionalChain([hooks, 'optionalAccess', _105 => _105.onAfterSchemaCreated])) {
       await hooks.onAfterSchemaCreated();
     }
   });