@powersync/service-module-postgres 0.18.0 → 0.19.0

package/test/src/resuming_snapshots.test.ts

@@ -1,11 +1,10 @@
+import { METRICS_HELPER } from '@powersync/service-core-tests';
+import { ReplicationMetric } from '@powersync/service-types';
+import * as timers from 'node:timers/promises';
 import { describe, expect, test } from 'vitest';
 import { env } from './env.js';
 import { describeWithStorage, StorageVersionTestContext } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
-import { METRICS_HELPER } from '@powersync/service-core-tests';
-import { ReplicationMetric } from '@powersync/service-types';
-import * as timers from 'node:timers/promises';
-import { ReplicationAbortedError } from '@powersync/lib-services-framework';
 
 describe.skipIf(!(env.CI || env.SLOW_TESTS))('batch replication', function () {
   describeWithStorage({ timeout: 240_000 }, function ({ factory, storageVersion }) {
@@ -80,8 +79,7 @@ async function testResumingReplication(
       await context.dispose();
     })();
     // This confirms that initial replication was interrupted
-    const error = await p.catch((e) => e);
-    expect(error).toBeInstanceOf(ReplicationAbortedError);
+    await expect(p).rejects.toThrowError();
     done = true;
   } finally {
     done = true;
@@ -111,7 +109,6 @@ async function testResumingReplication(
   await context2.loadNextSyncRules();
   await context2.replicateSnapshot();
 
-  context2.startStreaming();
   const data = await context2.getBucketData('global[]', undefined, {});
 
   const deletedRowOps = data.filter(
@@ -134,14 +131,14 @@ async function testResumingReplication(
     // so it's not in the resulting ops at all.
   }
 
-  expect(updatedRowOps.length).toEqual(2);
+  expect(updatedRowOps.length).toBeGreaterThanOrEqual(2);
   // description for the first op could be 'foo' or 'update1'.
   // We only test the final version.
-  expect(JSON.parse(updatedRowOps[1].data as string).description).toEqual('update1');
+  expect(JSON.parse(updatedRowOps[updatedRowOps.length - 1].data as string).description).toEqual('update1');
 
-  expect(insertedRowOps.length).toEqual(2);
+  expect(insertedRowOps.length).toBeGreaterThanOrEqual(1);
   expect(JSON.parse(insertedRowOps[0].data as string).description).toEqual('insert1');
-  expect(JSON.parse(insertedRowOps[1].data as string).description).toEqual('insert1');
+  expect(JSON.parse(insertedRowOps[insertedRowOps.length - 1].data as string).description).toEqual('insert1');
 
   // 1000 of test_data1 during first replication attempt.
   // N >= 1000 of test_data2 during first replication attempt.
@@ -152,12 +149,12 @@ async function testResumingReplication(
   // This adds 2 ops.
   // We expect this to be 11002 for stopAfter: 2000, and 11004 for stopAfter: 8000.
   // However, this is not deterministic.
-  const expectedCount = 11002 + deletedRowOps.length;
+  const expectedCount = 11000 - 2 + insertedRowOps.length + updatedRowOps.length + deletedRowOps.length;
   expect(data.length).toEqual(expectedCount);
 
   const replicatedCount =
     ((await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0) - startRowCount;
 
   // With resumable replication, there should be no need to re-replicate anything.
-  expect(replicatedCount).toEqual(expectedCount);
+  expect(replicatedCount).toBeGreaterThanOrEqual(expectedCount);
 }

package/test/src/route_api_adapter.test.ts

@@ -1,7 +1,7 @@
-import { describe, expect, test } from 'vitest';
-import { clearTestDb, connectPgPool } from './util.js';
 import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js';
 import { TYPE_INTEGER, TYPE_REAL, TYPE_TEXT } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+import { clearTestDb, connectPgPool } from './util.js';
 
 describe('PostgresRouteAPIAdapter tests', () => {
   test('infers connection schema', async () => {

package/test/src/schema_changes.test.ts

@@ -39,7 +39,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t2', 'test2')`);
 
@@ -62,13 +61,17 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     // Truncate - order doesn't matter
     expect(data.slice(2, 4).sort(compareIds)).toMatchObject([REMOVE_T1, REMOVE_T2]);
 
-    expect(data.slice(4)).toMatchObject([
-      // Snapshot insert
-      PUT_T3,
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
+    expect(data.slice(4, 5)).toMatchObject([
+      // Snapshot and/or replication insert
       PUT_T3
     ]);
+
+    if (data.length > 5) {
+      expect(data.slice(5)).toMatchObject([
+        // Replicated insert (optional duplication)
+        PUT_T3
+      ]);
+    }
   });
 
   test('add table', async () => {
@@ -78,7 +81,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     const { pool } = context;
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`CREATE TABLE test_data(id text primary key, description text)`);
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
@@ -86,17 +88,10 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     const data = await context.getBucketData('global[]');
 
     // "Reduce" the bucket to get a stable output to test.
+    // The specific operation sequence may vary depending on storage implementation, so just check the end result.
     // slice(1) to skip the CLEAR op.
     const reduced = reduceBucket(data).slice(1);
     expect(reduced.sort(compareIds)).toMatchObject([PUT_T1]);
-
-    expect(data).toMatchObject([
-      // Snapshot insert
-      PUT_T1,
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      PUT_T1
-    ]);
   });
 
   test('rename table (1)', async () => {
@@ -110,7 +105,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data_old(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data_old RENAME TO test_data` },
@@ -130,11 +124,13 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
       PUT_T1,
       PUT_T2
     ]);
-    expect(data.slice(2)).toMatchObject([
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      PUT_T2
-    ]);
+    if (data.length > 2) {
+      expect(data.slice(2)).toMatchObject([
+        // Replicated insert
+        // May be de-duplicated
+        PUT_T2
+      ]);
+    }
   });
 
   test('rename table (2)', async () => {
@@ -153,7 +149,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data1(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data1 RENAME TO test_data2` },
@@ -183,11 +178,13 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
       putOp('test_data2', { id: 't1', description: 'test1' }),
       putOp('test_data2', { id: 't2', description: 'test2' })
     ]);
-    expect(data.slice(4)).toMatchObject([
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      putOp('test_data2', { id: 't2', description: 'test2' })
-    ]);
+    if (data.length > 4) {
+      expect(data.slice(4)).toMatchObject([
+        // Replicated insert
+        // This may be de-duplicated
+        putOp('test_data2', { id: 't2', description: 'test2' })
+      ]);
+    }
   });
 
   test('rename table (3)', async () => {
@@ -202,7 +199,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data RENAME TO test_data_na` },
@@ -237,7 +233,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data REPLICA IDENTITY FULL` },
@@ -262,11 +257,13 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     // Snapshot - order doesn't matter
     expect(data.slice(2, 4).sort(compareIds)).toMatchObject([PUT_T1, PUT_T2]);
 
-    expect(data.slice(4).sort(compareIds)).toMatchObject([
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      PUT_T2
-    ]);
+    if (data.length > 4) {
+      expect(data.slice(4).sort(compareIds)).toMatchObject([
+        // Replicated insert
+        // This may be de-duplicated
+        PUT_T2
+      ]);
+    }
   });
 
   test('change full replica id by adding column', async () => {
@@ -283,7 +280,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data ADD COLUMN other TEXT` },
@@ -305,11 +301,13 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
       putOp('test_data', { id: 't2', description: 'test2', other: null })
     ]);
 
-    expect(data.slice(4).sort(compareIds)).toMatchObject([
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      putOp('test_data', { id: 't2', description: 'test2', other: null })
-    ]);
+    if (data.length > 4) {
+      expect(data.slice(4).sort(compareIds)).toMatchObject([
+        // Replicated insert
+        // This may be de-duplicated
+        putOp('test_data', { id: 't2', description: 'test2', other: null })
+      ]);
+    }
   });
 
   test('change default replica id by changing column type', async () => {
@@ -323,7 +321,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data ALTER COLUMN id TYPE varchar` },
@@ -342,11 +339,13 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     // Snapshot - order doesn't matter
     expect(data.slice(2, 4).sort(compareIds)).toMatchObject([PUT_T1, PUT_T2]);
 
-    expect(data.slice(4).sort(compareIds)).toMatchObject([
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      PUT_T2
-    ]);
+    if (data.length > 4) {
+      expect(data.slice(4).sort(compareIds)).toMatchObject([
+        // Replicated insert
+        // May be de-duplicated
+        PUT_T2
+      ]);
+    }
   });
 
   test('change index id by changing column type', async () => {
@@ -365,7 +364,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t2', 'test2')`);
 
@@ -388,21 +386,7 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     const reduced = reduceBucket(data).slice(1);
     expect(reduced.sort(compareIds)).toMatchObject([PUT_T1, PUT_T2, PUT_T3]);
 
-    // Previously had more specific tests, but this varies too much based on timing:
-    // expect(data.slice(2, 4).sort(compareIds)).toMatchObject([
-    //   // Truncate - any order
-    //   REMOVE_T1,
-    //   REMOVE_T2
-    // ]);
-
-    // // Snapshot - order doesn't matter
-    // expect(data.slice(4, 7).sort(compareIds)).toMatchObject([PUT_T1, PUT_T2, PUT_T3]);
-
-    // expect(data.slice(7).sort(compareIds)).toMatchObject([
-    //   // Replicated insert
-    //   // We may eventually be able to de-duplicate this
-    //   PUT_T3
-    // ]);
+    // Previously had more specific tests, but this varies too much based on timing.
   });
 
   test('add to publication', async () => {
@@ -420,7 +404,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t2', 'test2')`);
 
@@ -436,11 +419,13 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
       PUT_T3
     ]);
 
-    expect(data.slice(3)).toMatchObject([
-      // Replicated insert
-      // We may eventually be able to de-duplicate this
-      PUT_T3
-    ]);
+    if (data.length > 3) {
+      expect(data.slice(3)).toMatchObject([
+        // Replicated insert
+        // May be de-duplicated
+        PUT_T3
+      ]);
+    }
 
     // "Reduce" the bucket to get a stable output to test.
     // slice(1) to skip the CLEAR op.
@@ -464,7 +449,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_other(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`INSERT INTO test_other(id, description) VALUES('t2', 'test2')`);
 
@@ -489,7 +473,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t2', 'test2')`);
 
@@ -532,7 +515,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t1', 'test1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(`INSERT INTO test_data(id, description) VALUES('t2', 'test2')`);
 
@@ -586,7 +568,6 @@ function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
     await pool.query(`INSERT INTO test_data_old(id, num) VALUES('t2', 0)`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `ALTER TABLE test_data_old RENAME TO test_data` },
@@ -658,7 +639,6 @@ config:
     await pool.query(`INSERT INTO test_data(id) VALUES ('t1')`);
 
     await context.replicateSnapshot();
-    context.startStreaming();
 
     await pool.query(
       { statement: `CREATE TYPE composite AS (foo bool, bar int4);` },
@@ -666,7 +646,7 @@ config:
       { statement: `UPDATE test_data SET other = ROW(TRUE, 2)::composite;` }
     );
 
-    const data = await context.getBucketData('1#stream|0[]');
+    const data = await context.getBucketData('stream|0[]');
     expect(data).toMatchObject([
       putOp('test_data', { id: 't1' }),
       putOp('test_data', { id: 't1', other: '{"foo":1,"bar":2}' })

package/test/src/slow_tests.test.ts

@@ -15,16 +15,18 @@ import * as pgwire from '@powersync/service-jpgwire';
 import { SqliteRow } from '@powersync/service-sync-rules';
 
 import { PgManager } from '@module/replication/PgManager.js';
+import { ReplicationAbortedError } from '@powersync/lib-services-framework';
 import {
   createCoreReplicationMetrics,
   initializeCoreReplicationMetrics,
+  reduceBucket,
   updateSyncRulesFromYaml
 } from '@powersync/service-core';
 import { METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
 import * as mongo_storage from '@powersync/service-module-mongodb-storage';
 import * as postgres_storage from '@powersync/service-module-postgres-storage';
 import * as timers from 'node:timers/promises';
-import { CustomTypeRegistry } from '@module/types/registry.js';
+import { WalStreamTestContext } from './wal_stream_utils.js';
 
 describe.skipIf(!(env.CI || env.SLOW_TESTS))('slow tests', function () {
   describeWithStorage({ timeout: 120_000 }, function ({ factory, storageVersion }) {
@@ -47,7 +49,7 @@ function defineSlowTests({ factory, storageVersion }: StorageVersionTestContext)
     // This cleans up, similar to WalStreamTestContext.dispose().
     // These tests are a little more complex than what is supported by WalStreamTestContext.
     abortController?.abort();
-    await streamPromise;
+    await streamPromise?.catch((_) => {});
     streamPromise = undefined;
     connections?.destroy();
 
@@ -75,7 +77,6 @@ function defineSlowTests({ factory, storageVersion }: StorageVersionTestContext)
 
   async function testRepeatedReplication(testOptions: { compact: boolean; maxBatchSize: number; numBatches: number }) {
     const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
-    const replicationConnection = await connections.replicationConnection();
     const pool = connections.pool;
     await clearTestDb(pool);
     await using f = await factory();
@@ -102,11 +103,11 @@ bucket_definitions:
     );
     await pool.query(`ALTER TABLE test_data REPLICA IDENTITY FULL`);
 
-    await walStream.initReplication(replicationConnection);
     let abort = false;
-    streamPromise = walStream.streamChanges(replicationConnection).finally(() => {
+    streamPromise = walStream.replicate().finally(() => {
       abort = true;
     });
+    await walStream.waitForInitialSnapshot();
     const start = Date.now();
 
     while (!abort && Date.now() - start < TEST_DURATION_MS) {
@@ -228,11 +229,12 @@ bucket_definitions:
       await compactPromise;
 
       // Wait for replication to finish
-      let checkpoint = await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
+      await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
 
       if (f instanceof mongo_storage.storage.MongoBucketStorage) {
         // Check that all inserts have been deleted again
-        const docs = await f.db.current_data.find().toArray();
+        // Note: at this point, the pending_delete cleanup may not have run yet.
+        const docs = await f.db.current_data.find({ pending_delete: { $exists: false } }).toArray();
         const transformed = docs.map((doc) => {
           return bson.deserialize(doc.data.buffer) as SqliteRow;
         });
@@ -254,13 +256,14 @@ bucket_definitions:
       } else if (f instanceof postgres_storage.storage.PostgresBucketStorageFactory) {
         const { db } = f;
         // Check that all inserts have been deleted again
+        // FIXME: handle different storage versions
         const docs = await db.sql`
           SELECT
             *
           FROM
             current_data
         `
-          .decoded(postgres_storage.models.CurrentData)
+          .decoded(postgres_storage.models.V1CurrentData)
           .rows();
         const transformed = docs.map((doc) => {
           return bson.deserialize(doc.data) as SqliteRow;
@@ -293,14 +296,20 @@ bucket_definitions:
     }
 
     abortController.abort();
-    await streamPromise;
+    await streamPromise.catch((e) => {
+      if (e instanceof ReplicationAbortedError) {
+        // Ignore
+      } else {
+        throw e;
+      }
+    });
   }
 
   // Test repeatedly performing initial replication.
   //
   // If the first LSN does not correctly match with the first replication transaction,
   // we may miss some updates.
-  test('repeated initial replication', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+  test('repeated initial replication (1)', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
     const pool = await connectPgPool();
     await clearTestDb(pool);
     await using f = await factory();
@@ -337,7 +346,6 @@ bucket_definitions:
       i += 1;
 
       const connections = new PgManager(TEST_CONNECTION_OPTIONS, {});
-      const replicationConnection = await connections.replicationConnection();
 
       abortController = new AbortController();
       const options: WalStreamOptions = {
@@ -350,19 +358,14 @@ bucket_definitions:
 
       await storage.clear();
 
-      // 3. Start initial replication, then streaming, but don't wait for any of this
+      // 3. Start replication, but don't wait for it
       let initialReplicationDone = false;
-      streamPromise = (async () => {
-        await walStream.initReplication(replicationConnection);
-        initialReplicationDone = true;
-        await walStream.streamChanges(replicationConnection);
-      })()
-        .catch((e) => {
+      streamPromise = walStream.replicate();
+      walStream
+        .waitForInitialSnapshot()
+        .catch((_) => {})
+        .finally(() => {
           initialReplicationDone = true;
-          throw e;
-        })
-        .then((v) => {
-          return v;
         });
 
       // 4. While initial replication is still running, write more changes
@@ -405,8 +408,104 @@ bucket_definitions:
       }
 
       abortController.abort();
-      await streamPromise;
+      await streamPromise.catch((e) => {
+        if (e instanceof ReplicationAbortedError) {
+          // Ignore
+        } else {
+          throw e;
+        }
+      });
       await connections.end();
     }
   });
+
+  // Test repeatedly performing initial replication while deleting data.
+  //
+  // This specifically checks for data in the initial snapshot being deleted while snapshotting.
+  test('repeated initial replication with deletes', { timeout: TEST_DURATION_MS + TIMEOUT_MARGIN_MS }, async () => {
+    const syncRuleContent = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test_data"
+`;
+
+    const start = Date.now();
+    let i = 0;
+
+    while (Date.now() - start < TEST_DURATION_MS) {
+      i += 1;
+
+      // 1. Each iteration starts with a clean slate
+      await using context = await WalStreamTestContext.open(factory, {
+        walStreamOptions: { snapshotChunkLength: 100 }
+      });
+      const pool = context.pool;
+
+      // Introduce an artificial delay in snapshot queries, to make it more likely to reproduce an
+      // issue.
+      const originalSnapshotConnectionFn = context.connectionManager.snapshotConnection;
+      context.connectionManager.snapshotConnection = async () => {
+        const conn = await originalSnapshotConnectionFn.call(context.connectionManager);
+        // Wrap streaming query to add delays to snapshots
+        const originalStream = conn.stream;
+        conn.stream = async function* (...args: any[]) {
+          const delay = Math.random() * 20;
+          yield* originalStream.call(this, ...args);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        };
+        return conn;
+      };
+
+      await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
+      await context.updateSyncRules(syncRuleContent);
+
+      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') RETURNING id`
+        });
+      }
+      const results = await pool.query(...statements);
+      const ids = new Set(
+        results.results.map((sub) => {
+          return sub.rows[0].decodeWithoutCustomTypes(0) as string;
+        })
+      );
+
+      // 3. Start replication, but don't wait for it
+      let initialReplicationDone = false;
+
+      streamPromise = context.replicateSnapshot().finally(() => {
+        initialReplicationDone = true;
+      });
+
+      // 4. While initial replication is still running, delete random rows
+      while (!initialReplicationDone && ids.size > 0) {
+        let statements: pgwire.Statement[] = [];
+
+        const m = Math.floor(Math.random() * 10) + 1;
+        const idArray = Array.from(ids);
+        for (let i = 0; i < m; i++) {
+          const id = idArray[Math.floor(Math.random() * idArray.length)];
+          statements.push({
+            statement: `DELETE FROM test_data WHERE id = $1`,
+            params: [{ type: 'uuid', value: id }]
+          });
+          ids.delete(id);
+        }
+        await pool.query(...statements);
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 10));
+      }
+
+      await streamPromise;
+
+      // 5. Once initial replication is done, wait for the streaming changes to complete syncing.
+      const data = await context.getBucketData('global[]', 0n);
+      const normalized = reduceBucket(data).filter((op) => op.op !== 'CLEAR');
+      expect(normalized.length).toEqual(ids.size);
+    }
+  });
 }

package/test/src/storage_combination.test.ts

@@ -7,9 +7,9 @@ describe.skipIf(!env.TEST_POSTGRES_STORAGE)('replication storage combination - p
   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.test_utils.postgresTestStorageFactoryGenerator({
+      postgres_storage.test_utils.postgresTestSetup({
         url: env.PG_TEST_URL
-      }),
+      }).factory,
       { doNotClear: false }
     );
 

package/test/src/util.ts

@@ -7,6 +7,8 @@ import {
   CURRENT_STORAGE_VERSION,
   InternalOpId,
   LEGACY_STORAGE_VERSION,
+  SUPPORTED_STORAGE_VERSIONS,
+  TestStorageConfig,
   TestStorageFactory
 } from '@powersync/service-core';
 import * as pgwire from '@powersync/service-jpgwire';
@@ -22,11 +24,11 @@ export const INITIALIZED_MONGO_STORAGE_FACTORY = mongo_storage.test_utils.mongoT
   isCI: env.CI
 });
 
-export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestStorageFactoryGenerator({
+export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestSetup({
   url: env.PG_STORAGE_TEST_URL
 });
 
-const TEST_STORAGE_VERSIONS = [LEGACY_STORAGE_VERSION, CURRENT_STORAGE_VERSION];
+const TEST_STORAGE_VERSIONS = SUPPORTED_STORAGE_VERSIONS;
 
 export interface StorageVersionTestContext {
   factory: TestStorageFactory;
@@ -34,12 +36,12 @@ export interface StorageVersionTestContext {
 }
 
 export function describeWithStorage(options: TestOptions, fn: (context: StorageVersionTestContext) => void) {
-  const describeFactory = (storageName: string, factory: TestStorageFactory) => {
+  const describeFactory = (storageName: string, config: TestStorageConfig) => {
     describe(`${storageName} storage`, options, function () {
       for (const storageVersion of TEST_STORAGE_VERSIONS) {
         describe(`storage v${storageVersion}`, function () {
           fn({
-            factory,
+            factory: config.factory,
             storageVersion
           });
         });

package/test/src/validation.test.ts

@@ -6,7 +6,7 @@ import { WalStreamTestContext } from './wal_stream_utils.js';
 import { updateSyncRulesFromYaml } from '@powersync/service-core';
 
 test('validate tables', async () => {
-  await using context = await WalStreamTestContext.open(INITIALIZED_MONGO_STORAGE_FACTORY);
+  await using context = await WalStreamTestContext.open(INITIALIZED_MONGO_STORAGE_FACTORY.factory);
   const { pool } = context;
 
   await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);