@powersync/service-module-postgres-storage 0.0.0-dev-20260602073133 → 0.0.0-dev-20260803144812

package/dist/storage/batch/PostgresBucketBatch.js

@@ -55,7 +55,7 @@ export class PostgresBucketBatch extends BaseObserver {
         this.options = options;
         this.logger = options.logger;
         this.db = options.db;
-        this.group_id = options.group_id;
+        this.group_id = options.replicationStreamId;
         this.last_checkpoint_lsn = options.last_checkpoint_lsn;
         this.resumeFromLsn = options.resumeFromLsn;
         this.skipExistingRows = options.skip_existing_rows;
@@ -71,9 +71,6 @@ export class PostgresBucketBatch extends BaseObserver {
             this.persisted_op = options.keep_alive_op;
         }
     }
-    get lastCheckpointLsn() {
-        return this.last_checkpoint_lsn;
-    }
     async [Symbol.asyncDispose]() {
         if (this.batch != null || this.write_checkpoint_batch.length > 0) {
             // We don't error here, since:
@@ -87,9 +84,9 @@ export class PostgresBucketBatch extends BaseObserver {
         await this[Symbol.asyncDispose]();
     }
     async resolveTables(options) {
-        const syncRules = options.syncRules ?? this.sync_rules;
+        const syncRules = options.parsedSyncConfig?.hydratedSyncConfig ?? this.sync_rules;
         const { connection_id, source } = options;
-        const { schema, name: table, objectId, replicaIdColumns, connectionTag } = source;
+        const { schema, name: table, objectId, replicaIdColumns, connectionTag, sendsCompleteRows } = source;
         const normalizedReplicaIdColumns = replicaIdColumns.map((column) => ({
             name: column.name,
             type: column.type,
@@ -177,6 +174,7 @@ export class PostgresBucketBatch extends BaseObserver {
             sourceTable.syncEvent = syncRules.tableTriggersEvent(source);
             sourceTable.syncData = sourceTable.bucketDataSources.length > 0;
             sourceTable.syncParameters = sourceTable.parameterLookupSources.length > 0;
+            sourceTable.storeCurrentData = sendsCompleteRows !== true;
             let truncatedTables = [];
             if (objectId != null) {
                 truncatedTables = await db.sql `
@@ -279,17 +277,21 @@ export class PostgresBucketBatch extends BaseObserver {
     async save(record) {
         // TODO maybe share with abstract class
         const { after, before, sourceTable, tag } = record;
-        for (const event of this.getTableEvents(sourceTable)) {
-            this.iterateListeners((cb) => cb.replicationEvent?.({
-                batch: this,
-                table: sourceTable,
-                data: {
-                    op: tag,
-                    after: after && utils.isCompleteRow(this.options.store_current_data, after) ? after : undefined,
-                    before: before && utils.isCompleteRow(this.options.store_current_data, before) ? before : undefined
-                },
-                event
-            }));
+        const storeCurrentData = this.options.store_current_data && sourceTable.storeCurrentData;
+        // Only the table designated as event carrier by resolveTables may fire events.
+        if (sourceTable.syncEvent) {
+            for (const event of this.getTableEvents(sourceTable)) {
+                this.iterateListeners((cb) => cb.replicationEvent?.({
+                    batch: this,
+                    table: sourceTable,
+                    data: {
+                        op: tag,
+                        after: after && utils.isCompleteRow(storeCurrentData, after) ? after : undefined,
+                        before: before && utils.isCompleteRow(storeCurrentData, before) ? before : undefined
+                    },
+                    event
+                }));
+            }
         }
         /**
          * Return if the table is just an event table
@@ -332,7 +334,9 @@ export class PostgresBucketBatch extends BaseObserver {
         let processedCount = 0;
         while (lastBatchCount == BATCH_LIMIT) {
             lastBatchCount = 0;
+            let clearedError = false;
             await this.withReplicationTransaction(async (db) => {
+                clearedError = false;
                 const persistedBatch = new PostgresPersistedBatch({
                     group_id: this.group_id,
                     storageConfig: this.storageConfig,
@@ -370,10 +374,14 @@ export class PostgresBucketBatch extends BaseObserver {
                     }
                 }
                 const { flushedAny } = await persistedBatch.flush(db);
-                if (flushedAny) {
-                    await this.clearError(db);
-                }
+                clearedError = flushedAny && !this.clearedError;
             });
+            if (clearedError) {
+                // No need to clear an error more than once per batch, since an error would always result in restarting the batch.
+                // Cleared outside the replication transaction - see flushInner.
+                await this.clearError();
+                this.clearedError = true;
+            }
         }
         if (processedCount == 0) {
             // The op sequence should not have progressed
@@ -419,10 +427,21 @@ export class PostgresBucketBatch extends BaseObserver {
         }
         await this.hooks?.beforeBatchFlush?.(this);
         let resumeBatch = null;
+        let clearedError = false;
         const lastOp = await this.withReplicationTransaction(async (db) => {
-            resumeBatch = await this.replicateBatch(db, batch);
+            clearedError = false;
+            const result = await this.replicateBatch(db, batch);
+            resumeBatch = result.resumeBatch;
+            clearedError ||= result.clearedError;
             return this.getLastOpIdSequence(db);
         });
+        if (clearedError) {
+            // Clear the error outside the replication transaction (plain autocommit update,
+            // like the keepalive), to avoid serialization conflicts on the sync_rules row
+            // when multiple writers flush concurrently.
+            await this.clearError();
+            this.clearedError = true;
+        }
         // null if done, set if we need another flush
         this.batch = resumeBatch;
         if (lastOp == null) {
@@ -438,136 +457,143 @@ export class PostgresBucketBatch extends BaseObserver {
         await this.flush();
         const now = new Date().toISOString();
         const persisted_op = this.persisted_op ?? null;
-        const result = await this.db.sql `
-      WITH
-        selected AS (
-          SELECT
-            id,
-            state,
-            last_checkpoint,
-            last_checkpoint_lsn,
-            snapshot_done,
-            no_checkpoint_before,
-            keepalive_op,
-            (
-              snapshot_done = TRUE
-              AND (
-                last_checkpoint_lsn IS NULL
-                OR last_checkpoint_lsn <= ${{ type: 'varchar', value: lsn }}
-              )
+        // Transaction failures restart replication from the last durable checkpoint.
+        const result = await this.db.transaction(async (db) => {
+            const checkpoint = await db.sql `
+        WITH
+          selected AS (
+            SELECT
+              id,
+              state,
+              last_checkpoint,
+              last_checkpoint_lsn,
+              snapshot_done,
+              no_checkpoint_before,
+              keepalive_op,
+              (
+                snapshot_done = TRUE
+                AND (
+                  last_checkpoint_lsn IS NULL
+                  OR last_checkpoint_lsn <= ${{ type: 'varchar', value: lsn }}
+                )
+                AND (
+                  no_checkpoint_before IS NULL
+                  OR no_checkpoint_before <= ${{ type: 'varchar', value: lsn }}
+                )
+              ) AS can_checkpoint
+            FROM
+              sync_rules
+            WHERE
+              id = ${{ type: 'int4', value: this.group_id }}
+            FOR UPDATE
+          ),
+          computed AS (
+            SELECT
+              selected.*,
+              CASE
+                WHEN selected.can_checkpoint THEN GREATEST(
+                  selected.last_checkpoint,
+                  ${{ type: 'int8', value: persisted_op }},
+                  selected.keepalive_op,
+                  0
+                )
+                ELSE selected.last_checkpoint
+              END AS new_last_checkpoint,
+              CASE
+                WHEN selected.can_checkpoint THEN NULL
+                ELSE GREATEST(
+                  selected.keepalive_op,
+                  ${{ type: 'int8', value: persisted_op }},
+                  0
+                )
+              END AS new_keepalive_op
+            FROM
+              selected
+          ),
+          updated AS (
+            UPDATE sync_rules AS sr
+            SET
+              last_checkpoint_lsn = CASE
+                WHEN computed.can_checkpoint THEN ${{ type: 'varchar', value: lsn }}
+                ELSE sr.last_checkpoint_lsn
+              END,
+              last_checkpoint_ts = CASE
+                WHEN computed.can_checkpoint THEN ${{ type: 1184, value: now }}
+                ELSE sr.last_checkpoint_ts
+              END,
+              last_keepalive_ts = ${{ type: 1184, value: now }},
+              last_fatal_error = CASE
+                WHEN computed.can_checkpoint THEN NULL
+                ELSE sr.last_fatal_error
+              END,
+              keepalive_op = computed.new_keepalive_op,
+              last_checkpoint = computed.new_last_checkpoint,
+              snapshot_lsn = CASE
+                WHEN computed.can_checkpoint THEN NULL
+                ELSE sr.snapshot_lsn
+              END
+            FROM
+              computed
+            WHERE
+              sr.id = computed.id
               AND (
-                no_checkpoint_before IS NULL
-                OR no_checkpoint_before <= ${{ type: 'varchar', value: lsn }}
-              )
-            ) AS can_checkpoint
-          FROM
-            sync_rules
-          WHERE
-            id = ${{ type: 'int4', value: this.group_id }}
-          FOR UPDATE
-        ),
-        computed AS (
-          SELECT
-            selected.*,
-            CASE
-              WHEN selected.can_checkpoint THEN GREATEST(
-                selected.last_checkpoint,
-                ${{ type: 'int8', value: persisted_op }},
-                selected.keepalive_op,
-                0
+                sr.keepalive_op IS DISTINCT FROM computed.new_keepalive_op
+                OR sr.last_checkpoint IS DISTINCT FROM computed.new_last_checkpoint
+                OR ${{ type: 'bool', value: createEmptyCheckpoints }}
               )
-              ELSE selected.last_checkpoint
-            END AS new_last_checkpoint,
-            CASE
-              WHEN selected.can_checkpoint THEN NULL
-              ELSE GREATEST(
-                selected.keepalive_op,
-                ${{ type: 'int8', value: persisted_op }},
-                0
-              )
-            END AS new_keepalive_op
-          FROM
-            selected
-        ),
-        updated AS (
-          UPDATE sync_rules AS sr
-          SET
-            last_checkpoint_lsn = CASE
-              WHEN computed.can_checkpoint THEN ${{ type: 'varchar', value: lsn }}
-              ELSE sr.last_checkpoint_lsn
-            END,
-            last_checkpoint_ts = CASE
-              WHEN computed.can_checkpoint THEN ${{ type: 1184, value: now }}
-              ELSE sr.last_checkpoint_ts
-            END,
-            last_keepalive_ts = ${{ type: 1184, value: now }},
-            last_fatal_error = CASE
-              WHEN computed.can_checkpoint THEN NULL
-              ELSE sr.last_fatal_error
-            END,
-            keepalive_op = computed.new_keepalive_op,
-            last_checkpoint = computed.new_last_checkpoint,
-            snapshot_lsn = CASE
-              WHEN computed.can_checkpoint THEN NULL
-              ELSE sr.snapshot_lsn
-            END
-          FROM
-            computed
-          WHERE
-            sr.id = computed.id
-            AND (
-              sr.keepalive_op IS DISTINCT FROM computed.new_keepalive_op
-              OR sr.last_checkpoint IS DISTINCT FROM computed.new_last_checkpoint
-              OR ${{ type: 'bool', value: createEmptyCheckpoints }}
-            )
-          RETURNING
-            sr.id,
-            sr.state,
-            sr.last_checkpoint,
-            sr.last_checkpoint_lsn,
-            sr.snapshot_done,
-            sr.no_checkpoint_before,
-            computed.can_checkpoint,
-            computed.keepalive_op,
-            computed.new_last_checkpoint
-        )
-      SELECT
-        id,
-        state,
-        last_checkpoint,
-        last_checkpoint_lsn,
-        snapshot_done,
-        no_checkpoint_before,
-        can_checkpoint,
-        keepalive_op,
-        new_last_checkpoint,
-        TRUE AS created_checkpoint
-      FROM
-        updated
-      UNION ALL
-      SELECT
-        id,
-        state,
-        new_last_checkpoint AS last_checkpoint,
-        last_checkpoint_lsn,
-        snapshot_done,
-        no_checkpoint_before,
-        can_checkpoint,
-        keepalive_op,
-        new_last_checkpoint,
-        FALSE AS created_checkpoint
-      FROM
-        computed
-      WHERE
-        NOT EXISTS (
-          SELECT
-            1
-          FROM
-            updated
-        )
-    `
-            .decoded(CheckpointWithStatus)
-            .first();
+            RETURNING
+              sr.id,
+              sr.state,
+              sr.last_checkpoint,
+              sr.last_checkpoint_lsn,
+              sr.snapshot_done,
+              sr.no_checkpoint_before,
+              computed.can_checkpoint,
+              computed.keepalive_op,
+              computed.new_last_checkpoint
+          )
+        SELECT
+          id,
+          state,
+          last_checkpoint,
+          last_checkpoint_lsn,
+          snapshot_done,
+          no_checkpoint_before,
+          can_checkpoint,
+          keepalive_op,
+          new_last_checkpoint,
+          TRUE AS created_checkpoint
+        FROM
+          updated
+        UNION ALL
+        SELECT
+          id,
+          state,
+          new_last_checkpoint AS last_checkpoint,
+          last_checkpoint_lsn,
+          snapshot_done,
+          no_checkpoint_before,
+          can_checkpoint,
+          keepalive_op,
+          new_last_checkpoint,
+          FALSE AS created_checkpoint
+        FROM
+          computed
+        WHERE
+          NOT EXISTS (
+            SELECT
+              1
+            FROM
+              updated
+          )
+      `
+                .decoded(CheckpointWithStatus)
+                .first();
+            if (checkpoint?.can_checkpoint && checkpoint.state == storage.SyncRuleState.ACTIVE) {
+                await notifySyncRulesUpdate(db, checkpoint);
+            }
+            return checkpoint;
+        });
         if (result == null) {
             throw new ReplicationAssertionError('Failed to update sync_rules during checkpoint');
         }
@@ -591,10 +617,8 @@ export class PostgresBucketBatch extends BaseObserver {
                 });
             }
         }
-        await this.autoActivate(lsn);
-        await notifySyncRulesUpdate(this.db, {
+        await this.autoActivate(lsn, {
             id: result.id,
-            state: result.state,
             last_checkpoint: result.last_checkpoint,
             last_checkpoint_lsn: result.last_checkpoint_lsn
         });
@@ -637,20 +661,21 @@ export class PostgresBucketBatch extends BaseObserver {
     }
     async markSnapshotDone(no_checkpoint_before_lsn, options) {
         await this.db.transaction(async (db) => {
-            const snapshotRequiredCount = await db.sql `
+            const blockingTables = await db.sql `
         SELECT
-          COUNT(*) AS count
+          schema_name,
+          table_name
         FROM
           source_tables
         WHERE
           group_id = ${{ type: 'int4', value: this.group_id }}
           AND snapshot_done = FALSE
       `
-                .decoded(t.object({ count: bigint }))
-                .first();
-            if ((snapshotRequiredCount?.count ?? 0n) > 0n) {
+                .decoded(t.object({ schema_name: t.string, table_name: t.string }))
+                .rows();
+            if (blockingTables.length > 0) {
                 if (options?.throwOnConflict ?? true) {
-                    throw new ReplicationAssertionError(`Cannot mark snapshot done while ${snapshotRequiredCount?.count} source table${snapshotRequiredCount?.count == 1n ? '' : 's'} still require snapshotting`);
+                    throw new ReplicationAssertionError(`Cannot mark snapshot done while source tables still require snapshotting. Tables: ${blockingTables.map((t) => `${t.schema_name}.${t.table_name}`).join(', ')}`);
                 }
                 else {
                     return;
@@ -752,14 +777,20 @@ export class PostgresBucketBatch extends BaseObserver {
     }
     async replicateBatch(db, batch) {
         let sizes = undefined;
-        if (this.options.store_current_data && !this.options.skip_existing_rows) {
-            // We skip this step if we don't store current_data, since the sizes will
+        // Check if any table in this batch needs to store current_data
+        const anyTableStoresCurrentData = this.options.store_current_data && batch.batch.some((r) => r.record.sourceTable.storeCurrentData);
+        if (anyTableStoresCurrentData && !this.options.skip_existing_rows) {
+            // We skip this step if no tables store current_data, since the sizes will
             // always be small in that case.
             // With skipExistingRows, we don't load the full documents into memory,
             // so we can also skip the size lookup step.
             // Find sizes of current_data documents, to assist in intelligent batching without
             // exceeding memory limits.
-            const sizeLookups = batch.batch.map((r) => {
+            // Within this branch the batch stores current_data, so the per-table flag is the
+            // effective value - only look up sizes for tables that actually store current_data.
+            const sizeLookups = batch.batch
+                .filter((r) => r.record.sourceTable.storeCurrentData)
+                .map((r) => {
                 return {
                     source_table: postgresTableId(r.record.sourceTable.id),
                     /**
@@ -849,14 +880,13 @@ export class PostgresBucketBatch extends BaseObserver {
                 didFlush ||= flushedAny;
             }
         }
-        if (didFlush) {
-            await this.clearError(db);
-        }
+        // The error itself is cleared by the caller, outside the replication transaction - see flushInner.
+        const clearedError = didFlush && !this.clearedError;
         // Don't return empty batches
-        if (resumeBatch?.batch.length) {
-            return resumeBatch;
-        }
-        return null;
+        return {
+            resumeBatch: resumeBatch?.batch.length ? resumeBatch : null,
+            clearedError
+        };
     }
     async saveOperation(persistedBatch, operation, currentData) {
         const record = operation.record;
@@ -865,6 +895,9 @@ export class PostgresBucketBatch extends BaseObserver {
         const afterId = operation.afterId;
         let after = record.after;
         const sourceTable = record.sourceTable;
+        // Effective per-record flag: store current_data only if both the batch (source-level)
+        // and the table (e.g. non-FULL replica identity) require it.
+        const storeCurrentData = this.options.store_current_data && sourceTable.storeCurrentData;
         let existingBuckets = [];
         let newBuckets = [];
         let existingLookups = [];
@@ -890,7 +923,7 @@ export class PostgresBucketBatch extends BaseObserver {
                 existingBuckets = [];
                 existingLookups = [];
                 // Log to help with debugging if there was a consistency issue
-                if (this.options.store_current_data) {
+                if (storeCurrentData) {
                     if (this.markRecordUnavailable != null) {
                         // This will trigger a "resnapshot" of the record.
                         // This is not relevant if storeCurrentData is false, since we'll get the full row
@@ -906,7 +939,7 @@ export class PostgresBucketBatch extends BaseObserver {
             else {
                 existingBuckets = result.buckets;
                 existingLookups = result.lookups;
-                if (this.options.store_current_data) {
+                if (storeCurrentData) {
                     const data = storage.deserializeBson(result.data);
                     after = storage.mergeToast(after, data);
                 }
@@ -918,7 +951,9 @@ export class PostgresBucketBatch extends BaseObserver {
                 // Not an error if we re-apply a transaction
                 existingBuckets = [];
                 existingLookups = [];
-                // Log to help with debugging if there was a consistency issue
+                // Log to help with debugging if there was a consistency issue.
+                // Gate on the batch-level flag: FULL tables (per-record flag false) still get a
+                // current_data entry, so a missing record on DELETE is meaningful for them too.
                 if (this.options.store_current_data && this.markRecordUnavailable == null) {
                     this.logger.warn(`Cannot find previous record for delete on ${record.sourceTable.qualifiedName}: ${beforeId} / ${record.before?.id}`);
                 }
@@ -929,7 +964,7 @@ export class PostgresBucketBatch extends BaseObserver {
             }
         }
         let afterData;
-        if (afterId != null && !this.options.store_current_data) {
+        if (afterId != null && !storeCurrentData) {
             afterData = storage.serializeBson({});
         }
         else if (afterId != null) {
@@ -948,7 +983,7 @@ export class PostgresBucketBatch extends BaseObserver {
                 container.reporter.captureMessage(`Data too big on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${e.message}`, {
                     level: errors.ErrorSeverity.WARNING,
                     metadata: {
-                        replication_slot: this.options.slot_name,
+                        replication_slot: this.options.replicationStreamName,
                         table: record.sourceTable.qualifiedName
                     }
                 });
@@ -985,7 +1020,7 @@ export class PostgresBucketBatch extends BaseObserver {
         // However, it will be valid by the end of the transaction.
         //
         // In this case, we don't save the op, but we do save the current data.
-        if (afterId && after && utils.isCompleteRow(this.options.store_current_data, after)) {
+        if (afterId && after && utils.isCompleteRow(storeCurrentData, after)) {
             // Insert or update
             if (sourceTable.syncData) {
                 const { results: evaluated, errors: syncErrors } = this.sync_rules.evaluateRowWithErrors({
@@ -997,7 +1032,7 @@ export class PostgresBucketBatch extends BaseObserver {
                     container.reporter.captureMessage(`Failed to evaluate data query on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${error.error}`, {
                         level: errors.ErrorSeverity.WARNING,
                         metadata: {
-                            replication_slot: this.options.slot_name,
+                            replication_slot: this.options.replicationStreamName,
                             table: record.sourceTable.qualifiedName
                         }
                     });
@@ -1025,7 +1060,7 @@ export class PostgresBucketBatch extends BaseObserver {
                     container.reporter.captureMessage(`Failed to evaluate parameter query on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${error.error}`, {
                         level: errors.ErrorSeverity.WARNING,
                         metadata: {
-                            replication_slot: this.options.slot_name,
+                            replication_slot: this.options.replicationStreamName,
                             table: record.sourceTable.qualifiedName
                         }
                     });
@@ -1072,13 +1107,12 @@ export class PostgresBucketBatch extends BaseObserver {
      *
      * Called on new commits.
      */
-    async autoActivate(lsn) {
+    async autoActivate(lsn, checkpoint) {
         if (!this.needsActivation) {
             // Already activated
             return;
         }
-        let didActivate = false;
-        await this.db.transaction(async (db) => {
+        const activationResult = await this.db.transaction(async (db) => {
             const syncRulesRow = await db.sql `
         SELECT
           state,
@@ -1110,14 +1144,18 @@ export class PostgresBucketBatch extends BaseObserver {
             )
             AND id != ${{ type: 'int4', value: this.group_id }}
         `.execute();
-                didActivate = true;
-                this.needsActivation = false;
+                await notifySyncRulesUpdate(db, checkpoint);
+                return 'activated';
             }
             else if (syncRulesRow?.state != storage.SyncRuleState.PROCESSING) {
-                this.needsActivation = false;
+                return 'not-processing';
             }
+            return 'pending';
         });
-        if (didActivate) {
+        if (activationResult != 'pending') {
+            this.needsActivation = false;
+        }
+        if (activationResult == 'activated') {
             this.logger.info(`Activated new replication stream at ${lsn}`);
         }
     }
@@ -1165,10 +1203,6 @@ export class PostgresBucketBatch extends BaseObserver {
         }
     }
     async clearError(db = this.db) {
-        // No need to clear an error more than once per batch, since an error would always result in restarting the batch.
-        if (this.clearedError) {
-            return;
-        }
         await db.sql `
       UPDATE sync_rules
       SET
@@ -1176,7 +1210,6 @@ export class PostgresBucketBatch extends BaseObserver {
       WHERE
         id = ${{ type: 'int4', value: this.group_id }}
     `.execute();
-        this.clearedError = true;
     }
     async getLastOpIdSequence(db) {
         // When no op_id has been generated, last_value = 1 and nextval() will be 1.
@@ -1200,11 +1233,13 @@ export class PostgresBucketBatch extends BaseObserver {
  * active checkpoint has been updated.
  */
 export const notifySyncRulesUpdate = async (db, update) => {
-    if (update.state != storage.SyncRuleState.ACTIVE) {
-        return;
-    }
-    await db.query({
-        statement: `NOTIFY ${NOTIFICATION_CHANNEL}, '${models.ActiveCheckpointNotification.encode({ active_checkpoint: update })}'`
-    });
+    const payload = models.ActiveCheckpointNotification.encode({ active_checkpoint: update });
+    await db.sql `
+    SELECT
+      pg_notify (
+        ${{ type: 'varchar', value: NOTIFICATION_CHANNEL }},
+        ${{ type: 'varchar', value: payload }}
+      )
+  `.execute();
 };
 //# sourceMappingURL=PostgresBucketBatch.js.map