@event-driven-io/emmett-postgresql 0.43.0-beta.17 → 0.43.0-beta.19

package/dist/index.cjs

@@ -1,10 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let _event_driven_io_emmett = require("@event-driven-io/emmett");
 let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
-let uuid = require("uuid");
 let _event_driven_io_pongo = require("@event-driven-io/pongo");
 let _event_driven_io_pongo_pg = require("@event-driven-io/pongo/pg");
+let uuid = require("uuid");
+
+//#region src/eventStore/schema/createFunctionIfDoesNotExist.ts
+const createFunctionIfDoesNotExistSQL = (functionName, functionDefinition) => _event_driven_io_dumbo.SQL`
+DO $$
+BEGIN
+IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = '${_event_driven_io_dumbo.SQL.plain(functionName)}') THEN
+  ${functionDefinition}
+END IF;
+END $$;
+`;
 
+//#endregion
 //#region src/eventStore/schema/typing.ts
 const emmettPrefix = "emt";
 const globalTag = "global";
@@ -35,145 +46,6 @@ const messagesTable = {
 const processorsTable = { name: `${"emt"}_processors` };
 const projectionsTable = { name: `${"emt"}_projections` };
 
-//#endregion
-//#region src/eventStore/schema/readLastMessageGlobalPosition.ts
-const readLastMessageGlobalPosition = async (execute, options) => {
-	const result = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`SELECT global_position
-           FROM ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
-           ORDER BY transaction_id DESC, global_position DESC
-           LIMIT 1`));
-	return { currentGlobalPosition: result !== null ? BigInt(result.global_position) : null };
-};
-
-//#endregion
-//#region src/eventStore/schema/readMessagesBatch.ts
-const 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 ? _event_driven_io_dumbo.SQL`AND global_position >= ${from}` : after !== void 0 ? _event_driven_io_dumbo.SQL`AND global_position > ${after}` : _event_driven_io_dumbo.SQL.EMPTY;
-	const toCondition = "to" in options ? _event_driven_io_dumbo.SQL`AND global_position <= ${options.to}` : _event_driven_io_dumbo.SQL.EMPTY;
-	const limitCondition = "batchSize" in options ? _event_driven_io_dumbo.SQL`LIMIT ${options.batchSize}` : _event_driven_io_dumbo.SQL.EMPTY;
-	const messages = await (0, _event_driven_io_dumbo.mapRows)(execute.query(_event_driven_io_dumbo.SQL`
-          SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
-           FROM ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}
-           WHERE partition = ${options?.partition ?? defaultTag} 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 ? rawEvent.metadata ?? {} : {},
-			messageId: row.message_id,
-			streamName: row.stream_id,
-			streamPosition: BigInt(row.stream_position),
-			globalPosition: BigInt(row.global_position),
-			checkpoint: (0, _event_driven_io_emmett.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
-	};
-};
-
-//#endregion
-//#region src/eventStore/consumers/messageBatchProcessing/index.ts
-const DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
-const DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
-const postgreSQLEventStoreMessageBatchPuller = ({ executor, batchSize, eachBatch, pullingFrequencyInMs, stopWhen, signal }) => {
-	let isRunning = false;
-	let start;
-	const pullMessages = async (options) => {
-		try {
-			let after;
-			try {
-				after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : (0, _event_driven_io_emmett.parseBigIntProcessorCheckpoint)(options.startFrom.lastCheckpoint);
-			} catch (error) {
-				console.log("Error occurred during reading last processor checkpoint:", error);
-				options.started?.reject(error);
-				throw error;
-			}
-			options.started?.resolve();
-			const readMessagesOptions = {
-				after,
-				batchSize
-			};
-			let waitTime = 100;
-			while (isRunning && !signal?.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 (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
-					console.log(`No messages left to process after reaching global position ${currentGlobalPosition}. Stopping the puller.`);
-					isRunning = false;
-					break;
-				}
-				if (!areMessagesLeft) waitTime = Math.min(waitTime * 2, 1e3);
-				else waitTime = pullingFrequencyInMs;
-			}
-		} catch (error) {
-			console.log("Error occurred during message pulling:", error);
-			throw error;
-		}
-	};
-	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;
-		}
-	};
-};
-const 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];
-};
-
-//#endregion
-//#region src/eventStore/schema/createFunctionIfDoesNotExist.ts
-const createFunctionIfDoesNotExistSQL = (functionName, functionDefinition) => _event_driven_io_dumbo.SQL`
-DO $$
-BEGIN
-IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = '${_event_driven_io_dumbo.SQL.plain(functionName)}') THEN
-  ${functionDefinition}
-END IF;
-END $$;
-`;
-
 //#endregion
 //#region src/eventStore/schema/projections/projectionsLocks.ts
 const tryAcquireProjectionLockSQL = createFunctionIfDoesNotExistSQL("emt_try_acquire_projection_lock", _event_driven_io_dumbo.SQL`
@@ -865,127 +737,280 @@ const expectPongoDocuments = { fromCollection: (collectionName) => {
 } };
 
 //#endregion
-//#region src/eventStore/projections/postgresProjectionSpec.ts
-const PostgreSQLProjectionSpec = { for: (options) => {
-	{
-		const { projection, ...restOptions } = options;
-		const dumboOptions = {
-			...restOptions,
-			serialization: projection.serialization
-		};
-		const { connectionString } = dumboOptions;
-		let wasInitialised = false;
-		const initialize = async (pool) => {
-			const eventStore = getPostgreSQLEventStore(connectionString, { connectionOptions: { dumbo: pool } });
-			if (wasInitialised) return;
-			wasInitialised = true;
-			await eventStore.schema.migrate();
-			if (projection.init) await pool.withTransaction(async (transaction) => {
-				await projection.init({
-					registrationType: "async",
-					version: projection.version ?? 1,
-					status: "active",
-					context: await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction)
-				});
-			});
-		};
-		return (givenEvents) => {
-			return { when: (events, options) => {
-				const allEvents = [];
-				const run = async (pool) => {
-					let globalPosition = 0n;
-					const numberOfTimes = options?.numberOfTimes ?? 1;
-					for (const event of [...givenEvents, ...Array.from({ length: numberOfTimes }).flatMap(() => events)]) {
-						const metadata = {
-							checkpoint: (0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(++globalPosition),
-							globalPosition,
-							streamPosition: globalPosition,
-							streamName: `test-${(0, uuid.v4)()}`,
-							messageId: (0, uuid.v4)()
-						};
-						allEvents.push({
-							...event,
-							kind: "Event",
-							metadata: {
-								...metadata,
-								..."metadata" in event ? event.metadata ?? {} : {}
-							}
-						});
-					}
-					await initialize(pool);
-					await pool.withTransaction(async (transaction) => {
-						await handleProjections({
-							events: allEvents,
-							projections: [projection],
-							...await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction)
-						});
-					});
-				};
-				return {
-					then: async (assert, message) => {
-						const pool = (0, _event_driven_io_dumbo.dumbo)(dumboOptions);
-						try {
-							await run(pool);
-							const succeeded = await assert({
-								pool,
-								connectionString
-							});
-							if (succeeded !== void 0 && succeeded === false) (0, _event_driven_io_emmett.assertFails)(message ?? "Projection specification didn't match the criteria");
-						} finally {
-							await pool.close();
-						}
-					},
-					thenThrows: async (...args) => {
-						const pool = (0, _event_driven_io_dumbo.dumbo)(dumboOptions);
-						try {
-							await run(pool);
-							throw new _event_driven_io_emmett.AssertionError("Handler did not fail as expected");
-						} catch (error) {
-							if (error instanceof _event_driven_io_emmett.AssertionError) throw error;
-							if (args.length === 0) return;
-							if (!(0, _event_driven_io_emmett.isErrorConstructor)(args[0])) {
-								(0, _event_driven_io_emmett.assertTrue)(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
-								return;
-							}
-							(0, _event_driven_io_emmett.assertTrue)(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
-							if (args[1]) (0, _event_driven_io_emmett.assertTrue)(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
-						} finally {
-							await pool.close();
-						}
-					}
-				};
-			} };
-		};
-	}
-} };
-const eventInStream = (streamName, event) => {
-	return {
-		...event,
-		metadata: {
-			...event.metadata ?? {},
-			streamName: event.metadata?.streamName ?? streamName
-		}
-	};
-};
-const eventsInStream = (streamName, events) => {
-	return events.map((e) => eventInStream(streamName, e));
-};
-const newEventsInStream = eventsInStream;
-const assertSQLQueryResultMatches = (sql, rows) => async ({ pool: { execute } }) => {
-	const result = await execute.query(sql);
-	(0, _event_driven_io_emmett.assertThatArray)(rows).containsExactlyInAnyOrder(result.rows);
+//#region src/eventStore/schema/truncateTables.ts
+const truncateTables = async (execute, options) => {
+	await execute.command(_event_driven_io_dumbo.SQL`TRUNCATE TABLE 
+        ${_event_driven_io_dumbo.SQL.identifier(streamsTable.name)}, 
+        ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}, 
+        ${_event_driven_io_dumbo.SQL.identifier(processorsTable.name)}, 
+        ${_event_driven_io_dumbo.SQL.identifier(projectionsTable.name)} 
+        CASCADE${_event_driven_io_dumbo.SQL.plain(options?.resetSequences ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`);
 };
-const expectSQL = { query: (sql) => ({ resultRows: { toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows) } }) };
 
 //#endregion
-//#region src/eventStore/projections/postgreSQLProjection.ts
-const transactionToPostgreSQLProjectionHandlerContext = async (connectionString, pool, transaction) => ({
-	execute: transaction.execute,
-	connection: {
-		connectionString,
-		client: await transaction.connection.open(),
-		transaction,
-		pool
+//#region src/eventStore/postgreSQLEventStore.ts
+const defaultPostgreSQLOptions = {
+	projections: [],
+	schema: { autoMigration: "CreateOrUpdate" }
+};
+const PostgreSQLEventStoreDefaultStreamVersion = 0n;
+const getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
+	const poolOptions = {
+		connectionString,
+		...options.connectionOptions ? options.connectionOptions : {}
+	};
+	const pool = "dumbo" in poolOptions ? poolOptions.dumbo : (0, _event_driven_io_dumbo.dumbo)({
+		...poolOptions,
+		serialization: options.serialization
+	});
+	let migrateSchema = void 0;
+	const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
+	const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection }) => projection);
+	const migrate = async (migrationOptions) => {
+		if (!migrateSchema) {
+			migrateSchema = createEventStoreSchema(connectionString, pool, {
+				onBeforeSchemaCreated: async (context) => {
+					if (options.hooks?.onBeforeSchemaCreated) await options.hooks.onBeforeSchemaCreated(context);
+				},
+				onAfterSchemaCreated: async (context) => {
+					for (const projection of inlineProjections) if (projection.init) await projection.init({
+						version: projection.version ?? 1,
+						status: "active",
+						registrationType: "inline",
+						context: {
+							...context,
+							migrationOptions
+						}
+					});
+					if (options.hooks?.onAfterSchemaCreated) await options.hooks.onAfterSchemaCreated(context);
+				}
+			}, migrationOptions);
+			return migrateSchema;
+		}
+		const result = await migrateSchema;
+		if (migrationOptions?.dryRun) migrateSchema = void 0;
+		return {
+			applied: [],
+			skipped: result.applied.concat(result.skipped)
+		};
+	};
+	const ensureSchemaExists = () => {
+		if (!autoGenerateSchema) return Promise.resolve();
+		return migrate();
+	};
+	const beforeCommitHook = inlineProjections.length > 0 ? async (events, { transaction }) => handleProjections({
+		projections: inlineProjections,
+		events,
+		...await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction)
+	}) : void 0;
+	return {
+		schema: {
+			sql: () => _event_driven_io_dumbo.SQL.describe(schemaSQL, (0, _event_driven_io_dumbo.getFormatter)((0, _event_driven_io_dumbo.fromDatabaseDriverType)(pool.driverType).databaseType)),
+			print: () => console.log(_event_driven_io_dumbo.SQL.describe(schemaSQL, (0, _event_driven_io_dumbo.getFormatter)((0, _event_driven_io_dumbo.fromDatabaseDriverType)(pool.driverType).databaseType))),
+			migrate,
+			dangerous: { truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
+				await ensureSchemaExists();
+				await truncateTables(transaction.execute, truncateOptions);
+				if (truncateOptions?.truncateProjections) {
+					const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction);
+					for (const projection of options?.projections ?? []) if (projection.projection.truncate) await projection.projection.truncate(projectionContext);
+				}
+			}) }
+		},
+		async aggregateStream(streamName, options) {
+			const { evolve, initialState, read } = options;
+			const expectedStreamVersion = read?.expectedStreamVersion;
+			let state = initialState();
+			const result = await this.readStream(streamName, read);
+			const currentStreamVersion = result.currentStreamVersion;
+			(0, _event_driven_io_emmett.assertExpectedVersionMatchesCurrent)(currentStreamVersion, expectedStreamVersion, PostgreSQLEventStoreDefaultStreamVersion);
+			for (const event of result.events) {
+				if (!event) continue;
+				state = evolve(state, event);
+			}
+			return {
+				currentStreamVersion,
+				state,
+				streamExists: result.streamExists
+			};
+		},
+		readStream: async (streamName, readOptions) => {
+			await ensureSchemaExists();
+			return readStream(pool.execute, streamName, {
+				...readOptions,
+				serialization: options.serialization ?? readOptions?.serialization
+			});
+		},
+		appendToStream: async (streamName, events, appendOptions) => {
+			await ensureSchemaExists();
+			const [firstPart, ...rest] = streamName.split("-");
+			const streamType = firstPart && rest.length > 0 ? firstPart : _event_driven_io_emmett.unknownTag;
+			const appendResult = await pool.withConnection(async (connection) => appendToStream(connection, streamName, streamType, (0, _event_driven_io_emmett.downcastRecordedMessages)(events, appendOptions?.schema?.versioning), {
+				...appendOptions,
+				beforeCommitHook
+			}));
+			if (!appendResult.success) throw new _event_driven_io_emmett.ExpectedVersionConflictError(-1n, appendOptions?.expectedStreamVersion ?? _event_driven_io_emmett.NO_CONCURRENCY_CHECK);
+			return {
+				nextExpectedStreamVersion: appendResult.nextStreamPosition,
+				lastEventGlobalPosition: PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint(appendResult.checkpoints[appendResult.checkpoints.length - 1]),
+				createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
+			};
+		},
+		streamExists: async (streamName, options) => {
+			await ensureSchemaExists();
+			return streamExists(pool.execute, streamName, options);
+		},
+		consumer: (options) => postgreSQLEventStoreConsumer({
+			...options ?? {},
+			pool,
+			connectionString
+		}),
+		close: () => pool.close(),
+		async withSession(callback) {
+			return await pool.withConnection(async (connection) => {
+				const eventStore = getPostgreSQLEventStore(connectionString, {
+					...options,
+					connectionOptions: { connection },
+					schema: {
+						...options.schema ?? {},
+						autoMigration: "None"
+					}
+				});
+				return ensureSchemaExists().then(() => callback({
+					eventStore,
+					close: () => Promise.resolve()
+				}));
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/eventStore/projections/postgresProjectionSpec.ts
+const PostgreSQLProjectionSpec = { for: (options) => {
+	{
+		const { projection, ...restOptions } = options;
+		const dumboOptions = {
+			...restOptions,
+			serialization: projection.serialization
+		};
+		const { connectionString } = dumboOptions;
+		let wasInitialised = false;
+		const initialize = async (pool) => {
+			const eventStore = getPostgreSQLEventStore(connectionString, { connectionOptions: { dumbo: pool } });
+			if (wasInitialised) return;
+			wasInitialised = true;
+			await eventStore.schema.migrate();
+			if (projection.init) await pool.withTransaction(async (transaction) => {
+				await projection.init({
+					registrationType: "async",
+					version: projection.version ?? 1,
+					status: "active",
+					context: await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction)
+				});
+			});
+		};
+		return (givenEvents) => {
+			return { when: (events, options) => {
+				const allEvents = [];
+				const run = async (pool) => {
+					let globalPosition = 0n;
+					const numberOfTimes = options?.numberOfTimes ?? 1;
+					for (const event of [...givenEvents, ...Array.from({ length: numberOfTimes }).flatMap(() => events)]) {
+						const checkpoint = PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint({
+							transactionId: ++globalPosition,
+							globalPosition
+						});
+						const metadata = {
+							checkpoint,
+							globalPosition: checkpoint,
+							streamPosition: globalPosition,
+							streamName: `test-${(0, uuid.v4)()}`,
+							messageId: (0, uuid.v4)()
+						};
+						allEvents.push({
+							...event,
+							kind: "Event",
+							metadata: {
+								...metadata,
+								..."metadata" in event ? event.metadata ?? {} : {}
+							}
+						});
+					}
+					await initialize(pool);
+					await pool.withTransaction(async (transaction) => {
+						await handleProjections({
+							events: allEvents,
+							projections: [projection],
+							...await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction)
+						});
+					});
+				};
+				return {
+					then: async (assert, message) => {
+						const pool = (0, _event_driven_io_dumbo.dumbo)(dumboOptions);
+						try {
+							await run(pool);
+							const succeeded = await assert({
+								pool,
+								connectionString
+							});
+							if (succeeded !== void 0 && succeeded === false) (0, _event_driven_io_emmett.assertFails)(message ?? "Projection specification didn't match the criteria");
+						} finally {
+							await pool.close();
+						}
+					},
+					thenThrows: async (...args) => {
+						const pool = (0, _event_driven_io_dumbo.dumbo)(dumboOptions);
+						try {
+							await run(pool);
+							throw new _event_driven_io_emmett.AssertionError("Handler did not fail as expected");
+						} catch (error) {
+							if (error instanceof _event_driven_io_emmett.AssertionError) throw error;
+							if (args.length === 0) return;
+							if (!(0, _event_driven_io_emmett.isErrorConstructor)(args[0])) {
+								(0, _event_driven_io_emmett.assertTrue)(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+								return;
+							}
+							(0, _event_driven_io_emmett.assertTrue)(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+							if (args[1]) (0, _event_driven_io_emmett.assertTrue)(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
+						} finally {
+							await pool.close();
+						}
+					}
+				};
+			} };
+		};
+	}
+} };
+const eventInStream = (streamName, event) => {
+	return {
+		...event,
+		metadata: {
+			...event.metadata ?? {},
+			streamName: event.metadata?.streamName ?? streamName
+		}
+	};
+};
+const eventsInStream = (streamName, events) => {
+	return events.map((e) => eventInStream(streamName, e));
+};
+const newEventsInStream = eventsInStream;
+const assertSQLQueryResultMatches = (sql, rows) => async ({ pool: { execute } }) => {
+	const result = await execute.query(sql);
+	(0, _event_driven_io_emmett.assertThatArray)(rows).containsExactlyInAnyOrder(result.rows);
+};
+const expectSQL = { query: (sql) => ({ resultRows: { toBeTheSame: (rows) => assertSQLQueryResultMatches(sql, rows) } }) };
+
+//#endregion
+//#region src/eventStore/projections/postgreSQLProjection.ts
+const transactionToPostgreSQLProjectionHandlerContext = async (connectionString, pool, transaction) => ({
+	execute: transaction.execute,
+	connection: {
+		connectionString,
+		client: await transaction.connection.open(),
+		transaction,
+		pool
 	}
 });
 const handleProjections = async (options) => {
@@ -1059,6 +1084,74 @@ const postgreSQLRawSQLProjection = (options) => {
 	});
 };
 
+//#endregion
+//#region src/eventStore/schema/readMessagesBatch.ts
+const PostgreSQLEventStoreCheckpoint = {
+	default: {
+		transactionId: 0n,
+		globalPosition: 0n
+	},
+	parse: (checkPoint) => {
+		if (checkPoint === void 0 || checkPoint === null) return PostgreSQLEventStoreCheckpoint.default;
+		const [transactionId, globalPosition] = checkPoint.split(":");
+		return {
+			transactionId: BigInt(transactionId),
+			globalPosition: BigInt(globalPosition)
+		};
+	},
+	toProcessorCheckpoint: (checkPoint) => `${checkPoint.transactionId.toString().padStart(20, "0")}:${(0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(checkPoint.globalPosition)}`
+};
+const 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.globalPosition - options.from.globalPosition;
+	const fromCondition = from !== void 0 ? _event_driven_io_dumbo.SQL`AND (transaction_id, global_position) >= (${from.transactionId}, ${from.globalPosition})` : after !== void 0 ? _event_driven_io_dumbo.SQL`AND (transaction_id, global_position) > (${after.transactionId}, ${after.globalPosition})` : _event_driven_io_dumbo.SQL.EMPTY;
+	const toCondition = "to" in options ? _event_driven_io_dumbo.SQL`AND (transaction_id, global_position) <= (${options.to.transactionId}, ${options.to.globalPosition})` : _event_driven_io_dumbo.SQL.EMPTY;
+	const limitCondition = "batchSize" in options ? _event_driven_io_dumbo.SQL`LIMIT ${options.batchSize}` : _event_driven_io_dumbo.SQL.EMPTY;
+	const query = _event_driven_io_dumbo.SQL`
+    SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id, transaction_id
+    FROM ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}
+    WHERE partition = ${options?.partition ?? defaultTag} 
+      AND is_archived = FALSE 
+      AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+      ${fromCondition} ${toCondition}
+    ORDER BY transaction_id, global_position
+    ${limitCondition}`;
+	const messages = await (0, _event_driven_io_dumbo.mapRows)(execute.query(query), (row) => {
+		const rawEvent = {
+			type: row.message_type,
+			data: row.message_data,
+			metadata: row.message_metadata
+		};
+		const globalPosition = PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint({
+			transactionId: BigInt(row.transaction_id),
+			globalPosition: BigInt(row.global_position)
+		});
+		const metadata = {
+			..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
+			messageId: row.message_id,
+			streamName: row.stream_id,
+			streamPosition: BigInt(row.stream_position),
+			globalPosition,
+			checkpoint: globalPosition
+		};
+		return {
+			...rawEvent,
+			kind: "Event",
+			metadata
+		};
+	});
+	return messages.length > 0 ? {
+		currentCheckpoint: PostgreSQLEventStoreCheckpoint.parse(messages[messages.length - 1].metadata.checkpoint),
+		messages,
+		areMessagesLeft: messages.length === batchSize
+	} : {
+		currentCheckpoint: "from" in options ? options.from : "after" in options ? options.after : PostgreSQLEventStoreCheckpoint.default,
+		messages: [],
+		areMessagesLeft: false
+	};
+};
+
 //#endregion
 //#region src/eventStore/schema/appendToStream.ts
 const appendToStreamSQL = createFunctionIfDoesNotExistSQL("emt_append_to_stream", _event_driven_io_dumbo.SQL`CREATE OR REPLACE FUNCTION emt_append_to_stream(
@@ -1164,7 +1257,7 @@ const callAppendToStream = (params) => _event_driven_io_dumbo.SQL`SELECT * FROM
       ${params.expectedStreamPosition},
       ${params.partition}::text
     )`;
-const appendToStream = (pool, streamName, streamType, messages, options) => pool.withTransaction(async (transaction) => {
+const appendToStream = (connection, streamName, streamType, messages, options) => connection.withTransaction(async (transaction) => {
 	const { execute } = transaction;
 	if (messages.length === 0) return {
 		success: false,
@@ -1180,19 +1273,23 @@ const appendToStream = (pool, streamName, streamType, messages, options) => pool
 				..."metadata" in e ? e.metadata ?? {} : {}
 			}
 		}));
-		const { success, next_stream_position, global_positions, transaction_id } = await appendEventsRaw(execute, streamName, streamType, messagesToAppend, { expectedStreamVersion });
+		const { success, next_stream_position, global_positions, transaction_id } = await appentToStreamRaw(execute, streamName, streamType, messagesToAppend, { expectedStreamVersion });
 		if (!success || next_stream_position === null || global_positions === null || global_positions.length === 0 || transaction_id == null) return {
 			success: false,
 			result: { success: false }
 		};
 		const nextStreamPosition = BigInt(next_stream_position);
 		const globalPositions = global_positions.map(BigInt);
+		const transactionId = BigInt(transaction_id);
 		globalPositions.forEach((globalPosition, index) => {
 			messagesToAppend[index].metadata = {
 				...messagesToAppend[index].metadata,
 				streamName,
 				streamPosition: nextStreamPosition - BigInt(messagesToAppend.length) + BigInt(index + 1),
-				globalPosition
+				globalPosition: PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint({
+					transactionId,
+					globalPosition
+				})
 			};
 		});
 		if (options?.beforeCommitHook) await options.beforeCommitHook(messagesToAppend, { transaction });
@@ -1201,8 +1298,10 @@ const appendToStream = (pool, streamName, streamType, messages, options) => pool
 			result: {
 				success: true,
 				nextStreamPosition,
-				globalPositions,
-				transactionId: transaction_id
+				checkpoints: globalPositions.map((globalPosition) => ({
+					transactionId,
+					globalPosition
+				}))
 			}
 		};
 	} catch (error) {
@@ -1221,7 +1320,7 @@ const toExpectedVersion = (expected) => {
 	return expected;
 };
 const isOptimisticConcurrencyError = (error) => _event_driven_io_dumbo.DumboError.isInstanceOf(error, { errorType: _event_driven_io_dumbo.UniqueConstraintError.ErrorType });
-const appendEventsRaw = (execute, streamId, streamType, messages, options) => (0, _event_driven_io_dumbo.single)(execute.command(callAppendToStream({
+const appentToStreamRaw = (execute, streamId, streamType, messages, options) => (0, _event_driven_io_dumbo.single)(execute.command(callAppendToStream({
 	messageIds: messages.map((e) => e.metadata.messageId),
 	messagesData: messages.map((e) => e.data),
 	messagesMetadata: messages.map((e) => {
@@ -1254,7 +1353,7 @@ DECLARE
 BEGIN
   -- Handle the case when p_check_position is provided
   IF p_check_position IS NOT NULL THEN
-      -- Try to update if the position matches p_check_position
+      -- Try to update if the position matches p_check_position (new format)
       UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
       SET
         "last_processed_checkpoint" = p_position,
@@ -1269,6 +1368,38 @@ BEGIN
           RETURN 1;  -- Successfully updated
       END IF;
 
+      -- TODO: Remove once all deployments have run the 0.43.0 migration.
+      -- Handles mixed-format scenarios during blue-green deployment.
+      IF p_check_position LIKE '%:%' THEN
+          -- new code, stored value still in old format (plain globalpos)
+          UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+          SET
+            "last_processed_checkpoint" = p_position,
+            "last_processed_transaction_id" = p_transaction_id,
+            "last_updated" = now()
+          WHERE "processor_id" = p_processor_id
+            AND "last_processed_checkpoint" = split_part(p_check_position, ':', 2)
+            AND "last_processed_checkpoint" NOT LIKE '%:%'
+            AND "partition" = p_partition
+            AND "version" = p_version;
+      ELSE
+          -- old code, stored value already migrated to new format (txid:globalpos)
+          UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+          SET
+            "last_processed_checkpoint" = p_position,
+            "last_processed_transaction_id" = p_transaction_id,
+            "last_updated" = now()
+          WHERE "processor_id" = p_processor_id
+            AND split_part("last_processed_checkpoint", ':', 2) = p_check_position
+            AND "last_processed_checkpoint" LIKE '%:%'
+            AND "partition" = p_partition
+            AND "version" = p_version;
+      END IF;
+
+      IF FOUND THEN
+          RETURN 1;  -- Successfully updated (mixed-format fallback)
+      END IF;
+
       -- Retrieve the current position
       SELECT "last_processed_checkpoint" INTO current_position
       FROM "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
@@ -2521,42 +2652,158 @@ IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_subscriptions') THEN
             AND "partition" = p_partition            
             AND "version" = p_version ;
 
-          IF current_position = p_position THEN
-              RETURN 0;
-          ELSIF current_position > p_position THEN
-              RETURN 3;
-          ELSE
-              RETURN 2;
-          END IF;
+          IF current_position = p_position THEN
+              RETURN 0;
+          ELSIF current_position > p_position THEN
+              RETURN 3;
+          ELSE
+              RETURN 2;
+          END IF;
+      END IF;
+
+      BEGIN
+          INSERT INTO "emt_processors"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
+          VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
+          RETURN 1;
+      EXCEPTION WHEN unique_violation THEN
+          SELECT "last_processed_checkpoint" INTO current_position
+          FROM "emt_processors"
+          WHERE "processor_id" = p_processor_id 
+            AND "partition" = p_partition
+            AND "version" = p_version;
+
+          IF current_position = p_position THEN
+              RETURN 0;
+          ELSE
+              RETURN 2;
+          END IF;
+      END;
+    END;
+    $fn$ LANGUAGE plpgsql;
+END IF;
+END $$;
+`;
+const migration_0_43_0_cleanupLegacySubscription = (0, _event_driven_io_dumbo.sqlMigration)("emt:postgresql:eventstore:0.43.0:cleanup-legacy-subscription", [migration_0_43_0_cleanupLegacySubscriptionSQL]);
+const migration_0_43_0_updateStoreProcessorCheckpointSQL = _event_driven_io_dumbo.SQL`
+CREATE OR REPLACE FUNCTION store_processor_checkpoint(
+  p_processor_id           TEXT,
+  p_version                BIGINT,
+  p_position               TEXT,
+  p_check_position         TEXT,
+  p_transaction_id         xid8,
+  p_partition              TEXT DEFAULT '${_event_driven_io_dumbo.SQL.plain(defaultTag)}',
+  p_processor_instance_id  TEXT DEFAULT '${_event_driven_io_dumbo.SQL.plain(unknownTag$3)}'
+) RETURNS INT AS $spc$
+DECLARE
+  current_position TEXT;
+BEGIN
+  IF p_check_position IS NOT NULL THEN
+      UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+      SET
+        "last_processed_checkpoint" = p_position,
+        "last_processed_transaction_id" = p_transaction_id,
+        "last_updated" = now()
+      WHERE "processor_id" = p_processor_id
+        AND "last_processed_checkpoint" = p_check_position
+        AND "partition" = p_partition
+        AND "version" = p_version;
+
+      IF FOUND THEN
+          RETURN 1;
+      END IF;
+
+      -- TODO: Remove once all deployments have run the 0.43.0 migration.
+      -- Handles mixed-format scenarios during blue-green deployment.
+      IF p_check_position LIKE '%:%' THEN
+          -- new code, stored value still in old format (plain globalpos)
+          UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+          SET
+            "last_processed_checkpoint" = p_position,
+            "last_processed_transaction_id" = p_transaction_id,
+            "last_updated" = now()
+          WHERE "processor_id" = p_processor_id
+            AND "last_processed_checkpoint" = split_part(p_check_position, ':', 2)
+            AND "last_processed_checkpoint" NOT LIKE '%:%'
+            AND "partition" = p_partition
+            AND "version" = p_version;
+      ELSE
+          -- old code, stored value already migrated to new format (txid:globalpos)
+          UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+          SET
+            "last_processed_checkpoint" = p_position,
+            "last_processed_transaction_id" = p_transaction_id,
+            "last_updated" = now()
+          WHERE "processor_id" = p_processor_id
+            AND split_part("last_processed_checkpoint", ':', 2) = p_check_position
+            AND "last_processed_checkpoint" LIKE '%:%'
+            AND "partition" = p_partition
+            AND "version" = p_version;
+      END IF;
+
+      IF FOUND THEN
+          RETURN 1;
+      END IF;
+
+      SELECT "last_processed_checkpoint" INTO current_position
+      FROM "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+      WHERE "processor_id" = p_processor_id
+        AND "partition" = p_partition
+        AND "version" = p_version;
+
+      IF current_position = p_position THEN
+          RETURN 0;
+      ELSIF current_position > p_position THEN
+          RETURN 3;
+      ELSE
+          RETURN 2;
       END IF;
+  END IF;
 
-      BEGIN
-          INSERT INTO "emt_processors"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
-          VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
-          RETURN 1;
-      EXCEPTION WHEN unique_violation THEN
-          SELECT "last_processed_checkpoint" INTO current_position
-          FROM "emt_processors"
-          WHERE "processor_id" = p_processor_id 
-            AND "partition" = p_partition
-            AND "version" = p_version;
+  BEGIN
+      INSERT INTO "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"("processor_id", "version", "last_processed_checkpoint", "partition", "last_processed_transaction_id", "created_at", "last_updated")
+      VALUES (p_processor_id, p_version, p_position, p_partition, p_transaction_id, now(), now());
+      RETURN 1;
+  EXCEPTION WHEN unique_violation THEN
+      SELECT "last_processed_checkpoint" INTO current_position
+      FROM "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}"
+      WHERE "processor_id" = p_processor_id
+        AND "partition" = p_partition
+        AND "version" = p_version;
 
-          IF current_position = p_position THEN
-              RETURN 0;
-          ELSE
-              RETURN 2;
-          END IF;
-      END;
-    END;
-    $fn$ LANGUAGE plpgsql;
-END IF;
+      IF current_position = p_position THEN
+          RETURN 0;
+      ELSIF current_position > p_position THEN
+          RETURN 3;
+      ELSE
+          RETURN 2;
+      END IF;
+  END;
+END;
+$spc$ LANGUAGE plpgsql;
+`;
+const migration_0_43_0_updateStoreProcessorCheckpoint = (0, _event_driven_io_dumbo.sqlMigration)("emt:postgresql:eventstore:0.43.0:update-store-processor-checkpoint", [migration_0_43_0_updateStoreProcessorCheckpointSQL]);
+const migration_0_43_0_upgradeCheckpointFormatSQL = _event_driven_io_dumbo.SQL`
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = '${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}') THEN
+    UPDATE "${_event_driven_io_dumbo.SQL.plain(processorsTable.name)}" p
+    SET last_processed_checkpoint =
+      lpad(m.transaction_id::text, 20, '0') || ':' || p.last_processed_checkpoint
+    FROM "${_event_driven_io_dumbo.SQL.plain(messagesTable.name)}" m
+    WHERE m.global_position = p.last_processed_checkpoint::bigint
+      AND p.last_processed_checkpoint NOT LIKE '%:%';
+  END IF;
 END $$;
 `;
-const migration_0_43_0_cleanupLegacySubscription = (0, _event_driven_io_dumbo.sqlMigration)("emt:postgresql:eventstore:0.43.0:cleanup-legacy-subscription", [migration_0_43_0_cleanupLegacySubscriptionSQL]);
+const migration_0_43_0_upgradeCheckpointFormat = (0, _event_driven_io_dumbo.sqlMigration)("emt:postgresql:eventstore:0.43.0:upgrade-checkpoint-format", [migration_0_43_0_upgradeCheckpointFormatSQL]);
 
 //#endregion
 //#region src/eventStore/schema/migrations/0_43_0/index.ts
-const migrations_0_43_0 = [migration_0_43_0_cleanupLegacySubscription];
+const migrations_0_43_0 = [
+	migration_0_43_0_cleanupLegacySubscription,
+	migration_0_43_0_updateStoreProcessorCheckpoint,
+	migration_0_43_0_upgradeCheckpointFormat
+];
 
 //#endregion
 //#region src/eventStore/schema/migrations/index.ts
@@ -2586,14 +2833,42 @@ const pastEventStoreSchemaMigrations = [
 ];
 const eventStoreSchemaMigrations = [...pastEventStoreSchemaMigrations, schemaMigration$1];
 
+//#endregion
+//#region src/eventStore/schema/readLastMessageCheckpoint.ts
+const readLastMessageCheckpoint = async (execute, options) => {
+	const result = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`SELECT transaction_id, global_position
+           FROM ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}
+           WHERE partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+           ORDER BY transaction_id DESC, global_position DESC
+           LIMIT 1`));
+	return { currentCheckpoint: result !== null ? {
+		transactionId: BigInt(result.transaction_id),
+		globalPosition: BigInt(result.global_position)
+	} : null };
+};
+
 //#endregion
 //#region src/eventStore/schema/readProcessorCheckpoint.ts
+const resolveTransactionId = async (execute, rawCheckpoint) => {
+	if (rawCheckpoint.includes(":")) return rawCheckpoint;
+	const globalPosition = BigInt(rawCheckpoint);
+	if (globalPosition === 0n) return PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint(PostgreSQLEventStoreCheckpoint.default);
+	const row = await (0, _event_driven_io_dumbo.single)(execute.query(_event_driven_io_dumbo.SQL`SELECT transaction_id
+           FROM ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}
+           WHERE global_position = ${globalPosition}
+           LIMIT 1`));
+	return PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint({
+		transactionId: BigInt(row.transaction_id),
+		globalPosition
+	});
+};
 const readProcessorCheckpoint = async (execute, options) => {
 	const result = await (0, _event_driven_io_dumbo.singleOrNull)(execute.query(_event_driven_io_dumbo.SQL`SELECT last_processed_checkpoint
            FROM ${_event_driven_io_dumbo.SQL.identifier(processorsTable.name)}
            WHERE partition = ${options?.partition ?? defaultTag} AND processor_id = ${options.processorId} AND version = ${options.version ?? 1}
            LIMIT 1`));
-	return { lastProcessedCheckpoint: result !== null ? result.last_processed_checkpoint : null };
+	if (result === null) return { lastProcessedCheckpoint: null };
+	return { lastProcessedCheckpoint: await resolveTransactionId(execute, result.last_processed_checkpoint) };
 };
 
 //#endregion
@@ -2602,7 +2877,7 @@ const readStream = async (execute, streamId, options) => {
 	const fromCondition = options?.from ? `AND stream_position >= ${options.from}` : "";
 	const to = Number(options?.to ?? (options?.maxCount ? (options.from ?? 0n) + options.maxCount : NaN));
 	const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
-	const events = await (0, _event_driven_io_dumbo.mapRows)(execute.query(_event_driven_io_dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+	const events = await (0, _event_driven_io_dumbo.mapRows)(execute.query(_event_driven_io_dumbo.SQL`SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id, transaction_id
            FROM ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}
            WHERE stream_id = ${streamId} AND partition = ${options?.partition ?? defaultTag} AND is_archived = FALSE ${_event_driven_io_dumbo.SQL.plain(fromCondition)} ${_event_driven_io_dumbo.SQL.plain(toCondition)}
            ORDER BY stream_position ASC`), (row) => {
@@ -2611,13 +2886,17 @@ const readStream = async (execute, streamId, options) => {
 			data: row.message_data,
 			metadata: row.message_metadata
 		};
+		const globalPosition = PostgreSQLEventStoreCheckpoint.toProcessorCheckpoint({
+			transactionId: BigInt(row.transaction_id),
+			globalPosition: BigInt(row.global_position)
+		});
 		const metadata = {
 			..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
 			messageId: row.message_id,
 			streamName: streamId,
 			streamPosition: BigInt(row.stream_position),
-			globalPosition: BigInt(row.global_position),
-			checkpoint: (0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(BigInt(row.global_position))
+			globalPosition,
+			checkpoint: globalPosition
 		};
 		return (0, _event_driven_io_emmett.upcastRecordedMessage)({
 			...rawEvent,
@@ -2686,152 +2965,76 @@ const createEventStoreSchema = (connectionString, pool, hooks, options) => {
 };
 
 //#endregion
-//#region src/eventStore/schema/truncateTables.ts
-const truncateTables = async (execute, options) => {
-	await execute.command(_event_driven_io_dumbo.SQL`TRUNCATE TABLE 
-        ${_event_driven_io_dumbo.SQL.identifier(streamsTable.name)}, 
-        ${_event_driven_io_dumbo.SQL.identifier(messagesTable.name)}, 
-        ${_event_driven_io_dumbo.SQL.identifier(processorsTable.name)}, 
-        ${_event_driven_io_dumbo.SQL.identifier(projectionsTable.name)} 
-        CASCADE${_event_driven_io_dumbo.SQL.plain(options?.resetSequences ? "; ALTER SEQUENCE emt_global_message_position RESTART WITH 1" : "")};`);
-};
-
-//#endregion
-//#region src/eventStore/postgreSQLEventStore.ts
-const defaultPostgreSQLOptions = {
-	projections: [],
-	schema: { autoMigration: "CreateOrUpdate" }
-};
-const PostgreSQLEventStoreDefaultStreamVersion = 0n;
-const getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOptions) => {
-	const poolOptions = {
-		connectionString,
-		...options.connectionOptions ? options.connectionOptions : {}
-	};
-	const pool = "dumbo" in poolOptions ? poolOptions.dumbo : (0, _event_driven_io_dumbo.dumbo)({
-		...poolOptions,
-		serialization: options.serialization
-	});
-	let migrateSchema = void 0;
-	const autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
-	const inlineProjections = (options.projections ?? []).filter(({ type }) => type === "inline").map(({ projection }) => projection);
-	const migrate = async (migrationOptions) => {
-		if (!migrateSchema) {
-			migrateSchema = createEventStoreSchema(connectionString, pool, {
-				onBeforeSchemaCreated: async (context) => {
-					if (options.hooks?.onBeforeSchemaCreated) await options.hooks.onBeforeSchemaCreated(context);
-				},
-				onAfterSchemaCreated: async (context) => {
-					for (const projection of inlineProjections) if (projection.init) await projection.init({
-						version: projection.version ?? 1,
-						status: "active",
-						registrationType: "inline",
-						context: {
-							...context,
-							migrationOptions
-						}
-					});
-					if (options.hooks?.onAfterSchemaCreated) await options.hooks.onAfterSchemaCreated(context);
+//#region src/eventStore/consumers/messageBatchProcessing/index.ts
+const DefaultPostgreSQLEventStoreProcessorBatchSize = 100;
+const DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = 50;
+const postgreSQLEventStoreMessageBatchPuller = ({ executor, batchSize, eachBatch, pullingFrequencyInMs, stopWhen, signal }) => {
+	let isRunning = false;
+	let start;
+	const pullMessages = async (options) => {
+		try {
+			let after;
+			try {
+				after = options.startFrom === "BEGINNING" ? PostgreSQLEventStoreCheckpoint.default : options.startFrom === "END" ? (await readLastMessageCheckpoint(executor)).currentCheckpoint ?? PostgreSQLEventStoreCheckpoint.default : PostgreSQLEventStoreCheckpoint.parse(options.startFrom.lastCheckpoint);
+			} catch (error) {
+				console.log("Error occurred during reading last processor checkpoint:", error);
+				options.started?.reject(error);
+				throw error;
+			}
+			options.started?.resolve();
+			const readMessagesOptions = {
+				after,
+				batchSize
+			};
+			let waitTime = 100;
+			while (isRunning && !signal?.aborted) {
+				const { messages, currentCheckpoint, areMessagesLeft } = await readMessagesBatch(executor, readMessagesOptions);
+				if (messages.length > 0) {
+					const result = await eachBatch(messages);
+					if (result && result.type === "STOP") {
+						isRunning = false;
+						break;
+					}
 				}
-			}, migrationOptions);
-			return migrateSchema;
+				readMessagesOptions.after = currentCheckpoint;
+				await new Promise((resolve) => setTimeout(resolve, waitTime));
+				if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
+					console.log(`No messages left to process after reaching checkpoint ${_event_driven_io_emmett.JSONSerializer.serialize(readMessagesOptions.after)}. Stopping the puller.`);
+					isRunning = false;
+					break;
+				}
+				if (!areMessagesLeft) waitTime = Math.min(waitTime * 2, 1e3);
+				else waitTime = pullingFrequencyInMs;
+			}
+		} catch (error) {
+			console.log("Error occurred during message pulling:", error);
+			throw error;
 		}
-		const result = await migrateSchema;
-		if (migrationOptions?.dryRun) migrateSchema = void 0;
-		return {
-			applied: [],
-			skipped: result.applied.concat(result.skipped)
-		};
-	};
-	const ensureSchemaExists = () => {
-		if (!autoGenerateSchema) return Promise.resolve();
-		return migrate();
 	};
-	const beforeCommitHook = inlineProjections.length > 0 ? async (events, { transaction }) => handleProjections({
-		projections: inlineProjections,
-		events,
-		...await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction)
-	}) : void 0;
 	return {
-		schema: {
-			sql: () => _event_driven_io_dumbo.SQL.describe(schemaSQL, (0, _event_driven_io_dumbo.getFormatter)((0, _event_driven_io_dumbo.fromDatabaseDriverType)(pool.driverType).databaseType)),
-			print: () => console.log(_event_driven_io_dumbo.SQL.describe(schemaSQL, (0, _event_driven_io_dumbo.getFormatter)((0, _event_driven_io_dumbo.fromDatabaseDriverType)(pool.driverType).databaseType))),
-			migrate,
-			dangerous: { truncate: (truncateOptions) => pool.withTransaction(async (transaction) => {
-				await ensureSchemaExists();
-				await truncateTables(transaction.execute, truncateOptions);
-				if (truncateOptions?.truncateProjections) {
-					const projectionContext = await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, transaction);
-					for (const projection of options?.projections ?? []) if (projection.projection.truncate) await projection.projection.truncate(projectionContext);
-				}
-			}) }
-		},
-		async aggregateStream(streamName, options) {
-			const { evolve, initialState, read } = options;
-			const expectedStreamVersion = read?.expectedStreamVersion;
-			let state = initialState();
-			const result = await this.readStream(streamName, read);
-			const currentStreamVersion = result.currentStreamVersion;
-			(0, _event_driven_io_emmett.assertExpectedVersionMatchesCurrent)(currentStreamVersion, expectedStreamVersion, PostgreSQLEventStoreDefaultStreamVersion);
-			for (const event of result.events) {
-				if (!event) continue;
-				state = evolve(state, event);
-			}
-			return {
-				currentStreamVersion,
-				state,
-				streamExists: result.streamExists
-			};
-		},
-		readStream: async (streamName, readOptions) => {
-			await ensureSchemaExists();
-			return readStream(pool.execute, streamName, {
-				...readOptions,
-				serialization: options.serialization ?? readOptions?.serialization
-			});
-		},
-		appendToStream: async (streamName, events, appendOptions) => {
-			await ensureSchemaExists();
-			const [firstPart, ...rest] = streamName.split("-");
-			const appendResult = await appendToStream(pool, streamName, firstPart && rest.length > 0 ? firstPart : _event_driven_io_emmett.unknownTag, (0, _event_driven_io_emmett.downcastRecordedMessages)(events, appendOptions?.schema?.versioning), {
-				...appendOptions,
-				beforeCommitHook
-			});
-			if (!appendResult.success) throw new _event_driven_io_emmett.ExpectedVersionConflictError(-1n, appendOptions?.expectedStreamVersion ?? _event_driven_io_emmett.NO_CONCURRENCY_CHECK);
-			return {
-				nextExpectedStreamVersion: appendResult.nextStreamPosition,
-				lastEventGlobalPosition: appendResult.globalPositions[appendResult.globalPositions.length - 1],
-				createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
-			};
+		get isRunning() {
+			return isRunning;
 		},
-		streamExists: async (streamName, options) => {
-			await ensureSchemaExists();
-			return streamExists(pool.execute, streamName, options);
+		start: (options) => {
+			if (isRunning) return start;
+			isRunning = true;
+			start = (async () => {
+				return pullMessages(options);
+			})();
+			return start;
 		},
-		consumer: (options) => postgreSQLEventStoreConsumer({
-			...options ?? {},
-			pool,
-			connectionString
-		}),
-		close: () => pool.close(),
-		async withSession(callback) {
-			return await pool.withConnection(async (connection) => {
-				const eventStore = getPostgreSQLEventStore(connectionString, {
-					...options,
-					connectionOptions: { connection },
-					schema: {
-						...options.schema ?? {},
-						autoMigration: "None"
-					}
-				});
-				return ensureSchemaExists().then(() => callback({
-					eventStore,
-					close: () => Promise.resolve()
-				}));
-			});
+		stop: async () => {
+			if (!isRunning) return;
+			isRunning = false;
+			await start;
 		}
 	};
 };
+const 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];
+};
 
 //#endregion
 //#region src/eventStore/consumers/postgreSQLProcessor.ts
@@ -3043,6 +3246,7 @@ const postgreSQLEventStoreConsumer = (options) => {
 	let start;
 	let messagePuller;
 	const startedAwaiter = (0, _event_driven_io_emmett.asyncAwaiter)();
+	const isOwnPool = !options.pool;
 	const pool = options.pool ? options.pool : (0, _event_driven_io_dumbo.dumbo)({
 		connectionString: options.connectionString,
 		serialization: options.serialization
@@ -3191,7 +3395,7 @@ const postgreSQLEventStoreConsumer = (options) => {
 		stop,
 		close: async () => {
 			await stop();
-			await pool.close();
+			if (isOwnPool) await pool.close();
 		}
 	};
 };
@@ -3234,6 +3438,7 @@ const rebuildPostgreSQLProjections = (options) => {
 exports.DefaultPostgreSQLEventStoreProcessorBatchSize = DefaultPostgreSQLEventStoreProcessorBatchSize;
 exports.DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs = DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs;
 exports.DefaultPostgreSQLProcessorLockPolicy = DefaultPostgreSQLProcessorLockPolicy;
+exports.PostgreSQLEventStoreCheckpoint = PostgreSQLEventStoreCheckpoint;
 exports.PostgreSQLEventStoreDefaultStreamVersion = PostgreSQLEventStoreDefaultStreamVersion;
 exports.PostgreSQLProjectionSpec = PostgreSQLProjectionSpec;
 exports.activateProjection = activateProjection;
@@ -3247,6 +3452,7 @@ exports.addTenantForAllModulesSQL = addTenantForAllModulesSQL;
 exports.addTenantSQL = addTenantSQL;
 exports.appendToStream = appendToStream;
 exports.appendToStreamSQL = appendToStreamSQL;
+exports.appentToStreamRaw = appentToStreamRaw;
 exports.assertSQLQueryResultMatches = assertSQLQueryResultMatches;
 exports.callActivateProjection = callActivateProjection;
 exports.callAppendToStream = callAppendToStream;
@@ -3292,7 +3498,7 @@ exports.postgreSQLReactor = postgreSQLReactor;
 exports.postgreSQLWorkflowProcessor = postgreSQLWorkflowProcessor;
 exports.processorsTableSQL = processorsTableSQL;
 exports.projectionsTableSQL = projectionsTableSQL;
-exports.readLastMessageGlobalPosition = readLastMessageGlobalPosition;
+exports.readLastMessageCheckpoint = readLastMessageCheckpoint;
 exports.readMessagesBatch = readMessagesBatch;
 exports.readProcessorCheckpoint = readProcessorCheckpoint;
 exports.readProjectionInfo = readProjectionInfo;