@event-driven-io/emmett-postgresql 0.43.0-beta.14 → 0.43.0-beta.16

package/dist/index.js

@@ -1,4 +1,4 @@
-import { AssertionError, EmmettError, ExpectedVersionConflictError, NO_CONCURRENCY_CHECK, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, assertDeepEqual, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertIsNotNull, assertIsNull, assertThatArray, assertTrue, asyncAwaiter, asyncRetry, bigInt, bigIntProcessorCheckpoint, defaultProcessorPartition, defaultProcessorVersion, downcastRecordedMessages, getCheckpoint, getProcessorInstanceId, getProjectorId, getWorkflowId, hashText, isBigint, isErrorConstructor, parseBigIntProcessorCheckpoint, projection, projector, reactor, reduceAsync, unknownTag as unknownTag$1, upcastRecordedMessage, workflowProcessor } from "@event-driven-io/emmett";
+import { AssertionError, EmmettError, ExpectedVersionConflictError, NO_CONCURRENCY_CHECK, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, assertDeepEqual, assertEqual, assertExpectedVersionMatchesCurrent, assertFails, assertIsNotNull, assertIsNull, assertThatArray, assertTrue, asyncAwaiter, asyncRetry, bigInt, bigIntProcessorCheckpoint, defaultProcessorPartition, defaultProcessorVersion, downcastRecordedMessages, getCheckpoint, getProcessorInstanceId, getProjectorId, getWorkflowId, hashText, isBigint, isErrorConstructor, parseBigIntProcessorCheckpoint, projection, projector, reactor, reduceAsync, unknownTag, upcastRecordedMessage, workflowProcessor } from "@event-driven-io/emmett";
 import { DumboError, JSONSerializer, SQL, UniqueConstraintError, dumbo, fromDatabaseDriverType, getFormatter, mapRows, runSQLMigrations, single, singleOrNull, sqlMigration } from "@event-driven-io/dumbo";
 import { v4, v7 } from "uuid";
 import { pongoClient } from "@event-driven-io/pongo";
@@ -8,7 +8,7 @@ import { pgDriver } from "@event-driven-io/pongo/pg";
 const emmettPrefix = "emt";
 const globalTag = "global";
 const defaultTag = `${"emt"}:default`;
-const unknownTag = `${"emt"}:unknown`;
+const unknownTag$1 = `${"emt"}:unknown`;
 const globalNames = {
 	module: `${"emt"}:module:${globalTag}`,
 	tenant: `${"emt"}:tenant:${globalTag}`
@@ -98,36 +98,43 @@ const postgreSQLEventStoreMessageBatchPuller = ({ executor, batchSize, eachBatch
 	let isRunning = false;
 	let start;
 	const pullMessages = async (options) => {
-		let after;
 		try {
-			after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : parseBigIntProcessorCheckpoint(options.startFrom.lastCheckpoint);
-		} catch (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") {
+			let after;
+			try {
+				after = options.startFrom === "BEGINNING" ? 0n : options.startFrom === "END" ? (await readLastMessageGlobalPosition(executor)).currentGlobalPosition ?? 0n : 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;
 			}
-			readMessagesOptions.after = currentGlobalPosition;
-			await new Promise((resolve) => setTimeout(resolve, waitTime));
-			if (stopWhen?.noMessagesLeft === true && !areMessagesLeft) {
-				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 {
@@ -239,7 +246,7 @@ CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
     p_processor_id           TEXT,
     p_version                INT,
     p_partition              TEXT       DEFAULT '${SQL.plain(defaultTag)}',
-    p_processor_instance_id  TEXT       DEFAULT '${SQL.plain(unknownTag)}',
+    p_processor_instance_id  TEXT       DEFAULT '${SQL.plain(unknownTag$1)}',
     p_projection_name        TEXT       DEFAULT NULL,
     p_projection_type        VARCHAR(1) DEFAULT NULL,
     p_projection_kind        TEXT       DEFAULT NULL,
@@ -248,6 +255,9 @@ CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
 RETURNS TABLE (acquired BOOLEAN, checkpoint TEXT)
 LANGUAGE plpgsql
 AS $emt_try_acquire_processor_lock$
+DECLARE
+  current_position TEXT;
+  v_current_time TIMESTAMPTZ := clock_timestamp();
 BEGIN
     RETURN QUERY
     WITH lock_check AS (
@@ -265,16 +275,16 @@ BEGIN
             created_at,
             last_updated
         )
-        SELECT p_processor_id, p_partition, p_version, p_processor_instance_id, 'running', '${SQL.plain(bigInt.toNormalizedString(0n))}', '0'::xid8, now(), now()
+        SELECT p_processor_id, p_partition, p_version, p_processor_instance_id, 'running', '${SQL.plain(bigInt.toNormalizedString(0n))}', '0'::xid8, v_current_time, v_current_time
         WHERE (SELECT lock_acquired FROM lock_check) = true
         ON CONFLICT (processor_id, partition, version) DO UPDATE
         SET processor_instance_id = p_processor_instance_id,
             status = 'running',
-            last_updated = now()
+            last_updated = v_current_time
         WHERE ${SQL.plain(processorsTable.name)}.processor_instance_id = p_processor_instance_id
-           OR ${SQL.plain(processorsTable.name)}.processor_instance_id = '${SQL.plain(unknownTag)}'
+           OR ${SQL.plain(processorsTable.name)}.processor_instance_id = '${SQL.plain(unknownTag$1)}'
            OR ${SQL.plain(processorsTable.name)}.status = 'stopped'
-           OR ${SQL.plain(processorsTable.name)}.last_updated < now() - (p_lock_timeout_seconds || ' seconds')::interval
+           OR ${SQL.plain(processorsTable.name)}.last_updated < v_current_time - (p_lock_timeout_seconds || ' seconds')::interval
         RETURNING last_processed_checkpoint
     ),
     projection_status AS (
@@ -306,7 +316,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 '${SQL.plain(unknownTag)}',
+    p_processor_instance_id TEXT DEFAULT '${SQL.plain(unknownTag$1)}',
     p_projection_name       TEXT DEFAULT NULL
 )
 RETURNS BOOLEAN
@@ -326,7 +336,7 @@ BEGIN
 
     UPDATE ${SQL.plain(processorsTable.name)}
     SET status = 'stopped',
-        processor_instance_id = '${SQL.plain(unknownTag)}',
+        processor_instance_id = '${SQL.plain(unknownTag$1)}',
         last_updated = now()
     WHERE processor_id = p_processor_id
       AND partition = p_partition
@@ -379,6 +389,7 @@ const tryAcquireProcessorLock = async (execute, options) => {
 		projectionKind: options.projection?.kind ?? null,
 		lockTimeoutSeconds: options.lockTimeoutSeconds ?? 300
 	})));
+	console.log(`Lock acquisition attempt for processor '${options.processorId}' with processor instance '${options.processorInstanceId}' and lock '${options.lockKey}' resulted in: ${acquired}`);
 	return acquired ? {
 		acquired: true,
 		checkpoint
@@ -404,6 +415,7 @@ const releaseProcessorLock = async (execute, options) => {
 		processorInstanceId: options.processorInstanceId,
 		projectionName: options.projectionName ?? null
 	})));
+	console.log(`Lock for processor '${options.processorId}' with processor instance '${options.processorInstanceId}' and lock '${options.lockKey}' released: ${result}`);
 	return result;
 };
 
@@ -415,17 +427,26 @@ const postgreSQLProcessorLock = (options) => {
 	const lockKey = options.lockKey ?? toProcessorLockKey(options);
 	return {
 		tryAcquire: async (context) => {
-			if (acquired) return true;
+			if (acquired) {
+				console.log(`Lock for processor '${options.processorId}' is already acquired by this instance. Reusing the lock.`);
+				return true;
+			}
 			const result = await tryAcquireProcessorLockWithRetry(context.execute, {
 				...options,
 				lockKey
 			});
-			if (!result.acquired && options.lockAcquisitionPolicy?.type !== "skip") throw new EmmettError(`Failed to acquire lock for processor '${options.processorId}'`);
+			if (!result.acquired && options.lockAcquisitionPolicy?.type !== "skip") {
+				console.log(`Failed to acquire lock for processor '${options.processorId}' with policy '${options.lockAcquisitionPolicy?.type}'.`);
+				throw new EmmettError(`Failed to acquire lock for processor '${options.processorId}'`);
+			}
 			acquired = result.acquired;
 			return acquired;
 		},
 		release: async (context) => {
-			if (!acquired) return;
+			if (!acquired) {
+				console.log(`Lock for processor '${options.processorId}' is not acquired by this instance. Skipping release.`);
+				return;
+			}
 			const { projection, ...releaseOptions } = options;
 			await releaseProcessorLock(context.execute, {
 				...releaseOptions,
@@ -1216,156 +1237,118 @@ const appendEventsRaw = (execute, streamId, streamType, messages, options) => si
 })));
 
 //#endregion
-//#region src/eventStore/schema/migrations/0_38_7/0_38_7.migration.ts
-const dropFutureConceptModuleAndTenantFunctions = SQL`
-  DO $$
-  BEGIN
-      -- Check and drop functions related to future concept of modules and tenants
-      IF EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'add_module') THEN
-          DROP FUNCTION add_module(TEXT);
-      END IF;
-      
-      IF EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'add_tenant') THEN
-          DROP FUNCTION add_tenant(TEXT, TEXT);
-      END IF;
-
-      IF EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'add_module_for_all_tenants') THEN
-          DROP FUNCTION add_module_for_all_tenants(TEXT);
-      END IF;
-  
-      IF EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'add_tenant_for_all_modules') THEN
-          DROP FUNCTION add_tenant_for_all_modules(TEXT);
-      END IF;
-  END $$;
-`;
-const dropOldAppendToSQLWithoutGlobalPositions = SQL`
-  DO $$
-  DECLARE
-      v_current_return_type text;
-  BEGIN
-      -- Get the current return type definition as text
-      SELECT pg_get_function_result(p.oid)
-      INTO v_current_return_type
-      FROM pg_proc p
-      JOIN pg_namespace n ON p.pronamespace = n.oid
-      WHERE n.nspname = current_schema()  -- or specify your schema
-      AND p.proname = 'emt_append_to_stream'
-      AND p.pronargs = 10;  -- number of arguments
-      
-      -- Check if it contains the old column name
-      IF v_current_return_type IS NOT NULL AND 
-        v_current_return_type LIKE '%last_global_position%' AND 
-        v_current_return_type NOT LIKE '%global_positions%' THEN
-          DROP FUNCTION emt_append_to_stream(text[], jsonb[], jsonb[], text[], text[], text[], text, text, bigint, text);
-          RAISE NOTICE 'Old version of function dropped. Return type was: %', v_current_return_type;
-      END IF;
-  END $$;
-`;
-const migrationFromEventsToMessagesSQL = SQL`
-DO $$ 
+//#region src/eventStore/schema/storeProcessorCheckpoint.ts
+const storeSubscriptionCheckpointSQL = createFunctionIfDoesNotExistSQL("store_processor_checkpoint", 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 '${SQL.plain(defaultTag)}',
+  p_processor_instance_id  TEXT DEFAULT '${SQL.plain(unknownTag$1)}'
+) RETURNS INT AS $spc$
 DECLARE
-    partition_record RECORD;
+  current_position TEXT;
 BEGIN
-    -- Rename the main table and its columns if it exists
-    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_events') THEN
-        -- Rename all partitions first
-        FOR partition_record IN 
-            SELECT tablename 
-            FROM pg_tables 
-            WHERE tablename LIKE 'emt_events_%'
-            ORDER BY tablename DESC  -- to handle child partitions first
-        LOOP
-            EXECUTE format('ALTER TABLE %I RENAME TO %I', 
-                partition_record.tablename, 
-                REPLACE(partition_record.tablename, 'events', 'messages'));
-        END LOOP;
+  -- 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
+      UPDATE "${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;
 
-        -- Rename the main table
-        ALTER TABLE emt_events RENAME TO emt_messages;
-        
-        -- Rename columns
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_data TO message_data;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_metadata TO message_metadata;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_schema_version TO message_schema_version;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_type TO message_type;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_id TO message_id;
-        ALTER TABLE emt_messages 
-            ADD COLUMN message_kind CHAR(1) NOT NULL DEFAULT 'E';
+      IF FOUND THEN
+          RETURN 1;  -- Successfully updated
+      END IF;
 
-        -- Rename sequence if it exists
-        IF EXISTS (SELECT 1 FROM pg_sequences WHERE sequencename = 'emt_global_event_position') THEN
-            ALTER SEQUENCE emt_global_event_position 
-            RENAME TO emt_global_message_position;
-            
-            ALTER TABLE emt_messages 
-                ALTER COLUMN global_position 
-                SET DEFAULT nextval('emt_global_message_position');
-        END IF;
-    END IF;
-END $$;`;
-const migration_0_38_7_and_older = sqlMigration("emt:postgresql:eventstore:0.38.7:migrate-events-to-messages", [
-	dropFutureConceptModuleAndTenantFunctions,
-	dropOldAppendToSQLWithoutGlobalPositions,
-	migrationFromEventsToMessagesSQL
-]);
+      -- Retrieve the current position
+      SELECT "last_processed_checkpoint" INTO current_position
+      FROM "${SQL.plain(processorsTable.name)}"
+      WHERE "processor_id" = p_processor_id 
+        AND "partition" = p_partition 
+        AND "version" = p_version;
 
-//#endregion
-//#region src/eventStore/schema/migrations/0_38_7/0_38_7.snapshot.ts
-const schema_0_38_7 = SQL`
-DO $$ 
-DECLARE
-    partition_record RECORD;
-BEGIN
-    -- Rename the main table and its columns if it exists
-    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_events') THEN
-        -- Rename all partitions first
-        FOR partition_record IN 
-            SELECT tablename 
-            FROM pg_tables 
-            WHERE tablename LIKE 'emt_events_%'
-            ORDER BY tablename DESC  -- to handle child partitions first
-        LOOP
-            EXECUTE format('ALTER TABLE %I RENAME TO %I', 
-                partition_record.tablename, 
-                REPLACE(partition_record.tablename, 'events', 'messages'));
-        END LOOP;
+      -- Return appropriate codes based on current position
+      IF current_position = p_position THEN
+          RETURN 0;  -- Idempotent check: position already set
+      ELSIF current_position > p_position THEN
+          RETURN 3;  -- Current ahead: another process has progressed further
+      ELSE
+          RETURN 2;  -- Mismatch: check position doesn't match current
+      END IF;
+  END IF;
 
-        -- Rename the main table
-        ALTER TABLE emt_events RENAME TO emt_messages;
-        
-        -- Rename columns
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_data TO message_data;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_metadata TO message_metadata;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_schema_version TO message_schema_version;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_type TO message_type;
-        ALTER TABLE emt_messages 
-            RENAME COLUMN event_id TO message_id;
-        ALTER TABLE emt_messages 
-            ADD COLUMN message_kind CHAR(1) NOT NULL DEFAULT 'E';
+  -- Handle the case when p_check_position is NULL: Insert if not exists
+  BEGIN
+      INSERT INTO "${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;  -- Successfully inserted
+  EXCEPTION WHEN unique_violation THEN
+      -- If insertion failed, it means the row already exists
+      SELECT "last_processed_checkpoint" INTO current_position
+      FROM "${SQL.plain(processorsTable.name)}"
+      WHERE "processor_id" = p_processor_id 
+        AND "partition" = p_partition 
+        AND "version" = p_version;
 
-        -- Rename sequence if it exists
-        IF EXISTS (SELECT 1 FROM pg_sequences WHERE sequencename = 'emt_global_event_position') THEN
-            ALTER SEQUENCE emt_global_event_position 
-            RENAME TO emt_global_message_position;
-            
-            ALTER TABLE emt_messages 
-                ALTER COLUMN global_position 
-                SET DEFAULT nextval('emt_global_message_position');
-        END IF;
-    END IF;
-END $$;CREATE TABLE IF NOT EXISTS emt_streams(
+      IF current_position = p_position THEN
+          RETURN 0;  -- Idempotent check: position already set
+      ELSIF current_position > p_position THEN
+          RETURN 3;  -- Current ahead: another process has progressed further
+      ELSE
+          RETURN 2;  -- Insertion failed, row already exists with different position
+      END IF;
+  END;
+END;
+$spc$ LANGUAGE plpgsql;
+`);
+const callStoreProcessorCheckpoint = (params) => SQL`
+    SELECT store_processor_checkpoint(
+      ${params.processorId}, 
+      ${params.version}, 
+      ${params.position}, 
+      ${params.checkPosition}, 
+      pg_current_xact_id(), 
+      ${params.partition}, 
+      ${params.processorInstanceId}
+    ) as result;`;
+const storeProcessorCheckpoint = async (execute, options) => {
+	try {
+		const { result } = await single(execute.command(callStoreProcessorCheckpoint({
+			processorId: options.processorId,
+			version: options.version ?? 1,
+			position: options.newCheckpoint !== null ? options.newCheckpoint : null,
+			checkPosition: options.lastProcessedCheckpoint !== null ? options.lastProcessedCheckpoint : null,
+			partition: options.partition ?? defaultTag,
+			processorInstanceId: options.processorInstanceId ?? unknownTag$1
+		})));
+		return result === 1 ? {
+			success: true,
+			newCheckpoint: options.newCheckpoint
+		} : {
+			success: false,
+			reason: result === 0 ? "IGNORED" : result === 3 ? "CURRENT_AHEAD" : "MISMATCH"
+		};
+	} catch (error) {
+		console.log(error);
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/eventStore/schema/tables.ts
+const streamsTableSQL = SQL`
+  CREATE TABLE IF NOT EXISTS ${SQL.identifier(streamsTable.name)}(
       stream_id         TEXT                      NOT NULL,
       stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT 'global',
+      partition         TEXT                      NOT NULL DEFAULT '${SQL.plain(defaultTag)}',
       stream_type       TEXT                      NOT NULL,
       stream_metadata   JSONB                     NOT NULL,
       is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
@@ -1373,40 +1356,62 @@ END $$;CREATE TABLE IF NOT EXISTS emt_streams(
   ) PARTITION BY LIST (partition);
    
   CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
-  ON emt_streams(stream_id, partition, is_archived) 
-  INCLUDE (stream_position);
+  ON ${SQL.identifier(streamsTable.name)}(stream_id, partition, is_archived) 
+  INCLUDE (stream_position);`;
+const messagesTableSQL = SQL`
   CREATE SEQUENCE IF NOT EXISTS emt_global_message_position;
 
-  CREATE TABLE IF NOT EXISTS emt_messages(
-      stream_id              TEXT                      NOT NULL,
+  CREATE TABLE IF NOT EXISTS ${SQL.identifier(messagesTable.name)}(
       stream_position        BIGINT                    NOT NULL,
-      partition              TEXT                      NOT NULL DEFAULT 'global',
-      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      message_schema_version TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
       global_position        BIGINT                    DEFAULT nextval('emt_global_message_position'),
       transaction_id         XID8                      NOT NULL,
       created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
+      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 '${SQL.plain(defaultTag)}',
+      message_schema_version TEXT                      NOT NULL,
+      message_id             TEXT                      NOT NULL,
+      message_type           TEXT                      NOT NULL,
+      message_data           JSONB                     NOT NULL,
+      message_metadata       JSONB                     NOT NULL,
       PRIMARY KEY (stream_id, stream_position, partition, is_archived)
+  ) PARTITION BY LIST (partition);`;
+const processorsTableSQL = SQL`
+  CREATE TABLE IF NOT EXISTS ${SQL.identifier(processorsTable.name)}(
+      last_processed_transaction_id XID8                   NOT NULL,
+      version                       INT                    NOT NULL DEFAULT 1,
+      processor_id                  TEXT                   NOT NULL,
+      partition                     TEXT                   NOT NULL DEFAULT '${SQL.plain(defaultTag)}',
+      status                        TEXT                   NOT NULL DEFAULT 'stopped',
+      last_processed_checkpoint     TEXT                   NOT NULL,
+      processor_instance_id         TEXT                   DEFAULT '${SQL.plain(unknownTag$1)}',
+      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      PRIMARY KEY (processor_id, partition, version)
   ) PARTITION BY LIST (partition);
-  CREATE TABLE IF NOT EXISTS emt_subscriptions(
-      subscription_id                 TEXT                   NOT NULL,
-      version                         INT                    NOT NULL DEFAULT 1,
-      partition                       TEXT                   NOT NULL DEFAULT 'global',
-      last_processed_position         BIGINT                 NOT NULL,
-      last_processed_transaction_id   XID8                   NOT NULL,
-      PRIMARY KEY (subscription_id, partition, version)
+`;
+const projectionsTableSQL = SQL`
+  CREATE TABLE IF NOT EXISTS ${SQL.identifier(projectionsTable.name)}(
+      version                       INT                    NOT NULL DEFAULT 1,
+      type                          VARCHAR(1)             NOT NULL,
+      name                          TEXT                   NOT NULL,
+      partition                     TEXT                   NOT NULL DEFAULT '${SQL.plain(defaultTag)}',
+      kind                          TEXT                   NOT NULL,
+      status                        TEXT                   NOT NULL,
+      definition                    JSONB                  NOT NULL DEFAULT '{}'::jsonb,
+      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
+      PRIMARY KEY (name, partition, version)
   ) PARTITION BY LIST (partition);
-CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
+`;
+const sanitizeNameSQL = createFunctionIfDoesNotExistSQL("emt_sanitize_name", SQL`CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $emt_sanitize_name$
     BEGIN
         RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
     END;
-    $$ LANGUAGE plpgsql;
-  CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $$
+    $emt_sanitize_name$ LANGUAGE plpgsql;`);
+const addTablePartitions = createFunctionIfDoesNotExistSQL("emt_add_table_partition", SQL`
+  CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $emt_add_table_partition$
   DECLARE
     v_main_partiton_name     TEXT;
     v_active_partiton_name   TEXT;
@@ -1436,20 +1441,215 @@ CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
           v_archived_partiton_name, v_main_partiton_name
       );
   END;
-  $$ LANGUAGE plpgsql;
-  CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $$
+  $emt_add_table_partition$ LANGUAGE plpgsql;`);
+const addPartitionSQL = createFunctionIfDoesNotExistSQL("emt_add_partition", SQL`
+  CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $emt_add_partition$
   BEGIN                
-      PERFORM emt_add_table_partition('emt_messages', partition_name);
-      PERFORM emt_add_table_partition('emt_streams', partition_name);
+      PERFORM emt_add_table_partition('${SQL.plain(messagesTable.name)}', partition_name);
+      PERFORM emt_add_table_partition('${SQL.plain(streamsTable.name)}', partition_name);
+
+      EXECUTE format('
+          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+          FOR VALUES IN (%L);',
+          emt_sanitize_name('${SQL.plain(processorsTable.name)}' || '_' || partition_name), '${SQL.plain(processorsTable.name)}', partition_name
+      );
 
       EXECUTE format('
           CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
           FOR VALUES IN (%L);',
-          emt_sanitize_name('emt_subscriptions' || '_' || partition_name), 'emt_subscriptions', partition_name
+          emt_sanitize_name('${SQL.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL.plain(projectionsTable.name)}', partition_name
       );
   END;
-  $$ LANGUAGE plpgsql;
+  $emt_add_partition$ LANGUAGE plpgsql;`);
+const addModuleSQL = SQL`
+      CREATE OR REPLACE FUNCTION add_module(new_module TEXT) RETURNS void AS $$
+      BEGIN
+          -- For ${SQL.plain(messagesTable.name)} table
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
+              emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}'), '${SQL.plain(messagesTable.name)}', new_module, '${SQL.plain(globalTag)}'
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+              FOR VALUES IN (FALSE);',
+              emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+              FOR VALUES IN (TRUE);',
+              emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
+          );
+  
+          -- For ${SQL.plain(streamsTable.name)} table
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
+              emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}'), '${SQL.plain(streamsTable.name)}', new_module, '${SQL.plain(globalTag)}'
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+              FOR VALUES IN (FALSE);',
+              emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
+          );
+  
+          EXECUTE format('
+              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+              FOR VALUES IN (TRUE);',
+              emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
+          );
+      END;
+      $$ LANGUAGE plpgsql;
+    `;
+const addTenantSQL = SQL`
+    CREATE OR REPLACE FUNCTION add_tenant(new_module TEXT, new_tenant TEXT) RETURNS void AS $$
+    BEGIN
+        -- For ${SQL.plain(messagesTable.name)} table
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+            emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant), '${SQL.plain(messagesTable.name)}', new_module, new_tenant
+        );
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+            FOR VALUES IN (FALSE);',
+            emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
+        );
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+            FOR VALUES IN (TRUE);',
+            emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
+        );
+  
+        -- For ${SQL.plain(streamsTable.name)} table
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+            emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant), '${SQL.plain(streamsTable.name)}', new_module, new_tenant
+        );
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+            FOR VALUES IN (FALSE);',
+            emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+        );
+  
+        EXECUTE format('
+            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+            FOR VALUES IN (TRUE);',
+            emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+        );
+    END;
+    $$ LANGUAGE plpgsql;
+  `;
+const addModuleForAllTenantsSQL = SQL`
+    CREATE OR REPLACE FUNCTION add_module_for_all_tenants(new_module TEXT) RETURNS void AS $$
+    DECLARE
+        tenant_record RECORD;
+    BEGIN
+        PERFORM add_module(new_module);
+  
+        FOR tenant_record IN SELECT DISTINCT tenant FROM ${SQL.plain(messagesTable.name)}
+        LOOP
+            -- For ${SQL.plain(messagesTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL.plain(messagesTable.name)}', new_module, tenant_record.tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+  
+            -- For ${SQL.plain(streamsTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL.plain(streamsTable.name)}', new_module, tenant_record.tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
+            );
+        END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `;
+const addTenantForAllModulesSQL = SQL`
+    CREATE OR REPLACE FUNCTION add_tenant_for_all_modules(new_tenant TEXT) RETURNS void AS $$
+    DECLARE
+        module_record RECORD;
+    BEGIN
+        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${SQL.plain(messagesTable.name)}'
+        LOOP
+            -- For ${SQL.plain(messagesTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL.plain(messagesTable.name)}', module_record.partitionname, new_tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+  
+            -- For ${SQL.plain(streamsTable.name)} table
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
+                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL.plain(streamsTable.name)}', module_record.partitionname, new_tenant
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
+                FOR VALUES IN (FALSE);',
+                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+  
+            EXECUTE format('
+                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
+                FOR VALUES IN (TRUE);',
+                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
+            );
+        END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `;
+const addDefaultPartitionSQL = SQL`SELECT emt_add_partition('${SQL.plain(defaultTag)}');`;
 
+//#endregion
+//#region src/eventStore/schema/migrations/0_38_7/0_38_7.migration.ts
+const dropFutureConceptModuleAndTenantFunctions = SQL`
   DO $$
   BEGIN
       -- Check and drop functions related to future concept of modules and tenants
@@ -1469,9 +1669,9 @@ CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
           DROP FUNCTION add_tenant_for_all_modules(TEXT);
       END IF;
   END $$;
-
-
-  DO $$
+`;
+const dropOldAppendToSQLWithoutGlobalPositions = SQL`
+  DO $$
   DECLARE
       v_current_return_type text;
   BEGIN
@@ -1490,158 +1690,156 @@ CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $$
         v_current_return_type NOT LIKE '%global_positions%' THEN
           DROP FUNCTION emt_append_to_stream(text[], jsonb[], jsonb[], text[], text[], text[], text, text, bigint, text);
           RAISE NOTICE 'Old version of function dropped. Return type was: %', v_current_return_type;
-      END IF;
-  END $$;
-CREATE OR REPLACE FUNCTION emt_append_to_stream(
-      v_message_ids text[],
-      v_messages_data jsonb[],
-      v_messages_metadata jsonb[],
-      v_message_schema_versions text[],
-      v_message_types text[],
-      v_message_kinds text[],
-      v_stream_id text,
-      v_stream_type text,
-      v_expected_stream_position bigint DEFAULT NULL,
-      v_partition text DEFAULT emt_sanitize_name('default_partition')
-  ) RETURNS TABLE (
-      success boolean,
-      next_stream_position bigint,
-      global_positions bigint[],
-      transaction_id xid8
-  ) LANGUAGE plpgsql
-  AS $$
-  DECLARE
-      v_next_stream_position bigint;
-      v_position bigint;
-      v_updated_rows int;
-      v_transaction_id xid8;
-      v_global_positions bigint[];
-  BEGIN
-      v_transaction_id := pg_current_xact_id();
-
-      IF v_expected_stream_position IS NULL THEN
-          SELECT COALESCE(
-            (SELECT stream_position 
-            FROM emt_streams
-            WHERE stream_id = v_stream_id 
-              AND partition = v_partition 
-              AND is_archived = FALSE
-            LIMIT 1), 
-            0
-        ) INTO v_expected_stream_position;
-      END IF;
-
-      v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
-
-      IF v_expected_stream_position = 0 THEN
-          INSERT INTO emt_streams
-              (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
-          VALUES
-              (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
-      ELSE
-          UPDATE emt_streams as s              
-          SET stream_position = v_next_stream_position
-          WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
-
-          get diagnostics v_updated_rows = row_count;
 
-          IF v_updated_rows = 0 THEN
-              RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint[], NULL::xid8;
-              RETURN;
-          END IF;
+        CREATE OR REPLACE FUNCTION emt_append_to_stream(
+            v_message_ids text[],
+            v_messages_data jsonb[],
+            v_messages_metadata jsonb[],
+            v_message_schema_versions text[],
+            v_message_types text[],
+            v_message_kinds text[],
+            v_stream_id text,
+            v_stream_type text,
+            v_expected_stream_position bigint DEFAULT NULL,
+            v_partition text DEFAULT emt_sanitize_name('default_partition')
+        ) RETURNS TABLE (
+            success boolean,
+            next_stream_position bigint,
+            global_positions bigint[],
+            transaction_id xid8
+        ) LANGUAGE plpgsql
+        AS $emt_append_to_stream$
+        DECLARE
+            v_next_stream_position bigint;
+            v_position bigint;
+            v_updated_rows int;
+            v_transaction_id xid8;
+            v_global_positions bigint[];
+        BEGIN
+            v_transaction_id := pg_current_xact_id();
+
+            IF v_expected_stream_position IS NULL THEN
+                SELECT COALESCE(
+                    (SELECT stream_position 
+                    FROM emt_streams
+                    WHERE stream_id = v_stream_id 
+                    AND partition = v_partition 
+                    AND is_archived = FALSE
+                    LIMIT 1), 
+                    0
+                ) INTO v_expected_stream_position;
+            END IF;
+
+            v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
+
+            IF v_expected_stream_position = 0 THEN
+                INSERT INTO emt_streams
+                    (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
+                VALUES
+                    (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
+            ELSE
+                UPDATE emt_streams as s              
+                SET stream_position = v_next_stream_position
+                WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
+
+                get diagnostics v_updated_rows = row_count;
+
+                IF v_updated_rows = 0 THEN
+                    RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint[], NULL::xid8;
+                    RETURN;
+                END IF;
+            END IF;
+
+            WITH ev AS (
+                SELECT row_number() OVER () + v_expected_stream_position AS stream_position, 
+                        message_data, 
+                        message_metadata, 
+                        schema_version, 
+                        message_id, 
+                        message_type,
+                        message_kind
+                FROM (
+                    SELECT *
+                    FROM 
+                        unnest(v_message_ids, v_messages_data, v_messages_metadata, v_message_schema_versions, v_message_types, v_message_kinds) 
+                    AS message(message_id, message_data, message_metadata, schema_version, message_type, message_kind)
+                ) AS message
+            ),
+            all_messages_insert AS (
+                INSERT INTO emt_messages
+                    (stream_id, stream_position, partition, message_data, message_metadata, message_schema_version, message_type, message_kind, message_id, transaction_id)
+                SELECT 
+                    v_stream_id, ev.stream_position, v_partition, ev.message_data, ev.message_metadata, ev.schema_version, ev.message_type, ev.message_kind, ev.message_id, v_transaction_id
+                FROM ev
+                RETURNING global_position
+            )
+            SELECT 
+                array_agg(global_position ORDER BY global_position) INTO v_global_positions
+            FROM 
+                all_messages_insert;
+
+            RETURN QUERY SELECT TRUE, v_next_stream_position, v_global_positions, v_transaction_id;
+        END;
+        $emt_append_to_stream$;
       END IF;
-
-      WITH ev AS (
-          SELECT row_number() OVER () + v_expected_stream_position AS stream_position, 
-                message_data, 
-                message_metadata, 
-                schema_version, 
-                message_id, 
-                message_type,
-                message_kind
-          FROM (
-              SELECT *
-              FROM 
-                unnest(v_message_ids, v_messages_data, v_messages_metadata, v_message_schema_versions, v_message_types, v_message_kinds) 
-              AS message(message_id, message_data, message_metadata, schema_version, message_type, message_kind)
-          ) AS message
-      ),
-      all_messages_insert AS (
-          INSERT INTO emt_messages
-              (stream_id, stream_position, partition, message_data, message_metadata, message_schema_version, message_type, message_kind, message_id, transaction_id)
-          SELECT 
-              v_stream_id, ev.stream_position, v_partition, ev.message_data, ev.message_metadata, ev.schema_version, ev.message_type, ev.message_kind, ev.message_id, v_transaction_id
-          FROM ev
-          RETURNING global_position
-      )
-      SELECT 
-          array_agg(global_position ORDER BY global_position) INTO v_global_positions
-      FROM 
-          all_messages_insert;
-
-      RETURN QUERY SELECT TRUE, v_next_stream_position, v_global_positions, v_transaction_id;
-  END;
-  $$;
-  SELECT emt_add_partition('emt:default');
-CREATE OR REPLACE FUNCTION store_subscription_checkpoint(
-  p_subscription_id VARCHAR(100),
-  p_version BIGINT,
-  p_position BIGINT,
-  p_check_position BIGINT,
-  p_transaction_id xid8,
-  p_partition TEXT DEFAULT 'emt:default'
-) RETURNS INT AS $$
+  END $$;
+`;
+const migrationFromEventsToMessagesSQL = SQL`
+DO $$ 
 DECLARE
-  current_position BIGINT;
+    partition_record RECORD;
 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
-      UPDATE "emt_subscriptions"
-      SET 
-        "last_processed_position" = p_position, 
-        "last_processed_transaction_id" = p_transaction_id
-      WHERE "subscription_id" = p_subscription_id AND "last_processed_position" = p_check_position AND "partition" = p_partition;
-
-      IF FOUND THEN
-          RETURN 1;  -- Successfully updated
-      END IF;
-
-      -- Retrieve the current position
-      SELECT "last_processed_position" INTO current_position
-      FROM "emt_subscriptions"
-      WHERE "subscription_id" = p_subscription_id AND "partition" = p_partition;
+    -- Rename the main table and its columns if it exists
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_events') THEN
+        -- Rename all partitions first
+        FOR partition_record IN 
+            SELECT tablename 
+            FROM pg_tables 
+            WHERE tablename LIKE 'emt_events_%'
+            ORDER BY tablename DESC  -- to handle child partitions first
+        LOOP
+            EXECUTE format('ALTER TABLE %I RENAME TO %I', 
+                partition_record.tablename, 
+                REPLACE(partition_record.tablename, 'events', 'messages'));
+        END LOOP;
 
-      -- Return appropriate codes based on current position
-      IF current_position = p_position THEN
-          RETURN 0;  -- Idempotent check: position already set
-      ELSIF current_position > p_check_position THEN
-          RETURN 2;  -- Failure: current position is greater
-      ELSE
-          RETURN 2;  -- Default failure case for mismatched positions
-      END IF;
-  END IF;
+        -- Rename the main table
+        ALTER TABLE emt_events RENAME TO emt_messages;
+        
+        -- Rename columns
+        ALTER TABLE emt_messages 
+            RENAME COLUMN event_data TO message_data;
+        ALTER TABLE emt_messages 
+            RENAME COLUMN event_metadata TO message_metadata;
+        ALTER TABLE emt_messages 
+            RENAME COLUMN event_schema_version TO message_schema_version;
+        ALTER TABLE emt_messages 
+            RENAME COLUMN event_type TO message_type;
+        ALTER TABLE emt_messages 
+            RENAME COLUMN event_id TO message_id;
+        ALTER TABLE emt_messages 
+            ADD COLUMN message_kind CHAR(1) NOT NULL DEFAULT 'E';
 
-  -- Handle the case when p_check_position is NULL: Insert if not exists
-  BEGIN
-      INSERT INTO "emt_subscriptions"("subscription_id", "version", "last_processed_position", "partition", "last_processed_transaction_id")
-      VALUES (p_subscription_id, p_version, p_position, p_partition, p_transaction_id);
-      RETURN 1;  -- Successfully inserted
-  EXCEPTION WHEN unique_violation THEN
-      -- If insertion failed, it means the row already exists
-      SELECT "last_processed_position" INTO current_position
-      FROM "emt_subscriptions"
-      WHERE "subscription_id" = p_subscription_id AND "partition" = p_partition;
+        -- Rename sequence if it exists
+        IF EXISTS (SELECT 1 FROM pg_sequences WHERE sequencename = 'emt_global_event_position') THEN
+            ALTER SEQUENCE emt_global_event_position 
+            RENAME TO emt_global_message_position;
+            
+            ALTER TABLE emt_messages 
+                ALTER COLUMN global_position 
+                SET DEFAULT nextval('emt_global_message_position');
+        END IF;
+    END IF;
+END $$;`;
+const migration_0_38_7_and_older = sqlMigration("emt:postgresql:eventstore:0.38.7:migrate-events-to-messages:with_append_to_stream_update", [
+	dropFutureConceptModuleAndTenantFunctions,
+	dropOldAppendToSQLWithoutGlobalPositions,
+	migrationFromEventsToMessagesSQL
+]);
 
-      IF current_position = p_position THEN
-          RETURN 0;  -- Idempotent check: position already set
-      ELSE
-          RETURN 2;  -- Insertion failed, row already exists with different position
-      END IF;
-  END;
-END;
-$$ LANGUAGE plpgsql;
-`;
+//#endregion
+//#region src/eventStore/schema/migrations/0_38_7/index.ts
+const migrations_0_38_7 = [migration_0_38_7_and_older];
 
 //#endregion
 //#region src/eventStore/schema/migrations/0_42_0/0_42_0.migration.ts
@@ -2176,1064 +2374,216 @@ END;
 $emt_deactivate_projection$;
 `;
 const migration_0_42_0_2_AddProcessorProjectionFunctions = sqlMigration("emt:postgresql:eventstore:0.42.0-2:add-processor-projection-functions", [migration_0_42_0_2_AddProcessorProjectionFunctionsSQL]);
+const migration_0_42_0_3_FixProcessorLockTimeoutSQL = SQL`
+CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
+    p_lock_key               BIGINT,
+    p_processor_id           TEXT,
+    p_version                INT,
+    p_partition              TEXT       DEFAULT '${SQL.plain(defaultTag)}',
+    p_processor_instance_id  TEXT       DEFAULT '${SQL.plain(unknownTag$1)}',
+    p_projection_name        TEXT       DEFAULT NULL,
+    p_projection_type        VARCHAR(1) DEFAULT NULL,
+    p_projection_kind        TEXT       DEFAULT NULL,
+    p_lock_timeout_seconds   INT        DEFAULT 300
+)
+RETURNS TABLE (acquired BOOLEAN, checkpoint TEXT)
+LANGUAGE plpgsql
+AS $emt_try_acquire_processor_lock$
+DECLARE
+  current_position TEXT;
+  v_current_time TIMESTAMPTZ := clock_timestamp();
+BEGIN
+    RETURN QUERY
+    WITH lock_check AS (
+        SELECT pg_try_advisory_xact_lock(p_lock_key) AS lock_acquired
+    ),
+    ownership_check AS (
+        INSERT INTO emt_processors (
+            processor_id,
+            partition,
+            version,
+            processor_instance_id,
+            status,
+            last_processed_checkpoint,
+            last_processed_transaction_id,
+            created_at,
+            last_updated
+        )
+        SELECT p_processor_id, p_partition, p_version, p_processor_instance_id, 'running', '0000000000000000000', '0'::xid8, v_current_time, v_current_time
+        WHERE (SELECT lock_acquired FROM lock_check) = true
+        ON CONFLICT (processor_id, partition, version) DO UPDATE
+        SET processor_instance_id = p_processor_instance_id,
+            status = 'running',
+            last_updated = v_current_time
+        WHERE emt_processors.processor_instance_id = p_processor_instance_id
+           OR emt_processors.processor_instance_id = 'emt:unknown'
+           OR emt_processors.status = 'stopped'
+           OR emt_processors.last_updated < v_current_time - (p_lock_timeout_seconds || ' seconds')::interval
+        RETURNING last_processed_checkpoint
+    ),
+    projection_status AS (
+        INSERT INTO emt_projections (
+            name,
+            partition,
+            version,
+            type,
+            kind,
+            status,
+            definition
+        )
+        SELECT p_projection_name, p_partition, p_version, p_projection_type, p_projection_kind, 'async_processing', '{}'::jsonb
+        WHERE p_projection_name IS NOT NULL
+          AND (SELECT last_processed_checkpoint FROM ownership_check) IS NOT NULL
+        ON CONFLICT (name, partition, version) DO UPDATE
+        SET status = 'async_processing'
+        RETURNING name
+    )
+    SELECT
+        (SELECT COUNT(*) > 0 FROM ownership_check),
+        (SELECT oc.last_processed_checkpoint FROM ownership_check oc);
+END;
+$emt_try_acquire_processor_lock$;
+`;
+const migration_0_42_0_3_FixProcessorLockTimeout = sqlMigration("emt:postgresql:eventstore:0.42.0-3:fix-processor-lock-timeout", [migration_0_42_0_3_FixProcessorLockTimeoutSQL]);
 
 //#endregion
-//#region src/eventStore/schema/migrations/0_42_0/0_42_0.snapshot.ts
-const schema_0_42_0 = SQL`
-  CREATE TABLE IF NOT EXISTS emt_streams(
-      stream_id         TEXT                      NOT NULL,
-      stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT 'emt:default',
-      stream_type       TEXT                      NOT NULL,
-      stream_metadata   JSONB                     NOT NULL,
-      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);
-   
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
-  ON emt_streams(stream_id, partition, is_archived) 
-  INCLUDE (stream_position);
-  CREATE SEQUENCE IF NOT EXISTS emt_global_message_position;
+//#region src/eventStore/schema/migrations/0_42_0/index.ts
+const migrations_0_42_0 = [
+	migration_0_42_0_FromSubscriptionsToProcessors,
+	migration_0_42_0_2_AddProcessorProjectionFunctions,
+	migration_0_42_0_3_FixProcessorLockTimeout
+];
 
-  CREATE TABLE IF NOT EXISTS emt_messages(
-      stream_position        BIGINT                    NOT NULL,
-      global_position        BIGINT                    DEFAULT nextval('emt_global_message_position'),
-      transaction_id         XID8                      NOT NULL,
-      created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
-      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 'emt:default',
-      message_schema_version TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      PRIMARY KEY (stream_id, stream_position, partition, is_archived)
-  ) PARTITION BY LIST (partition);
-  CREATE TABLE IF NOT EXISTS emt_projections(
-      version                       INT                    NOT NULL DEFAULT 1,
-      type                          VARCHAR(1)             NOT NULL,
-      name                          TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT 'emt:default',
-      kind                          TEXT                   NOT NULL,
-      status                        TEXT                   NOT NULL,
-      definition                    JSONB                  NOT NULL DEFAULT '{}'::jsonb,
-      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      PRIMARY KEY (name, partition, version)
-  ) PARTITION BY LIST (partition);
-
-  CREATE TABLE IF NOT EXISTS emt_processors(
-      last_processed_transaction_id XID8                   NOT NULL,
-      version                       INT                    NOT NULL DEFAULT 1,
-      processor_id                  TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT 'emt:default',
-      status                        TEXT                   NOT NULL DEFAULT 'stopped',
-      last_processed_checkpoint     TEXT                   NOT NULL,
-      processor_instance_id         TEXT                   DEFAULT 'emt:unknown',
-      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      PRIMARY KEY (processor_id, partition, version)
-  ) PARTITION BY LIST (partition);
-
-DO $$
-BEGIN
-IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'emt_sanitize_name') THEN
-  CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $emt_sanitize_name$
-    BEGIN
-        RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
-    END;
-    $emt_sanitize_name$ LANGUAGE plpgsql;
-END IF;
-END $$;
-
-DO $$
-BEGIN
-IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'emt_add_table_partition') THEN
-  
-  CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $emt_add_table_partition$
-  DECLARE
-    v_main_partiton_name     TEXT;
-    v_active_partiton_name   TEXT;
-    v_archived_partiton_name TEXT;
-  BEGIN                
-      v_main_partiton_name     := emt_sanitize_name(tableName || '_' || partition_name);
-      v_active_partiton_name   := emt_sanitize_name(v_main_partiton_name   || '_active');
-      v_archived_partiton_name := emt_sanitize_name(v_main_partiton_name   || '_archived');
-
-
-      -- create default partition
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L) PARTITION BY LIST (is_archived);',
-          v_main_partiton_name, tableName, partition_name
-      );
-  
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (FALSE);',
-          v_active_partiton_name, v_main_partiton_name
-      );
-  
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (TRUE);',
-          v_archived_partiton_name, v_main_partiton_name
-      );
-  END;
-  $emt_add_table_partition$ LANGUAGE plpgsql;
-END IF;
-END $$;
-
-DO $$
-BEGIN
-IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'emt_add_partition') THEN
-  
-  CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $emt_add_partition$
-  BEGIN                
-      PERFORM emt_add_table_partition('emt_messages', partition_name);
-      PERFORM emt_add_table_partition('emt_streams', partition_name);
-
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L);',
-          emt_sanitize_name('emt_processors' || '_' || partition_name), 'emt_processors', partition_name
-      );
-
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L);',
-          emt_sanitize_name('emt_projections' || '_' || partition_name), 'emt_projections', partition_name
-      );
-  END;
-  $emt_add_partition$ LANGUAGE plpgsql;
-END IF;
-END $$;
-
-DO $$
-BEGIN
-IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'emt_append_to_stream') THEN
-  CREATE OR REPLACE FUNCTION emt_append_to_stream(
-      v_message_ids text[],
-      v_messages_data jsonb[],
-      v_messages_metadata jsonb[],
-      v_message_schema_versions text[],
-      v_message_types text[],
-      v_message_kinds text[],
-      v_stream_id text,
-      v_stream_type text,
-      v_expected_stream_position bigint DEFAULT NULL,
-      v_partition text DEFAULT emt_sanitize_name('default_partition')
-  ) RETURNS TABLE (
-      success boolean,
-      next_stream_position bigint,
-      global_positions bigint[],
-      transaction_id xid8
-  ) LANGUAGE plpgsql
-  AS $emt_append_to_stream$
-  DECLARE
-      v_next_stream_position bigint;
-      v_position bigint;
-      v_updated_rows int;
-      v_transaction_id xid8;
-      v_global_positions bigint[];
-  BEGIN
-      v_transaction_id := pg_current_xact_id();
-
-      IF v_expected_stream_position IS NULL THEN
-          SELECT COALESCE(
-            (SELECT stream_position 
-            FROM emt_streams
-            WHERE stream_id = v_stream_id 
-              AND partition = v_partition 
-              AND is_archived = FALSE
-            LIMIT 1), 
-            0
-        ) INTO v_expected_stream_position;
-      END IF;
-
-      v_next_stream_position := v_expected_stream_position + array_upper(v_messages_data, 1);
-
-      IF v_expected_stream_position = 0 THEN
-          INSERT INTO emt_streams
-              (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
-          VALUES
-              (v_stream_id, v_next_stream_position, v_partition, v_stream_type, '{}', FALSE);
-      ELSE
-          UPDATE emt_streams as s              
-          SET stream_position = v_next_stream_position
-          WHERE stream_id = v_stream_id AND stream_position = v_expected_stream_position AND partition = v_partition AND is_archived = FALSE;
-
-          get diagnostics v_updated_rows = row_count;
-
-          IF v_updated_rows = 0 THEN
-              RETURN QUERY SELECT FALSE, NULL::bigint, NULL::bigint[], NULL::xid8;
-              RETURN;
-          END IF;
-      END IF;
-
-      WITH ev AS (
-          SELECT row_number() OVER () + v_expected_stream_position AS stream_position, 
-                message_data, 
-                message_metadata, 
-                schema_version, 
-                message_id, 
-                message_type,
-                message_kind
-          FROM (
-              SELECT *
-              FROM 
-                unnest(v_message_ids, v_messages_data, v_messages_metadata, v_message_schema_versions, v_message_types, v_message_kinds) 
-              AS message(message_id, message_data, message_metadata, schema_version, message_type, message_kind)
-          ) AS message
-      ),
-      all_messages_insert AS (
-          INSERT INTO emt_messages
-              (stream_id, stream_position, partition, message_data, message_metadata, message_schema_version, message_type, message_kind, message_id, transaction_id)
-          SELECT 
-              v_stream_id, ev.stream_position, v_partition, ev.message_data, ev.message_metadata, ev.schema_version, ev.message_type, ev.message_kind, ev.message_id, v_transaction_id
-          FROM ev
-          RETURNING global_position
-      )
-      SELECT 
-          array_agg(global_position ORDER BY global_position) INTO v_global_positions
-      FROM 
-          all_messages_insert;
-
-      RETURN QUERY SELECT TRUE, v_next_stream_position, v_global_positions, v_transaction_id;
-  END;
-  $emt_append_to_stream$;
-  
-END IF;
-END $$;
-SELECT emt_add_partition('emt:default');
-DO $$
-BEGIN
-IF NOT EXISTS (SELECT 1 FROM pg_proc WHERE proname = 'store_processor_checkpoint') THEN
-  
-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 'emt:default',
-  p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
-) RETURNS INT AS $spc$
-DECLARE
-  current_position TEXT;
-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
-      UPDATE "emt_processors"
-      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;  -- Successfully updated
-      END IF;
-
-      -- Retrieve the current position
-      SELECT "last_processed_checkpoint" INTO current_position
-      FROM "emt_processors"
-      WHERE "processor_id" = p_processor_id 
-        AND "partition" = p_partition 
-        AND "version" = p_version;
-
-      -- Return appropriate codes based on current position
-      IF current_position = p_position THEN
-          RETURN 0;  -- Idempotent check: position already set
-      ELSIF current_position > p_position THEN
-          RETURN 3;  -- Current ahead: another process has progressed further
-      ELSE
-          RETURN 2;  -- Mismatch: check position doesn't match current
-      END IF;
-  END IF;
-
-  -- Handle the case when p_check_position is NULL: Insert if not exists
-  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;  -- Successfully inserted
-  EXCEPTION WHEN unique_violation THEN
-      -- If insertion failed, it means the row already exists
-      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;  -- Idempotent check: position already set
-      ELSIF current_position > p_position THEN
-          RETURN 3;  -- Current ahead: another process has progressed further
-      ELSE
-          RETURN 2;  -- Insertion failed, row already exists with different position
-      END IF;
-  END;
-END;
-$spc$ LANGUAGE plpgsql;
-
-END IF;
-END $$;
-
-CREATE OR REPLACE FUNCTION emt_try_acquire_processor_lock(
-    p_lock_key               BIGINT,
-    p_processor_id           TEXT,
-    p_version                INT,
-    p_partition              TEXT       DEFAULT 'emt:default',
-    p_processor_instance_id  TEXT       DEFAULT 'emt:unknown',
-    p_projection_name        TEXT       DEFAULT NULL,
-    p_projection_type        VARCHAR(1) DEFAULT NULL,
-    p_projection_kind        TEXT       DEFAULT NULL,
-    p_lock_timeout_seconds   INT        DEFAULT 300
-)
-RETURNS TABLE (acquired BOOLEAN, checkpoint TEXT)
-LANGUAGE plpgsql
-AS $emt_try_acquire_processor_lock$
-BEGIN
-    RETURN QUERY
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock(p_lock_key) AS lock_acquired
-    ),
-    ownership_check AS (
-        INSERT INTO emt_processors (
-            processor_id,
-            partition,
-            version,
-            processor_instance_id,
-            status,
-            last_processed_checkpoint,
-            last_processed_transaction_id,
-            created_at,
-            last_updated
-        )
-        SELECT p_processor_id, p_partition, p_version, p_processor_instance_id, 'running', '0000000000000000000', '0'::xid8, now(), now()
-        WHERE (SELECT lock_acquired FROM lock_check) = true
-        ON CONFLICT (processor_id, partition, version) DO UPDATE
-        SET processor_instance_id = p_processor_instance_id,
-            status = 'running',
-            last_updated = now()
-        WHERE emt_processors.processor_instance_id = p_processor_instance_id
-           OR emt_processors.processor_instance_id = 'emt:unknown'
-           OR emt_processors.status = 'stopped'
-           OR emt_processors.last_updated < now() - (p_lock_timeout_seconds || ' seconds')::interval
-        RETURNING last_processed_checkpoint
-    ),
-    projection_status AS (
-        INSERT INTO emt_projections (
-            name,
-            partition,
-            version,
-            type,
-            kind,
-            status,
-            definition
-        )
-        SELECT p_projection_name, p_partition, p_version, p_projection_type, p_projection_kind, 'async_processing', '{}'::jsonb
-        WHERE p_projection_name IS NOT NULL
-          AND (SELECT last_processed_checkpoint FROM ownership_check) IS NOT NULL
-        ON CONFLICT (name, partition, version) DO UPDATE
-        SET status = 'async_processing'
-        RETURNING name
-    )
-    SELECT
-        (SELECT COUNT(*) > 0 FROM ownership_check),
-        (SELECT oc.last_processed_checkpoint FROM ownership_check oc);
-END;
-$emt_try_acquire_processor_lock$;
-
-CREATE OR REPLACE FUNCTION emt_release_processor_lock(
-    p_lock_key              BIGINT,
-    p_processor_id          TEXT,
-    p_partition             TEXT,
-    p_version               INT,
-    p_processor_instance_id TEXT DEFAULT 'emt:unknown',
-    p_projection_name       TEXT DEFAULT NULL
-)
-RETURNS BOOLEAN
-LANGUAGE plpgsql
-AS $emt_release_processor_lock$
-DECLARE
-    v_rows_updated INT;
-BEGIN
-    IF p_projection_name IS NOT NULL THEN
-        UPDATE emt_projections
-        SET status = 'active',
-            last_updated = now()
-        WHERE partition = p_partition
-          AND name = p_projection_name
-          AND version = p_version;
-    END IF;
-
-    UPDATE emt_processors
-    SET status = 'stopped',
-        processor_instance_id = 'emt:unknown',
-        last_updated = now()
-    WHERE processor_id = p_processor_id
-      AND partition = p_partition
-      AND version = p_version
-      AND processor_instance_id = p_processor_instance_id;
-
-    GET DIAGNOSTICS v_rows_updated = ROW_COUNT;
-
-    PERFORM pg_advisory_unlock(p_lock_key);
-
-    RETURN v_rows_updated > 0;
-END;
-$emt_release_processor_lock$;
-
-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 emt_projections
-        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$;
-
-CREATE OR REPLACE FUNCTION emt_register_projection(
-    p_lock_key      BIGINT,
-    p_name          TEXT,
-    p_partition     TEXT,
-    p_version       INT,
-    p_type          VARCHAR(1),
-    p_kind          TEXT,
-    p_status        TEXT,
-    p_definition    JSONB
-)
-RETURNS BOOLEAN
-LANGUAGE plpgsql
-AS $emt_register_projection$
-DECLARE
-    v_result BOOLEAN;
-BEGIN
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock(p_lock_key) AS lock_acquired
-    ),
-    upsert_result AS (
-        INSERT INTO emt_projections (
-            name, partition, version, type, kind, status, definition, created_at, last_updated
-        )
-        SELECT p_name, p_partition, p_version, p_type, p_kind, p_status, p_definition, now(), now()
-        WHERE (SELECT lock_acquired FROM lock_check) = true
-        ON CONFLICT (name, partition, version) DO UPDATE
-        SET definition = EXCLUDED.definition,
-            last_updated = now()
-        RETURNING name
-    )
-    SELECT COUNT(*) > 0 INTO v_result FROM upsert_result;
-
-    RETURN v_result;
-END;
-$emt_register_projection$;
-
-CREATE OR REPLACE FUNCTION emt_activate_projection(
-    p_lock_key   BIGINT,
-    p_name       TEXT,
-    p_partition  TEXT,
-    p_version    INT
-)
-RETURNS BOOLEAN
-LANGUAGE plpgsql
-AS $emt_activate_projection$
-DECLARE
-    v_result BOOLEAN;
-BEGIN
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock(p_lock_key) AS lock_acquired
-    ),
-    update_result AS (
-        UPDATE emt_projections
-        SET status = 'active',
-            last_updated = now()
-        WHERE name = p_name
-          AND partition = p_partition
-          AND version = p_version
-          AND (SELECT lock_acquired FROM lock_check) = true
-        RETURNING name
-    )
-    SELECT COUNT(*) > 0 INTO v_result FROM update_result;
-
-    RETURN v_result;
-END;
-$emt_activate_projection$;
-
-CREATE OR REPLACE FUNCTION emt_deactivate_projection(
-    p_lock_key   BIGINT,
-    p_name       TEXT,
-    p_partition  TEXT,
-    p_version    INT
-)
-RETURNS BOOLEAN
-LANGUAGE plpgsql
-AS $emt_deactivate_projection$
-DECLARE
-    v_result BOOLEAN;
-BEGIN
-    WITH lock_check AS (
-        SELECT pg_try_advisory_xact_lock(p_lock_key) AS lock_acquired
-    ),
-    update_result AS (
-        UPDATE emt_projections
-        SET status = 'inactive',
-            last_updated = now()
-        WHERE name = p_name
-          AND partition = p_partition
-          AND version = p_version
-          AND (SELECT lock_acquired FROM lock_check) = true
-        RETURNING name
-    )
-    SELECT COUNT(*) > 0 INTO v_result FROM update_result;
-
-    RETURN v_result;
-END;
-$emt_deactivate_projection$;
-`;
-
-//#endregion
-//#region src/eventStore/schema/storeProcessorCheckpoint.ts
-const storeSubscriptionCheckpointSQL = createFunctionIfDoesNotExistSQL("store_processor_checkpoint", 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 '${SQL.plain(defaultTag)}',
-  p_processor_instance_id  TEXT DEFAULT '${SQL.plain(unknownTag)}'
-) RETURNS INT AS $spc$
-DECLARE
-  current_position TEXT;
-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
-      UPDATE "${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;  -- Successfully updated
-      END IF;
-
-      -- Retrieve the current position
-      SELECT "last_processed_checkpoint" INTO current_position
-      FROM "${SQL.plain(processorsTable.name)}"
-      WHERE "processor_id" = p_processor_id 
-        AND "partition" = p_partition 
-        AND "version" = p_version;
-
-      -- Return appropriate codes based on current position
-      IF current_position = p_position THEN
-          RETURN 0;  -- Idempotent check: position already set
-      ELSIF current_position > p_position THEN
-          RETURN 3;  -- Current ahead: another process has progressed further
-      ELSE
-          RETURN 2;  -- Mismatch: check position doesn't match current
-      END IF;
-  END IF;
-
-  -- Handle the case when p_check_position is NULL: Insert if not exists
-  BEGIN
-      INSERT INTO "${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;  -- Successfully inserted
-  EXCEPTION WHEN unique_violation THEN
-      -- If insertion failed, it means the row already exists
-      SELECT "last_processed_checkpoint" INTO current_position
-      FROM "${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;  -- Idempotent check: position already set
-      ELSIF current_position > p_position THEN
-          RETURN 3;  -- Current ahead: another process has progressed further
-      ELSE
-          RETURN 2;  -- Insertion failed, row already exists with different position
-      END IF;
-  END;
-END;
-$spc$ LANGUAGE plpgsql;
-`);
-const callStoreProcessorCheckpoint = (params) => SQL`
-    SELECT store_processor_checkpoint(
-      ${params.processorId}, 
-      ${params.version}, 
-      ${params.position}, 
-      ${params.checkPosition}, 
-      pg_current_xact_id(), 
-      ${params.partition}, 
-      ${params.processorInstanceId}
-    ) as result;`;
-const storeProcessorCheckpoint = async (execute, options) => {
-	try {
-		const { result } = await single(execute.command(callStoreProcessorCheckpoint({
-			processorId: options.processorId,
-			version: options.version ?? 1,
-			position: options.newCheckpoint !== null ? options.newCheckpoint : null,
-			checkPosition: options.lastProcessedCheckpoint !== null ? options.lastProcessedCheckpoint : null,
-			partition: options.partition ?? defaultTag,
-			processorInstanceId: options.processorInstanceId ?? unknownTag
-		})));
-		return result === 1 ? {
-			success: true,
-			newCheckpoint: options.newCheckpoint
-		} : {
-			success: false,
-			reason: result === 0 ? "IGNORED" : result === 3 ? "CURRENT_AHEAD" : "MISMATCH"
-		};
-	} catch (error) {
-		console.log(error);
-		throw error;
-	}
-};
-
-//#endregion
-//#region src/eventStore/schema/migrations/0_43_0/index.ts
-const migration_0_43_0_cleanupLegacySubscriptionSQL = SQL`
-DO $$
-BEGIN
-IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_subscriptions') THEN
-    -- Restore clean emt_add_partition (remove creation of emt_subscriptions partitions)
-    CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $fnpar$
-    BEGIN                
-        PERFORM emt_add_table_partition('${SQL.plain(messagesTable.name)}', partition_name);
-        PERFORM emt_add_table_partition('${SQL.plain(streamsTable.name)}', partition_name);
-    
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (%L);',
-            emt_sanitize_name('${SQL.plain(processorsTable.name)}' || '_' || partition_name), '${SQL.plain(processorsTable.name)}', partition_name
-        );
-    
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (%L);',
-            emt_sanitize_name('${SQL.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL.plain(projectionsTable.name)}', partition_name
-        );
-    END;
-    $fnpar$ LANGUAGE plpgsql;
-
-    -- Drop old subscriptions table if it exists
-    DROP TABLE IF EXISTS emt_subscriptions CASCADE;
-
-    -- Drop old function if it exists
-    DROP FUNCTION IF EXISTS store_subscription_checkpoint(character varying, bigint, bigint, bigint, xid8, text);
-    
-    -- Restore clean store_processor_checkpoint (remove dual-write logic)
-    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 '${SQL.plain(defaultTag)}',
-      p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
-    ) RETURNS INT AS $fn$
-    DECLARE
-      current_position TEXT;
-    BEGIN
-      IF p_check_position IS NOT NULL THEN
-          UPDATE "emt_processors"
-          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;
-
-          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;
-          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 = sqlMigration("emt:postgresql:eventstore:0.43.0:cleanup-legacy-subscription", [migration_0_43_0_cleanupLegacySubscriptionSQL]);
-const cleanupLegacySubscriptionTables = async (connectionString) => {
-	const pool = dumbo({ connectionString });
-	try {
-		await pool.withTransaction(async ({ execute }) => {
-			await execute.command(migration_0_43_0_cleanupLegacySubscriptionSQL);
-		});
-	} finally {
-		await pool.close();
-	}
-};
-
-//#endregion
-//#region src/eventStore/schema/tables.ts
-const streamsTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS ${SQL.identifier(streamsTable.name)}(
-      stream_id         TEXT                      NOT NULL,
-      stream_position   BIGINT                    NOT NULL,
-      partition         TEXT                      NOT NULL DEFAULT '${SQL.plain(defaultTag)}',
-      stream_type       TEXT                      NOT NULL,
-      stream_metadata   JSONB                     NOT NULL,
-      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
-      PRIMARY KEY (stream_id, partition, is_archived)
-  ) PARTITION BY LIST (partition);
-   
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_streams_unique 
-  ON ${SQL.identifier(streamsTable.name)}(stream_id, partition, is_archived) 
-  INCLUDE (stream_position);`;
-const messagesTableSQL = SQL`
-  CREATE SEQUENCE IF NOT EXISTS emt_global_message_position;
-
-  CREATE TABLE IF NOT EXISTS ${SQL.identifier(messagesTable.name)}(
-      stream_position        BIGINT                    NOT NULL,
-      global_position        BIGINT                    DEFAULT nextval('emt_global_message_position'),
-      transaction_id         XID8                      NOT NULL,
-      created                TIMESTAMPTZ               NOT NULL DEFAULT now(),
-      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 '${SQL.plain(defaultTag)}',
-      message_schema_version TEXT                      NOT NULL,
-      message_id             TEXT                      NOT NULL,
-      message_type           TEXT                      NOT NULL,
-      message_data           JSONB                     NOT NULL,
-      message_metadata       JSONB                     NOT NULL,
-      PRIMARY KEY (stream_id, stream_position, partition, is_archived)
-  ) PARTITION BY LIST (partition);`;
-const processorsTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS ${SQL.identifier(processorsTable.name)}(
-      last_processed_transaction_id XID8                   NOT NULL,
-      version                       INT                    NOT NULL DEFAULT 1,
-      processor_id                  TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT '${SQL.plain(defaultTag)}',
-      status                        TEXT                   NOT NULL DEFAULT 'stopped',
-      last_processed_checkpoint     TEXT                   NOT NULL,
-      processor_instance_id         TEXT                   DEFAULT '${SQL.plain(unknownTag)}',
-      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      PRIMARY KEY (processor_id, partition, version)
-  ) PARTITION BY LIST (partition);
-`;
-const projectionsTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS ${SQL.identifier(projectionsTable.name)}(
-      version                       INT                    NOT NULL DEFAULT 1,
-      type                          VARCHAR(1)             NOT NULL,
-      name                          TEXT                   NOT NULL,
-      partition                     TEXT                   NOT NULL DEFAULT '${SQL.plain(defaultTag)}',
-      kind                          TEXT                   NOT NULL,
-      status                        TEXT                   NOT NULL,
-      definition                    JSONB                  NOT NULL DEFAULT '{}'::jsonb,
-      created_at                    TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      last_updated                  TIMESTAMPTZ            NOT NULL DEFAULT now(),
-      PRIMARY KEY (name, partition, version)
-  ) PARTITION BY LIST (partition);
-`;
-const sanitizeNameSQL = createFunctionIfDoesNotExistSQL("emt_sanitize_name", SQL`CREATE OR REPLACE FUNCTION emt_sanitize_name(input_name TEXT) RETURNS TEXT AS $emt_sanitize_name$
-    BEGIN
-        RETURN REGEXP_REPLACE(input_name, '[^a-zA-Z0-9_]', '_', 'g');
-    END;
-    $emt_sanitize_name$ LANGUAGE plpgsql;`);
-const addTablePartitions = createFunctionIfDoesNotExistSQL("emt_add_table_partition", SQL`
-  CREATE OR REPLACE FUNCTION emt_add_table_partition(tableName TEXT, partition_name TEXT) RETURNS void AS $emt_add_table_partition$
-  DECLARE
-    v_main_partiton_name     TEXT;
-    v_active_partiton_name   TEXT;
-    v_archived_partiton_name TEXT;
-  BEGIN                
-      v_main_partiton_name     := emt_sanitize_name(tableName || '_' || partition_name);
-      v_active_partiton_name   := emt_sanitize_name(v_main_partiton_name   || '_active');
-      v_archived_partiton_name := emt_sanitize_name(v_main_partiton_name   || '_archived');
-
-
-      -- create default partition
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L) PARTITION BY LIST (is_archived);',
-          v_main_partiton_name, tableName, partition_name
-      );
-  
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (FALSE);',
-          v_active_partiton_name, v_main_partiton_name
-      );
-  
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (TRUE);',
-          v_archived_partiton_name, v_main_partiton_name
-      );
-  END;
-  $emt_add_table_partition$ LANGUAGE plpgsql;`);
-const addPartitionSQL = createFunctionIfDoesNotExistSQL("emt_add_partition", SQL`
-  CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $emt_add_partition$
-  BEGIN                
-      PERFORM emt_add_table_partition('${SQL.plain(messagesTable.name)}', partition_name);
-      PERFORM emt_add_table_partition('${SQL.plain(streamsTable.name)}', partition_name);
-
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L);',
-          emt_sanitize_name('${SQL.plain(processorsTable.name)}' || '_' || partition_name), '${SQL.plain(processorsTable.name)}', partition_name
-      );
-
-      EXECUTE format('
-          CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-          FOR VALUES IN (%L);',
-          emt_sanitize_name('${SQL.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL.plain(projectionsTable.name)}', partition_name
-      );
-  END;
-  $emt_add_partition$ LANGUAGE plpgsql;`);
-const addModuleSQL = SQL`
-      CREATE OR REPLACE FUNCTION add_module(new_module TEXT) RETURNS void AS $$
-      BEGIN
-          -- For ${SQL.plain(messagesTable.name)} table
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}'), '${SQL.plain(messagesTable.name)}', new_module, '${SQL.plain(globalTag)}'
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-              FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-              FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
-          );
-  
-          -- For ${SQL.plain(streamsTable.name)} table
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-              FOR VALUES IN (emt_sanitize_name(%L || ''__'' || %L)) PARTITION BY LIST (is_archived);',
-              emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}'), '${SQL.plain(streamsTable.name)}', new_module, '${SQL.plain(globalTag)}'
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-              FOR VALUES IN (FALSE);',
-              emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
-          );
-  
-          EXECUTE format('
-              CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-              FOR VALUES IN (TRUE);',
-              emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}' || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || '${SQL.plain(globalTag)}')
-          );
-      END;
-      $$ LANGUAGE plpgsql;
-    `;
-const addTenantSQL = SQL`
-    CREATE OR REPLACE FUNCTION add_tenant(new_module TEXT, new_tenant TEXT) RETURNS void AS $$
-    BEGIN
-        -- For ${SQL.plain(messagesTable.name)} table
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant), '${SQL.plain(messagesTable.name)}', new_module, new_tenant
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-            FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-            FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || new_tenant)
-        );
-  
-        -- For ${SQL.plain(streamsTable.name)} table
+//#endregion
+//#region src/eventStore/schema/migrations/0_43_0/0_43_0.migration.ts
+const migration_0_43_0_cleanupLegacySubscriptionSQL = SQL`
+DO $$
+BEGIN
+IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'emt_subscriptions') THEN
+    -- Restore clean emt_add_partition (remove creation of emt_subscriptions partitions)
+    CREATE OR REPLACE FUNCTION emt_add_partition(partition_name TEXT) RETURNS void AS $fnpar$
+    BEGIN                
+        PERFORM emt_add_table_partition('${SQL.plain(messagesTable.name)}', partition_name);
+        PERFORM emt_add_table_partition('${SQL.plain(streamsTable.name)}', partition_name);
+    
         EXECUTE format('
             CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-            FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-            emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant), '${SQL.plain(streamsTable.name)}', new_module, new_tenant
-        );
-  
-        EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-            FOR VALUES IN (FALSE);',
-            emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+            FOR VALUES IN (%L);',
+            emt_sanitize_name('${SQL.plain(processorsTable.name)}' || '_' || partition_name), '${SQL.plain(processorsTable.name)}', partition_name
         );
-  
+    
         EXECUTE format('
-            CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-            FOR VALUES IN (TRUE);',
-            emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || new_tenant)
+            CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
+            FOR VALUES IN (%L);',
+            emt_sanitize_name('${SQL.plain(projectionsTable.name)}' || '_' || partition_name), '${SQL.plain(projectionsTable.name)}', partition_name
         );
     END;
-    $$ LANGUAGE plpgsql;
-  `;
-const addModuleForAllTenantsSQL = SQL`
-    CREATE OR REPLACE FUNCTION add_module_for_all_tenants(new_module TEXT) RETURNS void AS $$
-    DECLARE
-        tenant_record RECORD;
-    BEGIN
-        PERFORM add_module(new_module);
-  
-        FOR tenant_record IN SELECT DISTINCT tenant FROM ${SQL.plain(messagesTable.name)}
-        LOOP
-            -- For ${SQL.plain(messagesTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL.plain(messagesTable.name)}', new_module, tenant_record.tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-  
-            -- For ${SQL.plain(streamsTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant), '${SQL.plain(streamsTable.name)}', new_module, tenant_record.tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || new_module || '__' || tenant_record.tenant)
-            );
-        END LOOP;
-    END;
-    $$ LANGUAGE plpgsql;
-  `;
-const addTenantForAllModulesSQL = SQL`
-    CREATE OR REPLACE FUNCTION add_tenant_for_all_modules(new_tenant TEXT) RETURNS void AS $$
+    $fnpar$ LANGUAGE plpgsql;
+
+    -- Drop old subscriptions table if it exists
+    DROP TABLE IF EXISTS emt_subscriptions CASCADE;
+
+    -- Drop old function if it exists
+    DROP FUNCTION IF EXISTS store_subscription_checkpoint(character varying, bigint, bigint, bigint, xid8, text);
+    
+    -- Restore clean store_processor_checkpoint (remove dual-write logic)
+    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 '${SQL.plain(defaultTag)}',
+      p_processor_instance_id  TEXT DEFAULT 'emt:unknown'
+    ) RETURNS INT AS $fn$
     DECLARE
-        module_record RECORD;
+      current_position TEXT;
     BEGIN
-        FOR module_record IN SELECT DISTINCT partitionname FROM pg_partman.part_config WHERE parent_table = '${SQL.plain(messagesTable.name)}'
-        LOOP
-            -- For ${SQL.plain(messagesTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL.plain(messagesTable.name)}', module_record.partitionname, new_tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(messagesTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-  
-            -- For ${SQL.plain(streamsTable.name)} table
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I PARTITION OF %I
-                FOR VALUES IN (emt_sanitize_name(''%s__%s'')) PARTITION BY LIST (is_archived);',
-                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant), '${SQL.plain(streamsTable.name)}', module_record.partitionname, new_tenant
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_active PARTITION OF %I
-                FOR VALUES IN (FALSE);',
-                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_active'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-  
-            EXECUTE format('
-                CREATE TABLE IF NOT EXISTS %I_archived PARTITION OF %I
-                FOR VALUES IN (TRUE);',
-                emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant || '_archived'), emt_sanitize_name('${SQL.plain(streamsTable.name)}_' || module_record.partitionname || '__' || new_tenant)
-            );
-        END LOOP;
+      IF p_check_position IS NOT NULL THEN
+          UPDATE "emt_processors"
+          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;
+
+          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;
+          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;
-    $$ LANGUAGE plpgsql;
-  `;
-const addDefaultPartitionSQL = SQL`SELECT emt_add_partition('${SQL.plain(defaultTag)}');`;
+    $fn$ LANGUAGE plpgsql;
+END IF;
+END $$;
+`;
+const migration_0_43_0_cleanupLegacySubscription = sqlMigration("emt:postgresql:eventstore:0.43.0:cleanup-legacy-subscription", [migration_0_43_0_cleanupLegacySubscriptionSQL]);
+
+//#endregion
+//#region src/eventStore/schema/migrations/0_43_0/index.ts
+const migrations_0_43_0 = [migration_0_43_0_cleanupLegacySubscription];
+
+//#endregion
+//#region src/eventStore/schema/migrations/index.ts
+const schemaSQL$1 = [
+	streamsTableSQL,
+	messagesTableSQL,
+	projectionsTableSQL,
+	processorsTableSQL,
+	sanitizeNameSQL,
+	addTablePartitions,
+	addPartitionSQL,
+	appendToStreamSQL,
+	addDefaultPartitionSQL,
+	storeSubscriptionCheckpointSQL,
+	tryAcquireProcessorLockSQL,
+	releaseProcessorLockSQL,
+	registerProjectionSQL,
+	activateProjectionSQL,
+	deactivateProjectionSQL
+];
+const currentPostgreSQLEventStoreSchemaVersion = "0.43.0";
+const schemaMigration$1 = sqlMigration("emt:postgresql:eventstore:initial", schemaSQL$1);
+const pastEventStoreSchemaMigrations = [
+	...migrations_0_38_7,
+	...migrations_0_42_0,
+	...migrations_0_43_0
+];
+const eventStoreSchemaMigrations = [...pastEventStoreSchemaMigrations, schemaMigration$1];
 
 //#endregion
 //#region src/eventStore/schema/readProcessorCheckpoint.ts
@@ -3315,12 +2665,6 @@ const schemaSQL = [
 	deactivateProjectionSQL
 ];
 const schemaMigration = sqlMigration("emt:postgresql:eventstore:initial", schemaSQL);
-const eventStoreSchemaMigrations = [
-	migration_0_38_7_and_older,
-	migration_0_42_0_FromSubscriptionsToProcessors,
-	migration_0_42_0_2_AddProcessorProjectionFunctions,
-	schemaMigration
-];
 const createEventStoreSchema = (connectionString, pool, hooks, options) => {
 	return pool.withTransaction(async (tx) => {
 		const context = await transactionToPostgreSQLProjectionHandlerContext(connectionString, pool, tx);
@@ -3371,24 +2715,32 @@ const getPostgreSQLEventStore = (connectionString, options = defaultPostgreSQLOp
 	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;
+		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();
@@ -3562,8 +2914,8 @@ const postgreSQLProjector = (options) => {
 		partition,
 		processorInstanceId,
 		projection: options.projection ? {
-			name: options.projection.name ?? unknownTag$1,
-			kind: options.projection.kind ?? unknownTag$1,
+			name: options.projection.name ?? unknownTag,
+			kind: options.projection.kind ?? unknownTag,
 			version: options.projection.version ?? version,
 			handlingType: "async"
 		} : void 0,
@@ -3701,10 +3053,15 @@ const postgreSQLEventStoreConsumer = (options) => {
 			reason: "No active processors"
 		};
 		return (await Promise.allSettled(activeProcessors.map(async (s) => {
-			return await s.handle(messagesBatch, { connection: {
-				connectionString: options.connectionString,
-				pool
-			} });
+			try {
+				return await s.handle(messagesBatch, { connection: {
+					connectionString: options.connectionString,
+					pool
+				} });
+			} catch (error) {
+				console.log(`Error during message batch processing for processor: ${s.id}`, error);
+				throw error;
+			}
 		}))).some((r) => r.status === "fulfilled" && r.value?.type !== "STOP") ? void 0 : { type: "STOP" };
 	};
 	const processorContext = {
@@ -3725,7 +3082,11 @@ const postgreSQLEventStoreConsumer = (options) => {
 			abortController?.abort();
 			await messagePuller.stop();
 		}
-		await start;
+		try {
+			await start;
+		} catch (error) {
+			console.log("Error during consumer stop:", error);
+		}
 		messagePuller = void 0;
 		abortController = null;
 		await stopProcessors();
@@ -3733,7 +3094,16 @@ const postgreSQLEventStoreConsumer = (options) => {
 	const init = async () => {
 		if (isInitialized) return;
 		const postgresProcessors = processors;
-		for (const processor of postgresProcessors) if (processor.init) await processor.init(processorContext);
+		for (const processor of postgresProcessors) if (processor.init) try {
+			await processor.init(processorContext);
+		} catch (error) {
+			console.log(`Error during processor initialization for processor: ${processor.id}. Stopping it.`, error);
+			await processor.close(processorContext).catch((closeError) => {
+				console.log(`Error during processor cleanup after failed initialization for processor: ${processor.id}`, closeError);
+			});
+			console.log(`Processor ${processor.id} stopped successfully after failed initialization.`);
+			throw error;
+		}
 		isInitialized = true;
 	};
 	return {
@@ -3760,9 +3130,13 @@ const postgreSQLEventStoreConsumer = (options) => {
 			return processor;
 		},
 		start: () => {
-			if (isRunning) return start;
+			if (isRunning) {
+				console.log("Consumer is already running. Returning the existing start promise.");
+				return start;
+			}
 			startedAwaiter.reset();
 			if (processors.length === 0) {
+				console.log("Cannot start consumer without at least a single processor");
 				const error = new EmmettError("Cannot start consumer without at least a single processor");
 				startedAwaiter.reject(error);
 				return Promise.reject(error);
@@ -3780,16 +3154,25 @@ const postgreSQLEventStoreConsumer = (options) => {
 						pullingFrequencyInMs: pulling?.pullingFrequencyInMs ?? 50,
 						signal: abortController.signal
 					});
-					if (!isInitialized) await init();
+					if (!isInitialized) {
+						console.log("Initializing consumer before starting message pulling.");
+						await init();
+					}
 					const startFrom = zipPostgreSQLEventStoreMessageBatchPullerStartFrom(await Promise.all(processors.map(async (o) => {
-						return await o.start({
-							execute: pool.execute,
-							connection: {
-								connectionString: options.connectionString,
-								pool
-							}
-						});
+						try {
+							return await o.start({
+								execute: pool.execute,
+								connection: {
+									connectionString: options.connectionString,
+									pool
+								}
+							});
+						} catch (error) {
+							console.log(`Error during processor start position retrieval for processor: ${o.id}. Stopping it.`, error);
+							throw error;
+						}
 					})));
+					console.log(`Starting message pulling with start position: ${JSONSerializer.serialize(startFrom)}. Waiting for messages...`);
 					await messagePuller.start({
 						startFrom,
 						started: startedAwaiter
@@ -3831,11 +3214,11 @@ const rebuildPostgreSQLProjections = (options) => {
 	};
 	const projections = "projections" in options ? options.projections.map((p) => "projection" in p ? {
 		truncateOnStart: true,
-		processorId: getProjectorId({ projectionName: p.projection.name ?? unknownTag$1 }),
+		processorId: getProjectorId({ projectionName: p.projection.name ?? unknownTag }),
 		...p
 	} : {
 		projection: p,
-		processorId: getProjectorId({ projectionName: p.name ?? unknownTag$1 }),
+		processorId: getProjectorId({ projectionName: p.name ?? unknownTag }),
 		truncateOnStart: true
 	}) : [options];
 	for (const projectionDefinition of projections) consumer.projector({
@@ -3847,5 +3230,5 @@ const rebuildPostgreSQLProjections = (options) => {
 };
 
 //#endregion
-export { DefaultPostgreSQLEventStoreProcessorBatchSize, DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs, DefaultPostgreSQLProcessorLockPolicy, PostgreSQLEventStoreDefaultStreamVersion, PostgreSQLProjectionSpec, activateProjection, activateProjectionSQL, addDefaultPartitionSQL, addModuleForAllTenantsSQL, addModuleSQL, addPartitionSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, appendToStream, appendToStreamSQL, assertSQLQueryResultMatches, callActivateProjection, callAppendToStream, callDeactivateProjection, callRegisterProjection, callReleaseProcessorLock, callStoreProcessorCheckpoint, callTryAcquireProcessorLock, callTryAcquireProjectionLock, cleanupLegacySubscriptionTables, createEventStoreSchema, deactivateProjection, deactivateProjectionSQL, defaultPostgreSQLOptions, defaultTag, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, emmettPrefix, eventInStream, eventStoreSchemaMigrations, eventsInStream, expectPongoDocuments, expectSQL, getPostgreSQLEventStore, globalNames, globalTag, handleProjections, messagesTable, messagesTableSQL, newEventsInStream, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, postgreSQLCheckpointer, postgreSQLEventStoreConsumer, postgreSQLEventStoreMessageBatchPuller, postgreSQLProcessorLock, postgreSQLProjection, postgreSQLProjectionLock, postgreSQLProjector, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, postgreSQLReactor, postgreSQLWorkflowProcessor, processorsTable, processorsTableSQL, projectionsTable, projectionsTableSQL, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readProjectionInfo, readStream, rebuildPostgreSQLProjections, registerProjection, registerProjectionSQL, releaseProcessorLockSQL, sanitizeNameSQL, schemaMigration, schemaSQL, storeProcessorCheckpoint, storeSubscriptionCheckpointSQL, streamExists, streamsTable, streamsTableSQL, toProcessorLockKey, toProjectionLockKey, transactionToPostgreSQLProjectionHandlerContext, tryAcquireProcessorLockSQL, tryAcquireProjectionLockSQL, unknownTag, zipPostgreSQLEventStoreMessageBatchPullerStartFrom };
+export { DefaultPostgreSQLEventStoreProcessorBatchSize, DefaultPostgreSQLEventStoreProcessorPullingFrequencyInMs, DefaultPostgreSQLProcessorLockPolicy, PostgreSQLEventStoreDefaultStreamVersion, PostgreSQLProjectionSpec, activateProjection, activateProjectionSQL, addDefaultPartitionSQL, addModuleForAllTenantsSQL, addModuleSQL, addPartitionSQL, addTablePartitions, addTenantForAllModulesSQL, addTenantSQL, appendToStream, appendToStreamSQL, assertSQLQueryResultMatches, callActivateProjection, callAppendToStream, callDeactivateProjection, callRegisterProjection, callReleaseProcessorLock, callStoreProcessorCheckpoint, callTryAcquireProcessorLock, callTryAcquireProjectionLock, createEventStoreSchema, currentPostgreSQLEventStoreSchemaVersion, deactivateProjection, deactivateProjectionSQL, defaultPostgreSQLOptions, documentDoesNotExist, documentExists, documentMatchingExists, documentsAreTheSame, documentsMatchingHaveCount, eventInStream, eventStoreSchemaMigrations, eventsInStream, expectPongoDocuments, expectSQL, getPostgreSQLEventStore, handleProjections, messagesTableSQL, newEventsInStream, pastEventStoreSchemaMigrations, pongoMultiStreamProjection, pongoProjection, pongoSingleStreamProjection, postgreSQLCheckpointer, postgreSQLEventStoreConsumer, postgreSQLEventStoreMessageBatchPuller, postgreSQLProcessorLock, postgreSQLProjection, postgreSQLProjectionLock, postgreSQLProjector, postgreSQLRawBatchSQLProjection, postgreSQLRawSQLProjection, postgreSQLReactor, postgreSQLWorkflowProcessor, processorsTableSQL, projectionsTableSQL, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readProjectionInfo, readStream, rebuildPostgreSQLProjections, registerProjection, registerProjectionSQL, releaseProcessorLockSQL, sanitizeNameSQL, schemaMigration, schemaSQL, storeProcessorCheckpoint, storeSubscriptionCheckpointSQL, streamExists, streamsTableSQL, toProcessorLockKey, toProjectionLockKey, transactionToPostgreSQLProjectionHandlerContext, tryAcquireProcessorLockSQL, tryAcquireProjectionLockSQL, zipPostgreSQLEventStoreMessageBatchPullerStartFrom };
 //# sourceMappingURL=index.js.map