@powersync/service-module-postgres 0.0.0-dev-20250122110924 → 0.0.0-dev-20250227082606

package/src/replication/WalStream.ts

@@ -1,6 +1,8 @@
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import {
   container,
+  DatabaseConnectionError,
+  ErrorCode,
   errors,
   logger,
   ReplicationAbortedError,
@@ -15,10 +17,6 @@ import { PgManager } from './PgManager.js';
 import { getPgOutputRelation, getRelId } from './PgRelation.js';
 import { checkSourceConfiguration, getReplicationIdentityColumns } from './replication-utils.js';
 
-export const ZERO_LSN = '00000000/00000000';
-export const PUBLICATION_NAME = 'powersync';
-export const POSTGRES_DEFAULT_SCHEMA = 'public';
-
 export interface WalStreamOptions {
   connections: PgManager;
   storage: storage.SyncRulesBucketStorage;
@@ -32,6 +30,35 @@ interface InitResult {
   needsNewSlot: boolean;
 }
 
+export const ZERO_LSN = '00000000/00000000';
+export const PUBLICATION_NAME = 'powersync';
+export const POSTGRES_DEFAULT_SCHEMA = 'public';
+
+export const KEEPALIVE_CONTENT = 'ping';
+export const KEEPALIVE_BUFFER = Buffer.from(KEEPALIVE_CONTENT);
+export const KEEPALIVE_STATEMENT: pgwire.Statement = {
+  statement: /* sql */ `
+    SELECT
+      *
+    FROM
+      pg_logical_emit_message(FALSE, 'powersync', $1)
+  `,
+  params: [{ type: 'varchar', value: KEEPALIVE_CONTENT }]
+} as const;
+
+export const isKeepAliveMessage = (msg: pgwire.PgoutputMessage) => {
+  return (
+    msg.tag == 'message' &&
+    msg.prefix == 'powersync' &&
+    msg.content &&
+    Buffer.from(msg.content).equals(KEEPALIVE_BUFFER)
+  );
+};
+
+export const sendKeepAlive = async (db: pgwire.PgClient) => {
+  await lib_postgres.retriedQuery(db, KEEPALIVE_STATEMENT);
+};
+
 export class MissingReplicationSlotError extends Error {
   constructor(message: string) {
     super(message);
@@ -71,10 +98,7 @@ export class WalStream {
           // Ping to speed up cancellation of streaming replication
           // We're not using pg_snapshot here, since it could be in the middle of
           // an initial replication transaction.
-          const promise = lib_postgres.retriedQuery(
-            this.connections.pool,
-            `SELECT * FROM pg_logical_emit_message(false, 'powersync', 'ping')`
-          );
+          const promise = sendKeepAlive(this.connections.pool);
           promise.catch((e) => {
             // Failures here are okay - this only speeds up stopping the process.
             logger.warn('Failed to ping connection', e);
@@ -180,6 +204,7 @@ export class WalStream {
 
   async initSlot(): Promise<InitResult> {
     await checkSourceConfiguration(this.connections.pool, PUBLICATION_NAME);
+    await this.ensureStorageCompatibility();
 
     const slotName = this.slot_name;
 
@@ -214,6 +239,11 @@ export class WalStream {
         needsNewSlot: r.needsNewSlot
       };
     } else {
+      if (snapshotDone) {
+        // This will create a new slot, while keeping the current sync rules active
+        throw new MissingReplicationSlotError(`Replication slot ${slotName} is missing`);
+      }
+      // This will clear data and re-create the same slot
       return { needsInitialSync: true, needsNewSlot: true };
     }
   }
@@ -382,6 +412,15 @@ WHERE  oid = $1::regclass`,
         await batch.commit(ZERO_LSN);
       }
     );
+    /**
+     * Send a keepalive message after initial replication.
+     * In some edge cases we wait for a keepalive after the initial snapshot.
+     * If we don't explicitly check the contents of keepalive messages then a keepalive is detected
+     * rather quickly after initial replication - perhaps due to other WAL events.
+     * If we do explicitly check the contents of messages, we need an actual keepalive payload in order
+     * to advance the active sync rules LSN.
+     */
+    await sendKeepAlive(db);
   }
 
   static *getQueryData(results: Iterable<DatabaseInputRow>): Generator<SqliteRow> {
@@ -599,13 +638,33 @@ WHERE  oid = $1::regclass`,
   async streamChanges(replicationConnection: pgwire.PgConnection) {
     // When changing any logic here, check /docs/wal-lsns.md.
 
+    const { createEmptyCheckpoints } = await this.ensureStorageCompatibility();
+
+    const replicationOptions: Record<string, string> = {
+      proto_version: '1',
+      publication_names: PUBLICATION_NAME
+    };
+
+    /**
+     * Viewing the contents of logical messages emitted with `pg_logical_emit_message`
+     * is only supported on Postgres >= 14.0.
+     * https://www.postgresql.org/docs/14/protocol-logical-replication.html
+     */
+    const exposesLogicalMessages = await this.checkLogicalMessageSupport();
+    if (exposesLogicalMessages) {
+      /**
+       * Only add this option if the Postgres server supports it.
+       * Adding the option to a server that doesn't support it will throw an exception when starting logical replication.
+       * Error: `unrecognized pgoutput option: messages`
+       */
+      replicationOptions['messages'] = 'true';
+    }
+
     const replicationStream = replicationConnection.logicalReplication({
       slot: this.slot_name,
-      options: {
-        proto_version: '1',
-        publication_names: PUBLICATION_NAME
-      }
+      options: replicationOptions
     });
+
     this.startedStreaming = true;
 
     // Auto-activate as soon as initial replication is done
@@ -628,6 +687,15 @@ WHERE  oid = $1::regclass`,
           // chunkLastLsn may come from normal messages in the chunk,
           // or from a PrimaryKeepalive message.
           const { messages, lastLsn: chunkLastLsn } = chunk;
+
+          /**
+           * We can check if an explicit keepalive was sent if `exposesLogicalMessages == true`.
+           * If we can't check the logical messages, we should assume a keepalive if we
+           * receive an empty array of messages in a replication event.
+           */
+          const assumeKeepAlive = !exposesLogicalMessages;
+          let keepAliveDetected = false;
+
           for (const msg of messages) {
             if (msg.tag == 'relation') {
               await this.handleRelation(batch, getPgOutputRelation(msg), true);
@@ -636,27 +704,44 @@ WHERE  oid = $1::regclass`,
             } else if (msg.tag == 'commit') {
               Metrics.getInstance().transactions_replicated_total.add(1);
               inTx = false;
-              await batch.commit(msg.lsn!);
+              await batch.commit(msg.lsn!, { createEmptyCheckpoints });
               await this.ack(msg.lsn!, replicationStream);
             } else {
               if (count % 100 == 0) {
                 logger.info(`${this.slot_name} replicating op ${count} ${msg.lsn}`);
               }
 
+              /**
+               * If we can see the contents of logical messages, then we can check if a keepalive
+               * message is present. We only perform a keepalive (below) if we explicitly detect a keepalive message.
+               * If we can't see the contents of logical messages, then we should assume a keepalive is required
+               * due to the default value of `assumeKeepalive`.
+               */
+              if (exposesLogicalMessages && isKeepAliveMessage(msg)) {
+                keepAliveDetected = true;
+              }
+
               count += 1;
               await this.writeChange(batch, msg);
             }
           }
 
           if (!inTx) {
-            // In a transaction, we ack and commit according to the transaction progress.
-            // Outside transactions, we use the PrimaryKeepalive messages to advance progress.
-            // Big caveat: This _must not_ be used to skip individual messages, since this LSN
-            // may be in the middle of the next transaction.
-            // It must only be used to associate checkpoints with LSNs.
-            if (await batch.keepalive(chunkLastLsn)) {
-              await this.ack(chunkLastLsn, replicationStream);
+            if (assumeKeepAlive || keepAliveDetected) {
+              // Reset the detection flag.
+              keepAliveDetected = false;
+
+              // In a transaction, we ack and commit according to the transaction progress.
+              // Outside transactions, we use the PrimaryKeepalive messages to advance progress.
+              // Big caveat: This _must not_ be used to skip individual messages, since this LSN
+              // may be in the middle of the next transaction.
+              // It must only be used to associate checkpoints with LSNs.
+              await batch.keepalive(chunkLastLsn);
             }
+
+            // We receive chunks with empty messages often (about each second).
+            // Acknowledging here progresses the slot past these and frees up resources.
+            await this.ack(chunkLastLsn, replicationStream);
           }
 
           Metrics.getInstance().chunks_replicated_total.add(1);
@@ -672,6 +757,53 @@ WHERE  oid = $1::regclass`,
 
     replicationStream.ack(lsn);
   }
+
+  /**
+   * Ensures that the storage is compatible with the replication connection.
+   * @throws {DatabaseConnectionError} If the storage is not compatible with the replication connection.
+   */
+  protected async ensureStorageCompatibility(): Promise<storage.ResolvedBucketBatchCommitOptions> {
+    const supportsLogicalMessages = await this.checkLogicalMessageSupport();
+
+    const storageIdentifier = await this.storage.factory.getSystemIdentifier();
+    if (storageIdentifier.type != lib_postgres.POSTGRES_CONNECTION_TYPE) {
+      return {
+        // Keep the same behaviour as before allowing Postgres storage.
+        createEmptyCheckpoints: true
+      };
+    }
+
+    const parsedStorageIdentifier = lib_postgres.utils.decodePostgresSystemIdentifier(storageIdentifier.id);
+    /**
+     * Check if the same server is being used for both the sync bucket storage and the logical replication.
+     */
+    const replicationIdentifier = await lib_postgres.utils.queryPostgresSystemIdentifier(this.connections.pool);
+
+    if (!supportsLogicalMessages && replicationIdentifier.server_id == parsedStorageIdentifier.server_id) {
+      throw new DatabaseConnectionError(
+        ErrorCode.PSYNC_S1144,
+        `Separate Postgres servers are required for the replication source and sync bucket storage when using Postgres versions below 14.0.`,
+        new Error('Postgres version is below 14')
+      );
+    }
+
+    return {
+      /**
+       * Don't create empty checkpoints if the same Postgres database is used for the data source
+       * and sync bucket storage. Creating empty checkpoints will cause WAL feedback loops.
+       */
+      createEmptyCheckpoints: replicationIdentifier.database_name != parsedStorageIdentifier.database_name
+    };
+  }
+
+  /**
+   * Check if the replication connection Postgres server supports
+   * viewing the contents of logical replication messages.
+   */
+  protected async checkLogicalMessageSupport() {
+    const version = await this.connections.getServerVersion();
+    return version ? version.compareMain('14.0.0') >= 0 : false;
+  }
 }
 
 async function touch() {

package/src/replication/WalStreamReplicationJob.ts

@@ -1,6 +1,6 @@
 import { container } from '@powersync/lib-services-framework';
 import { PgManager } from './PgManager.js';
-import { MissingReplicationSlotError, WalStream } from './WalStream.js';
+import { MissingReplicationSlotError, sendKeepAlive, WalStream } from './WalStream.js';
 
 import { replication } from '@powersync/service-core';
 import { ConnectionManagerFactory } from './ConnectionManagerFactory.js';
@@ -37,7 +37,7 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
    */
   async keepAlive() {
     try {
-      await this.connectionManager.pool.query(`SELECT * FROM pg_logical_emit_message(false, 'powersync', 'ping')`);
+      await sendKeepAlive(this.connectionManager.pool);
     } catch (e) {
       this.logger.warn(`KeepAlive failed, unable to post to WAL`, e);
     }
@@ -60,8 +60,8 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
       this.logger.error(`Replication failed on ${this.slotName}`, e);
 
       if (e instanceof MissingReplicationSlotError) {
-        // This stops replication on this slot, and creates a new slot
-        await this.options.storage.factory.slotRemoved(this.slotName);
+        // This stops replication on this slot and restarts with a new slot
+        await this.options.storage.factory.restartReplication(this.storage.group_id);
       }
     } finally {
       this.abortController.abort();
@@ -99,7 +99,7 @@ export class WalStreamReplicationJob extends replication.AbstractReplicationJob
       });
       await stream.replicate();
     } catch (e) {
-      this.logger.error(`Replication error`, e);
+      this.logger.error(`${this.slotName} Replication error`, e);
       if (e.cause != null) {
         // Example:
         // PgError.conn_ended: Unable to do postgres query on ended connection

package/test/src/checkpoints.test.ts

@@ -0,0 +1,74 @@
+import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js';
+import { checkpointUserId, createWriteCheckpoint } from '@powersync/service-core';
+import { describe, test } from 'vitest';
+import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
+import { WalStreamTestContext } from './wal_stream_utils.js';
+import { env } from './env.js';
+
+import timers from 'node:timers/promises';
+
+const BASIC_SYNC_RULES = `bucket_definitions:
+  global:
+    data:
+      - SELECT id, description, other FROM "test_data"`;
+
+describe.skipIf(!(env.CI || env.SLOW_TESTS))('checkpoint tests', () => {
+  test('write checkpoints', { timeout: 50_000 }, async () => {
+    const factory = INITIALIZED_MONGO_STORAGE_FACTORY;
+    await using context = await WalStreamTestContext.open(factory);
+
+    await context.updateSyncRules(BASIC_SYNC_RULES);
+    const { pool } = context;
+    const api = new PostgresRouteAPIAdapter(pool);
+
+    await pool.query(`CREATE TABLE test_data(id text primary key, description text, other text)`);
+
+    await context.replicateSnapshot();
+
+    context.startStreaming();
+    const storage = context.storage!;
+
+    const controller = new AbortController();
+    try {
+      const stream = storage.watchWriteCheckpoint({
+        user_id: checkpointUserId('test_user', 'test_client'),
+        signal: controller.signal
+      });
+
+      let lastWriteCheckpoint: bigint | null = null;
+
+      (async () => {
+        try {
+          for await (const cp of stream) {
+            lastWriteCheckpoint = cp.writeCheckpoint;
+          }
+        } catch (e) {
+          if (e.name != 'AbortError') {
+            throw e;
+          }
+        }
+      })();
+
+      for (let i = 0; i < 10; i++) {
+        const cp = await createWriteCheckpoint({
+          userId: 'test_user',
+          clientId: 'test_client',
+          api,
+          storage: context.factory
+        });
+
+        const start = Date.now();
+        while (lastWriteCheckpoint == null || lastWriteCheckpoint < BigInt(cp.writeCheckpoint)) {
+          if (Date.now() - start > 5_000) {
+            throw new Error(
+              `Timeout while waiting for checkpoint. last: ${lastWriteCheckpoint}, waiting for: ${cp.writeCheckpoint}`
+            );
+          }
+          await timers.setTimeout(5, undefined, { signal: controller.signal });
+        }
+      }
+    } finally {
+      controller.abort();
+    }
+  });
+});

package/test/src/slow_tests.test.ts

@@ -71,21 +71,13 @@ function defineSlowTests(factory: storage.TestStorageFactory) {
   // Past issues that this could reproduce intermittently:
   // * Skipping LSNs after a keepalive message
   // * Skipping LSNs when source transactions overlap
-  test(
-    'repeated replication - basic',
-    async () => {
-      await testRepeatedReplication({ compact: false, maxBatchSize: 50, numBatches: 5 });
-    },
-    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
-  );
-
-  test(
-    'repeated replication - compacted',
-    async () => {
-      await testRepeatedReplication({ compact: true, maxBatchSize: 100, numBatches: 2 });
-    },
-    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
-  );
+  test('repeated replication - basic', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+    await testRepeatedReplication({ compact: false, maxBatchSize: 50, numBatches: 5 });
+  });
+
+  test('repeated replication - compacted', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+    await testRepeatedReplication({ compact: true, maxBatchSize: 100, numBatches: 2 });
+  });
 
   async function testRepeatedReplication(testOptions: { compact: boolean; maxBatchSize: number; numBatches: number }) {
     const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
@@ -101,7 +93,7 @@ bucket_definitions:
       - SELECT * FROM "test_data"
 `;
     const syncRules = await f.updateSyncRules({ content: syncRuleContent });
-    using storage = f.getInstance(syncRules);
+    const storage = f.getInstance(syncRules);
     abortController = new AbortController();
     const options: WalStreamOptions = {
       abort_signal: abortController.signal,
@@ -314,116 +306,112 @@ bucket_definitions:
   //
   // If the first LSN does not correctly match with the first replication transaction,
   // we may miss some updates.
-  test(
-    'repeated initial replication',
-    async () => {
-      const pool = await connectPgPool();
-      await clearTestDb(pool);
-      await using f = await factory();
-
-      const syncRuleContent = `
+  test('repeated initial replication', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+    const pool = await connectPgPool();
+    await clearTestDb(pool);
+    await using f = await factory();
+
+    const syncRuleContent = `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "test_data"
 `;
-      const syncRules = await f.updateSyncRules({ content: syncRuleContent });
-      using storage = f.getInstance(syncRules);
+    const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+    const storage = f.getInstance(syncRules);
 
-      // 1. Setup some base data that will be replicated in initial replication
-      await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
+    // 1. Setup some base data that will be replicated in initial replication
+    await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
 
-      let statements: pgwire.Statement[] = [];
+    let statements: pgwire.Statement[] = [];
 
-      const n = Math.floor(Math.random() * 200);
-      for (let i = 0; i < n; i++) {
-        statements.push({
-          statement: `INSERT INTO test_data(description) VALUES('test_init')`
-        });
-      }
-      await pool.query(...statements);
-
-      const start = Date.now();
-      let i = 0;
-
-      while (Date.now() - start < TEST_DURATION_MS) {
-        // 2. Each iteration starts with a clean slate
-        await pool.query(`SELECT pg_drop_replication_slot(slot_name) FROM pg_replication_slots WHERE active = FALSE`);
-        i += 1;
-
-        const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
-        const replicationConnection = await connections.replicationConnection();
-
-        abortController = new AbortController();
-        const options: WalStreamOptions = {
-          abort_signal: abortController.signal,
-          connections,
-          storage: storage
-        };
-        walStream = new WalStream(options);
-
-        await storage.clear();
-
-        // 3. Start initial replication, then streaming, but don't wait for any of this
-        let initialReplicationDone = false;
-        streamPromise = (async () => {
-          await walStream.initReplication(replicationConnection);
-          await storage.autoActivate();
+    const n = Math.floor(Math.random() * 200);
+    for (let i = 0; i < n; i++) {
+      statements.push({
+        statement: `INSERT INTO test_data(description) VALUES('test_init')`
+      });
+    }
+    await pool.query(...statements);
+
+    const start = Date.now();
+    let i = 0;
+
+    while (Date.now() - start < TEST_DURATION_MS) {
+      // 2. Each iteration starts with a clean slate
+      await pool.query(`SELECT pg_drop_replication_slot(slot_name) FROM pg_replication_slots WHERE active = FALSE`);
+      i += 1;
+
+      const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
+      const replicationConnection = await connections.replicationConnection();
+
+      abortController = new AbortController();
+      const options: WalStreamOptions = {
+        abort_signal: abortController.signal,
+        connections,
+        storage: storage
+      };
+      walStream = new WalStream(options);
+
+      await storage.clear();
+
+      // 3. Start initial replication, then streaming, but don't wait for any of this
+      let initialReplicationDone = false;
+      streamPromise = (async () => {
+        await walStream.initReplication(replicationConnection);
+        await storage.autoActivate();
+        initialReplicationDone = true;
+        await walStream.streamChanges(replicationConnection);
+      })()
+        .catch((e) => {
           initialReplicationDone = true;
-          await walStream.streamChanges(replicationConnection);
-        })()
-          .catch((e) => {
-            initialReplicationDone = true;
-            throw e;
-          })
-          .then((v) => {
-            return v;
-          });
+          throw e;
+        })
+        .then((v) => {
+          return v;
+        });
 
-        // 4. While initial replication is still running, write more changes
-        while (!initialReplicationDone) {
-          let statements: pgwire.Statement[] = [];
-          const n = Math.floor(Math.random() * 10) + 1;
-          for (let i = 0; i < n; i++) {
-            const description = `test${i}`;
-            statements.push({
-              statement: `INSERT INTO test_data(description) VALUES('test1') returning id as test_id`,
-              params: [{ type: 'varchar', value: description }]
-            });
-          }
-          const results = await pool.query(...statements);
-          const ids = results.results.map((sub) => {
-            return sub.rows[0][0] as string;
-          });
-          await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
-          const deleteStatements: pgwire.Statement[] = ids.map((id) => {
-            return {
-              statement: `DELETE FROM test_data WHERE id = $1`,
-              params: [{ type: 'uuid', value: id }]
-            };
+      // 4. While initial replication is still running, write more changes
+      while (!initialReplicationDone) {
+        let statements: pgwire.Statement[] = [];
+        const n = Math.floor(Math.random() * 10) + 1;
+        for (let i = 0; i < n; i++) {
+          const description = `test${i}`;
+          statements.push({
+            statement: `INSERT INTO test_data(description) VALUES('test1') returning id as test_id`,
+            params: [{ type: 'varchar', value: description }]
           });
-          await pool.query(...deleteStatements);
-          await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
-        }
-
-        // 5. Once initial replication is done, wait for the streaming changes to complete syncing.
-        // getClientCheckpoint() effectively waits for the above replication to complete
-        // Race with streamingPromise to catch replication errors here.
-        let checkpoint = await Promise.race([
-          getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS }),
-          streamPromise
-        ]);
-        if (typeof checkpoint == undefined) {
-          // This indicates an issue with the test setup - streamingPromise completed instead
-          // of getClientCheckpoint()
-          throw new Error('Test failure - streamingPromise completed');
         }
+        const results = await pool.query(...statements);
+        const ids = results.results.map((sub) => {
+          return sub.rows[0][0] as string;
+        });
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
+        const deleteStatements: pgwire.Statement[] = ids.map((id) => {
+          return {
+            statement: `DELETE FROM test_data WHERE id = $1`,
+            params: [{ type: 'uuid', value: id }]
+          };
+        });
+        await pool.query(...deleteStatements);
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
+      }
 
-        abortController.abort();
-        await streamPromise;
-        await connections.end();
+      // 5. Once initial replication is done, wait for the streaming changes to complete syncing.
+      // getClientCheckpoint() effectively waits for the above replication to complete
+      // Race with streamingPromise to catch replication errors here.
+      let checkpoint = await Promise.race([
+        getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS }),
+        streamPromise
+      ]);
+      if (typeof checkpoint == undefined) {
+        // This indicates an issue with the test setup - streamingPromise completed instead
+        // of getClientCheckpoint()
+        throw new Error('Test failure - streamingPromise completed');
       }
-    },
-    { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }
-  );
+
+      abortController.abort();
+      await streamPromise;
+      await connections.end();
+    }
+  });
 }

package/test/src/storage_combination.test.ts

@@ -0,0 +1,35 @@
+import * as postgres_storage from '@powersync/service-module-postgres-storage';
+import { describe, expect, test } from 'vitest';
+import { env } from './env.js';
+import { WalStreamTestContext } from './wal_stream_utils.js';
+
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('replication storage combination - postgres', function () {
+  test('should allow the same Postgres cluster to be used for data and storage', async () => {
+    // Use the same cluster for the storage as the data source
+    await using context = await WalStreamTestContext.open(
+      postgres_storage.PostgresTestStorageFactoryGenerator({
+        url: env.PG_TEST_URL
+      }),
+      { doNotClear: false }
+    );
+
+    await context.updateSyncRules(/* yaml */
+    ` bucket_definitions:
+        global:
+          data:
+            - SELECT * FROM "test_data" `);
+
+    const { pool, connectionManager } = context;
+
+    const sourceVersion = await connectionManager.getServerVersion();
+
+    await pool.query(`CREATE TABLE test_data(id text primary key, description text, other text)`);
+
+    if (sourceVersion!.compareMain('14.0.0') < 0) {
+      await expect(context.replicateSnapshot()).rejects.toThrow();
+    } else {
+      // Should resolve
+      await context.replicateSnapshot();
+    }
+  });
+});