@powersync/service-module-postgres 0.2.4 → 0.4.0

package/src/utils/pgwire_utils.ts

@@ -1,9 +1,7 @@
 // Adapted from https://github.com/kagis/pgwire/blob/0dc927f9f8990a903f238737326e53ba1c8d094f/mod.js#L2218
 
 import * as pgwire from '@powersync/service-jpgwire';
-import { SqliteJsonValue, SqliteRow, toSyncRulesRow } from '@powersync/service-sync-rules';
-
-import { logger } from '@powersync/lib-services-framework';
+import { SqliteRow, toSyncRulesRow } from '@powersync/service-sync-rules';
 
 /**
  * pgwire message -> SQLite row.
@@ -28,46 +26,3 @@ export function constructBeforeRecord(message: pgwire.PgoutputDelete | pgwire.Pg
   const record = pgwire.decodeTuple(message.relation, rawData);
   return toSyncRulesRow(record);
 }
-
-export function escapeIdentifier(identifier: string) {
-  return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
-}
-
-export function autoParameter(arg: SqliteJsonValue | boolean): pgwire.StatementParam {
-  if (arg == null) {
-    return { type: 'varchar', value: null };
-  } else if (typeof arg == 'string') {
-    return { type: 'varchar', value: arg };
-  } else if (typeof arg == 'number') {
-    if (Number.isInteger(arg)) {
-      return { type: 'int8', value: arg };
-    } else {
-      return { type: 'float8', value: arg };
-    }
-  } else if (typeof arg == 'boolean') {
-    return { type: 'bool', value: arg };
-  } else if (typeof arg == 'bigint') {
-    return { type: 'int8', value: arg };
-  } else {
-    throw new Error(`Unsupported query parameter: ${typeof arg}`);
-  }
-}
-
-export async function retriedQuery(db: pgwire.PgClient, ...statements: pgwire.Statement[]): Promise<pgwire.PgResult>;
-export async function retriedQuery(db: pgwire.PgClient, query: string): Promise<pgwire.PgResult>;
-
-/**
- * Retry a simple query - up to 2 attempts total.
- */
-export async function retriedQuery(db: pgwire.PgClient, ...args: any[]) {
-  for (let tries = 2; ; tries--) {
-    try {
-      return await db.query(...args);
-    } catch (e) {
-      if (tries == 1) {
-        throw e;
-      }
-      logger.warn('Query error, retrying', e);
-    }
-  }
-}

package/test/src/__snapshots__/schema_changes.test.ts.snap

@@ -0,0 +1,5 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`schema changes - mongodb > add to publication (not in sync rules) 1`] = `0`;
+
+exports[`schema changes - postgres > add to publication (not in sync rules) 1`] = `16384`;

package/test/src/env.ts

@@ -2,6 +2,10 @@ import { utils } from '@powersync/lib-services-framework';
 
 export const env = utils.collectEnvironmentVariables({
   PG_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5432/powersync_test'),
+  PG_STORAGE_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5431/powersync_storage_test'),
+  MONGO_TEST_URL: utils.type.string.default('mongodb://localhost:27017/powersync_test'),
   CI: utils.type.boolean.default('false'),
-  SLOW_TESTS: utils.type.boolean.default('false')
+  SLOW_TESTS: utils.type.boolean.default('false'),
+  TEST_MONGO_STORAGE: utils.type.boolean.default('true'),
+  TEST_POSTGRES_STORAGE: utils.type.boolean.default('true')
 });

package/test/src/large_batch.test.ts

@@ -1,17 +1,31 @@
-import { MONGO_STORAGE_FACTORY, StorageFactory, StorageOptions } from '@core-tests/util.js';
+import { Metrics, storage } from '@powersync/service-core';
+import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
 import { populateData } from '../../dist/utils/populate_test_data.js';
 import { env } from './env.js';
-import { TEST_CONNECTION_OPTIONS } from './util.js';
+import {
+  INITIALIZED_MONGO_STORAGE_FACTORY,
+  INITIALIZED_POSTGRES_STORAGE_FACTORY,
+  TEST_CONNECTION_OPTIONS
+} from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
-import * as timers from 'timers/promises';
-import { Metrics } from '@powersync/service-core';
 
-describe('batch replication tests - mongodb', { timeout: 120_000 }, function () {
+describe.skipIf(!env.TEST_MONGO_STORAGE)('batch replication tests - mongodb', { timeout: 120_000 }, function () {
+  // These are slow but consistent tests.
+  // Not run on every test run, but we do run on CI, or when manually debugging issues.
+  if (env.CI || env.SLOW_TESTS) {
+    defineBatchTests(INITIALIZED_MONGO_STORAGE_FACTORY);
+  } else {
+    // Need something in this file.
+    test('no-op', () => {});
+  }
+});
+
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('batch replication tests - postgres', { timeout: 240_000 }, function () {
   // These are slow but consistent tests.
   // Not run on every test run, but we do run on CI, or when manually debugging issues.
   if (env.CI || env.SLOW_TESTS) {
-    defineBatchTests(MONGO_STORAGE_FACTORY);
+    defineBatchTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
   } else {
     // Need something in this file.
     test('no-op', () => {});
@@ -23,7 +37,7 @@ const BASIC_SYNC_RULES = `bucket_definitions:
     data:
       - SELECT id, description, other FROM "test_data"`;
 
-function defineBatchTests(factory: StorageFactory) {
+function defineBatchTests(factory: storage.TestStorageFactory) {
   test('update large record', async () => {
     await using context = await WalStreamTestContext.open(factory);
     // This test generates a large transaction in MongoDB, despite the replicated data

package/test/src/schema_changes.test.ts

@@ -1,14 +1,20 @@
-import { compareIds, putOp, removeOp } from '@core-tests/stream_utils.js';
-import { reduceBucket } from '@powersync/service-core';
-import { setTimeout } from 'node:timers/promises';
+import { compareIds, putOp, reduceBucket, removeOp, test_utils } from '@powersync/service-core-tests';
+import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
-import { INITIALIZED_MONGO_STORAGE_FACTORY, StorageFactory } from './util.js';
+
+import { storage } from '@powersync/service-core';
+import { env } from './env.js';
+import { INITIALIZED_MONGO_STORAGE_FACTORY, INITIALIZED_POSTGRES_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
-describe('schema changes', { timeout: 20_000 }, function () {
+describe.skipIf(!env.TEST_MONGO_STORAGE)('schema changes - mongodb', { timeout: 20_000 }, function () {
   defineTests(INITIALIZED_MONGO_STORAGE_FACTORY);
 });
 
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('schema changes - postgres', { timeout: 20_000 }, function () {
+  defineTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
+});
+
 const BASIC_SYNC_RULES = `
 bucket_definitions:
   global:
@@ -16,14 +22,14 @@ bucket_definitions:
       - SELECT id, * FROM "test_data"
 `;
 
-const PUT_T1 = putOp('test_data', { id: 't1', description: 'test1' });
-const PUT_T2 = putOp('test_data', { id: 't2', description: 'test2' });
-const PUT_T3 = putOp('test_data', { id: 't3', description: 'test3' });
+const PUT_T1 = test_utils.putOp('test_data', { id: 't1', description: 'test1' });
+const PUT_T2 = test_utils.putOp('test_data', { id: 't2', description: 'test2' });
+const PUT_T3 = test_utils.putOp('test_data', { id: 't3', description: 'test3' });
 
-const REMOVE_T1 = removeOp('test_data', 't1');
-const REMOVE_T2 = removeOp('test_data', 't2');
+const REMOVE_T1 = test_utils.removeOp('test_data', 't1');
+const REMOVE_T2 = test_utils.removeOp('test_data', 't2');
 
-function defineTests(factory: StorageFactory) {
+function defineTests(factory: storage.TestStorageFactory) {
   test('re-create table', async () => {
     await using context = await WalStreamTestContext.open(factory);
 
@@ -431,7 +437,7 @@ function defineTests(factory: StorageFactory) {
     expect(data).toMatchObject([]);
 
     const metrics = await storage.factory.getStorageMetrics();
-    expect(metrics.replication_size_bytes).toEqual(0);
+    expect(metrics.replication_size_bytes).toMatchSnapshot();
   });
 
   test('replica identity nothing', async () => {
@@ -544,7 +550,7 @@ function defineTests(factory: StorageFactory) {
     );
 
     // Need some delay for the snapshot to be triggered
-    await setTimeout(5);
+    await timers.setTimeout(5);
 
     let stop = false;
 

package/test/src/setup.ts

@@ -1,7 +1,13 @@
 import { container } from '@powersync/lib-services-framework';
-import { beforeAll } from 'vitest';
+import { test_utils } from '@powersync/service-core-tests';
+import { beforeAll, beforeEach } from 'vitest';
 
-beforeAll(() => {
+beforeAll(async () => {
   // Executes for every test file
   container.registerDefaults();
+  await test_utils.initMetrics();
+});
+
+beforeEach(async () => {
+  await test_utils.resetMetrics();
 });

package/test/src/slow_tests.test.ts

@@ -2,30 +2,48 @@ import * as bson from 'bson';
 import { afterEach, describe, expect, test } from 'vitest';
 import { WalStream, WalStreamOptions } from '../../src/replication/WalStream.js';
 import { env } from './env.js';
-import { clearTestDb, connectPgPool, getClientCheckpoint, TEST_CONNECTION_OPTIONS } from './util.js';
+import {
+  clearTestDb,
+  connectPgPool,
+  getClientCheckpoint,
+  INITIALIZED_MONGO_STORAGE_FACTORY,
+  INITIALIZED_POSTGRES_STORAGE_FACTORY,
+  TEST_CONNECTION_OPTIONS
+} from './util.js';
 
 import * as pgwire from '@powersync/service-jpgwire';
 import { SqliteRow } from '@powersync/service-sync-rules';
 
-import { mapOpEntry, MongoBucketStorage } from '@/storage/storage-index.js';
-import { validateCompactedBucket } from '@core-tests/bucket_validation.js';
-import { MONGO_STORAGE_FACTORY, StorageFactory } from '@core-tests/util.js';
 import { PgManager } from '@module/replication/PgManager.js';
+import { storage } from '@powersync/service-core';
+import { 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 { reduceBucket } from '@powersync/service-core';
 
-describe('slow tests - mongodb', function () {
+describe.skipIf(!env.TEST_MONGO_STORAGE)('slow tests - mongodb', function () {
   // These are slow, inconsistent tests.
   // Not run on every test run, but we do run on CI, or when manually debugging issues.
   if (env.CI || env.SLOW_TESTS) {
-    defineSlowTests(MONGO_STORAGE_FACTORY);
+    defineSlowTests(INITIALIZED_MONGO_STORAGE_FACTORY);
   } else {
     // Need something in this file.
     test('no-op', () => {});
   }
 });
 
-function defineSlowTests(factory: StorageFactory) {
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('slow tests - postgres', function () {
+  // These are slow, inconsistent tests.
+  // Not run on every test run, but we do run on CI, or when manually debugging issues.
+  if (env.CI || env.SLOW_TESTS) {
+    defineSlowTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
+  } else {
+    // Need something in this file.
+    test('no-op', () => {});
+  }
+});
+
+function defineSlowTests(factory: storage.TestStorageFactory) {
   let walStream: WalStream | undefined;
   let connections: PgManager | undefined;
   let abortController: AbortController | undefined;
@@ -74,7 +92,7 @@ function defineSlowTests(factory: StorageFactory) {
     const replicationConnection = await connections.replicationConnection();
     const pool = connections.pool;
     await clearTestDb(pool);
-    const f = (await factory()) as MongoBucketStorage;
+    await using f = await factory();
 
     const syncRuleContent = `
 bucket_definitions:
@@ -169,15 +187,50 @@ bucket_definitions:
           }
 
           const checkpoint = BigInt((await storage.getCheckpoint()).checkpoint);
-          const opsBefore = (await f.db.bucket_data.find().sort({ _id: 1 }).toArray())
-            .filter((row) => row._id.o <= checkpoint)
-            .map(mapOpEntry);
-          await storage.compact({ maxOpId: checkpoint });
-          const opsAfter = (await f.db.bucket_data.find().sort({ _id: 1 }).toArray())
-            .filter((row) => row._id.o <= checkpoint)
-            .map(mapOpEntry);
-
-          validateCompactedBucket(opsBefore, opsAfter);
+          if (f instanceof mongo_storage.storage.MongoBucketStorage) {
+            const opsBefore = (await f.db.bucket_data.find().sort({ _id: 1 }).toArray())
+              .filter((row) => row._id.o <= checkpoint)
+              .map(mongo_storage.storage.mapOpEntry);
+            await storage.compact({ maxOpId: checkpoint });
+            const opsAfter = (await f.db.bucket_data.find().sort({ _id: 1 }).toArray())
+              .filter((row) => row._id.o <= checkpoint)
+              .map(mongo_storage.storage.mapOpEntry);
+
+            test_utils.validateCompactedBucket(opsBefore, opsAfter);
+          } else if (f instanceof postgres_storage.PostgresBucketStorageFactory) {
+            const { db } = f;
+            const opsBefore = (
+              await db.sql`
+                SELECT
+                  *
+                FROM
+                  bucket_data
+                WHERE
+                  op_id <= ${{ type: 'int8', value: checkpoint }}
+                ORDER BY
+                  op_id ASC
+              `
+                .decoded(postgres_storage.models.BucketData)
+                .rows()
+            ).map(postgres_storage.utils.mapOpEntry);
+            await storage.compact({ maxOpId: checkpoint });
+            const opsAfter = (
+              await db.sql`
+                SELECT
+                  *
+                FROM
+                  bucket_data
+                WHERE
+                  op_id <= ${{ type: 'int8', value: checkpoint }}
+                ORDER BY
+                  op_id ASC
+              `
+                .decoded(postgres_storage.models.BucketData)
+                .rows()
+            ).map(postgres_storage.utils.mapOpEntry);
+
+            test_utils.validateCompactedBucket(opsBefore, opsAfter);
+          }
         }
       };
 
@@ -191,26 +244,66 @@ bucket_definitions:
       // Wait for replication to finish
       let checkpoint = await getClientCheckpoint(pool, storage.factory, { timeout: TIMEOUT_MARGIN_MS });
 
-      // Check that all inserts have been deleted again
-      const docs = await f.db.current_data.find().toArray();
-      const transformed = docs.map((doc) => {
-        return bson.deserialize(doc.data.buffer) as SqliteRow;
-      });
-      expect(transformed).toEqual([]);
-
-      // Check that each PUT has a REMOVE
-      const ops = await f.db.bucket_data.find().sort({ _id: 1 }).toArray();
-
-      // All a single bucket in this test
-      const bucket = ops.map((op) => mapOpEntry(op));
-      const reduced = reduceBucket(bucket);
-      expect(reduced).toMatchObject([
-        {
-          op_id: '0',
-          op: 'CLEAR'
-        }
-        // Should contain no additional data
-      ]);
+      if (f instanceof mongo_storage.storage.MongoBucketStorage) {
+        // Check that all inserts have been deleted again
+        const docs = await f.db.current_data.find().toArray();
+        const transformed = docs.map((doc) => {
+          return bson.deserialize(doc.data.buffer) as SqliteRow;
+        });
+        expect(transformed).toEqual([]);
+
+        // Check that each PUT has a REMOVE
+        const ops = await f.db.bucket_data.find().sort({ _id: 1 }).toArray();
+
+        // All a single bucket in this test
+        const bucket = ops.map((op) => mongo_storage.storage.mapOpEntry(op));
+        const reduced = test_utils.reduceBucket(bucket);
+        expect(reduced).toMatchObject([
+          {
+            op_id: '0',
+            op: 'CLEAR'
+          }
+          // Should contain no additional data
+        ]);
+      } else if (f instanceof postgres_storage.storage.PostgresBucketStorageFactory) {
+        const { db } = f;
+        // Check that all inserts have been deleted again
+        const docs = await db.sql`
+          SELECT
+            *
+          FROM
+            current_data
+        `
+          .decoded(postgres_storage.models.CurrentData)
+          .rows();
+        const transformed = docs.map((doc) => {
+          return bson.deserialize(doc.data) as SqliteRow;
+        });
+        expect(transformed).toEqual([]);
+
+        // Check that each PUT has a REMOVE
+        const ops = await db.sql`
+          SELECT
+            *
+          FROM
+            bucket_data
+          ORDER BY
+            op_id ASC
+        `
+          .decoded(postgres_storage.models.BucketData)
+          .rows();
+
+        // All a single bucket in this test
+        const bucket = ops.map((op) => postgres_storage.utils.mapOpEntry(op));
+        const reduced = test_utils.reduceBucket(bucket);
+        expect(reduced).toMatchObject([
+          {
+            op_id: '0',
+            op: 'CLEAR'
+          }
+          // Should contain no additional data
+        ]);
+      }
     }
 
     abortController.abort();
@@ -226,7 +319,7 @@ bucket_definitions:
     async () => {
       const pool = await connectPgPool();
       await clearTestDb(pool);
-      const f = await factory();
+      await using f = await factory();
 
       const syncRuleContent = `
 bucket_definitions:

package/test/src/util.ts

@@ -1,22 +1,23 @@
-import { connectMongo } from '@core-tests/util.js';
+import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js';
 import * as types from '@module/types/types.js';
-import * as pg_utils from '@module/utils/pgwire_utils.js';
+import * as lib_postgres from '@powersync/lib-service-postgres';
 import { logger } from '@powersync/lib-services-framework';
-import { BucketStorageFactory, Metrics, MongoBucketStorage, OpId } from '@powersync/service-core';
+import { BucketStorageFactory, OpId } from '@powersync/service-core';
 import * as pgwire from '@powersync/service-jpgwire';
-import { pgwireRows } 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 { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js';
 
-// The metrics need to be initialized before they can be used
-await Metrics.initialise({
-  disable_telemetry_sharing: true,
-  powersync_instance_id: 'test',
-  internal_metrics_endpoint: 'unused.for.tests.com'
+export const TEST_URI = env.PG_TEST_URL;
+
+export const INITIALIZED_MONGO_STORAGE_FACTORY = mongo_storage.MongoTestStorageFactoryGenerator({
+  url: env.MONGO_TEST_URL,
+  isCI: env.CI
 });
-Metrics.getInstance().resetCounters();
 
-export const TEST_URI = env.PG_TEST_URL;
+export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.PostgresTestStorageFactoryGenerator({
+  url: env.PG_STORAGE_TEST_URL
+});
 
 export const TEST_CONNECTION_OPTIONS = types.normalizeConnectionConfig({
   type: 'postgresql',
@@ -24,23 +25,6 @@ export const TEST_CONNECTION_OPTIONS = types.normalizeConnectionConfig({
   sslmode: 'disable'
 });
 
-export type StorageFactory = () => Promise<BucketStorageFactory>;
-
-export const INITIALIZED_MONGO_STORAGE_FACTORY: StorageFactory = async () => {
-  const db = await connectMongo();
-
-  // None of the PG tests insert data into this collection, so it was never created
-  if (!(await db.db.listCollections({ name: db.bucket_parameters.collectionName }).hasNext())) {
-    await db.db.createCollection('bucket_parameters');
-  }
-
-  await db.clear();
-
-  return new MongoBucketStorage(db, {
-    slot_name_prefix: 'test_'
-  });
-};
-
 export async function clearTestDb(db: pgwire.PgClient) {
   await db.query(
     "select pg_drop_replication_slot(slot_name) from pg_replication_slots where active = false and slot_name like 'test_%'"
@@ -61,7 +45,7 @@ export async function clearTestDb(db: pgwire.PgClient) {
   for (let row of tableRows) {
     const name = row.table_name;
     if (name.startsWith('test_')) {
-      await db.query(`DROP TABLE public.${pg_utils.escapeIdentifier(name)}`);
+      await db.query(`DROP TABLE public.${lib_postgres.escapeIdentifier(name)}`);
     }
   }
 }

package/test/src/validation.test.ts

@@ -1,10 +1,12 @@
-import { MONGO_STORAGE_FACTORY } from '@core-tests/util.js';
 import { getDebugTablesInfo } from '@module/replication/replication-utils.js';
 import { expect, test } from 'vitest';
+
+// Not quite a walStreamTest, but it helps to manage the connection
+import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
 
 test('validate tables', async () => {
-  await using context = await WalStreamTestContext.open(MONGO_STORAGE_FACTORY);
+  await using context = await WalStreamTestContext.open(INITIALIZED_MONGO_STORAGE_FACTORY);
   const { pool } = context;
 
   await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);

package/test/src/wal_stream.test.ts

@@ -1,13 +1,12 @@
-import { putOp, removeOp } from '@core-tests/stream_utils.js';
-import { MONGO_STORAGE_FACTORY } from '@core-tests/util.js';
-import { BucketStorageFactory, Metrics } from '@powersync/service-core';
+import { MissingReplicationSlotError } from '@module/replication/WalStream.js';
+import { Metrics, storage } from '@powersync/service-core';
+import { putOp, removeOp } from '@powersync/service-core-tests';
 import { pgwireRows } from '@powersync/service-jpgwire';
 import * as crypto from 'crypto';
 import { describe, expect, test } from 'vitest';
+import { env } from './env.js';
+import { INITIALIZED_MONGO_STORAGE_FACTORY, INITIALIZED_POSTGRES_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
-import { MissingReplicationSlotError } from '@module/replication/WalStream.js';
-
-type StorageFactory = () => Promise<BucketStorageFactory>;
 
 const BASIC_SYNC_RULES = `
 bucket_definitions:
@@ -16,11 +15,15 @@ bucket_definitions:
       - SELECT id, description FROM "test_data"
 `;
 
-describe('wal stream - mongodb', { timeout: 20_000 }, function () {
-  defineWalStreamTests(MONGO_STORAGE_FACTORY);
+describe.skipIf(!env.TEST_MONGO_STORAGE)('wal stream - mongodb', { timeout: 20_000 }, function () {
+  defineWalStreamTests(INITIALIZED_MONGO_STORAGE_FACTORY);
+});
+
+describe.skipIf(!env.TEST_POSTGRES_STORAGE)('wal stream - postgres', { timeout: 20_000 }, function () {
+  defineWalStreamTests(INITIALIZED_POSTGRES_STORAGE_FACTORY);
 });
 
-function defineWalStreamTests(factory: StorageFactory) {
+function defineWalStreamTests(factory: storage.TestStorageFactory) {
   test('replicating basic values', async () => {
     await using context = await WalStreamTestContext.open(factory);
     const { pool } = context;

package/test/src/wal_stream_utils.ts

@@ -1,10 +1,9 @@
-import { fromAsync } from '@core-tests/stream_utils.js';
 import { PgManager } from '@module/replication/PgManager.js';
 import { PUBLICATION_NAME, WalStream, WalStreamOptions } from '@module/replication/WalStream.js';
-import { BucketStorageFactory, OplogEntry, SyncRulesBucketStorage } from '@powersync/service-core';
+import { BucketStorageFactory, OplogEntry, storage, SyncRulesBucketStorage } from '@powersync/service-core';
+import { test_utils } from '@powersync/service-core-tests';
 import * as pgwire from '@powersync/service-jpgwire';
 import { clearTestDb, getClientCheckpoint, TEST_CONNECTION_OPTIONS } from './util.js';
-import { StorageOptions } from '@core-tests/util.js';
 
 export class WalStreamTestContext implements AsyncDisposable {
   private _walStream?: WalStream;
@@ -20,7 +19,7 @@ export class WalStreamTestContext implements AsyncDisposable {
    * This configures all the context, and tears it down afterwards.
    */
   static async open(
-    factory: (options: StorageOptions) => Promise<BucketStorageFactory>,
+    factory: (options: storage.TestStorageOptions) => Promise<BucketStorageFactory>,
     options?: { doNotClear?: boolean }
   ) {
     const f = await factory({ doNotClear: options?.doNotClear });
@@ -47,6 +46,7 @@ export class WalStreamTestContext implements AsyncDisposable {
     await this.streamPromise;
     await this.connectionManager.destroy();
     this.storage?.[Symbol.dispose]();
+    await this.factory?.[Symbol.asyncDispose]();
   }
 
   get pool() {
@@ -132,7 +132,7 @@ export class WalStreamTestContext implements AsyncDisposable {
   async getBucketsDataBatch(buckets: Record<string, string>, options?: { timeout?: number }) {
     let checkpoint = await this.getCheckpoint(options);
     const map = new Map<string, string>(Object.entries(buckets));
-    return fromAsync(this.storage!.getBucketDataBatch(checkpoint, map));
+    return test_utils.fromAsync(this.storage!.getBucketDataBatch(checkpoint, map));
   }
 
   /**
@@ -146,7 +146,7 @@ export class WalStreamTestContext implements AsyncDisposable {
     while (true) {
       const batch = this.storage!.getBucketDataBatch(checkpoint, map);
 
-      const batches = await fromAsync(batch);
+      const batches = await test_utils.fromAsync(batch);
       data = data.concat(batches[0]?.batch.data ?? []);
       if (batches.length == 0 || !batches[0]!.batch.has_more) {
         break;
@@ -164,7 +164,7 @@ export class WalStreamTestContext implements AsyncDisposable {
     const { checkpoint } = await this.storage!.getCheckpoint();
     const map = new Map<string, string>([[bucket, start]]);
     const batch = this.storage!.getBucketDataBatch(checkpoint, map);
-    const batches = await fromAsync(batch);
+    const batches = await test_utils.fromAsync(batch);
     return batches[0]?.batch.data ?? [];
   }
 }

package/tsconfig.json

@@ -26,6 +26,9 @@
     },
     {
       "path": "../../libs/lib-services"
+    },
+    {
+      "path": "../../libs/lib-postgres"
     }
   ]
 }