@powersync/service-module-postgres 0.14.4 → 0.15.0

package/src/module/PostgresModule.ts

@@ -1,6 +1,6 @@
+import { baseUri, NormalizedBasePostgresConnectionConfig } from '@powersync/lib-service-postgres';
 import {
   api,
-  auth,
   ConfigurationFileSyncRulesProvider,
   ConnectionTestResult,
   modules,
@@ -8,8 +8,8 @@ import {
   system
 } from '@powersync/service-core';
 import * as jpgwire from '@powersync/service-jpgwire';
+import { ReplicationMetric } from '@powersync/service-types';
 import { PostgresRouteAPIAdapter } from '../api/PostgresRouteAPIAdapter.js';
-import { SupabaseKeyCollector } from '../auth/SupabaseKeyCollector.js';
 import { ConnectionManagerFactory } from '../replication/ConnectionManagerFactory.js';
 import { PgManager } from '../replication/PgManager.js';
 import { PostgresErrorRateLimiter } from '../replication/PostgresErrorRateLimiter.js';
@@ -18,8 +18,6 @@ import { PUBLICATION_NAME } from '../replication/WalStream.js';
 import { WalStreamReplicator } from '../replication/WalStreamReplicator.js';
 import * as types from '../types/types.js';
 import { PostgresConnectionConfig } from '../types/types.js';
-import { baseUri, NormalizedBasePostgresConnectionConfig } from '@powersync/lib-service-postgres';
-import { ReplicationMetric } from '@powersync/service-types';
 import { getApplicationName } from '../utils/application-name.js';
 
 export class PostgresModule extends replication.ReplicationModule<types.PostgresConnectionConfig> {
@@ -32,19 +30,6 @@ export class PostgresModule extends replication.ReplicationModule<types.Postgres
   }
 
   async onInitialized(context: system.ServiceContextContainer): Promise<void> {
-    const client_auth = context.configuration.base_config.client_auth;
-
-    if (client_auth?.supabase && client_auth?.supabase_jwt_secret == null) {
-      // Only use the deprecated SupabaseKeyCollector when there is no
-      // secret hardcoded. Hardcoded secrets are handled elsewhere, using
-      // StaticSupabaseKeyCollector.
-
-      // Support for SupabaseKeyCollector is deprecated and support will be
-      // completely removed by Supabase soon. We can keep support a while
-      // longer for self-hosted setups, before also removing that on our side.
-      this.registerSupabaseAuth(context);
-    }
-
     // Record replicated bytes using global jpgwire metrics. Only registered if this module is replicating
     if (context.replicationEngine) {
       jpgwire.setMetricsRecorder({
@@ -110,32 +95,6 @@ export class PostgresModule extends replication.ReplicationModule<types.Postgres
     }
   }
 
-  // TODO: This should rather be done by registering the key collector in some kind of auth engine
-  private registerSupabaseAuth(context: system.ServiceContextContainer) {
-    const { configuration } = context;
-    // Register the Supabase key collector(s)
-    configuration.connections
-      ?.map((baseConfig) => {
-        if (baseConfig.type != types.POSTGRES_CONNECTION_TYPE) {
-          return;
-        }
-        try {
-          return this.resolveConfig(types.PostgresConnectionConfig.decode(baseConfig as any));
-        } catch (ex) {
-          this.logger.warn('Failed to decode configuration.', ex);
-        }
-      })
-      .filter((c) => !!c)
-      .forEach((config) => {
-        const keyCollector = new SupabaseKeyCollector(config!);
-        context.lifeCycleEngine.withLifecycle(keyCollector, {
-          // Close the internal pool
-          stop: (collector) => collector.shutdown()
-        });
-        configuration.client_keystore.collector.add(new auth.CachedKeyCollector(keyCollector));
-      });
-  }
-
   async testConnection(config: PostgresConnectionConfig): Promise<ConnectionTestResult> {
     this.decodeConfig(config);
     const normalizedConfig = this.resolveConfig(this.decodedConfig!);

package/src/replication/PgRelation.ts

@@ -1,4 +1,4 @@
-import { ReplicationAssertionError, ServiceError } from '@powersync/lib-services-framework';
+import { ReplicationAssertionError } from '@powersync/lib-services-framework';
 import { storage } from '@powersync/service-core';
 import { PgoutputRelation } from '@powersync/service-jpgwire';
 
@@ -27,6 +27,6 @@ export function getPgOutputRelation(source: PgoutputRelation): storage.SourceEnt
     name: source.name,
     schema: source.schema,
     objectId: getRelId(source),
-    replicationColumns: getReplicaIdColumns(source)
+    replicaIdColumns: getReplicaIdColumns(source)
   } satisfies storage.SourceEntityDescriptor;
 }

package/src/replication/SnapshotQuery.ts

@@ -36,7 +36,7 @@ export class SimpleSnapshotQuery implements SnapshotQuery {
   ) {}
 
   public async initialize(): Promise<void> {
-    await this.connection.query(`DECLARE snapshot_cursor CURSOR FOR SELECT * FROM ${this.table.escapedIdentifier}`);
+    await this.connection.query(`DECLARE snapshot_cursor CURSOR FOR SELECT * FROM ${this.table.qualifiedName}`);
   }
 
   public nextChunk(): AsyncIterableIterator<PgChunk> {
@@ -121,7 +121,7 @@ export class ChunkedSnapshotQuery implements SnapshotQuery {
     const escapedKeyName = escapeIdentifier(this.key.name);
     if (this.lastKey == null) {
       stream = this.connection.stream(
-        `SELECT * FROM ${this.table.escapedIdentifier} ORDER BY ${escapedKeyName} LIMIT ${this.chunkSize}`
+        `SELECT * FROM ${this.table.qualifiedName} ORDER BY ${escapedKeyName} LIMIT ${this.chunkSize}`
       );
     } else {
       if (this.key.typeId == null) {
@@ -129,7 +129,7 @@ export class ChunkedSnapshotQuery implements SnapshotQuery {
       }
       let type: StatementParam['type'] = Number(this.key.typeId);
       stream = this.connection.stream({
-        statement: `SELECT * FROM ${this.table.escapedIdentifier} WHERE ${escapedKeyName} > $1 ORDER BY ${escapedKeyName} LIMIT ${this.chunkSize}`,
+        statement: `SELECT * FROM ${this.table.qualifiedName} WHERE ${escapedKeyName} > $1 ORDER BY ${escapedKeyName} LIMIT ${this.chunkSize}`,
         params: [{ value: this.lastKey, type }]
       });
     }
@@ -197,7 +197,7 @@ export class IdSnapshotQuery implements SnapshotQuery {
       throw new Error(`Cannot determine primary key array type for ${JSON.stringify(keyDefinition)}`);
     }
     yield* this.connection.stream({
-      statement: `SELECT * FROM ${this.table.escapedIdentifier} WHERE ${escapeIdentifier(keyDefinition.name)} = ANY($1)`,
+      statement: `SELECT * FROM ${this.table.qualifiedName} WHERE ${escapeIdentifier(keyDefinition.name)} = ANY($1)`,
       params: [
         {
           type: type,

package/src/replication/WalStream.ts

@@ -256,7 +256,7 @@ export class WalStream {
           name,
           schema,
           objectId: relid,
-          replicationColumns: cresult.replicationColumns
+          replicaIdColumns: cresult.replicationColumns
         } as SourceEntityDescriptor,
         false
       );
@@ -321,7 +321,7 @@ export class WalStream {
 
     // Check that replication slot exists
     for (let i = 120; i >= 0; i--) {
-      await touch();
+      this.touch();
 
       if (i == 0) {
         container.reporter.captureException(last_error, {
@@ -479,7 +479,7 @@ WHERE  oid = $1::regclass`,
 
         for (let table of tablesWithStatus) {
           await this.snapshotTableInTx(batch, db, table);
-          await touch();
+          this.touch();
         }
 
         // Always commit the initial snapshot at zero.
@@ -628,7 +628,7 @@ WHERE  oid = $1::regclass`,
         at += rows.length;
         this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED).add(rows.length);
 
-        await touch();
+        this.touch();
       }
 
       // Important: flush before marking progress
@@ -737,6 +737,9 @@ WHERE  oid = $1::regclass`,
           rows.map((r) => r.key)
         );
       }
+      // Even with resnapshot, we need to wait until we get a new consistent checkpoint
+      // after the snapshot, so we need to send a keepalive message.
+      await sendKeepAlive(db);
     } finally {
       await db.end();
     }
@@ -837,7 +840,6 @@ WHERE  oid = $1::regclass`,
 
   async streamChanges(replicationConnection: pgwire.PgConnection) {
     // When changing any logic here, check /docs/wal-lsns.md.
-
     const { createEmptyCheckpoints } = await this.ensureStorageCompatibility();
 
     const replicationOptions: Record<string, string> = {
@@ -867,9 +869,6 @@ WHERE  oid = $1::regclass`,
 
     this.startedStreaming = true;
 
-    // Auto-activate as soon as initial replication is done
-    await this.storage.autoActivate();
-
     let resnapshot: { table: storage.SourceTable; key: PrimaryKeyValue }[] = [];
 
     const markRecordUnavailable = (record: SaveUpdate) => {
@@ -911,7 +910,7 @@ WHERE  oid = $1::regclass`,
         let count = 0;
 
         for await (const chunk of replicationStream.pgoutputDecode()) {
-          await touch();
+          this.touch();
 
           if (this.abort_signal.aborted) {
             break;
@@ -1091,11 +1090,10 @@ WHERE  oid = $1::regclass`,
     }
     return Date.now() - this.oldestUncommittedChange.getTime();
   }
-}
 
-async function touch() {
-  // FIXME: The hosted Kubernetes probe does not actually check the timestamp on this.
-  // FIXME: We need a timeout of around 5+ minutes in Kubernetes if we do start checking the timestamp,
-  // or reduce PING_INTERVAL here.
-  return container.probes.touch();
+  private touch() {
+    container.probes.touch().catch((e) => {
+      this.logger.error(`Error touching probe`, e);
+    });
+  }
 }

package/src/replication/replication-utils.ts

@@ -315,7 +315,15 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
 
   const id_columns = id_columns_result?.replicationColumns ?? [];
 
-  const sourceTable = new storage.SourceTable(0, connectionTag, relationId ?? 0, schema, name, id_columns, true);
+  const sourceTable = new storage.SourceTable({
+    id: 0,
+    connectionTag: connectionTag,
+    objectId: relationId ?? 0,
+    schema: schema,
+    name: name,
+    replicaIdColumns: id_columns,
+    snapshotComplete: true
+  });
 
   const syncData = syncRules.tableSyncsData(sourceTable);
   const syncParameters = syncRules.tableSyncsParameters(sourceTable);
@@ -342,7 +350,7 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
 
   let selectError = null;
   try {
-    await lib_postgres.retriedQuery(db, `SELECT * FROM ${sourceTable.escapedIdentifier} LIMIT 1`);
+    await lib_postgres.retriedQuery(db, `SELECT * FROM ${sourceTable.qualifiedName} LIMIT 1`);
   } catch (e) {
     selectError = { level: 'fatal', message: e.message };
   }

package/test/src/checkpoints.test.ts

@@ -36,6 +36,8 @@ const checkpointTests = (factory: TestStorageFactory) => {
     await context.replicateSnapshot();
 
     context.startStreaming();
+    // Wait for a consistent checkpoint before we start.
+    await context.getCheckpoint();
     const storage = context.storage!;
 
     const controller = new AbortController();

package/test/src/large_batch.test.ts

@@ -87,7 +87,6 @@ function defineBatchTests(factory: storage.TestStorageFactory) {
       const start = Date.now();
 
       await context.replicateSnapshot();
-      await context.storage!.autoActivate();
       context.startStreaming();
 
       const checkpoint = await context.getCheckpoint({ timeout: 100_000 });

package/test/src/slow_tests.test.ts

@@ -97,7 +97,6 @@ bucket_definitions:
     await pool.query(`ALTER TABLE test_data REPLICA IDENTITY FULL`);
 
     await walStream.initReplication(replicationConnection);
-    await storage.autoActivate();
     let abort = false;
     streamPromise = walStream.streamChanges(replicationConnection).finally(() => {
       abort = true;
@@ -348,7 +347,6 @@ bucket_definitions:
       let initialReplicationDone = false;
       streamPromise = (async () => {
         await walStream.initReplication(replicationConnection);
-        await storage.autoActivate();
         initialReplicationDone = true;
         await walStream.streamChanges(replicationConnection);
       })()

package/test/src/util.ts

@@ -90,10 +90,8 @@ export async function getClientCheckpoint(
   while (Date.now() - start < timeout) {
     const storage = await storageFactory.getActiveStorage();
     const cp = await storage?.getCheckpoint();
-    if (cp == null) {
-      throw new Error('No sync rules available');
-    }
-    if (cp.lsn && cp.lsn >= lsn) {
+
+    if (cp?.lsn != null && cp.lsn >= lsn) {
       logger.info(`Got write checkpoint: ${lsn} : ${cp.checkpoint}`);
       return cp.checkpoint;
     }

package/test/src/wal_stream.test.ts

@@ -34,13 +34,11 @@ bucket_definitions:
       `CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text, num int8)`
     );
 
-    await context.replicateSnapshot();
+    await context.initializeReplication();
 
     const startRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
     const startTxCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.TRANSACTIONS_REPLICATED)) ?? 0;
 
-    context.startStreaming();
-
     const [{ test_id }] = pgwireRows(
       await pool.query(
         `INSERT INTO test_data(description, num) VALUES('test1', 1152921504606846976) returning id as test_id`
@@ -53,7 +51,8 @@ bucket_definitions:
     const endRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
     const endTxCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.TRANSACTIONS_REPLICATED)) ?? 0;
     expect(endRowCount - startRowCount).toEqual(1);
-    expect(endTxCount - startTxCount).toEqual(1);
+    // In some rare cases there may be additional empty transactions, so we allow for that.
+    expect(endTxCount - startTxCount).toBeGreaterThanOrEqual(1);
   });
 
   test('replicating case sensitive table', async () => {
@@ -69,13 +68,11 @@ bucket_definitions:
     await pool.query(`DROP TABLE IF EXISTS "test_DATA"`);
     await pool.query(`CREATE TABLE "test_DATA"(id uuid primary key default uuid_generate_v4(), description text)`);
 
-    await context.replicateSnapshot();
+    await context.initializeReplication();
 
     const startRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
     const startTxCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.TRANSACTIONS_REPLICATED)) ?? 0;
 
-    context.startStreaming();
-
     const [{ test_id }] = pgwireRows(
       await pool.query(`INSERT INTO "test_DATA"(description) VALUES('test1') returning id as test_id`)
     );
@@ -86,7 +83,7 @@ bucket_definitions:
     const endRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
     const endTxCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.TRANSACTIONS_REPLICATED)) ?? 0;
     expect(endRowCount - startRowCount).toEqual(1);
-    expect(endTxCount - startTxCount).toEqual(1);
+    expect(endTxCount - startTxCount).toBeGreaterThanOrEqual(1);
   });
 
   test('replicating TOAST values', async () => {
@@ -143,8 +140,7 @@ bucket_definitions:
     await pool.query(`DROP TABLE IF EXISTS test_data`);
     await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
 
-    await context.replicateSnapshot();
-    context.startStreaming();
+    await context.initializeReplication();
 
     const [{ test_id }] = pgwireRows(
       await pool.query(`INSERT INTO test_data(description) VALUES('test1') returning id as test_id`)
@@ -166,8 +162,7 @@ bucket_definitions:
     await pool.query(`DROP TABLE IF EXISTS test_data`);
     await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
 
-    await context.replicateSnapshot();
-    context.startStreaming();
+    await context.initializeReplication();
 
     const [{ test_id }] = pgwireRows(
       await pool.query(`INSERT INTO test_data(description) VALUES('test1') returning id as test_id`)
@@ -179,8 +174,8 @@ bucket_definitions:
       )
     );
 
-    // This update may fail replicating with:
-    // Error: Update on missing record public.test_data:074a601e-fc78-4c33-a15d-f89fdd4af31d :: {"g":1,"t":"651e9fbe9fec6155895057ec","k":"1a0b34da-fb8c-5e6f-8421-d7a3c5d4df4f"}
+    // Since we don't have an old copy of the record with the new primary key, this
+    // may trigger a "resnapshot".
     await pool.query(`UPDATE test_data SET description = 'test2b' WHERE id = '${test_id2}'`);
 
     // Re-use old id again
@@ -264,16 +259,12 @@ bucket_definitions:
 
     await pool.query(`CREATE TABLE test_donotsync(id uuid primary key default uuid_generate_v4(), description text)`);
 
-    await context.replicateSnapshot();
+    await context.initializeReplication();
 
     const startRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
     const startTxCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.TRANSACTIONS_REPLICATED)) ?? 0;
 
-    context.startStreaming();
-
-    const [{ test_id }] = pgwireRows(
-      await pool.query(`INSERT INTO test_donotsync(description) VALUES('test1') returning id as test_id`)
-    );
+    await pool.query(`INSERT INTO test_donotsync(description) VALUES('test1') returning id as test_id`);
 
     const data = await context.getBucketData('global[]');
 
@@ -283,7 +274,7 @@ bucket_definitions:
 
     // There was a transaction, but we should not replicate any actual data
     expect(endRowCount - startRowCount).toEqual(0);
-    expect(endTxCount - startTxCount).toEqual(1);
+    expect(endTxCount - startTxCount).toBeGreaterThanOrEqual(1);
   });
 
   test('reporting slot issues', async () => {

package/test/src/wal_stream_utils.ts

@@ -118,11 +118,20 @@ export class WalStreamTestContext implements AsyncDisposable {
     return this._walStream!;
   }
 
+  /**
+   * Replicate a snapshot, start streaming, and wait for a consistent checkpoint.
+   */
+  async initializeReplication() {
+    await this.replicateSnapshot();
+    this.startStreaming();
+    // Make sure we're up to date
+    await this.getCheckpoint();
+  }
+
   async replicateSnapshot() {
     const promise = (async () => {
       this.replicationConnection = await this.connectionManager.replicationConnection();
       await this.walStream.initReplication(this.replicationConnection);
-      await this.storage!.autoActivate();
     })();
     this.snapshotPromise = promise.catch((e) => e);
     await promise;