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

package/dist/index.cjs

@@ -1,178 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var _dumbo = require('@event-driven-io/dumbo');
-
-// src/eventStore/schema/typing.ts
-var emmettPrefix = "emt";
-var globalTag = "global";
-var defaultTag = `${emmettPrefix}:default`;
-var unknownTag = `${emmettPrefix}:unknown`;
-var globalNames = {
-  module: `${emmettPrefix}:module:${globalTag}`,
-  tenant: `${emmettPrefix}:tenant:${globalTag}`
-};
-var columns = {
-  partition: {
-    name: "partition"
-  },
-  isArchived: { name: "is_archived" }
-};
-var streamsTable = {
-  name: `${emmettPrefix}_streams`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var messagesTable = {
-  name: `${emmettPrefix}_messages`,
-  columns: {
-    partition: columns.partition,
-    isArchived: columns.isArchived
-  }
-};
-var processorsTable = {
-  name: `${emmettPrefix}_processors`
-};
-var projectionsTable = {
-  name: `${emmettPrefix}_projections`
-};
-
-// src/eventStore/schema/readLastMessageGlobalPosition.ts
-var readLastMessageGlobalPosition = async (execute, options) => {
-  const result = await _dumbo.singleOrNull.call(void 0, 
-    execute.query(
-      _dumbo.SQL`SELECT global_position
-           FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.partition]), () => ( defaultTag))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
-           ORDER BY transaction_id, global_position
-           LIMIT 1`
-    )
-  );
-  return {
-    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
-  };
-};
-
-// src/eventStore/schema/readMessagesBatch.ts
-
-var readMessagesBatch = async (execute, options) => {
-  const from = "from" in options ? options.from : "after" in options ? options.after + 1n : 0n;
-  const batchSize = options && "batchSize" in options ? options.batchSize : options.to - options.from;
-  const fromCondition = from !== -0n ? `AND global_position >= ${from}` : "";
-  const toCondition = "to" in options ? `AND global_position <= ${options.to}` : "";
-  const limitCondition = "batchSize" in options ? `LIMIT ${options.batchSize}` : "";
-  const messages = await _dumbo.mapRows.call(void 0, 
-    execute.query(
-      _dumbo.SQL`
-          SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.partition]), () => ( defaultTag))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
-           ORDER BY transaction_id, global_position
-           ${_dumbo.SQL.plain(limitCondition)}`
-    ),
-    (row) => {
-      const rawEvent = {
-        type: row.message_type,
-        data: row.message_data,
-        metadata: row.message_metadata
-      };
-      const metadata = {
-        ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
-        messageId: row.message_id,
-        streamName: row.stream_id,
-        streamPosition: BigInt(row.stream_position),
-        globalPosition: BigInt(row.global_position)
-      };
-      return {
-        ...rawEvent,
-        kind: "Event",
-        metadata
-      };
-    }
-  );
-  return messages.length > 0 ? {
-    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
-    messages,
-    areMessagesLeft: messages.length === batchSize
-  } : {
-    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
-    messages: [],
-    areMessagesLeft: false
-  };
-};
-
-// src/eventStore/consumers/messageBatchProcessing/index.ts
-var DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
-var DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
-var postgreSQLEventStoreMessageBatchPuller = ({
-  executor,
-  batchSize,
-  eachBatch,
-  pullingFrequencyInMs,
-  stopWhen,
-  signal
-}) => {
-  let isRunning = false;
-  let start;
-  const pullMessages = async (options) => {
-    const after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? await _asyncNullishCoalesce((await readLastMessageGlobalPosition(executor)).currentGlobalPosition, async () => ( 0n)) : options.startFrom.lastCheckpoint;
-    const readMessagesOptions = {
-      after,
-      batchSize
-    };
-    let waitTime = 100;
-    while (isRunning && !_optionalChain([signal, 'optionalAccess', _4 => _4.aborted])) {
-      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
-      if (messages.length > 0) {
-        const result = await eachBatch(messages);
-        if (result && result.type === "STOP") {
-          isRunning = false;
-          break;
-        }
-      }
-      readMessagesOptions.after = currentGlobalPosition;
-      await new Promise((resolve) => setTimeout(resolve, waitTime));
-      if (_optionalChain([stopWhen, 'optionalAccess', _5 => _5.noMessagesLeft]) === true && !areMessagesLeft) {
-        isRunning = false;
-        break;
-      }
-      if (!areMessagesLeft) {
-        waitTime = Math.min(waitTime * 2, 1e3);
-      } else {
-        waitTime = pullingFrequencyInMs;
-      }
-    }
-  };
-  return {
-    get isRunning() {
-      return isRunning;
-    },
-    start: (options) => {
-      if (isRunning) return start;
-      isRunning = true;
-      start = (async () => {
-        return pullMessages(options);
-      })();
-      return start;
-    },
-    stop: async () => {
-      if (!isRunning) return;
-      isRunning = false;
-      await start;
-    }
-  };
-};
-var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
-  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
-    return "BEGINNING";
-  if (options.every((o) => o === "END")) return "END";
-  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
-};
-
-// src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
-
-
-// ../emmett/dist/chunk-AZDDB5SF.js
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-AZDDB5SF.js
 var isNumber = (val) => typeof val === "number" && val === val;
 var isBigint = (val) => typeof val === "bigint" && val === val;
 var isString = (val) => typeof val === "string";
@@ -213,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', _6 => _6.toString, 'call', _7 => _7()])}`))
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
     });
     this.current = current;
     this.expected = expected;
@@ -227,9 +53,9 @@ var _uuid = require('uuid');
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
-var emmettPrefix2 = "emt";
-var defaultTag2 = `${emmettPrefix2}:default`;
-var unknownTag2 = `${emmettPrefix2}:unknown`;
+var emmettPrefix = "emt";
+var defaultTag = `${emmettPrefix}:default`;
+var unknownTag = `${emmettPrefix}:unknown`;
 var STREAM_EXISTS = "STREAM_EXISTS";
 var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
 var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
@@ -246,7 +72,7 @@ var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) =>
 };
 var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
   constructor(current, expected) {
-    super(_optionalChain([current, 'optionalAccess', _8 => _8.toString, 'call', _9 => _9()]), _optionalChain([expected, 'optionalAccess', _10 => _10.toString, 'call', _11 => _11()]));
+    super(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
     Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
@@ -463,17 +289,17 @@ var ParseError = class extends Error {
 var JSONParser = {
   stringify: (value, options) => {
     return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _12 => _12.map]) ? options.map(value) : value,
+      _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', _13 => _13.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck]) && !_optionalChain([options, 'optionalAccess', _15 => _15.typeCheck, 'call', _16 => _16(parsed)]))
+    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', _17 => _17.map]) ? options.map(parsed) : parsed;
+    return _optionalChain([options, 'optionalAccess', _13 => _13.map]) ? options.map(parsed) : parsed;
   }
 };
 var asyncRetry = async (fn, opts) => {
@@ -482,14 +308,14 @@ var asyncRetry = async (fn, opts) => {
     async (bail) => {
       try {
         const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _18 => _18.shouldRetryResult]) && opts.shouldRetryResult(result)) {
+        if (_optionalChain([opts, 'optionalAccess', _14 => _14.shouldRetryResult]) && opts.shouldRetryResult(result)) {
           throw new EmmettError(
             `Retrying because of result: ${JSONParser.stringify(result)}`
           );
         }
         return result;
       } catch (error2) {
-        if (_optionalChain([opts, 'optionalAccess', _19 => _19.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+        if (_optionalChain([opts, 'optionalAccess', _15 => _15.shouldRetryError]) && !opts.shouldRetryError(error2)) {
           bail(error2);
           return void 0;
         }
@@ -534,190 +360,22 @@ var hashText = async (text) => {
   const view = new BigInt64Array(hashBuffer, 0, 1);
   return view[0];
 };
-var AssertionError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-var isSubset = (superObj, subObj) => {
-  const sup = superObj;
-  const sub = subObj;
-  assertOk(sup);
-  assertOk(sub);
-  return Object.keys(sub).every((ele) => {
-    if (typeof sub[ele] == "object") {
-      return isSubset(sup[ele], sub[ele]);
-    }
-    return sub[ele] === sup[ele];
-  });
+var getCheckpoint = (message2) => {
+  return message2.metadata.checkpoint;
 };
-var assertFails = (message2) => {
-  throw new AssertionError(_nullishCoalesce(message2, () => ( "That should not ever happened, right?")));
+var wasMessageHandled = (message2, checkpoint) => {
+  const messageCheckpoint = getCheckpoint(message2);
+  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
 };
-var assertDeepEqual = (actual, expected, message2) => {
-  if (!deepEquals(actual, expected))
-    throw new AssertionError(
-      _nullishCoalesce(message2, () => ( `subObj:
-${JSONParser.stringify(expected)}
-is not equal to
-${JSONParser.stringify(actual)}`))
-    );
-};
-function assertTrue(condition, message2) {
-  if (condition !== true)
-    throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is false`)));
-}
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
-}
-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)}`
-    );
-}
-function assertNotEqual(obj, other, message2) {
-  if (obj === other)
-    throw new AssertionError(
-      _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
-    );
-}
-function assertIsNotNull(result) {
-  assertNotEqual(result, null);
-  assertOk(result);
-}
-var assertThatArray = (array) => {
-  return {
-    isEmpty: () => assertEqual(
-      array.length,
-      0,
-      `Array is not empty ${JSONParser.stringify(array)}`
-    ),
-    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
-    hasSize: (length) => assertEqual(array.length, length),
-    containsElements: (other) => {
-      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
-    },
-    containsElementsMatching: (other) => {
-      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
-    },
-    containsOnlyElementsMatching: (other) => {
-      assertEqual(array.length, other.length, `Arrays lengths don't match`);
-      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
-    },
-    containsExactlyInAnyOrder: (other) => {
-      assertEqual(array.length, other.length);
-      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
-    },
-    containsExactlyInAnyOrderElementsOf: (other) => {
-      assertEqual(array.length, other.length);
-      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
-    },
-    containsExactlyElementsOf: (other) => {
-      assertEqual(array.length, other.length);
-      for (let i = 0; i < array.length; i++) {
-        assertTrue(deepEquals(array[i], other[i]));
-      }
-    },
-    containsExactly: (elem) => {
-      assertEqual(array.length, 1);
-      assertTrue(deepEquals(array[0], elem));
-    },
-    contains: (elem) => {
-      assertTrue(array.some((a) => deepEquals(a, elem)));
-    },
-    containsOnlyOnceElementsOf: (other) => {
-      assertTrue(
-        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
-      );
-    },
-    containsAnyOf: (other) => {
-      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
-    },
-    allMatch: (matches) => {
-      assertTrue(array.every(matches));
-    },
-    anyMatches: (matches) => {
-      assertTrue(array.some(matches));
-    },
-    allMatchAsync: async (matches) => {
-      for (const item of array) {
-        assertTrue(await matches(item));
-      }
-    }
-  };
-};
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _20 => _20.downcast]))
-    return recordedMessage;
-  const downcasted = options.downcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: downcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in downcasted ? downcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _21 => _21.downcast]))
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _22 => _22.upcast]))
-    return recordedMessage;
-  const upcasted = options.upcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: upcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in upcasted ? upcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var getCheckpoint = (message2) => {
-  return "checkpoint" in message2.metadata ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.checkpoint
-  ) : "globalPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.globalPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.globalPosition
-  ) : "streamPosition" in message2.metadata && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  isBigint(message2.metadata.streamPosition) ? (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    message2.metadata.streamPosition
-  ) : null;
-};
-var wasMessageHandled = (message2, checkpoint) => {
-  const messageCheckpoint = getCheckpoint(message2);
-  const checkpointBigint = checkpoint;
-  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpointBigint !== null && checkpointBigint !== void 0 && messageCheckpoint <= checkpointBigint;
-};
-var MessageProcessorType = {
-  PROJECTOR: "projector",
-  REACTOR: "reactor"
+var MessageProcessorType = {
+  PROJECTOR: "projector",
+  REACTOR: "reactor"
 };
 var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
+var bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
+var parseBigIntProcessorCheckpoint = (value) => BigInt(value);
 var defaultProcessorVersion = 1;
-var defaultProcessorPartition = defaultTag2;
+var defaultProcessorPartition = defaultTag;
 var getProcessorInstanceId = (processorId) => `${processorId}:${_uuid.v7.call(void 0, )}`;
 var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
 var reactor = (options) => {
@@ -781,7 +439,7 @@ var reactor = (options) => {
         }
         if (startFrom && startFrom !== "CURRENT") return startFrom;
         if (checkpoints) {
-          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _23 => _23.read, 'call', _24 => _24(
+          const readResult = await _optionalChain([checkpoints, 'optionalAccess', _16 => _16.read, 'call', _17 => _17(
             {
               processorId,
               partition
@@ -809,7 +467,7 @@ var reactor = (options) => {
           const upcasted = upcastRecordedMessage(
             // TODO: Make it smarter
             message2,
-            _optionalChain([options, 'access', _25 => _25.messageOptions, 'optionalAccess', _26 => _26.schema, 'optionalAccess', _27 => _27.versioning])
+            _optionalChain([options, 'access', _18 => _18.messageOptions, 'optionalAccess', _19 => _19.schema, 'optionalAccess', _20 => _20.versioning])
           );
           if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
             continue;
@@ -842,49 +500,381 @@ var reactor = (options) => {
           if (messageProcessingResult && messageProcessingResult.type === "SKIP")
             continue;
         }
-        return result;
-      }, partialContext);
+        return result;
+      }, partialContext);
+    }
+  };
+};
+var projector = (options) => {
+  const {
+    projection: projection2,
+    processorId = getProjectorId({
+      projectionName: _nullishCoalesce(projection2.name, () => ( "unknown"))
+    }),
+    ...rest
+  } = options;
+  return reactor({
+    ...rest,
+    type: MessageProcessorType.PROJECTOR,
+    canHandle: projection2.canHandle,
+    processorId,
+    messageOptions: options.projection.eventsOptions,
+    hooks: {
+      onInit: _optionalChain([options, 'access', _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) => {
+        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)]);
+      } : void 0,
+      onClose: _optionalChain([options, 'access', _30 => _30.hooks, 'optionalAccess', _31 => _31.onClose])
+    },
+    eachMessage: async (event2, context) => projection2.handle([event2], context)
+  });
+};
+var AssertionError = class extends Error {
+  constructor(message2) {
+    super(message2);
+  }
+};
+var isSubset = (superObj, subObj) => {
+  const sup = superObj;
+  const sub = subObj;
+  assertOk(sup);
+  assertOk(sub);
+  return Object.keys(sub).every((ele) => {
+    if (sub[ele] !== null && typeof sub[ele] == "object") {
+      return isSubset(sup[ele], sub[ele]);
+    }
+    return sub[ele] === sup[ele];
+  });
+};
+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:
+${JSONParser.stringify(expected)}
+is not equal to
+${JSONParser.stringify(actual)}`))
+    );
+};
+function assertTrue(condition, message2) {
+  if (condition !== true)
+    throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is false`)));
+}
+function assertOk(obj, message2) {
+  if (!obj) throw new AssertionError(_nullishCoalesce(message2, () => ( `Condition is not truthy`)));
+}
+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)}`
+    );
+}
+function assertNotEqual(obj, other, message2) {
+  if (obj === other)
+    throw new AssertionError(
+      _nullishCoalesce(message2, () => ( `Objects are equal: ${JSONParser.stringify(obj)}`))
+    );
+}
+function assertIsNotNull(result) {
+  assertNotEqual(result, null);
+  assertOk(result);
+}
+var assertThatArray = (array) => {
+  return {
+    isEmpty: () => assertEqual(
+      array.length,
+      0,
+      `Array is not empty ${JSONParser.stringify(array)}`
+    ),
+    isNotEmpty: () => assertNotEqual(array.length, 0, `Array is empty`),
+    hasSize: (length) => assertEqual(array.length, length),
+    containsElements: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
+    },
+    containsElementsMatching: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    containsOnlyElementsMatching: (other) => {
+      assertEqual(array.length, other.length, `Arrays lengths don't match`);
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    containsExactlyInAnyOrder: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyInAnyOrderElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
+    },
+    containsExactlyElementsOf: (other) => {
+      assertEqual(array.length, other.length);
+      for (let i = 0; i < array.length; i++) {
+        assertTrue(deepEquals(array[i], other[i]));
+      }
+    },
+    containsExactly: (elem) => {
+      assertEqual(array.length, 1);
+      assertTrue(deepEquals(array[0], elem));
+    },
+    contains: (elem) => {
+      assertTrue(array.some((a) => deepEquals(a, elem)));
+    },
+    containsOnlyOnceElementsOf: (other) => {
+      assertTrue(
+        other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
+      );
+    },
+    containsAnyOf: (other) => {
+      assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
+    },
+    allMatch: (matches) => {
+      assertTrue(array.every(matches));
+    },
+    anyMatches: (matches) => {
+      assertTrue(array.some(matches));
+    },
+    allMatchAsync: async (matches) => {
+      for (const item of array) {
+        assertTrue(await matches(item));
+      }
+    }
+  };
+};
+var downcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _32 => _32.downcast]))
+    return recordedMessage;
+  const downcasted = options.downcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: downcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in downcasted ? downcasted.metadata : {}
+      }
+    } : {}
+  };
+};
+var downcastRecordedMessages = (recordedMessages, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _33 => _33.downcast]))
+    return recordedMessages;
+  return recordedMessages.map(
+    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
+  );
+};
+var upcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _34 => _34.upcast]))
+    return recordedMessage;
+  const upcasted = options.upcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: upcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in upcasted ? upcasted.metadata : {}
+      }
+    } : {}
+  };
+};
+var projection = (definition) => definition;
+
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+var _dumbo = require('@event-driven-io/dumbo');
+
+// src/eventStore/schema/typing.ts
+var emmettPrefix2 = "emt";
+var globalTag = "global";
+var defaultTag2 = `${emmettPrefix2}:default`;
+var unknownTag2 = `${emmettPrefix2}:unknown`;
+var globalNames = {
+  module: `${emmettPrefix2}:module:${globalTag}`,
+  tenant: `${emmettPrefix2}:tenant:${globalTag}`
+};
+var columns = {
+  partition: {
+    name: "partition"
+  },
+  isArchived: { name: "is_archived" }
+};
+var streamsTable = {
+  name: `${emmettPrefix2}_streams`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+var messagesTable = {
+  name: `${emmettPrefix2}_messages`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+var processorsTable = {
+  name: `${emmettPrefix2}_processors`
+};
+var projectionsTable = {
+  name: `${emmettPrefix2}_projections`
+};
+
+// src/eventStore/schema/readLastMessageGlobalPosition.ts
+var readLastMessageGlobalPosition = async (execute, options) => {
+  const result = await _dumbo.singleOrNull.call(void 0, 
+    execute.query(
+      _dumbo.SQL`SELECT global_position
+           FROM ${_dumbo.SQL.identifier(messagesTable.name)}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+           ORDER BY transaction_id, global_position
+           LIMIT 1`
+    )
+  );
+  return {
+    currentGlobalPosition: result !== null ? BigInt(result.global_position) : null
+  };
+};
+
+// src/eventStore/schema/readMessagesBatch.ts
+
+var readMessagesBatch = async (execute, 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;
+  const fromCondition = from !== void 0 ? _dumbo.SQL`AND global_position >= ${from}` : after !== void 0 ? _dumbo.SQL`AND global_position > ${after}` : _dumbo.SQL.EMPTY;
+  const toCondition = "to" in options ? _dumbo.SQL`AND global_position <= ${options.to}` : _dumbo.SQL.EMPTY;
+  const limitCondition = "batchSize" in options ? _dumbo.SQL`LIMIT ${options.batchSize}` : _dumbo.SQL.EMPTY;
+  const messages = await _dumbo.mapRows.call(void 0, 
+    execute.query(
+      _dumbo.SQL`
+          SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${_dumbo.SQL.identifier(messagesTable.name)}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.partition]), () => ( defaultTag2))} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot()) ${fromCondition} ${toCondition}
+           ORDER BY transaction_id, global_position
+           ${limitCondition}`
+    ),
+    (row) => {
+      const rawEvent = {
+        type: row.message_type,
+        data: row.message_data,
+        metadata: row.message_metadata
+      };
+      const metadata = {
+        ..."metadata" in rawEvent ? _nullishCoalesce(rawEvent.metadata, () => ( {})) : {},
+        messageId: row.message_id,
+        streamName: row.stream_id,
+        streamPosition: BigInt(row.stream_position),
+        globalPosition: BigInt(row.global_position),
+        checkpoint: bigIntProcessorCheckpoint(BigInt(row.global_position))
+      };
+      return {
+        ...rawEvent,
+        kind: "Event",
+        metadata
+      };
+    }
+  );
+  return messages.length > 0 ? {
+    currentGlobalPosition: messages[messages.length - 1].metadata.globalPosition,
+    messages,
+    areMessagesLeft: messages.length === batchSize
+  } : {
+    currentGlobalPosition: "from" in options ? options.from : "after" in options ? options.after : 0n,
+    messages: [],
+    areMessagesLeft: false
+  };
+};
+
+// src/eventStore/consumers/messageBatchProcessing/index.ts
+var DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
+var DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
+var postgreSQLEventStoreMessageBatchPuller = ({
+  executor,
+  batchSize,
+  eachBatch,
+  pullingFrequencyInMs,
+  stopWhen,
+  signal
+}) => {
+  let isRunning = false;
+  let start;
+  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
+    };
+    let waitTime = 100;
+    while (isRunning && !_optionalChain([signal, 'optionalAccess', _37 => _37.aborted])) {
+      const { messages, currentGlobalPosition, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
+      if (messages.length > 0) {
+        const result = await eachBatch(messages);
+        if (result && result.type === "STOP") {
+          isRunning = false;
+          break;
+        }
+      }
+      readMessagesOptions.after = currentGlobalPosition;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+      if (_optionalChain([stopWhen, 'optionalAccess', _38 => _38.noMessagesLeft]) === true && !areMessagesLeft) {
+        isRunning = false;
+        break;
+      }
+      if (!areMessagesLeft) {
+        waitTime = Math.min(waitTime * 2, 1e3);
+      } else {
+        waitTime = pullingFrequencyInMs;
+      }
     }
   };
-};
-var projector = (options) => {
-  const {
-    projection: projection2,
-    processorId = getProjectorId({
-      projectionName: _nullishCoalesce(projection2.name, () => ( "unknown"))
-    }),
-    ...rest
-  } = options;
-  return reactor({
-    ...rest,
-    type: MessageProcessorType.PROJECTOR,
-    canHandle: projection2.canHandle,
-    processorId,
-    messageOptions: options.projection.eventsOptions,
-    hooks: {
-      onInit: _optionalChain([options, 'access', _28 => _28.hooks, 'optionalAccess', _29 => _29.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _30 => _30.hooks, 'optionalAccess', _31 => _31.onStart]) ? async (context) => {
-        if (options.truncateOnStart && options.projection.truncate)
-          await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _32 => _32.hooks, 'optionalAccess', _33 => _33.onStart])) await _optionalChain([options, 'access', _34 => _34.hooks, 'optionalAccess', _35 => _35.onStart, 'call', _36 => _36(context)]);
-      } : void 0,
-      onClose: _optionalChain([options, 'access', _37 => _37.hooks, 'optionalAccess', _38 => _38.onClose])
+  return {
+    get isRunning() {
+      return isRunning;
     },
-    eachMessage: async (event2, context) => projection2.handle([event2], context)
-  });
+    start: (options) => {
+      if (isRunning) return start;
+      isRunning = true;
+      start = (async () => {
+        return pullMessages(options);
+      })();
+      return start;
+    },
+    stop: async () => {
+      if (!isRunning) return;
+      isRunning = false;
+      await start;
+    }
+  };
+};
+var zipPostgreSQLEventStoreMessageBatchPullerStartFrom = (options) => {
+  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
+    return "BEGINNING";
+  if (options.every((o) => o === "END")) return "END";
+  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
 };
-var projection = (definition) => definition;
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 
 
+
 // src/eventStore/consumers/postgreSQLProcessor.ts
 
 
-// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
 
 
-// src/eventStore/schema/processors/processorsLocks.ts
+// src/eventStore/schema/projections/projectionsLocks.ts
 
 
 // src/eventStore/schema/createFunctionIfDoesNotExist.ts
@@ -898,7 +888,91 @@ END IF;
 END $$;
 `;
 
+// src/eventStore/schema/projections/projectionsLocks.ts
+var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
+  "emt_try_acquire_projection_lock",
+  _dumbo.SQL`
+CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
+    p_lock_key   BIGINT,
+    p_partition  TEXT,
+    p_name       TEXT,
+    p_version    INT
+)
+RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
+LANGUAGE plpgsql
+AS $emt_try_acquire_projection_lock$
+BEGIN
+    RETURN QUERY
+    WITH lock_check AS (
+        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
+    ),
+    status_check AS (
+        SELECT status = 'active' AS is_active
+        FROM ${_dumbo.SQL.plain(projectionsTable.name)}
+        WHERE partition = p_partition AND name = p_name AND version = p_version
+    )
+    SELECT
+        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
+        COALESCE((SELECT sc.is_active FROM status_check sc), true);
+END;
+$emt_try_acquire_projection_lock$;
+`
+);
+var callTryAcquireProjectionLock = (params) => _dumbo.SQL`SELECT * FROM emt_try_acquire_projection_lock(${params.lockKey}, ${params.partition}, ${params.name}, ${params.version});`;
+
+// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
+var tryAcquireProjectionLock = async (execute, {
+  lockKey,
+  projectionName,
+  partition,
+  version
+}) => {
+  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
+  const { acquired, is_active } = await _dumbo.single.call(void 0, 
+    execute.query(
+      callTryAcquireProjectionLock({
+        lockKey: lockKeyBigInt.toString(),
+        partition,
+        name: projectionName,
+        version
+      })
+    )
+  );
+  return acquired === true && is_active === true;
+};
+
+// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
+var postgreSQLProjectionLock = (options) => {
+  let acquired = false;
+  const lockKey = _nullishCoalesce(options.lockKey, () => ( toProjectionLockKey(options)));
+  return {
+    tryAcquire: async (context) => {
+      if (acquired) {
+        return true;
+      }
+      acquired = await tryAcquireProjectionLock(context.execute, {
+        ...options,
+        lockKey
+      });
+      return acquired;
+    },
+    release: (_context) => {
+      if (!acquired) return;
+      acquired = false;
+    }
+  };
+};
+var toProjectionLockKey = ({
+  projectionName,
+  partition,
+  version
+}) => `${partition}:${projectionName}:${version}`;
+
+// src/eventStore/projections/locks/tryAcquireProcessorLock.ts
+
+
 // src/eventStore/schema/processors/processorsLocks.ts
+
 var tryAcquireProcessorLockSQL = createFunctionIfDoesNotExistSQL(
   "emt_try_acquire_processor_lock",
   _dumbo.SQL`
@@ -906,8 +980,8 @@ CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
     p_lock_key               BIGINT,
     p_processor_id           TEXT,
     p_version                INT,
-    p_partition              TEXT       DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
-    p_processor_instance_id  TEXT       DEFAULT '${_dumbo.SQL.plain(unknownTag)}',
+    p_partition              TEXT       DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
+    p_processor_instance_id  TEXT       DEFAULT '${_dumbo.SQL.plain(unknownTag2)}',
     p_projection_name        TEXT       DEFAULT NULL,
     p_projection_type        VARCHAR(1) DEFAULT NULL,
     p_projection_kind        TEXT       DEFAULT NULL,
@@ -940,7 +1014,7 @@ BEGIN
             status = 'running',
             last_updated = now()
         WHERE ${_dumbo.SQL.plain(processorsTable.name)}.processor_instance_id = p_processor_instance_id
-           OR ${_dumbo.SQL.plain(processorsTable.name)}.processor_instance_id = '${_dumbo.SQL.plain(unknownTag)}'
+           OR ${_dumbo.SQL.plain(processorsTable.name)}.processor_instance_id = '${_dumbo.SQL.plain(unknownTag2)}'
            OR ${_dumbo.SQL.plain(processorsTable.name)}.status = 'stopped'
            OR ${_dumbo.SQL.plain(processorsTable.name)}.last_updated < now() - (p_lock_timeout_seconds || ' seconds')::interval
         RETURNING last_processed_checkpoint
@@ -977,7 +1051,7 @@ CREATE OR REPLACE FUNCTION emt_release_processor_lock(
     p_processor_id          TEXT,
     p_partition             TEXT,
     p_version               INT,
-    p_processor_instance_id TEXT DEFAULT '${_dumbo.SQL.plain(unknownTag)}',
+    p_processor_instance_id TEXT DEFAULT '${_dumbo.SQL.plain(unknownTag2)}',
     p_projection_name       TEXT DEFAULT NULL
 )
 RETURNS BOOLEAN
@@ -997,7 +1071,7 @@ BEGIN
 
     UPDATE ${_dumbo.SQL.plain(processorsTable.name)}
     SET status = 'stopped',
-        processor_instance_id = '${_dumbo.SQL.plain(unknownTag)}',
+        processor_instance_id = '${_dumbo.SQL.plain(unknownTag2)}',
         last_updated = now()
     WHERE processor_id = p_processor_id
       AND partition = p_partition
@@ -1057,7 +1131,7 @@ var tryAcquireProcessorLock = async (execute, options) => {
   return acquired ? { acquired: true, checkpoint } : { acquired: false };
 };
 var tryAcquireProcessorLockWithRetry = async (execute, options) => {
-  const policy = _nullishCoalesce(options.lockPolicy, () => ( DefaultPostgreSQLProcessorLockPolicy));
+  const policy = _nullishCoalesce(options.lockAcquisitionPolicy, () => ( DefaultPostgreSQLProcessorLockPolicy));
   if (policy.type === "retry") {
     return asyncRetry(() => tryAcquireProcessorLock(execute, options), {
       retries: policy.retries - 1,
@@ -1085,90 +1159,6 @@ var releaseProcessorLock = async (execute, options) => {
   return result;
 };
 
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-
-
-// src/eventStore/schema/projections/projectionsLocks.ts
-
-var tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL(
-  "emt_try_acquire_projection_lock",
-  _dumbo.SQL`
-CREATE OR REPLACE FUNCTION emt_try_acquire_projection_lock(
-    p_lock_key   BIGINT,
-    p_partition  TEXT,
-    p_name       TEXT,
-    p_version    INT
-)
-RETURNS TABLE (acquired BOOLEAN, is_active BOOLEAN)
-LANGUAGE plpgsql
-AS $emt_try_acquire_projection_lock$
-BEGIN
-    RETURN QUERY
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock_shared(p_lock_key) AS acquired
-    ),
-    status_check AS (
-        SELECT status = 'active' AS is_active
-        FROM ${_dumbo.SQL.plain(projectionsTable.name)}
-        WHERE partition = p_partition AND name = p_name AND version = p_version
-    )
-    SELECT
-        COALESCE((SELECT lc.acquired FROM lock_check lc), false),
-        COALESCE((SELECT sc.is_active FROM status_check sc), true);
-END;
-$emt_try_acquire_projection_lock$;
-`
-);
-var callTryAcquireProjectionLock = (params) => _dumbo.SQL`SELECT * FROM emt_try_acquire_projection_lock(${params.lockKey}, ${params.partition}, ${params.name}, ${params.version});`;
-
-// src/eventStore/projections/locks/tryAcquireProjectionLock.ts
-var tryAcquireProjectionLock = async (execute, {
-  lockKey,
-  projectionName,
-  partition,
-  version
-}) => {
-  const lockKeyBigInt = isBigint(lockKey) ? lockKey : await hashText(lockKey);
-  const { acquired, is_active } = await _dumbo.single.call(void 0, 
-    execute.query(
-      callTryAcquireProjectionLock({
-        lockKey: lockKeyBigInt.toString(),
-        partition,
-        name: projectionName,
-        version
-      })
-    )
-  );
-  return acquired === true && is_active === true;
-};
-
-// src/eventStore/projections/locks/postgreSQLProjectionLock.ts
-var postgreSQLProjectionLock = (options) => {
-  let acquired = false;
-  const lockKey = _nullishCoalesce(options.lockKey, () => ( toProjectionLockKey(options)));
-  return {
-    tryAcquire: async (context) => {
-      if (acquired) {
-        return true;
-      }
-      acquired = await tryAcquireProjectionLock(context.execute, {
-        ...options,
-        lockKey
-      });
-      return acquired;
-    },
-    release: (_context) => {
-      if (!acquired) return;
-      acquired = false;
-    }
-  };
-};
-var toProjectionLockKey = ({
-  projectionName,
-  partition,
-  version
-}) => `${partition}:${projectionName}:${version}`;
-
 // src/eventStore/projections/locks/postgreSQLProcessorLock.ts
 var DefaultPostgreSQLProcessorLockPolicy = {
   type: "fail"
@@ -1185,7 +1175,7 @@ var postgreSQLProcessorLock = (options) => {
         ...options,
         lockKey
       });
-      if (!result.acquired && _optionalChain([options, 'access', _45 => _45.lockPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
+      if (!result.acquired && _optionalChain([options, 'access', _45 => _45.lockAcquisitionPolicy, 'optionalAccess', _46 => _46.type]) !== "skip") {
         throw new EmmettError(
           `Failed to acquire lock for processor '${options.processorId}'`
         );
@@ -1932,7 +1922,7 @@ var appendEventsRaw = (execute, streamId, streamType, messages, options) => _dum
       streamId,
       streamType,
       expectedStreamPosition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _50 => _50.expectedStreamVersion]), () => ( null)),
-      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.partition]), () => ( defaultTag))
+      partition: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.partition]), () => ( defaultTag2))
     })
   )
 );
@@ -2427,7 +2417,7 @@ BEGIN
         END;
         $fnpar$ LANGUAGE plpgsql;
 
-        PERFORM emt_add_partition('${_dumbo.SQL.plain(defaultTag)}');
+        PERFORM emt_add_partition('${_dumbo.SQL.plain(defaultTag2)}');
 
         -- 3. Copy data from old table to new table
         INSERT INTO "emt_processors"
@@ -2543,7 +2533,7 @@ BEGIN
           p_position               TEXT,
           p_check_position         TEXT,
           p_transaction_id         xid8,
-          p_partition              TEXT DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+          p_partition              TEXT DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
           p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
         ) RETURNS INT AS $fn2$
         DECLARE
@@ -2678,7 +2668,7 @@ CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
     p_lock_key               BIGINT,
     p_processor_id           TEXT,
     p_version                INT,
-    p_partition              TEXT       DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+    p_partition              TEXT       DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
     p_processor_instance_id  TEXT       DEFAULT 'emt:unknown',
     p_projection_name        TEXT       DEFAULT NULL,
     p_projection_type        VARCHAR(1) DEFAULT NULL,
@@ -3457,8 +3447,8 @@ CREATE OR REPLACE FUNCTION store_processor_checkpoint(
   p_position               TEXT,
   p_check_position         TEXT,
   p_transaction_id         xid8,
-  p_partition              TEXT DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
-  p_processor_instance_id  TEXT DEFAULT '${_dumbo.SQL.plain(unknownTag)}'
+  p_partition              TEXT DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
+  p_processor_instance_id  TEXT DEFAULT '${_dumbo.SQL.plain(unknownTag2)}'
 ) RETURNS INT AS $spc$
 DECLARE
   current_position TEXT;
@@ -3539,10 +3529,10 @@ var storeProcessorCheckpoint = async (execute, options) => {
         callStoreProcessorCheckpoint({
           processorId: options.processorId,
           version: _nullishCoalesce(options.version, () => ( 1)),
-          position: options.newCheckpoint !== null ? bigInt.toNormalizedString(options.newCheckpoint) : null,
-          checkPosition: options.lastProcessedCheckpoint !== null ? bigInt.toNormalizedString(options.lastProcessedCheckpoint) : null,
-          partition: _nullishCoalesce(options.partition, () => ( defaultTag)),
-          processorInstanceId: _nullishCoalesce(options.processorInstanceId, () => ( unknownTag))
+          position: options.newCheckpoint !== null ? options.newCheckpoint : null,
+          checkPosition: options.lastProcessedCheckpoint !== null ? options.lastProcessedCheckpoint : null,
+          partition: _nullishCoalesce(options.partition, () => ( defaultTag2)),
+          processorInstanceId: _nullishCoalesce(options.processorInstanceId, () => ( unknownTag2))
         })
       )
     );
@@ -3602,7 +3592,7 @@ IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_subscriptions') THEN
       p_position               TEXT,
       p_check_position         TEXT,
       p_transaction_id         xid8,
-      p_partition              TEXT DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+      p_partition              TEXT DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
       p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
     ) RETURNS INT AS $fn$
     DECLARE
@@ -3679,7 +3669,7 @@ var streamsTableSQL = _dumbo.SQL`
   CREATE TABLE IF NOT EXISTS ${_dumbo.SQL.identifier(streamsTable.name)}(
       stream_id         TEXT                      NOT NULL,
       stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+      partition         TEXT                      NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
@@ -3700,7 +3690,7 @@ var messagesTableSQL = _dumbo.SQL`
       is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
       message_kind           VARCHAR(1)                NOT NULL DEFAULT 'E',
       stream_id              TEXT                      NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+      partition              TEXT                      NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
       message_schema_version TEXT                      NOT NULL,
       message_id             TEXT                      NOT NULL,
       message_type           TEXT                      NOT NULL,
@@ -3713,10 +3703,10 @@ var processorsTableSQL = _dumbo.SQL`
       last_processed_transaction_id XID8                   NOT NULL,
       version                       INT                    NOT NULL DEFAULT 1,
       processor_id                  TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+      partition                     TEXT                   NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
       status                        TEXT                   NOT NULL DEFAULT 'stopped',
       last_processed_checkpoint     TEXT                   NOT NULL,
-      processor_instance_id         TEXT                   DEFAULT '${_dumbo.SQL.plain(unknownTag)}',
+      processor_instance_id         TEXT                   DEFAULT '${_dumbo.SQL.plain(unknownTag2)}',
       created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
       last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
       PRIMARY KEY (processor_id, partition, version)
@@ -3727,7 +3717,7 @@ var projectionsTableSQL = _dumbo.SQL`
       version                       INT                    NOT NULL DEFAULT 1,
       type                          VARCHAR(1)             NOT NULL,
       name                          TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag)}',
+      partition                     TEXT                   NOT NULL DEFAULT '${_dumbo.SQL.plain(defaultTag2)}',
       kind                          TEXT                   NOT NULL,
       status                        TEXT                   NOT NULL,
       definition                    JSONB                  NOT NULL DEFAULT '{}'::jsonb,
@@ -3985,7 +3975,7 @@ var addTenantForAllModulesSQL = _dumbo.SQL`
     END;
     $$ LANGUAGE plpgsql;
   `;
-var addDefaultPartitionSQL = _dumbo.SQL`SELECT emt_add_partition('${_dumbo.SQL.plain(defaultTag)}');`;
+var addDefaultPartitionSQL = _dumbo.SQL`SELECT emt_add_partition('${_dumbo.SQL.plain(defaultTag2)}');`;
 
 // src/eventStore/schema/readProcessorCheckpoint.ts
 
@@ -3994,12 +3984,12 @@ 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', _52 => _52.partition]), () => ( defaultTag))} AND processor_id = ${options.processorId} AND version = ${_nullishCoalesce(options.version, () => ( 1))}
+           WHERE partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.partition]), () => ( defaultTag2))} AND processor_id = ${options.processorId} AND version = ${_nullishCoalesce(options.version, () => ( 1))}
            LIMIT 1`
     )
   );
   return {
-    lastProcessedCheckpoint: result !== null ? BigInt(result.last_processed_checkpoint) : null
+    lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null
   };
 };
 
@@ -4015,7 +4005,7 @@ var readStream = async (execute, streamId, options) => {
     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', _56 => _56.partition]), () => ( defaultTag))} AND is_archived = FALSE ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
+           WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _56 => _56.partition]), () => ( defaultTag2))} AND is_archived = FALSE ${_dumbo.SQL.plain(fromCondition)} ${_dumbo.SQL.plain(toCondition)}
            ORDER BY stream_position ASC`
     ),
     (row) => {
@@ -4029,7 +4019,8 @@ var readStream = async (execute, streamId, options) => {
         messageId: row.message_id,
         streamName: streamId,
         streamPosition: BigInt(row.stream_position),
-        globalPosition: BigInt(row.global_position)
+        globalPosition: BigInt(row.global_position),
+        checkpoint: bigIntProcessorCheckpoint(BigInt(row.global_position))
       };
       const event = {
         ...rawEvent,
@@ -4057,7 +4048,7 @@ 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', _59 => _59.partition]), () => ( defaultTag))} AND is_archived = FALSE)
+        WHERE stream_id = ${streamId} AND partition = ${_nullishCoalesce(_optionalChain([options, 'optionalAccess', _59 => _59.partition]), () => ( defaultTag2))} AND is_archived = FALSE)
       `
   );
   return _nullishCoalesce(_optionalChain([queryResult, 'access', _60 => _60.rows, 'access', _61 => _61[0], 'optionalAccess', _62 => _62.exists]), () => ( false));
@@ -4259,7 +4250,7 @@ var getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOpti
     appendToStream: async (streamName, events, options2) => {
       await ensureSchemaExists();
       const [firstPart, ...rest] = streamName.split("-");
-      const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag;
+      const streamType = firstPart && rest.length > 0 ? firstPart : unknownTag2;
       const appendResult = await appendToStream(
         // TODO: Fix this when introducing more drivers
         pool,
@@ -4361,7 +4352,8 @@ var PostgreSQLProjectionSpec = {
                 ...Array.from({ length: numberOfTimes }).flatMap(() => events)
               ]) {
                 const metadata = {
-                  globalPosition: ++globalPosition,
+                  checkpoint: bigIntProcessorCheckpoint(++globalPosition),
+                  globalPosition,
                   streamPosition: globalPosition,
                   streamName: `test-${_uuid.v4.call(void 0, )}`,
                   messageId: _uuid.v4.call(void 0, )
@@ -4478,7 +4470,7 @@ var handleProjections = async (options) => {
     projections: allProjections,
     events,
     connection: { pool, transaction, connectionString },
-    partition = defaultTag
+    partition = defaultTag2
   } = options;
   const eventTypes = events.map((e) => e.type);
   const projections = allProjections.filter(
@@ -4512,7 +4504,7 @@ var postgreSQLProjection = (definition) => projection({
   init: async (options) => {
     await registerProjection(options.context.execute, {
       // TODO: pass partition from options
-      partition: defaultTag,
+      partition: defaultTag2,
       status: "active",
       registration: {
         type: "async",
@@ -4574,10 +4566,10 @@ var postgreSQLCheckpointer = () => ({
     return { lastCheckpoint: _optionalChain([result, 'optionalAccess', _89 => _89.lastProcessedCheckpoint]) };
   },
   store: async (options, context) => {
-    const newPosition = getCheckpoint(options.message);
+    const newCheckpoint = getCheckpoint(options.message);
     const result = await storeProcessorCheckpoint(context.execute, {
       lastProcessedCheckpoint: options.lastCheckpoint,
-      newCheckpoint: newPosition,
+      newCheckpoint,
       processorId: options.processorId,
       partition: options.partition,
       version: options.version
@@ -4651,8 +4643,7 @@ var postgreSQLProjector = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy,
-    lockTimeoutSeconds
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4661,18 +4652,18 @@ var postgreSQLProjector = (options) => {
     partition,
     processorInstanceId,
     projection: options.projection ? {
-      name: _nullishCoalesce(options.projection.name, () => ( unknownTag2)),
-      kind: _nullishCoalesce(options.projection.kind, () => ( unknownTag2)),
+      name: _nullishCoalesce(options.projection.name, () => ( unknownTag)),
+      kind: _nullishCoalesce(options.projection.kind, () => ( unknownTag)),
       version: _nullishCoalesce(options.projection.version, () => ( version)),
       handlingType: "async"
     } : void 0,
-    lockPolicy,
-    lockTimeoutSeconds
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _96 => _96.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _97 => _97.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
-      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _96 => _96.hooks, 'optionalAccess', _97 => _97.onInit]) ? async (context) => {
+      onInit: options.projection.init !== void 0 || _optionalChain([options, 'access', _98 => _98.hooks, 'optionalAccess', _99 => _99.onInit]) ? async (context) => {
         if (options.projection.init)
           await options.projection.init({
             version: _nullishCoalesce(options.projection.version, () => ( version)),
@@ -4683,16 +4674,16 @@ var postgreSQLProjector = (options) => {
               migrationOptions: options.migrationOptions
             }
           });
-        if (_optionalChain([options, 'access', _98 => _98.hooks, 'optionalAccess', _99 => _99.onInit]))
+        if (_optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.onInit]))
           await options.hooks.onInit({
             ...context,
             migrationOptions: options.migrationOptions
           });
-      } : _optionalChain([options, 'access', _100 => _100.hooks, 'optionalAccess', _101 => _101.onInit]),
+      } : _optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onInit]),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _102 => _102.hooks, 'optionalAccess', _103 => _103.onClose])) await _optionalChain([options, 'access', _104 => _104.hooks, 'optionalAccess', _105 => _105.onClose, 'call', _106 => _106(context)]);
+        if (_optionalChain([options, 'access', _104 => _104.hooks, 'optionalAccess', _105 => _105.onClose])) await _optionalChain([options, 'access', _106 => _106.hooks, 'optionalAccess', _107 => _107.onClose, 'call', _108 => _108(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _107 => _107.hooks, 'optionalAccess', _108 => _108.onClose])
+      } : _optionalChain([options, 'access', _109 => _109.hooks, 'optionalAccess', _110 => _110.onClose])
     },
     processorLock
   );
@@ -4719,7 +4710,7 @@ var postgreSQLReactor = (options) => {
     processorInstanceId = getProcessorInstanceId(processorId),
     version = defaultProcessorVersion,
     partition = defaultProcessorPartition,
-    lockPolicy = DefaultPostgreSQLProcessorLockPolicy
+    lock
   } = options;
   const { pool, connectionString, close } = getProcessorPool(options);
   const processorLock = postgreSQLProcessorLock({
@@ -4728,15 +4719,16 @@ var postgreSQLReactor = (options) => {
     partition,
     processorInstanceId,
     projection: void 0,
-    lockPolicy
+    lockAcquisitionPolicy: _nullishCoalesce(_optionalChain([lock, 'optionalAccess', _111 => _111.acquisitionPolicy]), () => ( DefaultPostgreSQLProcessorLockPolicy)),
+    lockTimeoutSeconds: _optionalChain([lock, 'optionalAccess', _112 => _112.timeoutSeconds])
   });
   const hooks = wrapHooksWithProcessorLocks(
     {
       ..._nullishCoalesce(options.hooks, () => ( {})),
       onClose: close ? async (context) => {
-        if (_optionalChain([options, 'access', _109 => _109.hooks, 'optionalAccess', _110 => _110.onClose])) await _optionalChain([options, 'access', _111 => _111.hooks, 'optionalAccess', _112 => _112.onClose, 'call', _113 => _113(context)]);
+        if (_optionalChain([options, 'access', _113 => _113.hooks, 'optionalAccess', _114 => _114.onClose])) await _optionalChain([options, 'access', _115 => _115.hooks, 'optionalAccess', _116 => _116.onClose, 'call', _117 => _117(context)]);
         if (close) await close();
-      } : _optionalChain([options, 'access', _114 => _114.hooks, 'optionalAccess', _115 => _115.onClose])
+      } : _optionalChain([options, 'access', _118 => _118.hooks, 'optionalAccess', _119 => _119.onClose])
     },
     processorLock
   );
@@ -4756,14 +4748,6 @@ var postgreSQLReactor = (options) => {
     checkpoints: postgreSQLCheckpointer()
   });
 };
-var postgreSQLMessageProcessor = (options) => {
-  if ("projection" in options) {
-    return postgreSQLProjector(
-      options
-    );
-  }
-  return postgreSQLReactor(options);
-};
 
 // src/eventStore/consumers/postgreSQLEventStoreConsumer.ts
 var postgreSQLEventStoreConsumer = (options) => {
@@ -4793,7 +4777,7 @@ var postgreSQLEventStoreConsumer = (options) => {
       })
     );
     return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _116 => _116.value, 'optionalAccess', _117 => _117.type]) !== "STOP"
+      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _120 => _120.value, 'optionalAccess', _121 => _121.type]) !== "STOP"
     ) ? void 0 : {
       type: "STOP"
     };
@@ -4812,7 +4796,7 @@ var postgreSQLEventStoreConsumer = (options) => {
     if (!isRunning) return;
     isRunning = false;
     if (messagePuller) {
-      _optionalChain([abortController, 'optionalAccess', _118 => _118.abort, 'call', _119 => _119()]);
+      _optionalChain([abortController, 'optionalAccess', _122 => _122.abort, 'call', _123 => _123()]);
       await messagePuller.stop();
       messagePuller = void 0;
       abortController = null;
@@ -4865,8 +4849,8 @@ var postgreSQLEventStoreConsumer = (options) => {
         stopWhen: options.stopWhen,
         executor: pool.execute,
         eachBatch,
-        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _120 => _120.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
-        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _121 => _121.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
+        batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _124 => _124.batchSize]), () => ( DefaultPostgreSQLEventStoreProcessorBatchSize)),
+        pullingFrequencyInMs: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _125 => _125.pullingFrequencyInMs]), () => ( DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs)),
         signal: abortController.signal
       });
       start = (async () => {
@@ -4914,27 +4898,27 @@ var rebuildPostgreSQLProjections = (options) => {
     ...options,
     stopWhen: { noMessagesLeft: true }
   });
+  const lock = { acquisitionPolicy: defaultRebuildLockPolicy, ...options.lock };
   const projections = "projections" in options ? options.projections.map(
     (p) => "projection" in p ? {
-      lockPolicy: defaultRebuildLockPolicy,
       truncateOnStart: true,
       processorId: getProjectorId({
-        projectionName: _nullishCoalesce(p.projection.name, () => ( unknownTag2))
+        projectionName: _nullishCoalesce(p.projection.name, () => ( unknownTag))
       }),
       ...p
     } : {
       projection: p,
       processorId: getProjectorId({
-        projectionName: _nullishCoalesce(p.name, () => ( unknownTag2))
+        projectionName: _nullishCoalesce(p.name, () => ( unknownTag))
       }),
-      truncateOnStart: true,
-      lockPolicy: defaultRebuildLockPolicy
+      truncateOnStart: true
     }
   ) : [options];
   for (const projectionDefinition of projections) {
     consumer.projector({
       ...projectionDefinition,
-      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true))
+      truncateOnStart: _nullishCoalesce(projectionDefinition.truncateOnStart, () => ( true)),
+      lock
     });
   }
   return consumer;
@@ -5030,6 +5014,5 @@ var rebuildPostgreSQLProjections = (options) => {
 
 
 
-
-exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize; exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs; exports.DefaultPostgreSQLProcessorLockPolicy = DefaultPostgreSQLProcessorLockPolicy; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.activateProjection = activateProjection; exports.activateProjectionSQL = activateProjectionSQL; exports.addDefaultPartitionSQL = addDefaultPartitionSQL; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addPartitionSQL = addPartitionSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendToStream = appendToStream; exports.appendToStreamSQL = appendToStreamSQL; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.callActivateProjection = callActivateProjection; exports.callAppendToStream = callAppendToStream; exports.callDeactivateProjection = callDeactivateProjection; exports.callRegisterProjection = callRegisterProjection; exports.callReleaseProcessorLock = callReleaseProcessorLock; exports.callStoreProcessorCheckpoint = callStoreProcessorCheckpoint; exports.callTryAcquireProcessorLock = callTryAcquireProcessorLock; exports.callTryAcquireProjectionLock = callTryAcquireProjectionLock; exports.cleanupLegacySubscriptionTables = cleanupLegacySubscriptionTables; exports.createEventStoreSchema = createEventStoreSchema; exports.deactivateProjection = deactivateProjection; exports.deactivateProjectionSQL = deactivateProjectionSQL; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; exports.defaultTag = defaultTag; exports.documentDoesNotExist = documentDoesNotExist; exports.documentExists = documentExists; exports.documentMatchingExists = documentMatchingExists; exports.documentsAreTheSame = documentsAreTheSame; exports.documentsMatchingHaveCount = documentsMatchingHaveCount; exports.emmettPrefix = emmettPrefix; exports.eventInStream = eventInStream; exports.eventStoreSchemaMigrations = eventStoreSchemaMigrations; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLCheckpointer = postgreSQLCheckpointer; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLMessageProcessor = postgreSQLMessageProcessor; exports.postgreSQLProcessorLock = postgreSQLProcessorLock; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLProjectionLock = postgreSQLProjectionLock; exports.postgreSQLProjector = postgreSQLProjector; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.postgreSQLReactor = postgreSQLReactor; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readProjectionInfo = readProjectionInfo; exports.readStream = readStream; exports.rebuildPostgreSQLProjections = rebuildPostgreSQLProjections; exports.registerProjection = registerProjection; exports.registerProjectionSQL = registerProjectionSQL; exports.releaseProcessorLockSQL = releaseProcessorLockSQL; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaMigration = schemaMigration; exports.schemaSQL = schemaSQL; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.storeSubscriptionCheckpointSQL = storeSubscriptionCheckpointSQL; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.toProcessorLockKey = toProcessorLockKey; exports.toProjectionLockKey = toProjectionLockKey; exports.transactionToPostgreSQLProjectionHandlerContext = transactionToPostgreSQLProjectionHandlerContext; exports.tryAcquireProcessorLockSQL = tryAcquireProcessorLockSQL; exports.tryAcquireProjectionLockSQL = tryAcquireProjectionLockSQL; exports.unknownTag = unknownTag; exports.zipPostgreSQLEventStoreMessageBatchPullerStartFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom;
+exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize; exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs; exports.DefaultPostgreSQLProcessorLockPolicy = DefaultPostgreSQLProcessorLockPolicy; exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion; exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec; exports.activateProjection = activateProjection; exports.activateProjectionSQL = activateProjectionSQL; exports.addDefaultPartitionSQL = addDefaultPartitionSQL; exports.addModuleForAllTenantsSQL = addModuleForAllTenantsSQL; exports.addModuleSQL = addModuleSQL; exports.addPartitionSQL = addPartitionSQL; exports.addTablePartitions = addTablePartitions; exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL; exports.addTenantSQL = addTenantSQL; exports.appendToStream = appendToStream; exports.appendToStreamSQL = appendToStreamSQL; exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches; exports.callActivateProjection = callActivateProjection; exports.callAppendToStream = callAppendToStream; exports.callDeactivateProjection = callDeactivateProjection; exports.callRegisterProjection = callRegisterProjection; exports.callReleaseProcessorLock = callReleaseProcessorLock; exports.callStoreProcessorCheckpoint = callStoreProcessorCheckpoint; exports.callTryAcquireProcessorLock = callTryAcquireProcessorLock; exports.callTryAcquireProjectionLock = callTryAcquireProjectionLock; exports.cleanupLegacySubscriptionTables = cleanupLegacySubscriptionTables; exports.createEventStoreSchema = createEventStoreSchema; exports.deactivateProjection = deactivateProjection; exports.deactivateProjectionSQL = deactivateProjectionSQL; exports.defaultPostgreSQLOptions = defaultPostgreSQLOptions; 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.eventStoreSchemaMigrations = eventStoreSchemaMigrations; exports.eventsInStream = eventsInStream; exports.expectPongoDocuments = expectPongoDocuments; exports.expectSQL = expectSQL; exports.getPostgreSQLEventStore = getPostgreSQLEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.handleProjections = handleProjections; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.newEventsInStream = newEventsInStream; exports.pongoMultiStreamProjection = pongoMultiStreamProjection; exports.pongoProjection = pongoProjection; exports.pongoSingleStreamProjection = pongoSingleStreamProjection; exports.postgreSQLCheckpointer = postgreSQLCheckpointer; exports.postgreSQLEventStoreConsumer = postgreSQLEventStoreConsumer; exports.postgreSQLEventStoreMessageBatchPuller = postgreSQLEventStoreMessageBatchPuller; exports.postgreSQLProcessorLock = postgreSQLProcessorLock; exports.postgreSQLProjection = postgreSQLProjection; exports.postgreSQLProjectionLock = postgreSQLProjectionLock; exports.postgreSQLProjector = postgreSQLProjector; exports.postgreSQLRawBatchSQLProjection = postgreSQLRawBatchSQLProjection; exports.postgreSQLRawSQLProjection = postgreSQLRawSQLProjection; exports.postgreSQLReactor = postgreSQLReactor; exports.processorsTable = processorsTable; exports.processorsTableSQL = processorsTableSQL; exports.projectionsTable = projectionsTable; exports.projectionsTableSQL = projectionsTableSQL; exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition; exports.readMessagesBatch = readMessagesBatch; exports.readProcessorCheckpoint = readProcessorCheckpoint; exports.readProjectionInfo = readProjectionInfo; exports.readStream = readStream; exports.rebuildPostgreSQLProjections = rebuildPostgreSQLProjections; exports.registerProjection = registerProjection; exports.registerProjectionSQL = registerProjectionSQL; exports.releaseProcessorLockSQL = releaseProcessorLockSQL; exports.sanitizeNameSQL = sanitizeNameSQL; exports.schemaMigration = schemaMigration; exports.schemaSQL = schemaSQL; exports.storeProcessorCheckpoint = storeProcessorCheckpoint; exports.storeSubscriptionCheckpointSQL = storeSubscriptionCheckpointSQL; exports.streamExists = streamExists; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL; exports.toProcessorLockKey = toProcessorLockKey; exports.toProjectionLockKey = toProjectionLockKey; exports.transactionToPostgreSQLProjectionHandlerContext = transactionToPostgreSQLProjectionHandlerContext; exports.tryAcquireProcessorLockSQL = tryAcquireProcessorLockSQL; exports.tryAcquireProjectionLockSQL = tryAcquireProjectionLockSQL; exports.unknownTag = unknownTag2; exports.zipPostgreSQLEventStoreMessageBatchPullerStartFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom;
 //# sourceMappingURL=index.cjs.map