@powersync/service-module-postgres 0.0.0-dev-20241210162153 → 0.0.0-dev-20241219091224

package/test/src/wal_stream.test.ts

@@ -1,10 +1,11 @@
-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 { 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 { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
 import { WalStreamTestContext } from './wal_stream_utils.js';
+import { MissingReplicationSlotError } from '@module/replication/WalStream.js';
 
 type StorageFactory = () => Promise<BucketStorageFactory>;
 
@@ -16,7 +17,7 @@ bucket_definitions:
 `;
 
 describe('wal stream - mongodb', { timeout: 20_000 }, function () {
-  defineWalStreamTests(MONGO_STORAGE_FACTORY);
+  defineWalStreamTests(INITIALIZED_MONGO_STORAGE_FACTORY);
 });
 
 function defineWalStreamTests(factory: StorageFactory) {
@@ -291,4 +292,52 @@ bucket_definitions:
     expect(endRowCount - startRowCount).toEqual(0);
     expect(endTxCount - startTxCount).toEqual(1);
   });
+
+  test('reporting slot issues', async () => {
+    {
+      await using context = await WalStreamTestContext.open(factory);
+      const { pool } = context;
+      await context.updateSyncRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test_data"`);
+
+      await pool.query(
+        `CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text, num int8)`
+      );
+      await pool.query(
+        `INSERT INTO test_data(id, description) VALUES('8133cd37-903b-4937-a022-7c8294015a3a', 'test1') returning id as test_id`
+      );
+      await context.replicateSnapshot();
+      await context.startStreaming();
+
+      const data = await context.getBucketData('global[]');
+
+      expect(data).toMatchObject([
+        putOp('test_data', {
+          id: '8133cd37-903b-4937-a022-7c8294015a3a',
+          description: 'test1'
+        })
+      ]);
+
+      expect(await context.storage!.getStatus()).toMatchObject({ active: true, snapshot_done: true });
+    }
+
+    {
+      await using context = await WalStreamTestContext.open(factory, { doNotClear: true });
+      const { pool } = context;
+      await pool.query('DROP PUBLICATION powersync');
+      await pool.query(`UPDATE test_data SET description = 'updated'`);
+      await pool.query('CREATE PUBLICATION powersync FOR ALL TABLES');
+
+      await context.loadActiveSyncRules();
+      await expect(async () => {
+        await context.replicateSnapshot();
+      }).rejects.toThrowError(MissingReplicationSlotError);
+
+      // The error is handled on a higher level, which triggers
+      // creating a new replication slot.
+    }
+  });
 }

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 { StorageOptions, 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;
@@ -77,6 +76,16 @@ export class WalStreamTestContext implements AsyncDisposable {
     return this.storage!;
   }
 
+  async loadActiveSyncRules() {
+    const syncRules = await this.factory.getActiveSyncRulesContent();
+    if (syncRules == null) {
+      throw new Error(`Active sync rules not available`);
+    }
+
+    this.storage = this.factory.getInstance(syncRules);
+    return this.storage!;
+  }
+
   get walStream() {
     if (this.storage == null) {
       throw new Error('updateSyncRules() first');
@@ -122,7 +131,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));
   }
 
   /**
@@ -136,7 +145,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;
@@ -154,7 +163,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 ?? [];
   }
 }