@powersync/service-module-postgres-storage 0.0.0-dev-20250724091220 → 0.0.0-dev-20250724111728

package/src/storage/PostgresStorageProvider.ts

@@ -5,6 +5,7 @@ import { storage } from '@powersync/service-core';
 import { isPostgresStorageConfig, normalizePostgresStorageConfig, PostgresStorageConfig } from '../types/types.js';
 import { dropTables } from '../utils/db.js';
 import { PostgresBucketStorageFactory } from './PostgresBucketStorageFactory.js';
+import { PostgresReportStorageFactory } from './PostgresReportStorageFactory.js';
 
 export class PostgresStorageProvider implements storage.BucketStorageProvider {
   get type() {
@@ -28,9 +29,14 @@ export class PostgresStorageProvider implements storage.BucketStorageProvider {
       config: normalizedConfig,
       slot_name_prefix: options.resolvedConfig.slot_name_prefix
     });
+
+    const reportStorageFactory = new PostgresReportStorageFactory({
+      config: normalizedConfig
+    });
+
     return {
       // TODO: IMPLEMENT REPORT STORAGE
-      reportStorage: null,
+      reportStorage: reportStorageFactory,
       storage: storageFactory,
       shutDown: async () => storageFactory.db[Symbol.asyncDispose](),
       tearDown: async () => {

package/src/storage/PostgresSyncRulesStorage.ts

@@ -7,6 +7,7 @@ import {
   InternalOpId,
   internalToExternalOpId,
   LastValueSink,
+  maxLsn,
   storage,
   utils,
   WatchWriteCheckpointOptions
@@ -310,13 +311,14 @@ export class PostgresSyncRulesStorage
       SELECT
         last_checkpoint_lsn,
         no_checkpoint_before,
-        keepalive_op
+        keepalive_op,
+        snapshot_lsn
       FROM
         sync_rules
       WHERE
         id = ${{ type: 'int4', value: this.group_id }}
     `
-      .decoded(pick(models.SyncRules, ['last_checkpoint_lsn', 'no_checkpoint_before', 'keepalive_op']))
+      .decoded(pick(models.SyncRules, ['last_checkpoint_lsn', 'no_checkpoint_before', 'keepalive_op', 'snapshot_lsn']))
       .first();
 
     const checkpoint_lsn = syncRules?.last_checkpoint_lsn ?? null;
@@ -330,6 +332,7 @@ export class PostgresSyncRulesStorage
       last_checkpoint_lsn: checkpoint_lsn,
       keep_alive_op: syncRules?.keepalive_op,
       no_checkpoint_before_lsn: syncRules?.no_checkpoint_before ?? options.zeroLSN,
+      resumeFromLsn: maxLsn(syncRules?.snapshot_lsn, checkpoint_lsn),
       store_current_data: options.storeCurrentData,
       skip_existing_rows: options.skipExistingRows ?? false,
       batch_limits: this.options.batchLimits,
@@ -644,43 +647,6 @@ export class PostgresSyncRulesStorage
     `.execute();
   }
 
-  async autoActivate(): Promise<void> {
-    await this.db.transaction(async (db) => {
-      const syncRulesRow = await db.sql`
-        SELECT
-          state
-        FROM
-          sync_rules
-        WHERE
-          id = ${{ type: 'int4', value: this.group_id }}
-      `
-        .decoded(pick(models.SyncRules, ['state']))
-        .first();
-
-      if (syncRulesRow && syncRulesRow.state == storage.SyncRuleState.PROCESSING) {
-        await db.sql`
-          UPDATE sync_rules
-          SET
-            state = ${{ type: 'varchar', value: storage.SyncRuleState.ACTIVE }}
-          WHERE
-            id = ${{ type: 'int4', value: this.group_id }}
-        `.execute();
-      }
-
-      await db.sql`
-        UPDATE sync_rules
-        SET
-          state = ${{ type: 'varchar', value: storage.SyncRuleState.STOP }}
-        WHERE
-          (
-            state = ${{ value: storage.SyncRuleState.ACTIVE, type: 'varchar' }}
-            OR state = ${{ value: storage.SyncRuleState.ERRORED, type: 'varchar' }}
-          )
-          AND id != ${{ type: 'int4', value: this.group_id }}
-      `.execute();
-    });
-  }
-
   private async getChecksumsInternal(batch: storage.FetchPartialBucketChecksum[]): Promise<storage.PartialChecksumMap> {
     if (batch.length == 0) {
       return new Map();

package/src/storage/batch/PostgresBucketBatch.ts

@@ -31,6 +31,7 @@ export interface PostgresBucketBatchOptions {
   no_checkpoint_before_lsn: string;
   store_current_data: boolean;
   keep_alive_op?: InternalOpId | null;
+  resumeFromLsn: string | null;
   /**
    * Set to true for initial replication.
    */
@@ -61,6 +62,8 @@ export class PostgresBucketBatch
 
   public last_flushed_op: InternalOpId | null = null;
 
+  public resumeFromLsn: string | null;
+
   protected db: lib_postgres.DatabaseClient;
   protected group_id: number;
   protected last_checkpoint_lsn: string | null;
@@ -73,6 +76,7 @@ export class PostgresBucketBatch
   protected batch: OperationBatch | null;
   private lastWaitingLogThrottled = 0;
   private markRecordUnavailable: BucketStorageMarkRecordUnavailable | undefined;
+  private needsActivation = true;
 
   constructor(protected options: PostgresBucketBatchOptions) {
     super();
@@ -81,6 +85,7 @@ export class PostgresBucketBatch
     this.group_id = options.group_id;
     this.last_checkpoint_lsn = options.last_checkpoint_lsn;
     this.no_checkpoint_before_lsn = options.no_checkpoint_before_lsn;
+    this.resumeFromLsn = options.resumeFromLsn;
     this.write_checkpoint_batch = [];
     this.sync_rules = options.sync_rules;
     this.markRecordUnavailable = options.markRecordUnavailable;
@@ -321,6 +326,7 @@ export class PostgresBucketBatch
     // Don't create a checkpoint if there were no changes
     if (!createEmptyCheckpoints && this.persisted_op == null) {
       // Nothing to commit - return true
+      await this.autoActivate(lsn);
       return true;
     }
 
@@ -363,6 +369,7 @@ export class PostgresBucketBatch
       .decoded(StatefulCheckpoint)
       .first();
 
+    await this.autoActivate(lsn);
     await notifySyncRulesUpdate(this.db, doc!);
 
     this.persisted_op = null;
@@ -406,13 +413,14 @@ export class PostgresBucketBatch
       .decoded(StatefulCheckpoint)
       .first();
 
+    await this.autoActivate(lsn);
     await notifySyncRulesUpdate(this.db, updated!);
 
     this.last_checkpoint_lsn = lsn;
     return true;
   }
 
-  async setSnapshotLsn(lsn: string): Promise<void> {
+  async setResumeLsn(lsn: string): Promise<void> {
     await this.db.sql`
       UPDATE sync_rules
       SET
@@ -916,6 +924,59 @@ export class PostgresBucketBatch
     return result;
   }
 
+  /**
+   * Switch from processing -> active if relevant.
+   *
+   * Called on new commits.
+   */
+  private async autoActivate(lsn: string): Promise<void> {
+    if (!this.needsActivation) {
+      // Already activated
+      return;
+    }
+
+    let didActivate = false;
+    await this.db.transaction(async (db) => {
+      const syncRulesRow = await db.sql`
+        SELECT
+          state
+        FROM
+          sync_rules
+        WHERE
+          id = ${{ type: 'int4', value: this.group_id }}
+      `
+        .decoded(pick(models.SyncRules, ['state']))
+        .first();
+
+      if (syncRulesRow && syncRulesRow.state == storage.SyncRuleState.PROCESSING) {
+        await db.sql`
+          UPDATE sync_rules
+          SET
+            state = ${{ type: 'varchar', value: storage.SyncRuleState.ACTIVE }}
+          WHERE
+            id = ${{ type: 'int4', value: this.group_id }}
+        `.execute();
+        didActivate = true;
+      }
+
+      await db.sql`
+        UPDATE sync_rules
+        SET
+          state = ${{ type: 'varchar', value: storage.SyncRuleState.STOP }}
+        WHERE
+          (
+            state = ${{ value: storage.SyncRuleState.ACTIVE, type: 'varchar' }}
+            OR state = ${{ value: storage.SyncRuleState.ERRORED, type: 'varchar' }}
+          )
+          AND id != ${{ type: 'int4', value: this.group_id }}
+      `.execute();
+    });
+    if (didActivate) {
+      this.logger.info(`Activated new sync rules at ${lsn}`);
+    }
+    this.needsActivation = false;
+  }
+
   /**
    * Gets relevant {@link SqlEventDescriptor}s for the given {@link SourceTable}
    * TODO maybe share this with an abstract class