@event-driven-io/emmett-postgresql 0.43.0-beta.8 → 0.43.0-beta.9

package/dist/index.cjs

@@ -39,7 +39,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;
@@ -84,7 +84,7 @@ 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);
   }
 };
@@ -297,27 +297,109 @@ 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 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
-      // 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;
+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 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
+      (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();
@@ -325,14 +407,14 @@ var asyncRetry = async (fn, opts) => {
     async (bail) => {
       try {
         const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _14 => _14.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+        if (_optionalChain([opts, 'optionalAccess', _20 => _20.shouldRetryResult]) && opts.shouldRetryResult(result)) {
           throw new EmmettError(
-            `Retrying because of result: ${JSONParser.stringify(result)}`
+            `Retrying because of result: ${JSONSerializer.serialize(result)}`
           );
         }
         return result;
       } catch (error) {
-        if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error)) {
+        if (_optionalChain([opts, 'optionalAccess', _21 => _21.shouldRetryError]) && !opts.shouldRetryError(error)) {
           bail(error);
           return void 0;
         }
@@ -457,7 +539,7 @@ var reactor = (options) => {
         }
         if (startFrom && startFrom !== "CURRENT") return startFrom;
         if (checkpoints) {
-          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _16 => _16.read, 'call', _17 => _17(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _22 => _22.read, 'call', _23 => _23(
             {
               processorId,
               partition
@@ -485,7 +567,7 @@ var reactor = (options) => {
           const upcasted = upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
-            _optionalChain([options, 'access', _18 => _18.messageOptions, 'optionalAccess', _19 => _19.schema, 'optionalAccess', _20 => _20.versioning])
+            _optionalChain([options, 'access', _24 => _24.messageOptions, 'optionalAccess', _25 => _25.schema, 'optionalAccess', _26 => _26.versioning])
           );
           if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
             continue;
@@ -538,13 +620,13 @@ var projector = (options) => {
     processorId,
     messageOptions: options.projection.eventsOptions,
     hooks: {
-      onInit: _optionalChain([options, 'access', _21 => _21.hooks, 'optionalAccess', _22 => _22.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _23 => _23.hooks, 'optionalAccess', _24 => _24.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', _25 => _25.hooks, 'optionalAccess', _26 => _26.onStart])) await _optionalChain([options, 'access', _27 => _27.hooks, 'optionalAccess', _28 => _28.onStart, 'call', _29 => _29(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', _30 => _30.hooks, 'optionalAccess', _31 => _31.onClose])
+      onClose: _optionalChain([options, 'access', _36 => _36.hooks, 'optionalAccess', _37 => _37.onClose])
     },
     eachMessage: async (event2, context) => projection2.handle([event2], context)
   });
@@ -573,9 +655,9 @@ var assertDeepEqual = (actual, expected, message2) => {
   if (!deepEquals(actual, expected))
     throw new AssertionError(
       _nullishCoalesce(message2, () => ( `subObj:
-${JSONParser.stringify(expected)}
+${JSONSerializer.serialize(expected)}
 is not equal to
-${JSONParser.stringify(actual)}`))
+${JSONSerializer.serialize(actual)}`))
     );
 };
 function assertTrue(condition, message2) {
@@ -589,14 +671,14 @@ 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) {
@@ -611,7 +693,7 @@ var assertThatArray = (array) => {
     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),
@@ -668,7 +750,7 @@ var assertThatArray = (array) => {
   };
 };
 var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _32 => _32.downcast]))
+  if (!_optionalChain([options, 'optionalAccess', _38 => _38.downcast]))
     return recordedMessage;
   const downcasted = options.downcast(
     recordedMessage
@@ -686,14 +768,14 @@ var downcastRecordedMessage = (recordedMessage, options) => {
   };
 };
 var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _33 => _33.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', _34 => _34.upcast]))
+  if (!_optionalChain([options, 'optionalAccess', _40 => _40.upcast]))
     return recordedMessage;
   const upcasted = options.upcast(
     recordedMessage
@@ -761,11 +843,11 @@ var createWrappedEvolve = (evolve, workflowName, separateInputInboxFromProcessin
   return (state, event2) => {
     const metadata = event2.metadata;
     let processedInputIds = state.processedInputIds;
-    if (_optionalChain([metadata, 'optionalAccess', _35 => _35.input]) === true && typeof _optionalChain([metadata, 'optionalAccess', _36 => _36.originalMessageId]) === "string") {
+    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', _37 => _37.input]) === true) {
+    if (separateInputInboxFromProcessing && _optionalChain([metadata, 'optionalAccess', _43 => _43.input]) === true) {
       return {
         userState: state.userState,
         processedInputIds
@@ -795,7 +877,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', _38 => _38.metadata, 'optionalAccess', _39 => _39.messageId]) ? (
+        _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, )))
@@ -831,7 +913,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
           [inputToStore2],
           {
             ...handleOptions,
-            expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _40 => _40.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+            expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _46 => _46.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
           }
         );
         return {
@@ -852,7 +934,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', _41 => _41.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _47 => _47.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         }
       });
       const { currentStreamVersion } = aggregationResult;
@@ -876,7 +958,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', _42 => _42.outputs, 'optionalAccess', _43 => _43.commands]), () => ( []));
+      const outputCommandTypes = _nullishCoalesce(_optionalChain([options, 'access', _48 => _48.outputs, 'optionalAccess', _49 => _49.commands]), () => ( []));
       const taggedOutputMessages = outputMessages.map((msg) => {
         const action = outputCommandTypes.includes(
           msg.type
@@ -887,7 +969,7 @@ var WorkflowHandler = (options) => async (store, message2, handleOptions) => asy
       if (messagesToAppend.length === 0) {
         return emptyHandlerResult(currentStreamVersion);
       }
-      const expectedStreamVersion = _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _44 => _44.expectedStreamVersion]), () => ( (aggregationResult.streamExists ? currentStreamVersion : STREAM_DOES_NOT_EXIST)));
+      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
@@ -994,7 +1076,7 @@ var readLastMessageGlobalPosition = async (execute, options) => {
     execute.query(
       _dumbo.SQL`SELECT global_position
            FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _45 => _45.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
            ORDER BY transaction_id, global_position
            LIMIT 1`
     )
@@ -1018,7 +1100,7 @@ var readMessagesBatch = async (execute, options) => {
       _dumbo.SQL`
           SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
            FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _46 => _46.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
            ORDER BY transaction_id, global_position
            ${limitCondition}`
     ),
@@ -1074,7 +1156,7 @@ var postgreSQLEventStoreMessageBatchPuller = ({
       batchSize
     };
     let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _47 => _47.aborted])) {
+    while (isRunning && !_optionalChain([signal, 'optionalAccess', _53 => _53.aborted])) {
       const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
       if (messages.length > 0) {
         const result = await eachBatch(messages);
@@ -1085,7 +1167,7 @@ var postgreSQLEventStoreMessageBatchPuller = ({
       }
       readMessagesOptions.after = currentGlobalPosition;
       await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _48 => _48.noMessagesLeft]) === true && !areMessagesLeft) {
+      if (_optionalChain([stopWhen, 'optionalAccess', _54 => _54.noMessagesLeft]) === true && !areMessagesLeft) {
         isRunning = false;
         break;
       }
@@ -1387,9 +1469,9 @@ var tryAcquireProcessorLock = async (execute, options) => {
         version: options.version,
         partition: options.partition,
         processorInstanceId: options.processorInstanceId,
-        projectionName: _nullishCoalesce(_optionalChain([options, 'access', _49 => _49.projection, 'optionalAccess', _50 => _50.name]), () => ( null)),
-        projectionType: _optionalChain([options, 'access', _51 => _51.projection, 'optionalAccess', _52 => _52.handlingType]) ? options.projection.handlingType === "inline" ? "i" : "a" : null,
-        projectionKind: _nullishCoalesce(_optionalChain([options, 'access', _53 => _53.projection, 'optionalAccess', _54 => _54.kind]), () => ( null)),
+        projectionName: _nullishCoalesce(_optionalChain([options, 'access', _55 => _55.projection, 'optionalAccess', _56 => _56.name]), () => ( null)),
+        projectionType: _optionalChain([options, 'access', _57 => _57.projection, 'optionalAccess', _58 => _58.handlingType]) ? options.projection.handlingType === "inline" ? "i" : "a" : null,
+        projectionKind: _nullishCoalesce(_optionalChain([options, 'access', _59 => _59.projection, 'optionalAccess', _60 => _60.kind]), () => ( null)),
         lockTimeoutSeconds: _nullishCoalesce(options.lockTimeoutSeconds, () => ( PROCESSOR_LOCK_DEFAULT_TIMEOUT_SECONDS))
       })
     )
@@ -1441,7 +1523,7 @@ var postgreSQLProcessorLock = (options) => {
         ...options,
         lockKey
       });
-      if (!result.acquired && _optionalChain([options, 'access', _55 => _55.lockAcquisitionPolicy, 'optionalAccess', _56 => _56.type]) !== "skip") {
+      if (!result.acquired && _optionalChain([options, 'access', _61 => _61.lockAcquisitionPolicy, 'optionalAccess', _62 => _62.type]) !== "skip") {
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1455,7 +1537,7 @@ var postgreSQLProcessorLock = (options) => {
       await releaseProcessorLock(context.execute, {
         ...releaseOptions,
         lockKey,
-        projectionName: _optionalChain([projection2, 'optionalAccess', _57 => _57.name])
+        projectionName: _optionalChain([projection2, 'optionalAccess', _63 => _63.name])
       });
       acquired = false;
     }
@@ -1971,8 +2053,12 @@ var expectPongoDocuments = {
 var PostgreSQLProjectionSpec = {
   for: (options) => {
     {
-      const { projection: projection2, ...dumoOptions } = options;
-      const { connectionString } = dumoOptions;
+      const { projection: projection2, ...restOptions } = options;
+      const dumboOptions = {
+        ...restOptions,
+        serialization: projection2.serialization
+      };
+      const { connectionString } = dumboOptions;
       let wasInitialised = false;
       const initialize = async (pool) => {
         const eventStore = getPostgreSQLEventStore(connectionString, {
@@ -2002,7 +2088,7 @@ var PostgreSQLProjectionSpec = {
             const allEvents = [];
             const run = async (pool) => {
               let globalPosition = 0n;
-              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _58 => _58.numberOfTimes]), () => ( 1));
+              const numberOfTimes = _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _64 => _64.numberOfTimes]), () => ( 1));
               for (const event of [
                 ...givenEvents,
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
@@ -2038,7 +2124,7 @@ var PostgreSQLProjectionSpec = {
             };
             return {
               then: async (assert, message) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                const pool = _dumbo.dumbo.call(void 0, dumboOptions);
                 try {
                   await run(pool);
                   const succeeded = await assert({ pool, connectionString });
@@ -2051,7 +2137,7 @@ var PostgreSQLProjectionSpec = {
                 }
               },
               thenThrows: async (...args) => {
-                const pool = _dumbo.dumbo.call(void 0, dumoOptions);
+                const pool = _dumbo.dumbo.call(void 0, dumboOptions);
                 try {
                   await run(pool);
                   throw new AssertionError("Handler did not fail as expected");
@@ -2061,18 +2147,18 @@ var PostgreSQLProjectionSpec = {
                   if (!isErrorConstructor(args[0])) {
                     assertTrue(
                       args[0](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _59 => _59.toString, 'call', _60 => _60()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _65 => _65.toString, 'call', _66 => _66()])}`
                     );
                     return;
                   }
                   assertTrue(
                     error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _61 => _61.toString, 'call', _62 => _62()])}`
+                    `Caught error is not an instance of the expected type: ${_optionalChain([error, 'optionalAccess', _67 => _67.toString, 'call', _68 => _68()])}`
                   );
                   if (args[1]) {
                     assertTrue(
                       args[1](error),
-                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _63 => _63.toString, 'call', _64 => _64()])}`
+                      `Error didn't match the error condition: ${_optionalChain([error, 'optionalAccess', _69 => _69.toString, 'call', _70 => _70()])}`
                     );
                   }
                 } finally {
@@ -2091,7 +2177,7 @@ var eventInStream = (streamName, event) => {
     ...event,
     metadata: {
       ..._nullishCoalesce(event.metadata, () => ( {})),
-      streamName: _nullishCoalesce(_optionalChain([event, 'access', _65 => _65.metadata, 'optionalAccess', _66 => _66.streamName]), () => ( streamName))
+      streamName: _nullishCoalesce(_optionalChain([event, 'access', _71 => _71.metadata, 'optionalAccess', _72 => _72.streamName]), () => ( streamName))
     }
   };
 };
@@ -2342,7 +2428,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
     return { success: false, result: { success: false } };
   try {
     const expectedStreamVersion = toExpectedVersion(
-      _optionalChain([options, 'optionalAccess', _67 => _67.expectedStreamVersion])
+      _optionalChain([options, 'optionalAccess', _73 => _73.expectedStreamVersion])
     );
     const messagesToAppend = messages.map((e) => ({
       ...e,
@@ -2382,7 +2468,7 @@ var appendToStream = (pool, streamName, streamType, messages, options) => pool.w
         globalPosition
       };
     });
-    if (_optionalChain([options, 'optionalAccess', _68 => _68.beforeCommitHook]))
+    if (_optionalChain([options, 'optionalAccess', _74 => _74.beforeCommitHook]))
       await options.beforeCommitHook(messagesToAppend, { transaction });
     return {
       success: true,
@@ -2425,8 +2511,8 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
       messageKinds: messages.map((e) => e.kind === "Event" ? "E" : "C"),
       streamId,
       streamType,
-      expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _69 => _69.expectedStreamVersion]), () => ( null)),
-      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.partition]), () => ( defaultTag2))
+      expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.expectedStreamVersion]), () => ( null)),
+      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _76 => _76.partition]), () => ( defaultTag2))
     })
   )
 );
@@ -4488,7 +4574,7 @@ var readProcessorCheckpoint = async (execute, options) => {
     execute.query(
       _dumbo.SQL`SELECT last_processed_checkpoint
            FROM ${_dumbo.SQL.identifier(processorsTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _71 => _71.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId} AND version = ${_nullishCoalesce(options.version, () => ( 1))}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _77 => _77.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId} AND version = ${_nullishCoalesce(options.version, () => ( 1))}
            LIMIT 1`
     )
   );
@@ -4500,16 +4586,16 @@ var readProcessorCheckpoint = async (execute, options) => {
 // src/eventStore/schema/readStream.ts
 
 var readStream = async (execute, streamId, options) => {
-  const fromCondition = _optionalChain([options, 'optionalAccess', _72 => _72.from]) ? `AND stream_position >= ${options.from}` : "";
+  const fromCondition = _optionalChain([options, 'optionalAccess', _78 => _78.from]) ? `AND stream_position >= ${options.from}` : "";
   const to = Number(
-    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _73 => _73.to]), () => ( (_optionalChain([options, 'optionalAccess', _74 => _74.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
+    _nullishCoalesce(_optionalChain([options, 'optionalAccess', _79 => _79.to]), () => ( (_optionalChain([options, 'optionalAccess', _80 => _80.maxCount]) ? (_nullishCoalesce(options.from, () => ( 0n))) + options.maxCount : NaN)))
   );
   const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
   const events = await _dumbo.mapRows.call(void 0, 
     execute.query(
       _dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
            FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
+           WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _81 => _81.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
            ORDER BY stream_position ASC`
     ),
     (row) => {
@@ -4531,7 +4617,7 @@ var readStream = async (execute, streamId, options) => {
         kind: "Event",
         metadata
       };
-      return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _76 => _76.schema, 'optionalAccess', _77 => _77.versioning]));
+      return upcastRecordedMessage(event, _optionalChain([options, 'optionalAccess', _82 => _82.schema, 'optionalAccess', _83 => _83.versioning]));
     }
   );
   return events.length > 0 ? {
@@ -4552,10 +4638,10 @@ var streamExists = async (execute, streamId, options) => {
     _dumbo.SQL`SELECT EXISTS (
         SELECT 1
         from ${_dumbo.SQL.identifier(streamsTable.name)}
-        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _78 => _78.partition]), () => ( defaultTag2))} AND is_archived = FALSE)
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _84 => _84.partition]), () => ( defaultTag2))} AND is_archived = FALSE)
       `
   );
-  return _nullishCoalesce(_optionalChain([queryResult, 'access', _79 => _79.rows, 'access', _80 => _80[0], 'optionalAccess', _81 => _81.exists]), () => ( false));
+  return _nullishCoalesce(_optionalChain([queryResult, 'access', _85 => _85.rows, 'access', _86 => _86[0], 'optionalAccess', _87 => _87.exists]), () => ( false));
 };
 
 // src/eventStore/schema/index.ts
@@ -4593,9 +4679,13 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
       pool,
       tx
     );
-    const nestedPool = _dumbo.dumbo.call(void 0, { connectionString, connection: tx.connection });
+    const nestedPool = _dumbo.dumbo.call(void 0, {
+      connectionString,
+      connection: tx.connection,
+      serialization: _optionalChain([options, 'optionalAccess', _88 => _88.serialization])
+    });
     try {
-      if (_optionalChain([hooks, 'optionalAccess', _82 => _82.onBeforeSchemaCreated])) {
+      if (_optionalChain([hooks, 'optionalAccess', _89 => _89.onBeforeSchemaCreated])) {
         await hooks.onBeforeSchemaCreated(context);
       }
       const result = await _dumbo.runSQLMigrations.call(void 0, 
@@ -4603,7 +4693,7 @@ var createEventStoreSchema = (connectionString, pool, hooks, options) => {
         eventStoreSchemaMigrations,
         options
       );
-      if (_optionalChain([hooks, 'optionalAccess', _83 => _83.onAfterSchemaCreated])) {
+      if (_optionalChain([hooks, 'optionalAccess', _90 => _90.onAfterSchemaCreated])) {
         await hooks.onAfterSchemaCreated(context);
       }
       return result;
@@ -4622,7 +4712,7 @@ var truncateTables = async (execute, options) => {
         ${_dumbo.SQL.identifier(messagesTable.name)}, 
         ${_dumbo.SQL.identifier(processorsTable.name)}, 
         ${_dumbo.SQL.identifier(projectionsTable.name)} 
-        CASCADE${_dumbo.SQL.plain(_optionalChain([options, 'optionalAccess', _84 => _84.resetSequences]) ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`
+        CASCADE${_dumbo.SQL.plain(_optionalChain([options, 'optionalAccess', _91 => _91.resetSequences]) ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`
   );
 };
 
@@ -4637,9 +4727,9 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     connectionString,
     ...options.connectionOptions ? options.connectionOptions : {}
   };
-  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, poolOptions);
+  const pool = "dumbo" in poolOptions ? poolOptions.dumbo : _dumbo.dumbo.call(void 0, { ...poolOptions, serialization: options.serialization });
   let migrateSchema = void 0;
-  const autoGenerateSchema = _optionalChain([options, 'access', _85 => _85.schema, 'optionalAccess', _86 => _86.autoMigration]) === void 0 || _optionalChain([options, 'access', _87 => _87.schema, 'optionalAccess', _88 => _88.autoMigration]) !== "None";
+  const autoGenerateSchema = _optionalChain([options, 'access', _92 => _92.schema, 'optionalAccess', _93 => _93.autoMigration]) === void 0 || _optionalChain([options, 'access', _94 => _94.schema, 'optionalAccess', _95 => _95.autoMigration]) !== "None";
   const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
   const migrate = async (migrationOptions) => {
     if (!migrateSchema) {
@@ -4648,7 +4738,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         pool,
         {
           onBeforeSchemaCreated: async (context) => {
-            if (_optionalChain([options, 'access', _89 => _89.hooks, 'optionalAccess', _90 => _90.onBeforeSchemaCreated])) {
+            if (_optionalChain([options, 'access', _96 => _96.hooks, 'optionalAccess', _97 => _97.onBeforeSchemaCreated])) {
               await options.hooks.onBeforeSchemaCreated(context);
             }
           },
@@ -4663,7 +4753,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
                 });
               }
             }
-            if (_optionalChain([options, 'access', _91 => _91.hooks, 'optionalAccess', _92 => _92.onAfterSchemaCreated])) {
+            if (_optionalChain([options, 'access', _98 => _98.hooks, 'optionalAccess', _99 => _99.onAfterSchemaCreated])) {
               await options.hooks.onAfterSchemaCreated(context);
             }
           }
@@ -4705,13 +4795,13 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
           await ensureSchemaExists();
           await truncateTables(transaction.execute, truncateOptions);
-          if (_optionalChain([truncateOptions, 'optionalAccess', _93 => _93.truncateProjections])) {
+          if (_optionalChain([truncateOptions, 'optionalAccess', _100 => _100.truncateProjections])) {
             const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(
               connectionString,
               pool,
               transaction
             );
-            for (const projection2 of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _94 => _94.projections]), () => ( []))) {
+            for (const projection2 of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _101 => _101.projections]), () => ( []))) {
               if (projection2.projection.truncate)
                 await projection2.projection.truncate(projectionContext);
             }
@@ -4721,7 +4811,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     },
     async aggregateStream(streamName, options2) {
       const { evolve, initialState, read } = options2;
-      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _95 => _95.expectedStreamVersion]);
+      const expectedStreamVersion = _optionalChain([read, 'optionalAccess', _102 => _102.expectedStreamVersion]);
       let state = initialState();
       const result = await this.readStream(
         streamName,
@@ -4743,15 +4833,14 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         streamExists: result.streamExists
       };
     },
-    readStream: async (streamName, options2) => {
+    readStream: async (streamName, readOptions) => {
       await ensureSchemaExists();
-      return readStream(
-        pool.execute,
-        streamName,
-        options2
-      );
+      return readStream(pool.execute, streamName, {
+        ...readOptions,
+        serialization: _nullishCoalesce(options.serialization, () => ( _optionalChain([readOptions, 'optionalAccess', _103 => _103.serialization])))
+      });
     },
-    appendToStream: async (streamName, events, options2) => {
+    appendToStream: async (streamName, events, appendOptions) => {
       await ensureSchemaExists();
       const [firstPart, ...rest] = streamName.split("-");
       const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
@@ -4760,9 +4849,9 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         pool,
         streamName,
         streamType,
-        downcastRecordedMessages(events, _optionalChain([options2, 'optionalAccess', _96 => _96.schema, 'optionalAccess', _97 => _97.versioning])),
+        downcastRecordedMessages(events, _optionalChain([appendOptions, 'optionalAccess', _104 => _104.schema, 'optionalAccess', _105 => _105.versioning])),
         {
-          ...options2,
+          ...appendOptions,
           beforeCommitHook
         }
       );
@@ -4770,7 +4859,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
         throw new ExpectedVersionConflictError(
           -1n,
           //TODO: Return actual version in case of error
-          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _98 => _98.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
+          _nullishCoalesce(_optionalChain([appendOptions, 'optionalAccess', _106 => _106.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         );
       return {
         nextExpectedStreamVersion: appendResult.nextStreamPosition,
@@ -4819,7 +4908,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
 var postgreSQLCheckpointer = () => ({
   read: async (options, context) => {
     const result = await readProcessorCheckpoint(context.execute, options);
-    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _99 => _99.lastProcessedCheckpoint]) };
+    return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _107 => _107.lastProcessedCheckpoint]) };
   },
   store: async (options, context) => {
     const newCheckpoint = getCheckpoint(options.message);
@@ -4837,13 +4926,13 @@ var postgreSQLProcessingScope = (options) => {
   const processorConnectionString = options.connectionString;
   const processorPool = options.pool;
   const processingScope = async (handler, partialContext) => {
-    const connection = _optionalChain([partialContext, 'optionalAccess', _100 => _100.connection]);
-    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _101 => _101.connectionString])));
+    const connection = _optionalChain([partialContext, 'optionalAccess', _108 => _108.connection]);
+    const connectionString = _nullishCoalesce(processorConnectionString, () => ( _optionalChain([connection, 'optionalAccess', _109 => _109.connectionString])));
     if (!connectionString)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
       );
-    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _102 => _102.pool]) : processorPool), () => ( processorPool));
+    const pool = _nullishCoalesce((!processorConnectionString || connectionString == processorConnectionString ? _optionalChain([connection, 'optionalAccess', _110 => _110.pool]) : processorPool), () => ( processorPool));
     if (!pool)
       throw new EmmettError(
         `PostgreSQL processor '${options.processorId}' is missing connection string. Ensure that you passed it through options`
@@ -4875,7 +4964,8 @@ var getProcessorPool = (options) => {
   const processorConnectionString = "connectionString" in poolOptions ? _nullishCoalesce(poolOptions.connectionString, () => ( null)) : null;
   const processorPool = "dumbo" in poolOptions ? poolOptions.dumbo : processorConnectionString ? _dumbo.dumbo.call(void 0, {
     connectionString: processorConnectionString,
-    ...poolOptions
+    ...poolOptions,
+    serialization: options.serialization
   }) : null;
   return {
     pool: processorPool,
@@ -4887,11 +4977,11 @@ var wrapHooksWithProcessorLocks = (hooks, processorLock) => ({
   ..._nullishCoalesce(hooks, () => ( {})),
   onStart: async (context) => {
     await processorLock.tryAcquire({ execute: context.execute });
-    if (_optionalChain([hooks, 'optionalAccess', _103 => _103.onStart])) await hooks.onStart(context);
+    if (_optionalChain([hooks, 'optionalAccess', _111 => _111.onStart])) await hooks.onStart(context);
   },
-  onClose: _optionalChain([hooks, 'optionalAccess', _104 => _104.onClose]) || processorLock ? async (context) => {
+  onClose: _optionalChain([hooks, 'optionalAccess', _112 => _112.onClose]) || processorLock ? async (context) => {
     await processorLock.release({ execute: context.execute });
-    if (_optionalChain([hooks, 'optionalAccess', _105 => _105.onClose])) await hooks.onClose(context);
+    if (_optionalChain([hooks, 'optionalAccess', _113 => _113.onClose])) await hooks.onClose(context);
   } : void 0
 });
 var postgreSQLProjector = (options) => {
@@ -4916,13 +5006,13 @@ var postgreSQLProjector = (options) => {
       version: _nullishCoalesce(options.projection.version, () => ( version)),
       handlingType: "async"
     } : void 0,
-    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _106 => _106.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
-    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _107 => _107.timeoutSeconds])
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _114 => _114.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _115 => _115.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
-      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _108 => _108.hooks, 'optionalAccess', _109 => _109.onInit]) ? async (context) => {
+      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _116 => _116.hooks, 'optionalAccess', _117 => _117.onInit]) ? async (context) => {
         if (options.projection.init)
           await options.projection.init({
             version: _nullishCoalesce(options.projection.version, () => ( version)),
@@ -4933,16 +5023,16 @@ var postgreSQLProjector = (options) => {
               migrationOptions: options.migrationOptions
             }
           });
-        if (_optionalChain([options, 'access', _110 => _110.hooks, 'optionalAccess', _111 => _111.onInit]))
+        if (_optionalChain([options, 'access', _118 => _118.hooks, 'optionalAccess', _119 => _119.onInit]))
           await options.hooks.onInit({
             ...context,
             migrationOptions: options.migrationOptions
           });
-      } : _optionalChain([options, 'access', _112 => _112.hooks, 'optionalAccess', _113 => _113.onInit]),
+      } : _optionalChain([options, 'access', _120 => _120.hooks, 'optionalAccess', _121 => _121.onInit]),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _114 => _114.hooks, 'optionalAccess', _115 => _115.onClose])) await _optionalChain([options, 'access', _116 => _116.hooks, 'optionalAccess', _117 => _117.onClose, 'call', _118 => _118(context)]);
+        if (_optionalChain([options, 'access', _122 => _122.hooks, 'optionalAccess', _123 => _123.onClose])) await _optionalChain([options, 'access', _124 => _124.hooks, 'optionalAccess', _125 => _125.onClose, 'call', _126 => _126(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _119 => _119.hooks, 'optionalAccess', _120 => _120.onClose])
+      } : _optionalChain([options, 'access', _127 => _127.hooks, 'optionalAccess', _128 => _128.onClose])
     },
     processorLock
   );
@@ -4980,17 +5070,17 @@ var postgreSQLWorkflowProcessor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _121 => _121.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
-    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _122 => _122.timeoutSeconds])
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _129 => _129.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _130 => _130.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _123 => _123.hooks, 'optionalAccess', _124 => _124.onClose]))
-          await _optionalChain([options, 'access', _125 => _125.hooks, 'optionalAccess', _126 => _126.onClose, 'call', _127 => _127(context)]);
+        if (_optionalChain([options, 'access', _131 => _131.hooks, 'optionalAccess', _132 => _132.onClose]))
+          await _optionalChain([options, 'access', _133 => _133.hooks, 'optionalAccess', _134 => _134.onClose, 'call', _135 => _135(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _128 => _128.hooks, 'optionalAccess', _129 => _129.onClose])
+      } : _optionalChain([options, 'access', _136 => _136.hooks, 'optionalAccess', _137 => _137.onClose])
     },
     processorLock
   );
@@ -5025,16 +5115,16 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _130 => _130.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
-    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _131 => _131.timeoutSeconds])
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _138 => _138.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _139 => _139.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _132 => _132.hooks, 'optionalAccess', _133 => _133.onClose])) await _optionalChain([options, 'access', _134 => _134.hooks, 'optionalAccess', _135 => _135.onClose, 'call', _136 => _136(context)]);
+        if (_optionalChain([options, 'access', _140 => _140.hooks, 'optionalAccess', _141 => _141.onClose])) await _optionalChain([options, 'access', _142 => _142.hooks, 'optionalAccess', _143 => _143.onClose, 'call', _144 => _144(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _137 => _137.hooks, 'optionalAccess', _138 => _138.onClose])
+      } : _optionalChain([options, 'access', _145 => _145.hooks, 'optionalAccess', _146 => _146.onClose])
     },
     processorLock
   );
@@ -5064,7 +5154,10 @@ var postgreSQLEventStoreConsumer = (options) => {
   let abortController = null;
   let start;
   let messagePuller;
-  const pool = options.pool ? options.pool : _dumbo.dumbo.call(void 0, { connectionString: options.connectionString });
+  const pool = options.pool ? options.pool : _dumbo.dumbo.call(void 0, {
+    connectionString: options.connectionString,
+    serialization: options.serialization
+  });
   const eachBatch = async (messagesBatch) => {
     const activeProcessors = processors.filter((s) => s.isActive);
     if (activeProcessors.length === 0)
@@ -5083,7 +5176,7 @@ var postgreSQLEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _139 => _139.value, 'optionalAccess', _140 => _140.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _147 => _147.value, 'optionalAccess', _148 => _148.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -5103,7 +5196,7 @@ var postgreSQLEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _141 => _141.abort, 'call', _142 => _142()]);
+      _optionalChain([abortController, 'optionalAccess', _149 => _149.abort, 'call', _150 => _150()]);
       await messagePuller.stop();
     }
     await start;
@@ -5164,8 +5257,8 @@ var postgreSQLEventStoreConsumer = (options) => {
         stopWhen: options.stopWhen,
         executor: pool.execute,
         eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _143 => _143.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _144 => _144.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _151 => _151.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _152 => _152.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       start = (async () => {