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

package/dist/index.cjs

@@ -1,4 +1,131 @@
-"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
+"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
 var isNumber = (val) => typeof val === "number" && val === val;
 var isString = (val) => typeof val === "string";
 var isErrorConstructor = (expect) => {
@@ -38,7 +165,7 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
   constructor(current, expected, message) {
     super({
       errorCode: EmmettError.Codes.ConcurrencyError,
-      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
     });
     this.current = current;
     this.expected = expected;
@@ -49,12 +176,24 @@ var ConcurrencyError = class _ConcurrencyError extends EmmettError {
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
+
 var emmettPrefix = "emt";
 var defaultTag = `${emmettPrefix}:default`;
 var unknownTag = `${emmettPrefix}:unknown`;
+var canCreateEventStoreSession = (eventStore) => "withSession" in eventStore;
+var nulloSessionFactory = (eventStore) => ({
+  withSession: (callback) => {
+    const nulloSession = {
+      eventStore,
+      close: () => Promise.resolve()
+    };
+    return callback(nulloSession);
+  }
+});
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -71,12 +210,12 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
+    super(_optionalChain([current, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([expected, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var isExpectedVersionConflictError = (error2) => error2 instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
-  error2,
+var isExpectedVersionConflictError = (error) => error instanceof ExpectedVersionConflictError || EmmettError.isInstanceOf(
+  error,
   ExpectedVersionConflictError.Codes.ConcurrencyError
 );
 var isPrimitive = (value) => {
@@ -284,26 +423,132 @@ var toNormalizedString = (value) => value.toString().padStart(19, "0");
 var bigInt = {
   toNormalizedString
 };
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+var bigIntReplacer = (_key, value) => {
+  return typeof value === "bigint" ? value.toString() : value;
+};
+var dateReplacer = (_key, value) => {
+  return value instanceof Date ? value.toISOString() : value;
+};
+var isFirstLetterNumeric = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57;
+};
+var isFirstLetterNumericOrMinus = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57 || c === 45;
+};
+var bigIntReviver = (_key, value, context) => {
+  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    try {
+      return BigInt(_nullishCoalesce(_optionalChain([context, 'optionalAccess', _7 => _7.source]), () => ( value.toString())));
+    } catch (e2) {
+      return value;
+    }
+  }
+  if (typeof value === "string" && value.length > 15) {
+    if (isFirstLetterNumericOrMinus(value)) {
+      const num = Number(value);
+      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
+        try {
+          return BigInt(value);
+        } catch (e3) {
+        }
+      }
+    }
+  }
+  return value;
+};
+var dateReviver = (_key, value) => {
+  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
   }
+  return value;
+};
+var composeJSONReplacers = (...replacers) => {
+  const filteredReplacers = replacers.filter((r) => r !== void 0);
+  if (filteredReplacers.length === 0) return void 0;
+  return (key, value) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredReplacers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, replacer) => replacer(key, accValue),
+      value
+    )
+  );
 };
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _8 => _8.map]) ? options.map(value) : value,
-      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+var composeJSONRevivers = (...revivers) => {
+  const filteredRevivers = revivers.filter((r) => r !== void 0);
+  if (filteredRevivers.length === 0) return void 0;
+  return (key, value, context) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredRevivers.reduce(
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (_, v) => typeof v === "bigint" ? v.toString() : v
-    );
-  },
-  parse: (text, options) => {
-    const parsed = JSON.parse(text, _optionalChain([options, 'optionalAccess', _9 => _9.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _10 => _10.typeCheck]) && !_optionalChain([options, 'optionalAccess', _11 => _11.typeCheck, 'call', _12 => _12(parsed)]))
-      throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
-  }
+      (accValue, reviver) => reviver(key, accValue, context),
+      value
+    )
+  );
+};
+var JSONReplacer = (opts) => composeJSONReplacers(
+  _optionalChain([opts, 'optionalAccess', _8 => _8.replacer]),
+  _optionalChain([opts, 'optionalAccess', _9 => _9.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _10 => _10.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  _optionalChain([opts, 'optionalAccess', _11 => _11.reviver]),
+  _optionalChain([opts, 'optionalAccess', _12 => _12.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _13 => _13.parseDates]) === true ? JSONRevivers.date : void 0
+);
+var JSONReplacers = {
+  bigInt: bigIntReplacer,
+  date: dateReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, serializerOptions) => JSON.stringify(
+      object,
+      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
+    ),
+    deserialize: (payload, deserializerOptions) => JSON.parse(
+      payload,
+      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
+    )
+  };
+};
+var JSONSerializer = Object.assign(jsonSerializer(), {
+  from: (options) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.serialization, 'optionalAccess', _15 => _15.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _16 => _16.serialization, 'optionalAccess', _17 => _17.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _18 => _18.serialization, 'optionalAccess', _19 => _19.options])) : JSONSerializer)))
+});
+var NoRetries = { retries: 0 };
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return _asyncretry2.default.call(void 0, 
+    async (bail) => {
+      try {
+        const result = await fn();
+        if (_optionalChain([opts, 'optionalAccess', _20 => _20.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+          throw new EmmettError(
+            `Retrying because of result: ${JSONSerializer.serialize(result)}`
+          );
+        }
+        return result;
+      } catch (error) {
+        if (_optionalChain([opts, 'optionalAccess', _21 => _21.shouldRetryError]) && !opts.shouldRetryError(error)) {
+          bail(error);
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
 };
 var onShutdown = (handler) => {
   const signals = ["SIGTERM", "SIGINT"];
@@ -395,12 +640,13 @@ var reactor = (options) => {
     id: processorId,
     instanceId,
     type,
+    canHandle,
     init,
     start: async (startOptions) => {
       if (isActive) return;
       await init(startOptions);
       isActive = true;
-      closeSignal = onShutdown(() => close({}));
+      closeSignal = onShutdown(() => close(startOptions));
       if (lastCheckpoint !== null)
         return {
           lastCheckpoint
@@ -411,7 +657,7 @@ var reactor = (options) => {
         }
         if (startFrom && startFrom !== "CURRENT") return startFrom;
         if (checkpoints) {
-          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _14 => _14.read, 'call', _15 => _15(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _22 => _22.read, 'call', _23 => _23(
             {
               processorId,
               partition
@@ -439,7 +685,7 @@ var reactor = (options) => {
           const upcasted = upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
-            _optionalChain([options, 'access', _16 => _16.messageOptions, 'optionalAccess', _17 => _17.schema, 'optionalAccess', _18 => _18.versioning])
+            _optionalChain([options, 'access', _24 => _24.messageOptions, 'optionalAccess', _25 => _25.schema, 'optionalAccess', _26 => _26.versioning])
           );
           if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
             continue;
@@ -492,13 +738,13 @@ var projector = (options) => {
     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) => {
+      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) => {
         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)]);
+        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)]);
       } : void 0,
-      onClose: _optionalChain([options, 'access', _28 => _28.hooks, 'optionalAccess', _29 => _29.onClose])
+      onClose: _optionalChain([options, 'access', _36 => _36.hooks, 'optionalAccess', _37 => _37.onClose])
     },
     eachMessage: async (event2, context) => projection2.handle([event2], context)
   });
@@ -523,6 +769,15 @@ var isSubset = (superObj, subObj) => {
 var assertFails = (message2) => {
   throw new AssertionError(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
 };
+var assertDeepEqual = (actual, expected, message2) => {
+  if (!deepEquals(actual, expected))
+    throw new AssertionError(
+      _nullishCoalesce(message2, () => ( `subObj:
+${JSONSerializer.serialize(expected)}
+is not equal to
+${JSONSerializer.serialize(actual)}`))
+    );
+};
 function assertTrue(condition, message2) {
   if (condition !== true)
     throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is false`)));
@@ -534,22 +789,29 @@ function assertEqual(expected, actual, message2) {
   if (expected !== actual)
     throw new AssertionError(
       `${_nullishCoalesce(message2, () => ( "Objects are not equal"))}:
-Expected: ${JSONParser.stringify(expected)}
-Actual: ${JSONParser.stringify(actual)}`
+Expected: ${JSONSerializer.serialize(expected)}
+Actual: ${JSONSerializer.serialize(actual)}`
     );
 }
 function assertNotEqual(obj, other, message2) {
   if (obj === other)
     throw new AssertionError(
-      _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
+      _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONSerializer.serialize(obj)}`))
     );
 }
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+function assertIsNull(result) {
+  assertEqual(result, null);
+}
 var assertThatArray = (array) => {
   return {
     isEmpty: () => assertEqual(
       array.length,
       0,
-      `Array is not empty ${JSONParser.stringify(array)}`
+      `Array is not empty ${JSONSerializer.serialize(array)}`
     ),
     isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
     hasSize: (length) => assertEqual(array.length, length),
@@ -606,7 +868,7 @@ var assertThatArray = (array) => {
   };
 };
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _30 => _30.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _38 => _38.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -624,14 +886,14 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _31 => _31.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _39 => _39.downcast]))
     return recordedMessages;
   return recordedMessages.map(
     (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
   );
 };
 var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _32 => _32.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _40 => _40.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -649,6 +911,418 @@ var upcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var projection = (definition) => definition;
+var WorkflowHandlerStreamVersionConflictRetryOptions = {
+  retries: 3,
+  minTimeout: 100,
+  factor: 1.5,
+  shouldRetryError: isExpectedVersionConflictError
+};
+var fromWorkflowHandlerRetryOptions = (retryOptions) => {
+  if (retryOptions === void 0) return NoRetries;
+  if ("onVersionConflict" in retryOptions) {
+    if (typeof retryOptions.onVersionConflict === "boolean")
+      return WorkflowHandlerStreamVersionConflictRetryOptions;
+    else if (typeof retryOptions.onVersionConflict === "number")
+      return {
+        ...WorkflowHandlerStreamVersionConflictRetryOptions,
+        retries: retryOptions.onVersionConflict
+      };
+    else return retryOptions.onVersionConflict;
+  }
+  return retryOptions;
+};
+var emptyHandlerResult = (nextExpectedStreamVersion = 0n) => ({
+  newMessages: [],
+  createdNewStream: false,
+  nextExpectedStreamVersion
+});
+var createInputMetadata = (originalMessageId, action) => ({
+  originalMessageId,
+  input: true,
+  action
+});
+var tagOutputMessage = (msg, action) => {
+  const existingMetadata = "metadata" in msg && msg.metadata ? msg.metadata : {};
+  return {
+    ...msg,
+    metadata: {
+      ...existingMetadata,
+      action
+    }
+  };
+};
+var createWrappedInitialState = (initialState) => {
+  return () => ({
+    userState: initialState(),
+    processedInputIds: /* @__PURE__ */ new Set()
+  });
+};
+var createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessing) => {
+  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") {
+      processedInputIds = new Set(state.processedInputIds);
+      processedInputIds.add(metadata.originalMessageId);
+    }
+    if (separateInputInboxFromProcessing && _optionalChain([metadata, 'optionalAccess', _43 => _43.input]) === true) {
+      return {
+        userState: state.userState,
+        processedInputIds
+      };
+    }
+    const eventType = event2.type;
+    const eventForEvolve = eventType.startsWith(`${workflowName}:`) ? {
+      ...event2,
+      type: eventType.replace(`${workflowName}:`, "")
+    } : event2;
+    return {
+      userState: evolve(state.userState, eventForEvolve),
+      processedInputIds
+    };
+  };
+};
+var workflowStreamName = ({
+  workflowName,
+  workflowId
+}) => `emt:workflow:${workflowName}:${workflowId}`;
+var WorkflowHandler = (options) => async (store, message2, handleOptions) => asyncRetry(
+  async () => {
+    const result = await withSession2(store, async ({ eventStore }) => {
+      const {
+        workflow: { evolve, initialState, decide, name: workflowName },
+        getWorkflowId: getWorkflowId2
+      } = 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]) ? (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          message2.metadata.messageId
+        ) : void 0), () => ( _uuid.v7.call(void 0, )))
+      );
+      const messageWithMetadata = {
+        ...message2,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        metadata: {
+          messageId: inputMessageId,
+          ...message2.metadata
+        }
+      };
+      const workflowId = getWorkflowId2(messageWithMetadata);
+      if (!workflowId) {
+        return emptyHandlerResult();
+      }
+      const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({ workflowName, workflowId });
+      const messageType = messageWithMetadata.type;
+      const hasWorkflowPrefix = messageType.startsWith(`${workflowName}:`);
+      if (options.separateInputInboxFromProcessing && !hasWorkflowPrefix) {
+        const inputMetadata2 = createInputMetadata(
+          inputMessageId,
+          "InitiatedBy"
+        );
+        const inputToStore2 = {
+          type: `${workflowName}:${messageWithMetadata.type}`,
+          data: messageWithMetadata.data,
+          kind: messageWithMetadata.kind,
+          metadata: inputMetadata2
+        };
+        const appendResult2 = await eventStore.appendToStream(
+          streamName,
+          [inputToStore2],
+          {
+            ...handleOptions,
+            expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _46 => _46.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          }
+        );
+        return {
+          ...appendResult2,
+          newMessages: []
+        };
+      }
+      const wrappedInitialState = createWrappedInitialState(initialState);
+      const wrappedEvolve = createWrappedEvolve(
+        evolve,
+        workflowName,
+        _nullishCoalesce(options.separateInputInboxFromProcessing, () => ( false))
+      );
+      const aggregationResult = await eventStore.aggregateStream(streamName, {
+        evolve: wrappedEvolve,
+        initialState: wrappedInitialState,
+        read: {
+          ...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))
+        }
+      });
+      const { currentStreamVersion } = aggregationResult;
+      const { userState: state, processedInputIds } = aggregationResult.state;
+      if (processedInputIds.has(inputMessageId)) {
+        return emptyHandlerResult(currentStreamVersion);
+      }
+      const messageForDecide = hasWorkflowPrefix ? {
+        ...messageWithMetadata,
+        type: messageType.replace(`${workflowName}:`, "")
+      } : messageWithMetadata;
+      const result2 = decide(messageForDecide, state);
+      const inputMetadata = createInputMetadata(
+        inputMessageId,
+        aggregationResult.streamExists ? "Received" : "InitiatedBy"
+      );
+      const inputToStore = {
+        type: `${workflowName}:${messageWithMetadata.type}`,
+        data: messageWithMetadata.data,
+        kind: messageWithMetadata.kind,
+        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 taggedOutputMessages = outputMessages.map((msg) => {
+        const action = outputCommandTypes.includes(
+          msg.type
+        ) ? "Sent" : "Published";
+        return tagOutputMessage(msg, action);
+      });
+      const messagesToAppend = options.separateInputInboxFromProcessing && hasWorkflowPrefix ? [...taggedOutputMessages] : [inputToStore, ...taggedOutputMessages];
+      if (messagesToAppend.length === 0) {
+        return emptyHandlerResult(currentStreamVersion);
+      }
+      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _50 => _50.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
+      const appendResult = await eventStore.appendToStream(
+        streamName,
+        // TODO: Fix this cast
+        messagesToAppend,
+        {
+          ...handleOptions,
+          expectedStreamVersion
+        }
+      );
+      return {
+        ...appendResult,
+        newMessages: outputMessages
+      };
+    });
+    return result;
+  },
+  fromWorkflowHandlerRetryOptions(
+    handleOptions && "retry" in handleOptions ? handleOptions.retry : options.retry
+  )
+);
+var withSession2 = (eventStore, callback) => {
+  const sessionFactory = canCreateEventStoreSession(eventStore) ? eventStore : nulloSessionFactory(eventStore);
+  return sessionFactory.withSession(callback);
+};
+var getWorkflowId = (options) => `emt:processor:workflow:${options.workflowName}`;
+var workflowProcessor = (options) => {
+  const { workflow, ...rest } = options;
+  const inputs = [...options.inputs.commands, ...options.inputs.events];
+  let canHandle = inputs;
+  if (options.separateInputInboxFromProcessing)
+    canHandle = [
+      ...canHandle,
+      ...options.inputs.commands.map((t) => `${workflow.name}:${t}`),
+      ...options.inputs.events.map((t) => `${workflow.name}:${t}`)
+    ];
+  if (options.outputHandler)
+    canHandle = [...canHandle, ...options.outputHandler.canHandle];
+  const handle = WorkflowHandler(options);
+  return reactor({
+    ...rest,
+    processorId: _nullishCoalesce(options.processorId, () => ( getWorkflowId({ workflowName: workflow.name }))),
+    canHandle,
+    type: MessageProcessorType.PROJECTOR,
+    eachMessage: async (message2, context) => {
+      const messageType = message2.type;
+      const metadata = message2.metadata;
+      const isInput = _optionalChain([metadata, 'optionalAccess', _51 => _51.input]) === true;
+      if (isInput || inputs.includes(messageType)) {
+        const result = await handle(
+          context.connection.messageStore,
+          message2,
+          context
+        );
+        if (options.stopAfter && result.newMessages.length > 0) {
+          for (const outputMessage of result.newMessages) {
+            if (options.stopAfter(
+              outputMessage
+            )) {
+              return { type: "STOP", reason: "Stop condition reached" };
+            }
+          }
+        }
+        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 (handledOutputMessages instanceof EmmettError) {
+          return {
+            type: "STOP",
+            reason: "Routing error",
+            error: handledOutputMessages
+          };
+        }
+        const messagesToAppend = Array.isArray(handledOutputMessages) ? handledOutputMessages : handledOutputMessages ? [handledOutputMessages] : [];
+        if (messagesToAppend.length === 0) {
+          return;
+        }
+        const workflowId = options.getWorkflowId(
+          message2
+        );
+        if (!workflowId) return;
+        const streamName = options.mapWorkflowId ? options.mapWorkflowId(workflowId) : workflowStreamName({
+          workflowName: workflow.name,
+          workflowId
+        });
+        await context.connection.messageStore.appendToStream(
+          streamName,
+          messagesToAppend
+        );
+        return;
+      }
+      return;
+    }
+  });
+};
+
+// src/eventStore/projections/pongo/pongoProjectionSpec.ts
+
+
+
+var withCollection = async (handle, options) => {
+  const { connection, inDatabase, inCollection } = options;
+  const driver = await pongoDriverRegistry.tryResolve(
+    connection.driverType
+  );
+  const pongo = _pongo.pongoClient.call(void 0, {
+    connectionOptions: { connection },
+    driver
+  });
+  try {
+    const collection = pongo.db(inDatabase).collection(inCollection);
+    return handle(collection);
+  } finally {
+    await pongo.close();
+  }
+};
+var withoutIdAndVersion = (doc) => {
+  const { _id, _version, ...without } = doc;
+  return without;
+};
+var assertDocumentsEqual = (actual, expected) => {
+  if ("_id" in expected)
+    assertEqual(
+      expected._id,
+      actual._id,
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      `Document ids are not matching! Expected: ${expected._id}, Actual: ${actual._id}`
+    );
+  return assertDeepEqual(
+    withoutIdAndVersion(actual),
+    withoutIdAndVersion(expected)
+  );
+};
+var documentExists = (document, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNotNull(result);
+    assertDocumentsEqual(result, document);
+  },
+  { ...options, ...assertOptions }
+);
+var documentsAreTheSame = (documents, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      documents.length,
+      result.length,
+      "Different Documents Count than expected"
+    );
+    for (let i = 0; i < documents.length; i++) {
+      assertThatArray(result).contains(documents[i]);
+    }
+  },
+  { ...options, ...assertOptions }
+);
+var documentsMatchingHaveCount = (expectedCount, options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertEqual(
+      expectedCount,
+      result.length,
+      "Different Documents Count than expected"
+    );
+  },
+  { ...options, ...assertOptions }
+);
+var documentMatchingExists = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.find(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertThatArray(result).isNotEmpty();
+  },
+  { ...options, ...assertOptions }
+);
+var documentDoesNotExist = (options) => (assertOptions) => withCollection(
+  async (collection) => {
+    const result = await collection.findOne(
+      "withId" in options ? { _id: options.withId } : options.matchingFilter
+    );
+    assertIsNull(result);
+  },
+  { ...options, ...assertOptions }
+);
+var expectPongoDocuments = {
+  fromCollection: (collectionName) => {
+    return {
+      withId: (id) => {
+        return {
+          toBeEqual: (document) => documentExists(document, {
+            withId: id,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            withId: id,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            withId: id,
+            inCollection: collectionName
+          })
+        };
+      },
+      matching: (filter) => {
+        return {
+          toBeTheSame: (documents) => documentsAreTheSame(documents, {
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          toHaveCount: (expectedCount) => documentsMatchingHaveCount(expectedCount, {
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          toExist: () => documentMatchingExists({
+            matchingFilter: filter,
+            inCollection: collectionName
+          }),
+          notToExist: () => documentDoesNotExist({
+            matchingFilter: filter,
+            inCollection: collectionName
+          })
+        };
+      }
+    };
+  }
+};
 
 // src/eventStore/projections/sqliteProjection.ts
 var handleProjections = async (options) => {
@@ -721,6 +1395,11 @@ var SQLiteProjectionSpec = {
     {
       const driverType = options.driver.driverType;
       const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
+        serialization: options.serialization,
+        transactionOptions: {
+          allowNestedTransactions: true,
+          mode: "session_based"
+        },
         ...options.driver.mapToDumboOptions(options)
       })));
       const projection2 = options.projection;
@@ -731,7 +1410,7 @@ var SQLiteProjectionSpec = {
             const allEvents = [];
             const run = async (connection) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _33 => _33.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _56 => _56.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -798,18 +1477,18 @@ var SQLiteProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _34 => _34.toString, 'call', _35 => _35()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _57 => _57.toString, 'call', _58 => _58()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _36 => _36.toString, 'call', _37 => _37()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _38 => _38.toString, 'call', _39 => _39()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()])}`
                     );
                   }
                 }
@@ -826,7 +1505,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _40 => _40.metadata, 'optionalAccess', _41 => _41.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _63 => _63.metadata, 'optionalAccess', _64 => _64.streamName]), () => ( streamName))
     }
   };
 };
@@ -898,7 +1577,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', _42 => _42.expectedStreamVersion])
+    _optionalChain([options, 'optionalAccess', _65 => _65.expectedStreamVersion])
   );
   const messagesToAppend = messages.map(
     (m, i) => ({
@@ -921,13 +1600,13 @@ var appendToStream = async (connection, streamName, streamType, messages, option
           streamType,
           downcastRecordedMessages(
             messagesToAppend,
-            _optionalChain([options, 'optionalAccess', _43 => _43.schema, 'optionalAccess', _44 => _44.versioning])
+            _optionalChain([options, 'optionalAccess', _66 => _66.schema, 'optionalAccess', _67 => _67.versioning])
           ),
           {
             expectedStreamVersion
           }
         );
-        if (_optionalChain([options, 'optionalAccess', _45 => _45.onBeforeCommit]))
+        if (_optionalChain([options, 'optionalAccess', _68 => _68.onBeforeCommit]))
           await options.onBeforeCommit(messagesToAppend, { connection });
         return { success: true, result };
       }
@@ -951,7 +1630,7 @@ var toExpectedVersion = (expected) => {
   return expected;
 };
 var appendToStreamRaw = async (execute, streamId, streamType, messages, options) => {
-  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.expectedStreamVersion]), () => ( null));
+  let expectedStreamVersion = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _69 => _69.expectedStreamVersion]), () => ( null));
   const currentStreamVersion = await getLastStreamPosition(
     execute,
     streamId,
@@ -969,7 +1648,7 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
             VALUES  (
                 ${streamId},
                 ${messages.length},
-                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _47 => _47.partition]), () => ( streamsTable.columns.partition))},
+                ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.partition]), () => ( streamsTable.columns.partition))},
                 ${streamType},
                 '[]',
                 false
@@ -979,7 +1658,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', _48 => _48.partition]), () => ( streamsTable.columns.partition))}
+            AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _71 => _71.partition]), () => ( streamsTable.columns.partition))}
             AND is_archived = false
             RETURNING stream_position;
           `;
@@ -987,12 +1666,12 @@ var appendToStreamRaw = async (execute, streamId, streamType, messages, options)
     messages,
     expectedStreamVersion,
     streamId,
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _49 => _49.partition, 'optionalAccess', _50 => _50.toString, 'call', _51 => _51()]), () => ( defaultTag2))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _72 => _72.partition, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()]), () => ( defaultTag2))
   );
   const results = await execute.batchCommand([streamSQL, insertSQL], { assertChanges: true });
   const [streamResult, messagesResult] = results;
-  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]);
+  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]);
   if (!streamPosition)
     throw new ExpectedVersionConflictError(0n, _nullishCoalesce(expectedStreamVersion, () => ( 0n)));
   if (!globalPosition) throw new Error("Could not find global position");
@@ -1008,7 +1687,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', _59 => _59.stream_position]) == null) {
+  if (_optionalChain([result, 'optionalAccess', _82 => _82.stream_position]) == null) {
     expectedStreamVersion = 0n;
   } else {
     expectedStreamVersion = BigInt(result.stream_position);
@@ -1017,7 +1696,7 @@ async function getLastStreamPosition(execute, streamId, expectedStreamVersion) {
 }
 var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
   const values = messages.map((message) => {
-    if (_optionalChain([message, 'access', _60 => _60.metadata, 'optionalAccess', _61 => _61.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
+    if (_optionalChain([message, 'access', _83 => _83.metadata, 'optionalAccess', _84 => _84.streamPosition]) == null || typeof message.metadata.streamPosition !== "bigint") {
       throw new Error("Stream position is required");
     }
     const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
@@ -1184,7 +1863,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
       _dumbo.SQL`
          SELECT global_position
          FROM ${identifier3(messagesTable.name)}
-         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.partition]), () => ( defaultTag2))} AND is_archived = FALSE
+         WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _85 => _85.partition]), () => ( defaultTag2))} AND is_archived = FALSE
          ORDER BY global_position
          LIMIT 1`
     )
@@ -1198,6 +1877,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
 
 var { identifier: identifier4 } = _dumbo.SQL;
 var readMessagesBatch = async (execute, options) => {
+  const { serializer } = options;
   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;
@@ -1208,15 +1888,15 @@ 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', _63 => _63.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _86 => _86.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
            ORDER BY global_position
            ${limitCondition}`
     ),
     (row) => {
       const rawEvent = {
         type: row.message_type,
-        data: JSONParser.parse(row.message_data),
-        metadata: JSONParser.parse(row.message_metadata)
+        data: serializer.deserialize(row.message_data),
+        metadata: serializer.deserialize(row.message_metadata)
       };
       const metadata = {
         ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
@@ -1252,7 +1932,7 @@ var readProcessorCheckpoint = async (execute, options) => {
     execute.query(
       _dumbo.SQL`SELECT last_processed_checkpoint
            FROM ${identifier5(processorsTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _64 => _64.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId}
            LIMIT 1`
     )
   );
@@ -1276,18 +1956,21 @@ var sqliteEventStoreMessageBatchPuller = ({
   eachBatch,
   pullingFrequencyInMs,
   stopWhen,
-  signal
+  signal,
+  serialization
 }) => {
   let isRunning = false;
   let start;
+  const serializer = JSONSerializer.from({ serialization });
   const pullMessages = async (options) => {
     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
+      batchSize,
+      serializer
     };
     let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _65 => _65.aborted])) {
+    while (isRunning && !_optionalChain([signal, 'optionalAccess', _88 => _88.aborted])) {
       const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
       if (messages.length > 0) {
         const result = await eachBatch(messages);
@@ -1298,7 +1981,7 @@ var sqliteEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _66 => _66.noMessagesLeft]) === true && !areMessagesLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _89 => _89.noMessagesLeft]) === true && !areMessagesLeft) {
         isRunning = false;
         break;
       }
@@ -1343,7 +2026,7 @@ var zipSQLiteEventStoreMessageBatchPullerStartFrom = (options) => {
 var sqliteCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _67 => _67.lastProcessedCheckpoint]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _90 => _90.lastProcessedCheckpoint]) };
   },
   store: async (options, context) => {
     const newCheckpoint = getCheckpoint(options.message);
@@ -1361,7 +2044,7 @@ var sqliteCheckpointer = () => ({
 // src/eventStore/consumers/sqliteProcessor.ts
 var sqliteProcessingScope = () => {
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _68 => _68.connection]);
+    const connection = _optionalChain([partialContext, 'optionalAccess', _91 => _91.connection]);
     if (!connection)
       throw new EmmettError("Connection is required in context or options");
     return connection.withTransaction(
@@ -1376,6 +2059,49 @@ var sqliteProcessingScope = () => {
   };
   return processingScope;
 };
+var sqliteWorkflowProcessingScope = (messageStore) => {
+  const processingScope = async (handler, partialContext) => {
+    const connection = _optionalChain([partialContext, 'optionalAccess', _92 => _92.connection]);
+    if (!connection)
+      throw new EmmettError("Connection is required in context or options");
+    return connection.withTransaction(
+      async (transaction) => {
+        return handler({
+          ...partialContext,
+          connection: Object.assign(connection, { messageStore }),
+          execute: transaction.execute
+        });
+      }
+    );
+  };
+  return processingScope;
+};
+var sqliteWorkflowProcessor = (options) => {
+  const {
+    processorId = _nullishCoalesce(options.processorId, () => ( getWorkflowId({
+      workflowName: _nullishCoalesce(options.workflow.name, () => ( "unknown"))
+    }))),
+    processorInstanceId = getProcessorInstanceId(processorId),
+    version = defaultProcessorVersion,
+    partition = defaultProcessorPartition
+  } = options;
+  const hooks = {
+    ..._nullishCoalesce(options.hooks, () => ( {})),
+    onClose: _optionalChain([options, 'access', _93 => _93.hooks, 'optionalAccess', _94 => _94.onClose])
+  };
+  return workflowProcessor({
+    ...options,
+    processorId,
+    processorInstanceId,
+    version,
+    partition,
+    hooks,
+    processingScope: sqliteWorkflowProcessingScope(
+      options.messageStore
+    ),
+    checkpoints: sqliteCheckpointer()
+  });
+};
 var sqliteReactor = (options) => {
   const {
     processorId = options.processorId,
@@ -1406,7 +2132,7 @@ var sqliteProjector = (options) => {
   } = options;
   const hooks = {
     ..._nullishCoalesce(options.hooks, () => ( {})),
-    onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _69 => _69.hooks, 'optionalAccess', _70 => _70.onInit]) ? async (context) => {
+    onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _95 => _95.hooks, 'optionalAccess', _96 => _96.onInit]) ? async (context) => {
       if (options.projection.init)
         await options.projection.init({
           version: _nullishCoalesce(options.projection.version, () => ( version)),
@@ -1417,13 +2143,13 @@ var sqliteProjector = (options) => {
             migrationOptions: options.migrationOptions
           }
         });
-      if (_optionalChain([options, 'access', _71 => _71.hooks, 'optionalAccess', _72 => _72.onInit]))
+      if (_optionalChain([options, 'access', _97 => _97.hooks, 'optionalAccess', _98 => _98.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])
+    } : _optionalChain([options, 'access', _99 => _99.hooks, 'optionalAccess', _100 => _100.onInit]),
+    onClose: _optionalChain([options, 'access', _101 => _101.hooks, 'optionalAccess', _102 => _102.onClose])
   };
   const processor = projector({
     ...options,
@@ -1448,11 +2174,12 @@ var sqliteEventStoreConsumer = (options) => {
   let start;
   let messagePuller;
   const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
-    ...options.driver.mapToDumboOptions(options),
+    serialization: options.serialization,
     transactionOptions: {
       allowNestedTransactions: true,
       mode: "session_based"
-    }
+    },
+    ...options.driver.mapToDumboOptions(options)
   })));
   const eachBatch = (messagesBatch) => pool.withConnection(async (connection) => {
     const activeProcessors = processors.filter((s) => s.isActive);
@@ -1470,7 +2197,7 @@ var sqliteEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _77 => _77.value, 'optionalAccess', _78 => _78.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _103 => _103.value, 'optionalAccess', _104 => _104.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -1484,12 +2211,12 @@ var sqliteEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _79 => _79.abort, 'call', _80 => _80()]);
+      _optionalChain([abortController, 'optionalAccess', _105 => _105.abort, 'call', _106 => _106()]);
       await messagePuller.stop();
-      messagePuller = void 0;
-      abortController = null;
     }
     await start;
+    messagePuller = void 0;
+    abortController = null;
     await stopProcessors();
   };
   const init = async () => {
@@ -1531,6 +2258,22 @@ var sqliteEventStoreConsumer = (options) => {
       );
       return processor;
     },
+    workflowProcessor: (processorOptions) => {
+      const messageStore = getSQLiteEventStore({
+        ...options,
+        pool,
+        schema: { autoMigration: "None" }
+      });
+      const processor = sqliteWorkflowProcessor({
+        ...processorOptions,
+        messageStore
+      });
+      processors.push(
+        // TODO: change that
+        processor
+      );
+      return processor;
+    },
     start: () => {
       if (isRunning) return start;
       if (processors.length === 0)
@@ -1543,8 +2286,8 @@ var sqliteEventStoreConsumer = (options) => {
         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)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _107 => _107.batchSize]), () => ( DefaultSQLiteEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _108 => _108.pullingFrequencyInMs]), () => ( DefaultSQLiteEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       start = (async () => {
@@ -1583,22 +2326,20 @@ var sqliteEventStoreConsumer = (options) => {
 var SQLiteEventStoreDefaultStreamVersion = 0n;
 var getSQLiteEventStore = (options) => {
   let autoGenerateSchema = false;
+  const serializer = JSONSerializer.from(options);
   const pool = _nullishCoalesce(options.pool, () => ( _dumbo.dumbo.call(void 0, {
-    ...options.driver.mapToDumboOptions(options),
+    serialization: options.serialization,
     transactionOptions: {
       allowNestedTransactions: true,
       mode: "session_based"
-    }
+    },
+    ...options.driver.mapToDumboOptions(options)
   })));
   let migrateSchema = void 0;
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  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);
-  });
+  const onBeforeCommitHook = _optionalChain([options, 'access', _109 => _109.hooks, 'optionalAccess', _110 => _110.onBeforeCommit]);
   if (options) {
-    autoGenerateSchema = _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) === void 0 || _optionalChain([options, 'access', _87 => _87.schema, 'optionalAccess', _88 => _88.autoMigration]) !== "None";
+    autoGenerateSchema = _optionalChain([options, 'access', _111 => _111.schema, 'optionalAccess', _112 => _112.autoMigration]) === void 0 || _optionalChain([options, 'access', _113 => _113.schema, 'optionalAccess', _114 => _114.autoMigration]) !== "None";
   }
   const migrate = (connection) => {
     if (!migrateSchema) {
@@ -1618,29 +2359,32 @@ var getSQLiteEventStore = (options) => {
               });
             }
           }
-          if (_optionalChain([options, 'access', _89 => _89.hooks, 'optionalAccess', _90 => _90.onBeforeSchemaCreated])) {
+          if (_optionalChain([options, 'access', _115 => _115.hooks, 'optionalAccess', _116 => _116.onBeforeSchemaCreated])) {
             await options.hooks.onBeforeSchemaCreated(context);
           }
         },
-        onAfterSchemaCreated: _optionalChain([options, 'access', _91 => _91.hooks, 'optionalAccess', _92 => _92.onAfterSchemaCreated])
+        onAfterSchemaCreated: _optionalChain([options, 'access', _117 => _117.hooks, 'optionalAccess', _118 => _118.onAfterSchemaCreated])
       });
     }
     return migrateSchema;
   };
-  const ensureSchemaExists = (connection) => {
+  const ensureSchemaExists = () => {
     if (!autoGenerateSchema) return Promise.resolve();
-    return migrate(connection);
+    return pool.withConnection((connection) => migrate(connection));
   };
   return {
     async aggregateStream(streamName, options2) {
+      await ensureSchemaExists();
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _93 => _93.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _119 => _119.expectedStreamVersion]);
       let state = initialState();
       if (typeof streamName !== "string") {
         throw new Error("Stream name is not string");
       }
-      const result = await withConnection(
-        ({ execute }) => readStream(execute, streamName, read)
+      const result = await readStream(
+        pool.execute,
+        streamName,
+        { ...read, serializer: _nullishCoalesce(_optionalChain([read, 'optionalAccess', _120 => _120.serialization, 'optionalAccess', _121 => _121.serializer]), () => ( serializer)) }
       );
       const currentStreamVersion = result.currentStreamVersion;
       assertExpectedVersionMatchesCurrent(
@@ -1658,13 +2402,18 @@ var getSQLiteEventStore = (options) => {
         streamExists: result.streamExists
       };
     },
-    readStream: async (streamName, options2) => withConnection(
-      ({ execute }) => readStream(execute, streamName, options2)
-    ),
+    readStream: async (streamName, readOptions) => {
+      await ensureSchemaExists();
+      return readStream(pool.execute, streamName, {
+        ...readOptions,
+        serializer: _nullishCoalesce(_optionalChain([options, 'access', _122 => _122.serialization, 'optionalAccess', _123 => _123.serializer]), () => ( serializer))
+      });
+    },
     appendToStream: async (streamName, events, appendOptions) => {
+      await ensureSchemaExists();
       const [firstPart, ...rest] = streamName.split("-");
       const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
-      const appendResult = await withConnection(
+      const appendResult = await pool.withConnection(
         (connection) => appendToStream(connection, streamName, streamType, events, {
           ...appendOptions,
           onBeforeCommit: async (messages, context) => {
@@ -1676,15 +2425,17 @@ var getSQLiteEventStore = (options) => {
                 connection: context.connection,
                 driverType: options.driver.driverType
               });
-            if (onBeforeCommitHook) await onBeforeCommitHook(messages, context);
+            if (onBeforeCommitHook)
+              await onBeforeCommitHook(messages, context);
           }
-        })
+        }),
+        { readonly: false }
       );
       if (!appendResult.success)
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _94 => _94.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _124 => _124.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -1692,16 +2443,41 @@ var getSQLiteEventStore = (options) => {
         createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
       };
     },
-    streamExists(streamName, options2) {
-      return withConnection(
-        ({ execute }) => streamExists(execute, streamName, options2)
-      );
+    async streamExists(streamName, options2) {
+      await ensureSchemaExists();
+      return streamExists(pool.execute, streamName, options2);
     },
     consumer: (consumerOptions) => sqliteEventStoreConsumer({
       ..._nullishCoalesce(options, () => ( {})),
       ..._nullishCoalesce(consumerOptions, () => ( {})),
       pool
     }),
+    async withSession(callback) {
+      return await pool.withConnection(async (connection) => {
+        const sessionStore = getSQLiteEventStore({
+          ...options,
+          pool: _dumbo.dumbo.call(void 0, {
+            ...options.driver.mapToDumboOptions(options),
+            connection,
+            serialization: options.serialization
+          }),
+          transactionOptions: {
+            allowNestedTransactions: true,
+            mode: "session_based"
+          },
+          schema: {
+            ...options.schema,
+            autoMigration: "None"
+          },
+          serialization: options.serialization
+        });
+        await ensureSchemaExists();
+        return callback({
+          eventStore: sessionStore,
+          close: () => Promise.resolve()
+        });
+      });
+    },
     close: () => pool.close(),
     schema: {
       sql: () => schemaSQL.join(""),
@@ -1714,22 +2490,23 @@ var getSQLiteEventStore = (options) => {
 // src/eventStore/schema/readStream.ts
 var { identifier: identifier6 } = _dumbo.SQL;
 var readStream = async (execute, streamId, options) => {
-  const fromCondition = _optionalChain([options, 'optionalAccess', _95 => _95.from]) ? _dumbo.SQL`AND stream_position >= ${options.from}` : _dumbo.SQL.EMPTY;
+  const { serializer } = options;
+  const fromCondition = options.from ? _dumbo.SQL`AND stream_position >= ${options.from}` : _dumbo.SQL.EMPTY;
   const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _96 => _96.to]), () => ( (_optionalChain([options, 'optionalAccess', _97 => _97.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _125 => _125.to]), () => ( (_optionalChain([options, 'optionalAccess', _126 => _126.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', _98 => _98.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _127 => _127.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${fromCondition} ${toCondition}
         ORDER BY stream_position ASC`
   );
   const messages = results.map((row) => {
     const rawEvent = {
       type: row.message_type,
-      data: JSONParser.parse(row.message_data),
-      metadata: JSONParser.parse(row.message_metadata)
+      data: serializer.deserialize(row.message_data),
+      metadata: serializer.deserialize(row.message_metadata)
     };
     const metadata = {
       ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
@@ -1744,7 +2521,7 @@ var readStream = async (execute, streamId, options) => {
       kind: "Event",
       metadata
     };
-    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _99 => _99.schema, 'optionalAccess', _100 => _100.versioning]));
+    return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _128 => _128.schema, 'optionalAccess', _129 => _129.versioning]));
   });
   return messages.length > 0 ? {
     currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
@@ -1789,7 +2566,7 @@ async function storeSubscriptionCheckpointSQLite(execute, processorId, version,
                WHERE processor_id = ${processorId} AND partition = ${partition}`
       )
     );
-    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _101 => _101.last_processed_checkpoint]) !== null ? current_position.last_processed_checkpoint : null;
+    const currentPosition = current_position && _optionalChain([current_position, 'optionalAccess', _130 => _130.last_processed_checkpoint]) !== null ? current_position.last_processed_checkpoint : null;
     if (currentPosition === position) {
       return 0;
     } else if (position !== null && currentPosition !== null && currentPosition > position) {
@@ -1817,7 +2594,7 @@ async function storeSubscriptionCheckpointSQLite(execute, processorId, version,
             WHERE processor_id = ${processorId} AND partition = ${partition}`
         )
       );
-      const currentPosition = current && _optionalChain([current, 'optionalAccess', _102 => _102.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
+      const currentPosition = current && _optionalChain([current, 'optionalAccess', _131 => _131.last_processed_checkpoint]) !== null ? BigInt(current.last_processed_checkpoint) : null;
       if (currentPosition === position) {
         return 0;
       } else {
@@ -1850,7 +2627,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', _103 => _103.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _132 => _132.partition]), () => ( defaultTag2))} AND is_archived = FALSE) as exists
       `
   )
 );
@@ -1916,13 +2693,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', _104 => _104.onBeforeSchemaCreated])) {
+    if (_optionalChain([hooks, 'optionalAccess', _133 => _133.onBeforeSchemaCreated])) {
       await hooks.onBeforeSchemaCreated({
         connection: tx.connection
       });
     }
     await tx.execute.batchCommand(schemaSQL);
-    if (_optionalChain([hooks, 'optionalAccess', _105 => _105.onAfterSchemaCreated])) {
+    if (_optionalChain([hooks, 'optionalAccess', _134 => _134.onAfterSchemaCreated])) {
       await hooks.onAfterSchemaCreated();
     }
   });
@@ -1966,5 +2743,14 @@ var createEventStoreSchema = async (pool, hooks) => {
 
 
 
-exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
+
+
+
+
+
+
+
+
+
+exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.SQLiteProjectionSpec = SQLiteProjectionSpec; exports.appendToStream = appendToStream; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag2; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix2; exports.eventInStream = eventInStream; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.migration_0_42_0_FromSubscriptionsToProcessors = migration_0_42_0_FromSubscriptionsToProcessors; exports.migration_0_42_0_SQLs = migration_0_42_0_SQLs; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.schema_0_41_0 = schema_0_41_0; exports.schema_0_42_0 = schema_0_42_0; exports.sqliteProjection = sqliteProjection; exports.sqliteRawBatchSQLProjection = sqliteRawBatchSQLProjection; exports.sqliteRawSQLProjection = sqliteRawSQLProjection; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.unknownTag = unknownTag2;
 //# sourceMappingURL=index.cjs.map