@powersync/service-module-mongodb-storage 0.23.1 → 0.24.0

package/src/storage/implementation/v1/MongoBucketBatchV1.ts

@@ -1,14 +1,15 @@
 import { mongo } from '@powersync/lib-service-mongodb';
-import { ReplicationAssertionError } from '@powersync/lib-services-framework';
+import { ErrorCode, ReplicationAssertionError, ServiceError } from '@powersync/lib-services-framework';
 import { ColumnDescriptor, InternalOpId, SourceTable, storage } from '@powersync/service-core';
 import { HydratedSyncConfig } from '@powersync/service-sync-rules';
 import * as bson from 'bson';
 import { mongoTableId } from '../../../utils/util.js';
 import { calculateCheckpointState } from '../CheckpointState.js';
 import { MongoBucketBatch, MongoBucketBatchOptions } from '../MongoBucketBatch.js';
+import { MongoIdSequence, OpIdRangeExhausted } from '../MongoIdSequence.js';
 import { MongoSyncRulesLock } from '../MongoSyncRulesLock.js';
 import { MongoWriteBatch } from '../MongoWriteBatch.js';
-import { PersistedBatch } from '../common/PersistedBatch.js';
+import { OperationBatch } from '../OperationBatch.js';
 import { SourceRecordStore } from '../common/SourceRecordStore.js';
 import { SyncRuleDocumentBase } from '../models.js';
 import { PersistedBatchV1 } from './PersistedBatchV1.js';
@@ -37,6 +38,306 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     this.store = new SourceRecordStoreV1(this.db, this.replicationStreamId);
   }
 
+  private async withReplicationTransaction(
+    description: string,
+    callback: (session: mongo.ClientSession, opSeq: MongoIdSequence) => Promise<void>,
+    finish?: (stream: SyncRuleDocumentBase, lastOp: InternalOpId) => Promise<boolean>,
+    projection?: mongo.Document
+  ): Promise<void> {
+    let flushTry = 0;
+    const lastTry = Date.now() + 90000;
+    const allocator = this.options.opIdAllocator;
+    let lastOp = 0n;
+    // Refill outside the publication transaction, before evaluating any rows.
+    // Exhaustion remains a fallback for large batches or a newer stream head.
+    this.options.replicationLock.throwIfAborted();
+    await allocator.ensureCapacity();
+    while (true) {
+      try {
+        await this.withFencedTransaction(
+          () => this.fence(this.session, projection),
+          async (stream) => {
+            flushTry += 1;
+            if (flushTry > 20 && Date.now() > lastTry) {
+              throw new ServiceError(ErrorCode.PSYNC_S1402, 'Max transaction tries exceeded');
+            }
+            // The fence already holds this stream document for the transaction.
+            // A different writer may have used higher IDs since our last flush.
+            const opSeq = allocator.sequence(this.persistedOpHead(stream));
+            await callback(this.session, opSeq);
+            lastOp = opSeq.last();
+
+            if (!(await finish?.(stream, lastOp))) {
+              const writes = this.db.createWriteBatch(this.session, { ordered: false });
+              this.onReplicationTransactionFlush(writes, lastOp);
+              await writes.execute();
+            }
+          },
+          this.session,
+          description
+        );
+        allocator.consume(lastOp);
+        return;
+      } catch (error) {
+        if (!(error instanceof OpIdRangeExhausted)) {
+          throw error;
+        }
+        // The transaction aborted every write. Reserve outside it and replay
+        // evaluation from the same committed stream head.
+        this.options.replicationLock.throwIfAborted();
+        await allocator.reserve();
+      }
+    }
+  }
+
+  private async clearError(session: mongo.ClientSession): Promise<void> {
+    await this.db.sync_rules.updateOne(
+      { _id: this.replicationStreamId },
+      { $set: { last_fatal_error: null, last_fatal_error_ts: null } },
+      { session }
+    );
+  }
+
+  protected override async flushInner(
+    options?: storage.BatchBucketFlushOptions,
+    checkpoint?: (stream: SyncRuleDocumentBase, lastOp: InternalOpId, writes?: MongoWriteBatch) => Promise<void>,
+    projection?: mongo.Document
+  ): Promise<storage.FlushedResult | null> {
+    const batch = this.batch;
+    let last_op: InternalOpId | null = null;
+    let resumeBatch: OperationBatch | null = null;
+    let clearedError = false;
+
+    using _ = this.tracer.span('storage', 'flush');
+
+    await this.hooks?.beforeBatchFlush?.(this);
+    if (this.write_checkpoint_batch.length > 0) {
+      // Collection/index creation cannot run inside the replication transaction.
+      await this.prepareCustomWriteCheckpoints();
+    }
+
+    await this.withReplicationTransaction(
+      `Flushing ${batch?.length ?? 0} ops`,
+      async (session, opSeq) => {
+        clearedError = false;
+        if (batch != null) {
+          const result = await this.replicateBatch(session, batch, opSeq, options);
+          resumeBatch = result.resumeBatch;
+          clearedError ||= result.clearedError;
+        }
+
+        if (this.write_checkpoint_batch.length > 0) {
+          this.logger.info(`Writing ${this.write_checkpoint_batch.length} custom write checkpoints`);
+          await this.batchCreateCustomWriteCheckpoints(session, opSeq.next());
+        }
+
+        last_op = opSeq.last();
+      },
+      async (stream, lastOp) => {
+        if (checkpoint != null && resumeBatch == null) {
+          // The checkpoint must also persist the head, including when visibility is blocked.
+          await checkpoint(stream, lastOp);
+          return true;
+        }
+        return false;
+      },
+      projection
+    );
+
+    // Keep checkpoints available if the transaction retries after writing them.
+    this.write_checkpoint_batch = [];
+
+    if (clearedError) {
+      this.clearedError = true;
+    }
+
+    // null if done, set if we need another flush
+    this.batch = resumeBatch;
+
+    if (last_op == null) {
+      throw new ReplicationAssertionError('Unexpected last_op == null');
+    }
+
+    this.recordPersistedOp(last_op);
+    this.last_flushed_op = last_op;
+    await this.hooks?.afterBatchFlush?.(this);
+    return { flushed_op: last_op };
+  }
+
+  private async replicateBatch(
+    session: mongo.ClientSession,
+    batch: OperationBatch,
+    op_seq: MongoIdSequence,
+    options?: storage.BucketBatchCommitOptions
+  ): Promise<{ resumeBatch: OperationBatch | null; clearedError: boolean }> {
+    let sizes: Map<string, number> | undefined = undefined;
+    using _ = this.tracer.span('storage', 'replicate_batch');
+    // Only look up current_data sizes if the batch stores current_data and at least one
+    // table in it does too (per-table can disable it, e.g. Postgres REPLICA IDENTITY FULL).
+    const anyTableStoresCurrentData =
+      this.storeCurrentData && batch.batch.some((r) => r.record.sourceTable.storeCurrentData);
+    if (anyTableStoresCurrentData && !this.skipExistingRows) {
+      // 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.
+      //
+      // A previous attempt tried to do batching by the results of the current_data query
+      // (automatically limited to 48MB(?) per batch by MongoDB). The issue is that it changes
+      // the order of processing, which then becomes really tricky to manage.
+      // This now takes 2+ queries, but doesn't have any issues with order of operations.
+      // Within this branch this.storeCurrentData is true, 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) => ({
+          sourceTableId: mongoTableId(r.record.sourceTable.id),
+          replicaId: r.beforeId
+        }));
+
+      sizes = await this.sourceRecordStore.loadSizes(session, sizeLookups);
+    }
+
+    // If set, we need to start a new transaction with this batch.
+    let resumeBatch: OperationBatch | null = null;
+    let transactionSize = 0;
+
+    let didFlush = false;
+
+    // Now batch according to the sizes
+    // This is a single batch if storeCurrentData == false
+    for await (let b of batch.batched(sizes)) {
+      if (resumeBatch) {
+        for (let op of b) {
+          resumeBatch.push(op);
+        }
+        continue;
+      }
+      using lookupSpan = this.tracer.span('storage', 'lookup');
+      const lookups = b.map((r) => ({
+        sourceTableId: mongoTableId(r.record.sourceTable.id),
+        replicaId: r.beforeId
+      }));
+      let sourceRecordLookup = await this.sourceRecordStore.loadDocuments(session, lookups, this.skipExistingRows);
+      lookupSpan.end();
+
+      let persistedBatch: PersistedBatchV1 | null = this.createPersistedBatch(transactionSize);
+
+      // The current code structure makes it tricky to cleanly split this span from the one
+      // where fluhsing. So we manually end and re-create this span whenever we flush.
+      let evalSpan = this.tracer.span('evaluate');
+      for (let op of b) {
+        if (resumeBatch) {
+          resumeBatch.push(op);
+          continue;
+        }
+        const sourceRecord = sourceRecordLookup.get(op.internalBeforeKey) ?? null;
+        if (sourceRecord != null) {
+          // If it will be used again later, it will be set again using nextData below
+          sourceRecordLookup.delete(op.internalBeforeKey);
+        }
+        const nextData = this.saveOperation(persistedBatch!, op, sourceRecord, op_seq, this.markRecordUnavailable);
+        if (nextData != null) {
+          // Update our current_data and size cache
+          sourceRecordLookup.set(op.internalAfterKey!, nextData);
+          sizes?.set(op.internalAfterKey!, nextData.data?.length() ?? 0);
+        }
+
+        if (persistedBatch!.shouldFlushTransaction()) {
+          evalSpan.end();
+          // Transaction is getting big.
+          // Flush, and resume in a new transaction.
+          using persistSpan = this.tracer.span('storage', 'persist_flush');
+          const { flushedAny } = await persistedBatch!.flush(this.session, options);
+
+          didFlush ||= flushedAny;
+          persistedBatch = null;
+          // Computing our current progress is a little tricky here, since
+          // we're stopping in the middle of a batch.
+          // We create a new batch, and push any remaining operations to it.
+          resumeBatch = new OperationBatch();
+          persistSpan.end();
+          evalSpan = this.tracer.span('evaluate');
+        }
+      }
+      evalSpan.end();
+
+      if (persistedBatch) {
+        transactionSize = persistedBatch.currentSize;
+        using _ = this.tracer.span('storage', 'persist_flush');
+        const { flushedAny } = await persistedBatch.flush(this.session, options);
+        didFlush ||= flushedAny;
+      }
+    }
+
+    const clearedError = didFlush && !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.
+      using _ = this.tracer.span('storage', 'clear_error');
+      await this.clearError(this.session);
+    }
+
+    return {
+      resumeBatch: resumeBatch?.hasData() ? resumeBatch : null,
+      clearedError
+    };
+  }
+
+  protected override async truncateSingleInternal(sourceTable: storage.SourceTable): Promise<InternalOpId> {
+    let last_op: InternalOpId | null = null;
+
+    // To avoid too large transactions, we limit the amount of data we delete per transaction.
+    // Since we don't use the record data here, we don't have explicit size limits per batch.
+    const BATCH_LIMIT = 2000;
+
+    let lastBatchCount = BATCH_LIMIT;
+    while (lastBatchCount == BATCH_LIMIT) {
+      await this.withReplicationTransaction(`Truncate ${sourceTable.qualifiedName}`, async (session, opSeq) => {
+        using evalSpan = this.tracer.span('evaluate');
+        const sourceTableId = mongoTableId(sourceTable.id);
+        const batch = await this.sourceRecordStore.loadTruncateBatch(session, sourceTableId, BATCH_LIMIT);
+        const persistedBatch = this.createPersistedBatch(0);
+
+        for (let value of batch) {
+          persistedBatch.saveBucketData({
+            op_seq: opSeq,
+            before_buckets: value.buckets,
+            evaluated: [],
+            table: sourceTable,
+            sourceKey: value.replicaId
+          });
+          persistedBatch.saveParameterData({
+            op_seq: opSeq,
+            existing_lookups: value.lookups,
+            evaluated: [],
+            sourceTable: sourceTable,
+            sourceKey: value.replicaId
+          });
+
+          // Since this is not from streaming replication, we can do a hard delete
+          persistedBatch.hardDeleteCurrentData(sourceTableId, value.replicaId);
+        }
+        evalSpan.end();
+
+        using _ = this.tracer.span('storage', 'persist_flush');
+        await persistedBatch.flush(session);
+        lastBatchCount = batch.length;
+
+        last_op = opSeq.last();
+      });
+    }
+
+    if (last_op) {
+      this.recordPersistedOp(last_op);
+    }
+
+    return last_op!;
+  }
+
   protected override persistedOpHead(stream: SyncRuleDocumentBase): InternalOpId {
     const legacy = stream as SyncRuleDocumentV1;
     const checkpoint = legacy.last_checkpoint ?? 0n;
@@ -58,12 +359,12 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     ]);
   }
 
-  protected override recordPersistedOp(lastOp: InternalOpId): void {
+  private recordPersistedOp(lastOp: InternalOpId): void {
     this.persisted_op = lastOp;
   }
 
-  protected createPersistedBatch(writtenSize: number): PersistedBatch {
-    return new PersistedBatchV1(this.db, this.replicationStreamId, this.mapping, writtenSize, {
+  protected createPersistedBatch(writtenSize: number): PersistedBatchV1 {
+    return new PersistedBatchV1(this.db, this.replicationStreamId, writtenSize, {
       logger: this.logger
     });
   }
@@ -75,10 +376,7 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     // No-op for V1: source records live in a shared collection.
   }
 
-  protected override async batchCreateCustomWriteCheckpoints(
-    session: mongo.ClientSession,
-    opId: InternalOpId
-  ): Promise<void> {
+  private async batchCreateCustomWriteCheckpoints(session: mongo.ClientSession, opId: InternalOpId): Promise<void> {
     // Only the final checkpoint per user/stream is visible after this transaction.
     const checkpoints = new Map(
       this.write_checkpoint_batch.map((checkpoint) => [
@@ -112,7 +410,9 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     );
   }
 
-  async resolveTables(options: storage.ResolveTablesOptions): Promise<storage.ResolveTablesResult> {
+  protected override async resolveTablesInternal(
+    options: storage.ResolveTablesOptions
+  ): Promise<storage.ResolveTablesResult> {
     const syncRules = options.parsedSyncConfig?.hydratedSyncConfig ?? this.sync_rules;
     const reconcile = options.reconcileSourceTables ?? storage.defaultSourceTableReconciler;
     const { connection_id, source } = options;
@@ -145,13 +445,24 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
       const resolution = await reconcile({ source, candidates });
       storage.validateSourceTableCandidateResolution(candidates, resolution);
 
+      const materializedResolution = storage.materializeSourceTableResolution(candidateTables, resolution);
+      const compatibleTables = materializedResolution.compatibleTables;
+
+      if (!syncRules.tableSyncsAny(source)) {
+        // Still reconcile old mappings so renames out of scope remove previously replicated data.
+        // Skip updating source_metadata below: these records are dropped by the caller in this
+        // same transaction, so persisting new metadata into them first is wasted work.
+        result = {
+          tables: [],
+          dropTables: [...materializedResolution.incompatibleTables, ...compatibleTables]
+        };
+        return;
+      }
+
       for (const { id, sourceMetadata } of storage.diffSourceTableUpdates(candidateTables, resolution)) {
         await col.updateOne({ _id: mongoTableId(id) }, { $set: { source_metadata: sourceMetadata } }, { session });
       }
 
-      const materializedResolution = storage.materializeSourceTableResolution(candidateTables, resolution);
-      const compatibleTables = materializedResolution.compatibleTables;
-
       // V1 keeps one record, preferring one that has already been snapshotted.
       const reuse = compatibleTables.find((table) => table.snapshotComplete) ?? compatibleTables[0] ?? null;
 
@@ -225,7 +536,9 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     return table;
   }
 
-  async getSourceTableStatus(table: storage.SourceTable): Promise<storage.SourceTable | null> {
+  protected override async getSourceTableStatusInternal(
+    table: storage.SourceTable
+  ): Promise<storage.SourceTable | null> {
     const doc = await this.db.sourceTablesV1(this.replicationStreamId).findOne(
       {
         group_id: this.replicationStreamId,
@@ -241,7 +554,10 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     return this.hydrateSourceTable(doc, table.ref.connectionTag, this.sync_rules, undefined);
   }
 
-  async commit(lsn: string, options?: storage.BucketBatchCommitOptions): Promise<storage.CheckpointResult> {
+  protected override async commitInternal(
+    lsn: string,
+    options?: storage.BucketBatchCommitOptions
+  ): Promise<storage.CheckpointResult> {
     const { createEmptyCheckpoints } = { ...storage.DEFAULT_BUCKET_BATCH_COMMIT_OPTIONS, ...options };
 
     using _ = this.tracer.span('storage', 'commit');
@@ -394,9 +710,6 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
       await this.autoActivate(lsn);
       await this.db.notifyCheckpoint();
       this.persisted_op = null;
-      if (checkpointState.newLastCheckpoint != null) {
-        await this.sourceRecordStore.postCommitCleanup(checkpointState.newLastCheckpoint, this.logger);
-      }
     }
 
     return {
@@ -405,18 +718,14 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     };
   }
 
-  async keepalive(lsn: string): Promise<storage.CheckpointResult> {
-    return await this.commit(lsn, { createEmptyCheckpoints: true });
-  }
-
-  async setResumeLsn(lsn: string): Promise<void> {
+  protected override async setResumeLsnInternal(lsn: string): Promise<void> {
     using _ = this.tracer.span('storage', 'set_resume_lsn');
     // Losing occasional resume LSN would only reprocess source changes.
     // Keep the lease check atomic, but do not wait for majority replication of this resume hint.
     await this.updateStreamMetadata({ snapshot_lsn: { $literal: lsn } }, {}, { w: 1 });
   }
 
-  async markAllSnapshotDone(no_checkpoint_before_lsn: string): Promise<void> {
+  protected override async markAllSnapshotDoneInternal(no_checkpoint_before_lsn: string): Promise<void> {
     await this.updateStreamMetadata(this.snapshotDoneUpdate(no_checkpoint_before_lsn));
   }
 
@@ -427,7 +736,10 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     };
   }
 
-  async markSnapshotDone(no_checkpoint_before_lsn: string, options?: { throwOnConflict?: boolean }): Promise<void> {
+  protected override async markSnapshotDoneInternal(
+    no_checkpoint_before_lsn: string,
+    options?: { throwOnConflict?: boolean }
+  ): Promise<void> {
     await this.withTransaction(async () => {
       // Protect against race conditions
       const blockingTables = await this.db
@@ -458,11 +770,11 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     });
   }
 
-  async markTableSnapshotRequired(_table: storage.SourceTable): Promise<void> {
+  protected override async markTableSnapshotRequiredInternal(_table: storage.SourceTable): Promise<void> {
     await this.updateStreamMetadata({ snapshot_done: false });
   }
 
-  async markTableSnapshotDone(
+  protected override async markTableSnapshotDoneInternal(
     tables: storage.SourceTable[],
     no_checkpoint_before_lsn?: string
   ): Promise<storage.SourceTable[]> {

package/src/storage/implementation/v1/PersistedBatchV1.ts

@@ -2,14 +2,16 @@ import { mongo } from '@powersync/lib-service-mongodb';
 import { ReplicationAssertionError } from '@powersync/lib-services-framework';
 import { storage } from '@powersync/service-core';
 import * as bson from 'bson';
+import { BatchOperationBuffer } from '../common/BatchOperationBuffer.js';
 
-import { BucketDataSource, BucketDefinitionId } from '@powersync/service-sync-rules';
 import { mongoTableId } from '../../../utils/util.js';
 import { EMPTY_DATA } from '../MongoBucketBatchShared.js';
 import { MongoWriteBatch } from '../MongoWriteBatch.js';
 import {
   BucketStateUpdate,
   PersistedBatch,
+  PersistedBatchOptions,
+  SaveBucketDataOptions,
   SaveParameterDataOptions,
   UpsertCurrentDataOptions
 } from '../common/PersistedBatch.js';
@@ -23,20 +25,68 @@ import {
   taggedBucketParameterDocumentToV1
 } from './models.js';
 
-export class PersistedBatchV1 extends PersistedBatch {
-  declare protected readonly db: VersionedPowerSyncMongoV1;
+export class PersistedBatchV1 implements PersistedBatch {
+  private readonly operations: BatchOperationBuffer;
 
   // Each upsert supplies the complete source-record state. Only its final
   // state matters within a flush; bucket and parameter history is kept separately.
-  currentData = new Map<string, mongo.AnyBulkWriteOperation<CurrentDataDocument>>();
+  private readonly currentData = new Map<string, mongo.AnyBulkWriteOperation<CurrentDataDocument>>();
 
-  protected checkDefinitionId(_definitionId: BucketDefinitionId | null): BucketDefinitionId {
-    // V1 storage doesn't persist the id, and we don't use it.
-    return LEGACY_BUCKET_DATA_DEFINITION_ID;
+  constructor(
+    private readonly db: VersionedPowerSyncMongoV1,
+    private readonly group_id: number,
+    writtenSize: number,
+    options?: PersistedBatchOptions
+  ) {
+    this.operations = new BatchOperationBuffer(
+      group_id,
+      writtenSize,
+      {
+        checkDefinitionId: () => LEGACY_BUCKET_DATA_DEFINITION_ID,
+        getBucketDefinitionId: () => LEGACY_BUCKET_DATA_DEFINITION_ID
+      },
+      options?.logger
+    );
+  }
+
+  get currentSize(): number {
+    return this.operations.currentSize;
+  }
+
+  saveBucketData(options: SaveBucketDataOptions): void {
+    this.operations.saveBucketData(options);
   }
 
-  protected getBucketDefinitionId(_bucketSource: BucketDataSource): BucketDefinitionId {
-    return LEGACY_BUCKET_DATA_DEFINITION_ID;
+  shouldFlushTransaction(): boolean {
+    return this.operations.shouldFlushTransaction(this.currentData.size);
+  }
+
+  /**
+   * Keeps track of bulkwrite operations within a transaction.
+   *
+   * There may be multiple of these batches per transaction, but it may not span
+   * multiple transactions.
+   */
+  async flush(session: mongo.ClientSession, options?: storage.BucketBatchCommitOptions) {
+    const startAt = performance.now();
+    const writes = this.db.createWriteBatch(session, { ordered: false });
+    if (this.operations.bucketDataCount > 0) {
+      await this.queueBucketData(writes);
+    }
+    if (this.operations.bucketParameters.length > 0) {
+      this.queueBucketParameters(writes);
+    }
+    if (this.currentData.size > 0) {
+      this.queueCurrentData(writes);
+    }
+    if (this.operations.bucketStates.size > 0) {
+      this.queueBucketStates(writes);
+    }
+    await writes.execute();
+    const stats = this.operations.logFlush(startAt, this.currentData.size, options);
+    this.currentData.clear();
+    this.operations.clear();
+    return stats;
   }
 
   saveParameterData(data: SaveParameterDataOptions) {
@@ -55,7 +105,7 @@ export class PersistedBatchV1 extends PersistedBatch {
       remaining_lookups.delete(binLookup.toString('base64'));
 
       const op_id = data.op_seq.next();
-      this.debugLastOpId = op_id;
+      this.operations.debugLastOpId = op_id;
       const values: BucketParameterDocument = {
         _id: op_id,
         key: {
@@ -66,17 +116,17 @@ export class PersistedBatchV1 extends PersistedBatch {
         lookup: binLookup,
         bucket_parameters: result.bucketParameters
       };
-      this.bucketParameters.push({
+      this.operations.bucketParameters.push({
         ...values,
         index: LEGACY_BUCKET_PARAMETER_INDEX_ID
       });
 
-      this.currentSize += 200;
+      this.operations.currentSize += 200;
     }
 
     for (let lookup of remaining_lookups.values()) {
       const op_id = data.op_seq.next();
-      this.debugLastOpId = op_id;
+      this.operations.debugLastOpId = op_id;
       const values: BucketParameterDocument = {
         _id: op_id,
         key: {
@@ -87,12 +137,12 @@ export class PersistedBatchV1 extends PersistedBatch {
         lookup,
         bucket_parameters: []
       };
-      this.bucketParameters.push({
+      this.operations.bucketParameters.push({
         ...values,
         index: LEGACY_BUCKET_PARAMETER_INDEX_ID
       });
 
-      this.currentSize += 200;
+      this.operations.currentSize += 200;
     }
   }
 
@@ -102,7 +152,7 @@ export class PersistedBatchV1 extends PersistedBatch {
         filter: { _id: this.currentDataId(sourceTableId, replicaId) }
       }
     });
-    this.currentSize += 50;
+    this.operations.currentSize += 50;
   }
 
   softDeleteCurrentData(sourceTableId: bson.ObjectId, replicaId: storage.ReplicaId, _checkpointGreaterThan: bigint) {
@@ -140,17 +190,13 @@ export class PersistedBatchV1 extends PersistedBatch {
         upsert: true
       }
     });
-    this.currentSize += (values.data?.length() ?? 0) + 100;
-  }
-
-  protected get currentDataCount() {
-    return this.currentData.size;
+    this.operations.currentSize += (values.data?.length() ?? 0) + 100;
   }
 
-  protected async queueBucketData(writes: MongoWriteBatch) {
+  private async queueBucketData(writes: MongoWriteBatch) {
     writes.bulkWriteUnordered(
       this.db.bucketDataV1,
-      this.bucketData.map((document) => ({
+      this.operations.bucketData.map((document) => ({
         insertOne: {
           document: serializeBucketDataV1(document)
         }
@@ -158,10 +204,10 @@ export class PersistedBatchV1 extends PersistedBatch {
     );
   }
 
-  protected queueBucketParameters(writes: MongoWriteBatch): void {
+  private queueBucketParameters(writes: MongoWriteBatch): void {
     writes.bulkWriteUnordered(
       this.db.parameterIndexV1,
-      this.bucketParameters.map((document) => ({
+      this.operations.bucketParameters.map((document) => ({
         insertOne: {
           document: taggedBucketParameterDocumentToV1(document)
         }
@@ -169,7 +215,7 @@ export class PersistedBatchV1 extends PersistedBatch {
     );
   }
 
-  protected queueCurrentData(writes: MongoWriteBatch): void {
+  private queueCurrentData(writes: MongoWriteBatch): void {
     if (this.currentData.size == 0) {
       return;
     }
@@ -177,16 +223,12 @@ export class PersistedBatchV1 extends PersistedBatch {
     writes.bulkWriteUnordered(this.db.sourceRecordsV1, [...this.currentData.values()]);
   }
 
-  protected queueBucketStates(writes: MongoWriteBatch): void {
+  private queueBucketStates(writes: MongoWriteBatch): void {
     writes.bulkWriteUnordered(this.db.bucketStateV1, this.getBucketStateUpdates());
   }
 
-  protected resetCurrentData() {
-    this.currentData.clear();
-  }
-
   private getBucketStateUpdates(): mongo.AnyBulkWriteOperation<BucketStateDocumentV1>[] {
-    return Array.from(this.bucketStates.values()).map((state: BucketStateUpdate) => {
+    return Array.from(this.operations.bucketStates.values()).map((state: BucketStateUpdate) => {
       return {
         updateOne: {
           filter: {

package/src/storage/implementation/v1/SourceRecordStoreV1.ts

@@ -1,5 +1,4 @@
 import { mongo } from '@powersync/lib-service-mongodb';
-import { Logger } from '@powersync/lib-services-framework';
 import { storage } from '@powersync/service-core';
 import { EvaluatedParameters, EvaluatedRow } from '@powersync/service-sync-rules';
 import * as bson from 'bson';
@@ -149,8 +148,4 @@ export class SourceRecordStoreV1 implements SourceRecordStore {
       this.createLoadedDocument(sourceTableId, doc._id, null, doc.buckets, doc.lookups)
     );
   }
-
-  async postCommitCleanup(_lastCheckpoint: bigint, _logger: Logger): Promise<void> {
-    // No-op for V1.
-  }
 }