@event-driven-io/emmett-sqlite 0.43.0-beta.11 → 0.43.0-beta.13

package/dist/index.cjs

@@ -1,131 +1,4 @@
-"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;// src/eventStore/projections/pongo/pongoProjections.ts
-
-
-var _pongo = require('@event-driven-io/pongo');
-var pongoProjection = ({
-  name,
-  kind,
-  version,
-  truncate,
-  handle,
-  canHandle,
-  eventsOptions
-}) => sqliteProjection({
-  name,
-  version,
-  kind: _nullishCoalesce(kind, () => ( "emt:projections:postgresql:pongo:generic")),
-  canHandle,
-  eventsOptions,
-  handle: async (events, context) => {
-    const { connection } = context;
-    const driver = await pongoDriverRegistry.tryResolve(
-      context.driverType
-    );
-    const pongo = _pongo.pongoClient.call(void 0, {
-      driver,
-      connectionOptions: { connection }
-    });
-    try {
-      await handle(events, {
-        ...context,
-        pongo
-      });
-    } finally {
-      await pongo.close();
-    }
-  },
-  truncate: truncate ? async (context) => {
-    const { connection } = context;
-    const driver = await pongoDriverRegistry.tryResolve(
-      context.driverType
-    );
-    const pongo = _pongo.pongoClient.call(void 0, {
-      driver,
-      connectionOptions: { connection }
-    });
-    try {
-      await truncate({
-        ...context,
-        pongo
-      });
-    } finally {
-      await pongo.close();
-    }
-  } : void 0
-});
-var pongoMultiStreamProjection = (options) => {
-  const { collectionName, getDocumentId, canHandle } = options;
-  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
-  return pongoProjection({
-    name: collectionNameWithVersion,
-    version: options.version,
-    kind: _nullishCoalesce(options.kind, () => ( "emt:projections:postgresql:pongo:multi_stream")),
-    eventsOptions: options.eventsOptions,
-    handle: async (events, { pongo }) => {
-      const collection = pongo.db().collection(
-        collectionNameWithVersion,
-        options.collectionOptions
-      );
-      for (const event of events) {
-        await collection.handle(getDocumentId(event), async (document) => {
-          return "initialState" in options ? await options.evolve(
-            _nullishCoalesce(document, () => ( options.initialState())),
-            event
-          ) : await options.evolve(
-            document,
-            event
-          );
-        });
-      }
-    },
-    canHandle,
-    truncate: async (context) => {
-      const { connection } = context;
-      const driver = await pongoDriverRegistry.tryResolve(
-        context.driverType
-      );
-      const pongo = _pongo.pongoClient.call(void 0, {
-        driver,
-        connectionOptions: { connection }
-      });
-      try {
-        await pongo.db().collection(
-          collectionNameWithVersion,
-          options.collectionOptions
-        ).deleteMany();
-      } finally {
-        await pongo.close();
-      }
-    },
-    init: async (context) => {
-      const { connection } = context;
-      const driver = await pongoDriverRegistry.tryResolve(
-        context.driverType
-      );
-      const pongo = _pongo.pongoClient.call(void 0, {
-        connectionOptions: { connection },
-        driver
-      });
-      try {
-        await pongo.db().collection(
-          collectionNameWithVersion,
-          options.collectionOptions
-        ).schema.migrate();
-      } finally {
-        await pongo.close();
-      }
-    }
-  });
-};
-var pongoSingleStreamProjection = (options) => {
-  return pongoMultiStreamProjection({
-    ...options,
-    kind: "emt:projections:postgresql:pongo:single_stream",
-    getDocumentId: _nullishCoalesce(options.getDocumentId, () => ( ((event) => event.metadata.streamName)))
-  });
-};
-
-// ../emmett/dist/chunk-AZDDB5SF.js
+"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 isString = (val) => typeof val === "string";
 var isErrorConstructor = (expect) => {
@@ -218,6 +91,13 @@ var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersion
   error,
   ExpectedVersionConflictError.Codes.ConcurrencyError
 );
+async function reduceAsync(items, fn, initial) {
+  let accumulator = initial;
+  for (let i = 0; i < items.length; i++) {
+    accumulator = await fn(accumulator, items[i], i);
+  }
+  return accumulator;
+}
 var isPrimitive = (value) => {
   const type = typeof value;
   return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
@@ -609,7 +489,40 @@ var reactor = (options) => {
     canHandle,
     stopAfter
   } = options;
-  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
+  const isCustomBatch = "eachBatch" in options && !!options.eachBatch;
+  const eachBatch = isCustomBatch ? options.eachBatch : async (messages, context) => {
+    let result = void 0;
+    for (let i = 0; i < messages.length; i++) {
+      const message2 = messages[i];
+      const messageProcessingResult = await options.eachMessage(
+        message2,
+        context
+      );
+      if (messageProcessingResult && messageProcessingResult.type === "STOP") {
+        result = {
+          ...messageProcessingResult,
+          lastSuccessfulMessage: messageProcessingResult.error ? messages[i - 1] : message2
+        };
+        break;
+      }
+      if (stopAfter && stopAfter(message2)) {
+        result = {
+          type: "STOP",
+          reason: "Stop condition reached",
+          lastSuccessfulMessage: message2
+        };
+        break;
+      }
+      if (messageProcessingResult && messageProcessingResult.type === "SKIP") {
+        result = {
+          ...messageProcessingResult,
+          lastSuccessfulMessage: message2
+        };
+        continue;
+      }
+    }
+    return result;
+  };
   let isInitiated = false;
   let isActive = false;
   let lastCheckpoint = null;
@@ -647,10 +560,11 @@ var reactor = (options) => {
       await init(startOptions);
       isActive = true;
       closeSignal = onShutdown(() => close(startOptions));
-      if (lastCheckpoint !== null)
+      if (lastCheckpoint !== null) {
         return {
           lastCheckpoint
         };
+      }
       return await processingScope(async (context) => {
         if (hooks.onStart) {
           await hooks.onStart(context);
@@ -679,46 +593,48 @@ var reactor = (options) => {
     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(
+        const messagesAboveCheckpoint = messages.filter(
+          (message2) => !wasMessageHandled(message2, lastCheckpoint)
+        );
+        const upcastedMessages = messagesAboveCheckpoint.map(
+          (message2) => upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
             _optionalChain([options, 'access', _24 => _24.messageOptions, 'optionalAccess', _25 => _25.schema, 'optionalAccess', _26 => _26.versioning])
+          )
+        ).filter(
+          (upcasted) => !canHandle || canHandle.includes(upcasted.type)
+        );
+        const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
+        const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
+        const batchResult = await eachBatch(unhandledMessages, context);
+        const messageProcessingResult = _optionalChain([batchResult, 'optionalAccess', _27 => _27.type]) === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
+          type: "STOP",
+          reason: "Stop condition reached",
+          lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
+        } : batchResult;
+        const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
+        const checkpointMessage = _optionalChain([messageProcessingResult, 'optionalAccess', _28 => _28.type]) === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
+        if (checkpointMessage && checkpoints) {
+          const storeCheckpointResult = await checkpoints.store(
+            {
+              processorId,
+              version,
+              message: checkpointMessage,
+              lastCheckpoint,
+              partition
+            },
+            context
           );
-          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 (storeCheckpointResult.success) {
+            lastCheckpoint = storeCheckpointResult.newCheckpoint;
           }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
         }
-        return result;
+        if (isStop) {
+          isActive = false;
+          return messageProcessingResult;
+        }
+        return void 0;
       }, partialContext);
     }
   };
@@ -738,15 +654,15 @@ var projector = (options) => {
     processorId,
     messageOptions: options.projection.eventsOptions,
     hooks: {
-      onInit: _optionalChain([options, 'access', _27 => _27.hooks, 'optionalAccess', _28 => _28.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _29 => _29.hooks, 'optionalAccess', _30 => _30.onStart]) ? async (context) => {
+      onInit: _optionalChain([options, 'access', _29 => _29.hooks, 'optionalAccess', _30 => _30.onInit]),
+      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart]) ? async (context) => {
         if (options.truncateOnStart && options.projection.truncate)
           await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _31 => _31.hooks, 'optionalAccess', _32 => _32.onStart])) await _optionalChain([options, 'access', _33 => _33.hooks, 'optionalAccess', _34 => _34.onStart, 'call', _35 => _35(context)]);
+        if (_optionalChain([options, 'access', _33 => _33.hooks, 'optionalAccess', _34 => _34.onStart])) await _optionalChain([options, 'access', _35 => _35.hooks, 'optionalAccess', _36 => _36.onStart, 'call', _37 => _37(context)]);
       } : void 0,
-      onClose: _optionalChain([options, 'access', _36 => _36.hooks, 'optionalAccess', _37 => _37.onClose])
+      onClose: _optionalChain([options, 'access', _38 => _38.hooks, 'optionalAccess', _39 => _39.onClose])
     },
-    eachMessage: async (event2, context) => projection2.handle([event2], context)
+    eachBatch: async (events, context) => projection2.handle(events, context)
   });
 };
 var AssertionError = class extends Error {
@@ -868,7 +784,7 @@ var assertThatArray = (array) => {
   };
 };
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _38 => _38.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _40 => _40.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -886,14 +802,14 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _39 => _39.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _41 => _41.downcast]))
     return recordedMessages;
   return recordedMessages.map(
     (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
   );
 };
 var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _40 => _40.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _42 => _42.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -961,11 +877,11 @@ var createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessin
   return (state, event2) => {
     const metadata = event2.metadata;
     let processedInputIds = state.processedInputIds;
-    if (_optionalChain([metadata, 'optionalAccess', _41 => _41.input]) === true && typeof _optionalChain([metadata, 'optionalAccess', _42 => _42.originalMessageId]) === "string") {
+    if (_optionalChain([metadata, 'optionalAccess', _43 => _43.input]) === true && typeof _optionalChain([metadata, 'optionalAccess', _44 => _44.originalMessageId]) === "string") {
       processedInputIds = new Set(state.processedInputIds);
       processedInputIds.add(metadata.originalMessageId);
     }
-    if (separateInputInboxFromProcessing && _optionalChain([metadata, 'optionalAccess', _43 => _43.input]) === true) {
+    if (separateInputInboxFromProcessing && _optionalChain([metadata, 'optionalAccess', _45 => _45.input]) === true) {
       return {
         userState: state.userState,
         processedInputIds
@@ -995,7 +911,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
       } = options;
       const inputMessageId = (
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        _nullishCoalesce(("metadata" in message2 && _optionalChain([message2, 'access', _44 => _44.metadata, 'optionalAccess', _45 => _45.messageId]) ? (
+        _nullishCoalesce(("metadata" in message2 && _optionalChain([message2, 'access', _46 => _46.metadata, 'optionalAccess', _47 => _47.messageId]) ? (
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
           message2.metadata.messageId
         ) : void 0), () => ( _uuid.v7.call(void 0, )))
@@ -1031,7 +947,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
           [inputToStore2],
           {
             ...handleOptions,
-            expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _46 => _46.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+            expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _48 => _48.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
           }
         );
         return {
@@ -1052,7 +968,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
           ...handleOptions,
           // expected stream version is passed to fail fast
           // if stream is in the wrong state
-          expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _47 => _47.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _49 => _49.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         }
       });
       const { currentStreamVersion } = aggregationResult;
@@ -1076,7 +992,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
         metadata: inputMetadata
       };
       const outputMessages = (Array.isArray(result2) ? result2 : [result2]).filter((msg) => msg !== void 0 && msg !== null);
-      const outputCommandTypes = _nullishCoalesce(_optionalChain([options, 'access', _48 => _48.outputs, 'optionalAccess', _49 => _49.commands]), () => ( []));
+      const outputCommandTypes = _nullishCoalesce(_optionalChain([options, 'access', _50 => _50.outputs, 'optionalAccess', _51 => _51.commands]), () => ( []));
       const taggedOutputMessages = outputMessages.map((msg) => {
         const action = outputCommandTypes.includes(
           msg.type
@@ -1087,7 +1003,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
       if (messagesToAppend.length === 0) {
         return emptyHandlerResult(currentStreamVersion);
       }
-      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _50 => _50.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
+      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _52 => _52.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
       const appendResult = await eventStore.appendToStream(
         streamName,
         // TODO: Fix this cast
@@ -1134,7 +1050,7 @@ var workflowProcessor = (options) => {
     eachMessage: async (message2, context) => {
       const messageType = message2.type;
       const metadata = message2.metadata;
-      const isInput = _optionalChain([metadata, 'optionalAccess', _51 => _51.input]) === true;
+      const isInput = _optionalChain([metadata, 'optionalAccess', _53 => _53.input]) === true;
       if (isInput || inputs.includes(messageType)) {
         const result = await handle(
           context.connection.messageStore,
@@ -1152,11 +1068,9 @@ var workflowProcessor = (options) => {
         }
         return;
       }
-      if (_optionalChain([options, 'access', _52 => _52.outputHandler, 'optionalAccess', _53 => _53.canHandle, 'access', _54 => _54.includes, 'call', _55 => _55(messageType)]) === true) {
-        const handledOutputMessages = await options.outputHandler.handle(
-          message2,
-          context
-        );
+      if (_optionalChain([options, 'access', _54 => _54.outputHandler, 'optionalAccess', _55 => _55.canHandle, 'access', _56 => _56.includes, 'call', _57 => _57(messageType)]) === true) {
+        const recordedMessage = message2;
+        const handledOutputMessages = options.outputHandler.eachBatch ? await options.outputHandler.eachBatch([recordedMessage], context) : await options.outputHandler.eachMessage(recordedMessage, context);
         if (handledOutputMessages instanceof EmmettError) {
           return {
             type: "STOP",
@@ -1187,6 +1101,146 @@ var workflowProcessor = (options) => {
   });
 };
 
+// src/eventStore/projections/pongo/pongoProjections.ts
+
+
+var _pongo = require('@event-driven-io/pongo');
+var pongoProjection = ({
+  name,
+  kind,
+  version,
+  truncate,
+  handle,
+  canHandle,
+  eventsOptions
+}) => sqliteProjection({
+  name,
+  version,
+  kind: _nullishCoalesce(kind, () => ( "emt:projections:postgresql:pongo:generic")),
+  canHandle,
+  eventsOptions,
+  handle: async (events, context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = _pongo.pongoClient.call(void 0, {
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await handle(events, {
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  },
+  truncate: truncate ? async (context) => {
+    const { connection } = context;
+    const driver = await pongoDriverRegistry.tryResolve(
+      context.driverType
+    );
+    const pongo = _pongo.pongoClient.call(void 0, {
+      driver,
+      connectionOptions: { connection }
+    });
+    try {
+      await truncate({
+        ...context,
+        pongo
+      });
+    } finally {
+      await pongo.close();
+    }
+  } : void 0
+});
+var pongoMultiStreamProjection = (options) => {
+  const { collectionName, getDocumentId, canHandle } = options;
+  const collectionNameWithVersion = options.version && options.version > 0 ? `${collectionName}_v${options.version}` : collectionName;
+  return pongoProjection({
+    name: collectionNameWithVersion,
+    version: options.version,
+    kind: _nullishCoalesce(options.kind, () => ( "emt:projections:postgresql:pongo:multi_stream")),
+    eventsOptions: options.eventsOptions,
+    handle: async (events, { pongo }) => {
+      const collection = pongo.db().collection(
+        collectionNameWithVersion,
+        options.collectionOptions
+      );
+      const eventsByDocumentId = events.map((event) => {
+        const documentId = getDocumentId(event);
+        return {
+          documentId,
+          event
+        };
+      }).reduce((acc, { documentId, event }) => {
+        if (!acc.has(documentId)) {
+          acc.set(documentId, []);
+        }
+        acc.get(documentId).push(event);
+        return acc;
+      }, /* @__PURE__ */ new Map());
+      await collection.handle(
+        [...eventsByDocumentId.keys()],
+        (document, id) => {
+          const events2 = eventsByDocumentId.get(id);
+          return reduceAsync(
+            events2,
+            async (acc, event) => await options.evolve(acc, event),
+            _nullishCoalesce(document, () => ( ("initialState" in options ? options.initialState() : null)))
+          );
+        }
+      );
+    },
+    canHandle,
+    truncate: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = _pongo.pongoClient.call(void 0, {
+        driver,
+        connectionOptions: { connection }
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).deleteMany();
+      } finally {
+        await pongo.close();
+      }
+    },
+    init: async (context) => {
+      const { connection } = context;
+      const driver = await pongoDriverRegistry.tryResolve(
+        context.driverType
+      );
+      const pongo = _pongo.pongoClient.call(void 0, {
+        connectionOptions: { connection },
+        driver
+      });
+      try {
+        await pongo.db().collection(
+          collectionNameWithVersion,
+          options.collectionOptions
+        ).schema.migrate();
+      } finally {
+        await pongo.close();
+      }
+    }
+  });
+};
+var pongoSingleStreamProjection = (options) => {
+  return pongoMultiStreamProjection({
+    ...options,
+    kind: "emt:projections:postgresql:pongo:single_stream",
+    getDocumentId: _nullishCoalesce(options.getDocumentId, () => ( ((event) => event.metadata.streamName)))
+  });
+};
+
 // src/eventStore/projections/pongo/pongoProjectionSpec.ts
 
 
@@ -1410,7 +1464,7 @@ var SQLiteProjectionSpec = {
             const allEvents = [];
             const run = async (connection) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _56 => _56.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _58 => _58.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -1477,18 +1531,18 @@ var SQLiteProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _57 => _57.toString, 'call', _58 => _58()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _63 => _63.toString, 'call', _64 => _64()])}`
                     );
                   }
                 }
@@ -1505,7 +1559,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _63 => _63.metadata, 'optionalAccess', _64 => _64.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _65 => _65.metadata, 'optionalAccess', _66 => _66.streamName]), () => ( streamName))
     }
   };
 };
@@ -1577,7 +1631,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', _65 => _65.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _67 => _67.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -1600,13 +1654,13 @@ var appendToStream = async (connection, streamName, streamType, messages, option
           streamType,
           downcastRecordedMessages(
             messagesToAppend,
-            _optionalChain([options, 'optionalAccess', _66 => _66.schema, 'optionalAccess', _67 => _67.versioning])
+            _optionalChain([options, 'optionalAccess', _68 => _68.schema, 'optionalAccess', _69 => _69.versioning])
           ),
           {
             expectedStreamVersion
           }
         );
-        if (_optionalChain([options, 'optionalAccess', _68 => _68.onBeforeCommit]))
+        if (_optionalChain([options, 'optionalAccess', _70 => _70.onBeforeCommit]))
           await options.onBeforeCommit(messagesToAppend, { connection });
         return { success: true, result };
       }
@@ -1630,7 +1684,7 @@ var toExpectedVersion = (expected) => {
   return expected;
 };
 var appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
-  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _69 => _69.expectedStreamVersion]), () => ( null));
+  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _71 => _71.expectedStreamVersion]), () => ( null));
   const currentStreamVersion = await getLastStreamPosition(
     execute,
     streamId,
@@ -1648,7 +1702,7 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
             VALUES  (
                 ${streamId},
                 ${messages.length},
-                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.partition]), () => ( streamsTable.columns.partition))},
+                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _72 => _72.partition]), () => ( streamsTable.columns.partition))},
                 ${streamType},
                 '[]',
                 false
@@ -1658,7 +1712,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', _71 => _71.partition]), () => ( streamsTable.columns.partition))}
+            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _73 => _73.partition]), () => ( streamsTable.columns.partition))}
             AND is_archived = false
             RETURNING stream_position;
           `;
@@ -1666,12 +1720,12 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
     messages,
     expectedStreamVersion,
     streamId,
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _72 => _72.partition, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()]), () => ( defaultTag2))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _74 => _74.partition, 'optionalAccess', _75 => _75.toString, 'call', _76 => _76()]), () => ( defaultTag2))
   );
   const results = await execute.batchCommand([streamSQL, insertSQL], { assertChanges: true });
   const [streamResult, messagesResult] = results;
-  const streamPosition = _optionalChain([streamResult, 'optionalAccess', _75 => _75.rows, 'access', _76 => _76[0], 'optionalAccess', _77 => _77.stream_position]);
-  const globalPosition = _optionalChain([messagesResult, 'optionalAccess', _78 => _78.rows, 'access', _79 => _79.at, 'call', _80 => _80(-1), 'optionalAccess', _81 => _81.global_position]);
+  const streamPosition = _optionalChain([streamResult, 'optionalAccess', _77 => _77.rows, 'access', _78 => _78[0], 'optionalAccess', _79 => _79.stream_position]);
+  const globalPosition = _optionalChain([messagesResult, 'optionalAccess', _80 => _80.rows, 'access', _81 => _81.at, 'call', _82 => _82(-1), 'optionalAccess', _83 => _83.global_position]);
   if (!streamPosition)
     throw new ExpectedVersionConflictError(0n, _nullishCoalesce(expectedStreamVersion, () => ( 0n)));
   if (!globalPosition) throw new Error("Could not find global position");
@@ -1687,7 +1741,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', _82 => _82.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _84 => _84.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -1696,7 +1750,7 @@ async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
 }
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const values = messages.map((message) => {
-    if (_optionalChain([message, 'access', _83 => _83.metadata, 'optionalAccess', _84 => _84.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+    if (_optionalChain([message, 'access', _85 => _85.metadata, 'optionalAccess', _86 => _86.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
       throw new Error("Stream position is required");
     }
     const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -1863,7 +1917,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
       _dumbo.SQL`
          SELECT global_position
          FROM ${identifier3(messagesTable.name)}
-         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _85 => _85.partition]), () => ( defaultTag2))} AND is_archived = FALSE
+         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.partition]), () => ( defaultTag2))} AND is_archived = FALSE
          ORDER BY global_position
          LIMIT 1`
     )
@@ -1888,7 +1942,7 @@ var readMessagesBatch = async (execute, options) => {
     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', _86 => _86.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _88 => _88.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
            ORDER BY global_position
            ${limitCondition}`
     ),
@@ -1932,7 +1986,7 @@ var readProcessorCheckpoint = async (execute, options) => {
     execute.query(
       _dumbo.SQL`SELECT last_processed_checkpoint
            FROM ${identifier5(processorsTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
            LIMIT 1`
     )
   );
@@ -1970,7 +2024,7 @@ var sqliteEventStoreMessageBatchPuller = ({
       serializer
     };
     let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _88 => _88.aborted])) {
+    while (isRunning && !_optionalChain([signal, 'optionalAccess', _90 => _90.aborted])) {
       const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
       if (messages.length > 0) {
         const result = await eachBatch(messages);
@@ -1981,7 +2035,7 @@ var sqliteEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _89 => _89.noMessagesLeft]) === true && !areMessagesLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _91 => _91.noMessagesLeft]) === true && !areMessagesLeft) {
         isRunning = false;
         break;
       }
@@ -2026,7 +2080,7 @@ var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
 var sqliteCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _90 => _90.lastProcessedCheckpoint]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _92 => _92.lastProcessedCheckpoint]) };
   },
   store: async (options, context) => {
     const newCheckpoint = getCheckpoint(options.message);
@@ -2044,7 +2098,7 @@ var sqliteCheckpointer = () => ({
 // src/eventStore/consumers/sqliteProcessor.ts
 var sqliteProcessingScope = () => {
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _91 => _91.connection]);
+    const connection = _optionalChain([partialContext, 'optionalAccess', _93 => _93.connection]);
     if (!connection)
       throw new EmmettError("Connection is required in context or options");
     return connection.withTransaction(
@@ -2061,7 +2115,7 @@ var sqliteProcessingScope = () => {
 };
 var sqliteWorkflowProcessingScope = (messageStore) => {
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _92 => _92.connection]);
+    const connection = _optionalChain([partialContext, 'optionalAccess', _94 => _94.connection]);
     if (!connection)
       throw new EmmettError("Connection is required in context or options");
     return connection.withTransaction(
@@ -2087,7 +2141,7 @@ var sqliteWorkflowProcessor = (options) => {
   } = options;
   const hooks = {
     ..._nullishCoalesce(options.hooks, () => ( {})),
-    onClose: _optionalChain([options, 'access', _93 => _93.hooks, 'optionalAccess', _94 => _94.onClose])
+    onClose: _optionalChain([options, 'access', _95 => _95.hooks, 'optionalAccess', _96 => _96.onClose])
   };
   return workflowProcessor({
     ...options,
@@ -2132,7 +2186,7 @@ var sqliteProjector = (options) => {
   } = options;
   const hooks = {
     ..._nullishCoalesce(options.hooks, () => ( {})),
-    onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _95 => _95.hooks, 'optionalAccess', _96 => _96.onInit]) ? async (context) => {
+    onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _97 => _97.hooks, 'optionalAccess', _98 => _98.onInit]) ? async (context) => {
       if (options.projection.init)
         await options.projection.init({
           version: _nullishCoalesce(options.projection.version, () => ( version)),
@@ -2143,13 +2197,13 @@ var sqliteProjector = (options) => {
             migrationOptions: options.migrationOptions
           }
         });
-      if (_optionalChain([options, 'access', _97 => _97.hooks, 'optionalAccess', _98 => _98.onInit]))
+      if (_optionalChain([options, 'access', _99 => _99.hooks, 'optionalAccess', _100 => _100.onInit]))
         await options.hooks.onInit({
           ...context,
           migrationOptions: options.migrationOptions
         });
-    } : _optionalChain([options, 'access', _99 => _99.hooks, 'optionalAccess', _100 => _100.onInit]),
-    onClose: _optionalChain([options, 'access', _101 => _101.hooks, 'optionalAccess', _102 => _102.onClose])
+    } : _optionalChain([options, 'access', _101 => _101.hooks, 'optionalAccess', _102 => _102.onInit]),
+    onClose: _optionalChain([options, 'access', _103 => _103.hooks, 'optionalAccess', _104 => _104.onClose])
   };
   const processor = projector({
     ...options,
@@ -2197,7 +2251,7 @@ var sqliteEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _103 => _103.value, 'optionalAccess', _104 => _104.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _105 => _105.value, 'optionalAccess', _106 => _106.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -2211,7 +2265,7 @@ var sqliteEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _105 => _105.abort, 'call', _106 => _106()]);
+      _optionalChain([abortController, 'optionalAccess', _107 => _107.abort, 'call', _108 => _108()]);
       await messagePuller.stop();
     }
     await start;
@@ -2286,8 +2340,8 @@ var sqliteEventStoreConsumer = (options) => {
         stopWhen: options.stopWhen,
         executor: pool.execute,
         eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _107 => _107.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _108 => _108.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _109 => _109.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _110 => _110.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       start = (async () => {
@@ -2337,9 +2391,9 @@ 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', _109 => _109.hooks, 'optionalAccess', _110 => _110.onBeforeCommit]);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _111 => _111.hooks, 'optionalAccess', _112 => _112.onBeforeCommit]);
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _111 => _111.schema, 'optionalAccess', _112 => _112.autoMigration]) === void 0 || _optionalChain([options, 'access', _113 => _113.schema, 'optionalAccess', _114 => _114.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _113 => _113.schema, 'optionalAccess', _114 => _114.autoMigration]) === void 0 || _optionalChain([options, 'access', _115 => _115.schema, 'optionalAccess', _116 => _116.autoMigration]) !== "None";
   }
   const migrate = (connection) => {
     if (!migrateSchema) {
@@ -2359,11 +2413,11 @@ var getSQLiteEventStore = (options) => {
               });
             }
           }
-          if (_optionalChain([options, 'access', _115 => _115.hooks, 'optionalAccess', _116 => _116.onBeforeSchemaCreated])) {
+          if (_optionalChain([options, 'access', _117 => _117.hooks, 'optionalAccess', _118 => _118.onBeforeSchemaCreated])) {
             await options.hooks.onBeforeSchemaCreated(context);
           }
         },
-        onAfterSchemaCreated: _optionalChain([options, 'access', _117 => _117.hooks, 'optionalAccess', _118 => _118.onAfterSchemaCreated])
+        onAfterSchemaCreated: _optionalChain([options, 'access', _119 => _119.hooks, 'optionalAccess', _120 => _120.onAfterSchemaCreated])
       });
     }
     return migrateSchema;
@@ -2376,7 +2430,7 @@ var getSQLiteEventStore = (options) => {
     async aggregateStream(streamName, options2) {
       await ensureSchemaExists();
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _119 => _119.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _121 => _121.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
@@ -2384,7 +2438,7 @@ var getSQLiteEventStore = (options) => {
       const result = await readStream(
         pool.execute,
         streamName,
-        { ...read, serializer: _nullishCoalesce(_optionalChain([read, 'optionalAccess', _120 => _120.serialization, 'optionalAccess', _121 => _121.serializer]), () => ( serializer)) }
+        { ...read, serializer: _nullishCoalesce(_optionalChain([read, 'optionalAccess', _122 => _122.serialization, 'optionalAccess', _123 => _123.serializer]), () => ( serializer)) }
       );
       const currentStreamVersion = result.currentStreamVersion;
       assertExpectedVersionMatchesCurrent(
@@ -2406,7 +2460,7 @@ var getSQLiteEventStore = (options) => {
       await ensureSchemaExists();
       return readStream(pool.execute, streamName, {
         ...readOptions,
-        serializer: _nullishCoalesce(_optionalChain([options, 'access', _122 => _122.serialization, 'optionalAccess', _123 => _123.serializer]), () => ( serializer))
+        serializer: _nullishCoalesce(_optionalChain([options, 'access', _124 => _124.serialization, 'optionalAccess', _125 => _125.serializer]), () => ( serializer))
       });
     },
     appendToStream: async (streamName, events, appendOptions) => {
@@ -2435,7 +2489,7 @@ var getSQLiteEventStore = (options) => {
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _124 => _124.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _126 => _126.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -2493,13 +2547,13 @@ var readStream = async (execute, streamId, options) => {
   const { serializer } = options;
   const fromCondition = options.from ? _dumbo.SQL`AND stream_position >= ${options.from}` : _dumbo.SQL.EMPTY;
   const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _125 => _125.to]), () => ( (_optionalChain([options, 'optionalAccess', _126 => _126.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _127 => _127.to]), () => ( (_optionalChain([options, 'optionalAccess', _128 => _128.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', _127 => _127.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _129 => _129.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
         ORDER BY stream_position ASC`
   );
   const messages = results.map((row) => {
@@ -2521,7 +2575,7 @@ var readStream = async (execute, streamId, options) => {
       kind: "Event",
       metadata
     };
-    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _128 => _128.schema, 'optionalAccess', _129 => _129.versioning]));
+    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _130 => _130.schema, 'optionalAccess', _131 => _131.versioning]));
   });
   return messages.length > 0 ? {
     currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
@@ -2566,7 +2620,7 @@ async function storeSubscriptionCheckpointSQLite(execute, processorId, version,
                WHERE processor_id = ${processorId} AND partition = ${partition}`
       )
     );
-    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _130 => _130.last_processed_checkpoint]) !== null ? current_position.last_processed_checkpoint : null;
+    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _132 => _132.last_processed_checkpoint]) !== null ? current_position.last_processed_checkpoint : null;
     if (currentPosition === position) {
       return 0;
     } else if (position !== null && currentPosition !== null && currentPosition > position) {
@@ -2594,7 +2648,7 @@ async function storeSubscriptionCheckpointSQLite(execute, processorId, version,
             WHERE processor_id = ${processorId} AND partition = ${partition}`
         )
       );
-      const currentPosition = current && _optionalChain([current, 'optionalAccess', _131 => _131.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
+      const currentPosition = current && _optionalChain([current, 'optionalAccess', _133 => _133.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
       if (currentPosition === position) {
         return 0;
       } else {
@@ -2627,7 +2681,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', _132 => _132.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _134 => _134.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
       `
   )
 );
@@ -2693,13 +2747,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', _133 => _133.onBeforeSchemaCreated])) {
+    if (_optionalChain([hooks, 'optionalAccess', _135 => _135.onBeforeSchemaCreated])) {
       await hooks.onBeforeSchemaCreated({
         connection: tx.connection
       });
     }
     await tx.execute.batchCommand(schemaSQL);
-    if (_optionalChain([hooks, 'optionalAccess', _134 => _134.onAfterSchemaCreated])) {
+    if (_optionalChain([hooks, 'optionalAccess', _136 => _136.onAfterSchemaCreated])) {
       await hooks.onAfterSchemaCreated();
     }
   });