@powersync/service-module-postgres 0.17.1 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @powersync/service-module-postgres
 
+## 0.18.0
+
+### Minor Changes
+
+- 8bd83e8: Introduce storage versions.
+
+### Patch Changes
+
+- Updated dependencies [15aea77]
+- Updated dependencies [0998251]
+- Updated dependencies [65f3c89]
+- Updated dependencies [1c45667]
+- Updated dependencies [8785a3f]
+- Updated dependencies [8a4c34e]
+- Updated dependencies [b440093]
+- Updated dependencies [d7ff4ad]
+- Updated dependencies [c683322]
+- Updated dependencies [8bd83e8]
+- Updated dependencies [83989b2]
+- Updated dependencies [79a9729]
+- Updated dependencies [5edd95f]
+  - @powersync/lib-service-postgres@0.4.22
+  - @powersync/service-jpgwire@0.21.13
+  - @powersync/service-core@1.20.0
+  - @powersync/service-types@0.15.0
+  - @powersync/service-sync-rules@0.32.0
+  - @powersync/lib-services-framework@0.8.3
+
+## 0.17.2
+
+### Patch Changes
+
+- Updated dependencies [a04252d]
+  - @powersync/service-sync-rules@0.31.1
+  - @powersync/lib-services-framework@0.8.2
+  - @powersync/service-jpgwire@0.21.12
+  - @powersync/service-core@1.19.2
+  - @powersync/lib-service-postgres@0.4.21
+
 ## 0.17.1
 
 ### Patch Changes

package/dist/types/types.d.ts

@@ -28,6 +28,7 @@ export declare const PostgresConnectionConfig: t.Intersection<t.Codec<{
     reject_ip_ranges?: string[] | undefined;
     slot_name_prefix?: string | undefined;
     max_pool_size?: number | undefined;
+    connect_timeout?: number | undefined;
 }, {
     type: string;
     id?: string | undefined;
@@ -51,6 +52,7 @@ export declare const PostgresConnectionConfig: t.Intersection<t.Codec<{
     reject_ip_ranges?: string[] | undefined;
     slot_name_prefix?: string | undefined;
     max_pool_size?: number | undefined;
+    connect_timeout?: number | undefined;
 }, string, t.CodecProps>, t.ObjectCodec<{}>>;
 /**
  * Config input specified when starting services
@@ -80,5 +82,6 @@ export declare function normalizeConnectionConfig(options: PostgresConnectionCon
     lookup: import("net").LookupFunction | undefined;
     client_certificate: string | undefined;
     client_private_key: string | undefined;
+    connect_timeout_ms: number | undefined;
     max_pool_size: number;
 };

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.17.1",
+  "version": "0.18.0",
   "main": "dist/index.js",
   "license": "FSL-1.1-ALv2",
   "type": "module",
@@ -25,20 +25,20 @@
     "semver": "^7.5.4",
     "ts-codec": "^1.3.0",
     "uuid": "^11.1.0",
-    "@powersync/lib-service-postgres": "0.4.20",
-    "@powersync/lib-services-framework": "0.8.1",
-    "@powersync/service-core": "1.19.1",
-    "@powersync/service-jpgwire": "0.21.11",
+    "@powersync/lib-service-postgres": "0.4.22",
+    "@powersync/lib-services-framework": "0.8.3",
+    "@powersync/service-core": "1.20.0",
+    "@powersync/service-jpgwire": "0.21.13",
     "@powersync/service-jsonbig": "0.17.12",
-    "@powersync/service-sync-rules": "0.31.0",
-    "@powersync/service-types": "0.14.0"
+    "@powersync/service-sync-rules": "0.32.0",
+    "@powersync/service-types": "0.15.0"
   },
   "devDependencies": {
     "@types/semver": "^7.5.4",
-    "@powersync/service-core-tests": "0.13.1",
-    "@powersync/service-module-mongodb-storage": "0.13.1",
-    "@powersync/lib-service-postgres": "0.4.20",
-    "@powersync/service-module-postgres-storage": "0.11.1"
+    "@powersync/service-core-tests": "0.14.0",
+    "@powersync/service-module-mongodb-storage": "0.14.0",
+    "@powersync/lib-service-postgres": "0.4.22",
+    "@powersync/service-module-postgres-storage": "0.12.0"
   },
   "scripts": {
     "build": "tsc -b",

package/test/src/checkpoints.test.ts

@@ -1,7 +1,7 @@
 import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js';
-import { checkpointUserId, createWriteCheckpoint, TestStorageFactory } from '@powersync/service-core';
+import { checkpointUserId, createWriteCheckpoint } from '@powersync/service-core';
 import { describe, test } from 'vitest';
-import { describeWithStorage } from './util.js';
+import { describeWithStorage, StorageVersionTestContext } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
 import timers from 'node:timers/promises';
@@ -15,9 +15,9 @@ describe('checkpoint tests', () => {
   describeWithStorage({}, checkpointTests);
 });
 
-const checkpointTests = (factory: TestStorageFactory) => {
+const checkpointTests = ({ factory, storageVersion }: StorageVersionTestContext) => {
   test('write checkpoints', { timeout: 50_000 }, async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await WalStreamTestContext.open(factory, { storageVersion });
 
     await context.updateSyncRules(BASIC_SYNC_RULES);
     const { pool } = context;

package/test/src/chunked_snapshots.test.ts

@@ -1,17 +1,21 @@
-import { reduceBucket, TestStorageFactory } from '@powersync/service-core';
+import { reduceBucket } from '@powersync/service-core';
 import { METRICS_HELPER } from '@powersync/service-core-tests';
 import { SqliteJsonValue } from '@powersync/service-sync-rules';
 import * as crypto from 'node:crypto';
 import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
-import { describeWithStorage } from './util.js';
+import { describeWithStorage, StorageVersionTestContext } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
 describe('chunked snapshots', () => {
   describeWithStorage({ timeout: 120_000 }, defineBatchTests);
 });
 
-function defineBatchTests(factory: TestStorageFactory) {
+function defineBatchTests({ factory, storageVersion }: StorageVersionTestContext) {
+  const openContext = (options?: Parameters<typeof WalStreamTestContext.open>[1]) => {
+    return WalStreamTestContext.open(factory, { ...options, storageVersion });
+  };
+
   // We need to test every supported type, since chunking could be quite sensitive to
   // how each specific type is handled.
   test('chunked snapshot edge case (int2)', async () => {
@@ -89,7 +93,7 @@ function defineBatchTests(factory: TestStorageFactory) {
     // 5. Logical replication picks up the UPDATE above, but it is missing the TOAST column.
     // 6. We end up with a row that has a missing TOAST column.
 
-    await using context = await WalStreamTestContext.open(factory, {
+    await using context = await openContext({
       // We need to use a smaller chunk size here, so that we can run a query in between chunks
       walStreamOptions: { snapshotChunkLength: 100 }
     });

package/test/src/large_batch.test.ts

@@ -1,14 +1,11 @@
-import { storage } from '@powersync/service-core';
 import { describe, expect, test } from 'vitest';
 import { populateData } from '../../dist/utils/populate_test_data.js';
 import { env } from './env.js';
-import { describeWithStorage, TEST_CONNECTION_OPTIONS } from './util.js';
+import { describeWithStorage, StorageVersionTestContext, TEST_CONNECTION_OPTIONS } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
 describe.skipIf(!(env.CI || env.SLOW_TESTS))('batch replication', function () {
-  describeWithStorage({ timeout: 240_000 }, function (factory) {
-    defineBatchTests(factory);
-  });
+  describeWithStorage({ timeout: 240_000 }, defineBatchTests);
 });
 
 const BASIC_SYNC_RULES = `bucket_definitions:
@@ -16,9 +13,13 @@ const BASIC_SYNC_RULES = `bucket_definitions:
     data:
       - SELECT id, description, other FROM "test_data"`;
 
-function defineBatchTests(factory: storage.TestStorageFactory) {
+function defineBatchTests({ factory, storageVersion }: StorageVersionTestContext) {
+  const openContext = (options?: Parameters<typeof WalStreamTestContext.open>[1]) => {
+    return WalStreamTestContext.open(factory, { ...options, storageVersion });
+  };
+
   test('update large record', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // This test generates a large transaction in MongoDB, despite the replicated data
     // not being that large.
     // If we don't limit transaction size, we could run into this error:
@@ -41,17 +42,16 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
 
     context.startStreaming();
 
-    const checkpoint = await context.getCheckpoint({ timeout: 100_000 });
+    const checksum = await context.getChecksums(['global[]'], { timeout: 50_000 });
     const duration = Date.now() - start;
     const used = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
-    const checksum = await context.storage!.getChecksums(checkpoint, ['global[]']);
     expect(checksum.get('global[]')!.count).toEqual(operation_count);
     const perSecond = Math.round((operation_count / duration) * 1000);
     console.log(`${operation_count} ops in ${duration}ms ${perSecond} ops/s. ${used}MB heap`);
   });
 
   test('initial replication performance', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Manual test to check initial replication performance and memory usage
     await context.updateSyncRules(BASIC_SYNC_RULES);
     const { pool } = context;
@@ -89,9 +89,8 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
       await context.replicateSnapshot();
       context.startStreaming();
 
-      const checkpoint = await context.getCheckpoint({ timeout: 100_000 });
+      const checksum = await context.getChecksums(['global[]'], { timeout: 100_000 });
       const duration = Date.now() - start;
-      const checksum = await context.storage!.getChecksums(checkpoint, ['global[]']);
       expect(checksum.get('global[]')!.count).toEqual(operation_count);
       const perSecond = Math.round((operation_count / duration) * 1000);
       console.log(`${operation_count} ops in ${duration}ms ${perSecond} ops/s.`);
@@ -102,7 +101,7 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
   });
 
   test('large number of operations', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // This just tests performance of a large number of operations inside a transaction.
     await context.updateSyncRules(BASIC_SYNC_RULES);
     const { pool } = context;
@@ -141,10 +140,9 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
 
     context.startStreaming();
 
-    const checkpoint = await context.getCheckpoint({ timeout: 50_000 });
+    const checksum = await context.getChecksums(['global[]']);
     const duration = Date.now() - start;
     const used = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
-    const checksum = await context.storage!.getChecksums(checkpoint, ['global[]']);
     expect(checksum.get('global[]')!.count).toEqual(operationCount);
     const perSecond = Math.round((operationCount / duration) * 1000);
     // This number depends on the test machine, so we keep the test significantly
@@ -158,10 +156,8 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
     const truncateStart = Date.now();
     await pool.query(`TRUNCATE test_data`);
 
-    const checkpoint2 = await context.getCheckpoint({ timeout: 20_000 });
+    const checksum2 = await context.getChecksums(['global[]'], { timeout: 20_000 });
     const truncateDuration = Date.now() - truncateStart;
-
-    const checksum2 = await context.storage!.getChecksums(checkpoint2, ['global[]']);
     const truncateCount = checksum2.get('global[]')!.count - checksum.get('global[]')!.count;
     expect(truncateCount).toEqual(numTransactions * perTransaction);
     const truncatePerSecond = Math.round((truncateCount / truncateDuration) * 1000);
@@ -183,7 +179,7 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
     // 4. Another document to make sure the internal batching overflows
     //    to a second batch.
 
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     await context.updateSyncRules(`bucket_definitions:
   global:
     data:
@@ -227,9 +223,7 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
     await context.replicateSnapshot();
 
     context.startStreaming();
-
-    const checkpoint = await context.getCheckpoint({ timeout: 50_000 });
-    const checksum = await context.storage!.getChecksums(checkpoint, ['global[]']);
+    const checksum = await context.getChecksums(['global[]'], { timeout: 50_000 });
     expect(checksum.get('global[]')!.count).toEqual((numDocs + 2) * 4);
   });
 

package/test/src/resuming_snapshots.test.ts

@@ -1,27 +1,30 @@
 import { describe, expect, test } from 'vitest';
 import { env } from './env.js';
-import { describeWithStorage } from './util.js';
+import { describeWithStorage, StorageVersionTestContext } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
-import { TestStorageFactory } from '@powersync/service-core';
 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) {
+  describeWithStorage({ timeout: 240_000 }, function ({ factory, storageVersion }) {
     test('resuming initial replication (1)', async () => {
       // Stop early - likely to not include deleted row in first replication attempt.
-      await testResumingReplication(factory, 2000);
+      await testResumingReplication(factory, storageVersion, 2000);
     });
     test('resuming initial replication (2)', async () => {
       // Stop late - likely to include deleted row in first replication attempt.
-      await testResumingReplication(factory, 8000);
+      await testResumingReplication(factory, storageVersion, 8000);
     });
   });
 });
 
-async function testResumingReplication(factory: TestStorageFactory, stopAfter: number) {
+async function testResumingReplication(
+  factory: StorageVersionTestContext['factory'],
+  storageVersion: number,
+  stopAfter: number
+) {
   // This tests interrupting and then resuming initial replication.
   // We interrupt replication after test_data1 has fully replicated, and
   // test_data2 has partially replicated.
@@ -33,7 +36,10 @@ async function testResumingReplication(factory: TestStorageFactory, stopAfter: n
   //    have been / have not been replicated at that point is not deterministic.
   //    We do allow for some variation in the test results to account for this.
 
-  await using context = await WalStreamTestContext.open(factory, { walStreamOptions: { snapshotChunkLength: 1000 } });
+  await using context = await WalStreamTestContext.open(factory, {
+    storageVersion,
+    walStreamOptions: { snapshotChunkLength: 1000 }
+  });
 
   await context.updateSyncRules(`bucket_definitions:
   global:
@@ -84,6 +90,7 @@ async function testResumingReplication(factory: TestStorageFactory, stopAfter: n
   // Bypass the usual "clear db on factory open" step.
   await using context2 = await WalStreamTestContext.open(factory, {
     doNotClear: true,
+    storageVersion,
     walStreamOptions: { snapshotChunkLength: 1000 }
   });
 

package/test/src/route_api_adapter.test.ts

@@ -20,7 +20,9 @@ describe('PostgresRouteAPIAdapter tests', () => {
       `);
 
       const schema = await api.getConnectionSchema();
-      expect(schema).toStrictEqual([
+      // Ignore any other potential schemas in the test database, for example the 'powersync' schema.
+      const filtered = schema.filter((s) => s.name == 'public');
+      expect(filtered).toStrictEqual([
         {
           name: 'public',
           tables: [

package/test/src/schema_changes.test.ts

@@ -2,8 +2,7 @@ import { compareIds, putOp, reduceBucket, removeOp, test_utils } from '@powersyn
 import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
 
-import { storage } from '@powersync/service-core';
-import { describeWithStorage } from './util.js';
+import { describeWithStorage, StorageVersionTestContext } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
 describe('schema changes', { timeout: 20_000 }, function () {
@@ -24,9 +23,12 @@ const PUT_T3 = test_utils.putOp('test_data', { id: 't3', description: 'test3' })
 const REMOVE_T1 = test_utils.removeOp('test_data', 't1');
 const REMOVE_T2 = test_utils.removeOp('test_data', 't2');
 
-function defineTests(factory: storage.TestStorageFactory) {
+function defineTests({ factory, storageVersion }: StorageVersionTestContext) {
+  const openContext = (options?: Parameters<typeof WalStreamTestContext.open>[1]) => {
+    return WalStreamTestContext.open(factory, { ...options, storageVersion });
+  };
   test('re-create table', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
 
     // Drop a table and re-create it.
     await context.updateSyncRules(BASIC_SYNC_RULES);
@@ -70,7 +72,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('add table', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Add table after initial replication
     await context.updateSyncRules(BASIC_SYNC_RULES);
     const { pool } = context;
@@ -98,7 +100,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('rename table (1)', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
 
     await context.updateSyncRules(BASIC_SYNC_RULES);
@@ -136,7 +138,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('rename table (2)', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Rename table in sync rules -> in sync rules
     const { pool } = context;
 
@@ -189,7 +191,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('rename table (3)', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Rename table in sync rules -> not in sync rules
 
     const { pool } = context;
@@ -224,7 +226,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('change replica id', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Change replica id from default to full
     // Causes a re-import of the table.
 
@@ -268,7 +270,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('change full replica id by adding column', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Change replica id from full by adding column
     // Causes a re-import of the table.
     // Other changes such as renaming column would have the same effect
@@ -311,7 +313,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('change default replica id by changing column type', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Change default replica id by changing column type
     // Causes a re-import of the table.
     const { pool } = context;
@@ -348,7 +350,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('change index id by changing column type', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Change index replica id by changing column type
     // Causes a re-import of the table.
     // Secondary functionality tested here is that replica id column order stays
@@ -404,7 +406,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('add to publication', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Add table to publication after initial replication
     const { pool } = context;
 
@@ -447,7 +449,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('add to publication (not in sync rules)', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Add table to publication after initial replication
     // Since the table is not in sync rules, it should not be replicated.
     const { pool } = context;
@@ -474,7 +476,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('replica identity nothing', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Technically not a schema change, but fits here.
     // Replica ID works a little differently here - the table doesn't have
     // one defined, but we generate a unique one for each replicated row.
@@ -521,7 +523,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('replica identity default without PK', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     // Same as no replica identity
     const { pool } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
@@ -573,7 +575,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   //   await new Promise((resolve) => setTimeout(resolve, 100));
   //   await this.snapshotTable(batch, db, result.table);
   test('table snapshot consistency', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
     const { pool } = context;
 
     await context.updateSyncRules(BASIC_SYNC_RULES);
@@ -640,7 +642,7 @@ function defineTests(factory: storage.TestStorageFactory) {
   });
 
   test('custom types', async () => {
-    await using context = await WalStreamTestContext.open(factory);
+    await using context = await openContext();
 
     await context.updateSyncRules(`
 streams:

package/test/src/slow_tests.test.ts

@@ -7,6 +7,7 @@ import {
   connectPgPool,
   describeWithStorage,
   getClientCheckpoint,
+  StorageVersionTestContext,
   TEST_CONNECTION_OPTIONS
 } from './util.js';
 
@@ -14,7 +15,11 @@ import * as pgwire from '@powersync/service-jpgwire';
 import { SqliteRow } from '@powersync/service-sync-rules';
 
 import { PgManager } from '@module/replication/PgManager.js';
-import { createCoreReplicationMetrics, initializeCoreReplicationMetrics, storage } from '@powersync/service-core';
+import {
+  createCoreReplicationMetrics,
+  initializeCoreReplicationMetrics,
+  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';
@@ -22,12 +27,12 @@ import * as timers from 'node:timers/promises';
 import { CustomTypeRegistry } from '@module/types/registry.js';
 
 describe.skipIf(!(env.CI || env.SLOW_TESTS))('slow tests', function () {
-  describeWithStorage({ timeout: 120_000 }, function (factory) {
-    defineSlowTests(factory);
+  describeWithStorage({ timeout: 120_000 }, function ({ factory, storageVersion }) {
+    defineSlowTests({ factory, storageVersion });
   });
 });
 
-function defineSlowTests(factory: storage.TestStorageFactory) {
+function defineSlowTests({ factory, storageVersion }: StorageVersionTestContext) {
   let walStream: WalStream | undefined;
   let connections: PgManager | undefined;
   let abortController: AbortController | undefined;
@@ -81,7 +86,7 @@ bucket_definitions:
     data:
       - SELECT * FROM "test_data"
 `;
-    const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+    const syncRules = await f.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent, { storageVersion }));
     const storage = f.getInstance(syncRules);
     abortController = new AbortController();
     const options: WalStreamOptions = {
@@ -306,7 +311,8 @@ bucket_definitions:
     data:
       - SELECT id, description FROM "test_data"
 `;
-    const syncRules = await f.updateSyncRules({ content: syncRuleContent });
+
+    const syncRules = await f.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent, { storageVersion }));
     const storage = f.getInstance(syncRules);
 
     // 1. Setup some base data that will be replicated in initial replication

package/test/src/util.ts

@@ -2,12 +2,18 @@ import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js'
 import * as types from '@module/types/types.js';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { logger } from '@powersync/lib-services-framework';
-import { BucketStorageFactory, InternalOpId, TestStorageFactory } from '@powersync/service-core';
+import {
+  BucketStorageFactory,
+  CURRENT_STORAGE_VERSION,
+  InternalOpId,
+  LEGACY_STORAGE_VERSION,
+  TestStorageFactory
+} from '@powersync/service-core';
 import * as pgwire from '@powersync/service-jpgwire';
 import * as mongo_storage from '@powersync/service-module-mongodb-storage';
 import * as postgres_storage from '@powersync/service-module-postgres-storage';
-import { env } from './env.js';
 import { describe, TestOptions } from 'vitest';
+import { env } from './env.js';
 
 export const TEST_URI = env.PG_TEST_URL;
 
@@ -20,14 +26,34 @@ export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.
   url: env.PG_STORAGE_TEST_URL
 });
 
-export function describeWithStorage(options: TestOptions, fn: (factory: TestStorageFactory) => void) {
-  describe.skipIf(!env.TEST_MONGO_STORAGE)(`mongodb storage`, options, function () {
-    fn(INITIALIZED_MONGO_STORAGE_FACTORY);
-  });
+const TEST_STORAGE_VERSIONS = [LEGACY_STORAGE_VERSION, CURRENT_STORAGE_VERSION];
+
+export interface StorageVersionTestContext {
+  factory: TestStorageFactory;
+  storageVersion: number;
+}
 
-  describe.skipIf(!env.TEST_POSTGRES_STORAGE)(`postgres storage`, options, function () {
-    fn(INITIALIZED_POSTGRES_STORAGE_FACTORY);
-  });
+export function describeWithStorage(options: TestOptions, fn: (context: StorageVersionTestContext) => void) {
+  const describeFactory = (storageName: string, factory: TestStorageFactory) => {
+    describe(`${storageName} storage`, options, function () {
+      for (const storageVersion of TEST_STORAGE_VERSIONS) {
+        describe(`storage v${storageVersion}`, function () {
+          fn({
+            factory,
+            storageVersion
+          });
+        });
+      }
+    });
+  };
+
+  if (env.TEST_MONGO_STORAGE) {
+    describeFactory('mongodb', INITIALIZED_MONGO_STORAGE_FACTORY);
+  }
+
+  if (env.TEST_POSTGRES_STORAGE) {
+    describeFactory('postgres', INITIALIZED_POSTGRES_STORAGE_FACTORY);
+  }
 }
 
 export const TEST_CONNECTION_OPTIONS = types.normalizeConnectionConfig({

package/test/src/validation.test.ts

@@ -3,6 +3,7 @@ import { expect, test } from 'vitest';
 
 import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
 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);
@@ -19,7 +20,7 @@ bucket_definitions:
       - SELECT * FROM "other%"
 `;
 
-  const syncRules = await context.factory.updateSyncRules({ content: syncRuleContent });
+  const syncRules = await context.factory.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent));
 
   const tablePatterns = syncRules.parsed({ defaultSchema: 'public' }).sync_rules.config.getSourceTables();
   const tableInfo = await getDebugTablesInfo({