@powersync/service-module-postgres 0.0.0-dev-20250117095455 → 0.0.0-dev-20250214100224

package/test/src/checkpoints.test.ts

@@ -0,0 +1,70 @@
+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 timers from 'node:timers/promises';
+
+const BASIC_SYNC_RULES = `bucket_definitions:
+  global:
+    data:
+      - SELECT id, description, other FROM "test_data"`;
+
+describe('checkpoint tests', () => {
+  test('write checkpoints', { timeout: 30_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 controller = new AbortController();
+    try {
+      const stream = context.factory.watchWriteCheckpoint(
+        checkpointUserId('test_user', 'test_client'),
+        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 > 2_000) {
+            throw new Error(`Timeout while waiting for checkpoint`);
+          }
+          await timers.setTimeout(0, undefined, { signal: controller.signal });
+        }
+      }
+    } finally {
+      controller.abort();
+    }
+  });
+});

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();
+    }
+  });
+});

package/test/src/util.ts

@@ -68,7 +68,7 @@ export async function getClientCheckpoint(
   const start = Date.now();
 
   const api = new PostgresRouteAPIAdapter(db);
-  const lsn = await api.getReplicationHead();
+  const lsn = await api.createReplicationHead(async (lsn) => lsn);
 
   // This old API needs a persisted checkpoint id.
   // Since we don't use LSNs anymore, the only way to get that is to wait.

package/test/src/wal_stream_utils.ts

@@ -62,7 +62,7 @@ export class WalStreamTestContext implements AsyncDisposable {
   }
 
   async updateSyncRules(content: string) {
-    const syncRules = await this.factory.updateSyncRules({ content: content });
+    const syncRules = await this.factory.updateSyncRules({ content: content, validate: true });
     this.storage = this.factory.getInstance(syncRules);
     return this.storage!;
   }