@powersync/service-module-mongodb 0.0.0-dev-20260225160713 → 0.0.0-dev-20260511080634

package/dist/replication/ChangeStream.js

@@ -1,65 +1,16 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { isMongoNetworkTimeoutError, isMongoServerError, mongo } from '@powersync/lib-service-mongodb';
-import { container, DatabaseConnectionError, logger as defaultLogger, ErrorCode, ReplicationAbortedError, ReplicationAssertionError, ServiceError } from '@powersync/lib-services-framework';
-import { RelationCache, SaveOperationTag } from '@powersync/service-core';
+import { mongo } from '@powersync/lib-service-mongodb';
+import { container, DatabaseConnectionError, ErrorCode, ReplicationAbortedError, ReplicationAssertionError, ServiceError } from '@powersync/lib-services-framework';
+import { PerformanceTracer, RelationCache, ReplicationLagTracker, SaveOperationTag } from '@powersync/service-core';
 import { ReplicationMetric } from '@powersync/service-types';
+import { performance } from 'node:perf_hooks';
 import { MongoLSN } from '../common/MongoLSN.js';
 import { PostImagesOption } from '../types/types.js';
 import { escapeRegExp } from '../utils.js';
-import { constructAfterRecord, createCheckpoint, getCacheIdentifier, getMongoRelation, STANDALONE_CHECKPOINT_ID } from './MongoRelation.js';
+import { createCheckpoint, getCacheIdentifier, getMongoRelation, STANDALONE_CHECKPOINT_ID } from './MongoRelation.js';
 import { ChunkedSnapshotQuery } from './MongoSnapshotQuery.js';
+import { parseChangeDocument, rawChangeStream } from './RawChangeStream.js';
 import { CHECKPOINTS_COLLECTION, timestampToDate } from './replication-utils.js';
+import { DirectSourceRowConverter } from './SourceRowConverter.js';
 /**
  * Thrown when the change stream is not valid anymore, and replication
  * must be restarted.
@@ -85,20 +36,12 @@ export class ChangeStream {
     maxAwaitTimeMS;
     abort_signal;
     relationCache = new RelationCache(getCacheIdentifier);
-    /**
-     * Time of the oldest uncommitted change, according to the source db.
-     * This is used to determine the replication lag.
-     */
-    oldestUncommittedChange = null;
-    /**
-     * Keep track of whether we have done a commit or keepalive yet.
-     * We can only compute replication lag if isStartingReplication == false, or oldestUncommittedChange is present.
-     */
-    isStartingReplication = true;
+    replicationLag = new ReplicationLagTracker();
     checkpointStreamId = new mongo.ObjectId();
     logger;
     snapshotChunkLength;
     changeStreamTimeout;
+    sourceRowConverter;
     constructor(options) {
         this.storage = options.storage;
         this.metrics = options.metrics;
@@ -111,6 +54,7 @@ export class ChangeStream {
         this.sync_rules = options.storage.getParsedSyncRules({
             defaultSchema: this.defaultDb.databaseName
         });
+        this.sourceRowConverter = new DirectSourceRowConverter(this.sync_rules.compatibility);
         // The change stream aggregation command should timeout before the socket times out,
         // so we use 90% of the socket timeout value.
         this.changeStreamTimeout = Math.ceil(this.client.options.socketTimeoutMS * 0.9);
@@ -118,7 +62,7 @@ export class ChangeStream {
         this.abort_signal.addEventListener('abort', () => {
             // TODO: Fast abort?
         }, { once: true });
-        this.logger = options.logger ?? defaultLogger;
+        this.logger = options.logger ?? this.storage.logger;
     }
     get stopped() {
         return this.abort_signal.aborted;
@@ -188,46 +132,51 @@ export class ChangeStream {
      * This LSN can survive initial replication restarts.
      */
     async getSnapshotLsn() {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const hello = await this.defaultDb.command({ hello: 1 });
-            // Basic sanity check
-            if (hello.msg == 'isdbgrid') {
-                throw new ServiceError(ErrorCode.PSYNC_S1341, 'Sharded MongoDB Clusters are not supported yet (including MongoDB Serverless instances).');
+        const hello = await this.defaultDb.command({ hello: 1 });
+        // Basic sanity check
+        if (hello.msg == 'isdbgrid') {
+            throw new ServiceError(ErrorCode.PSYNC_S1341, 'Sharded MongoDB Clusters are not supported yet (including MongoDB Serverless instances).');
+        }
+        else if (hello.setName == null) {
+            throw new ServiceError(ErrorCode.PSYNC_S1342, 'Standalone MongoDB instances are not supported - use a replicaset.');
+        }
+        // Open a change stream just to get a resume token for later use.
+        // We could use clusterTime from the hello command, but that won't tell us if the
+        // snapshot isn't valid anymore.
+        // If we just use the first resumeToken from the stream, we get two potential issues:
+        // 1. The resumeToken may just be a wrapped clusterTime, which does not detect changes
+        //    in source db or other stream issues.
+        // 2. The first actual change we get may have the same clusterTime, causing us to incorrect
+        //    skip that event.
+        // Instead, we create a new checkpoint document, and wait until we get that document back in the stream.
+        // To avoid potential race conditions with the checkpoint creation, we create a new checkpoint document
+        // periodically until the timeout is reached.
+        const LSN_TIMEOUT_SECONDS = 60;
+        const LSN_CREATE_INTERVAL_SECONDS = 1;
+        // Create a checkpoint, and open a change stream using startAtOperationTime with the checkpoint's operationTime.
+        const firstCheckpointLsn = await createCheckpoint(this.client, this.defaultDb, this.checkpointStreamId);
+        const startTime = performance.now();
+        let lastCheckpointCreated = performance.now();
+        let eventsSeen = 0;
+        let batchesSeen = 0;
+        const filters = this.getSourceNamespaceFilters();
+        const iter = this.rawChangeStreamBatches({
+            lsn: firstCheckpointLsn,
+            maxAwaitTimeMS: 0,
+            signal: this.abort_signal,
+            filters
+        });
+        for await (let { events } of iter) {
+            if (performance.now() - startTime >= LSN_TIMEOUT_SECONDS * 1000) {
+                break;
             }
-            else if (hello.setName == null) {
-                throw new ServiceError(ErrorCode.PSYNC_S1342, 'Standalone MongoDB instances are not supported - use a replicaset.');
+            if (performance.now() - lastCheckpointCreated >= LSN_CREATE_INTERVAL_SECONDS * 1000) {
+                await createCheckpoint(this.client, this.defaultDb, this.checkpointStreamId);
+                lastCheckpointCreated = performance.now();
             }
-            // Open a change stream just to get a resume token for later use.
-            // We could use clusterTime from the hello command, but that won't tell us if the
-            // snapshot isn't valid anymore.
-            // If we just use the first resumeToken from the stream, we get two potential issues:
-            // 1. The resumeToken may just be a wrapped clusterTime, which does not detect changes
-            //    in source db or other stream issues.
-            // 2. The first actual change we get may have the same clusterTime, causing us to incorrect
-            //    skip that event.
-            // Instead, we create a new checkpoint document, and wait until we get that document back in the stream.
-            // To avoid potential race conditions with the checkpoint creation, we create a new checkpoint document
-            // periodically until the timeout is reached.
-            const LSN_TIMEOUT_SECONDS = 60;
-            const LSN_CREATE_INTERVAL_SECONDS = 1;
-            const streamManager = __addDisposableResource(env_1, this.openChangeStream({ lsn: null, maxAwaitTimeMs: 0 }), true);
-            const { stream } = streamManager;
-            const startTime = performance.now();
-            let lastCheckpointCreated = -10_000;
-            let eventsSeen = 0;
-            while (performance.now() - startTime < LSN_TIMEOUT_SECONDS * 1000) {
-                if (performance.now() - lastCheckpointCreated >= LSN_CREATE_INTERVAL_SECONDS * 1000) {
-                    await createCheckpoint(this.client, this.defaultDb, this.checkpointStreamId);
-                    lastCheckpointCreated = performance.now();
-                }
-                // tryNext() doesn't block, while next() / hasNext() does block until there is data on the stream
-                const changeDocument = await stream.tryNext().catch((e) => {
-                    throw mapChangeStreamError(e);
-                });
-                if (changeDocument == null) {
-                    continue;
-                }
+            batchesSeen += 1;
+            for (let rawChangeDocument of events) {
+                const changeDocument = parseChangeDocument(rawChangeDocument);
                 const ns = 'ns' in changeDocument && 'coll' in changeDocument.ns ? changeDocument.ns : undefined;
                 if (ns?.coll == CHECKPOINTS_COLLECTION && 'documentKey' in changeDocument) {
                     const checkpointId = changeDocument.documentKey._id;
@@ -242,56 +191,38 @@ export class ChangeStream {
                 }
                 eventsSeen += 1;
             }
-            // Could happen if there is a very large replication lag?
-            throw new ServiceError(ErrorCode.PSYNC_S1301, `Timeout after while waiting for checkpoint document for ${LSN_TIMEOUT_SECONDS}s. Streamed events = ${eventsSeen}`);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
         }
+        // Could happen if there is a very large replication lag?
+        throw new ServiceError(ErrorCode.PSYNC_S1301, `Timeout after while waiting for checkpoint document for ${LSN_TIMEOUT_SECONDS}s. Streamed events = ${eventsSeen}, batches = ${batchesSeen}`);
     }
     /**
      * Given a snapshot LSN, validate that we can read from it, by opening a change stream.
      */
     async validateSnapshotLsn(lsn) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const streamManager = __addDisposableResource(env_2, this.openChangeStream({ lsn: lsn, maxAwaitTimeMs: 0 }), true);
-            const { stream } = streamManager;
-            try {
-                // tryNext() doesn't block, while next() / hasNext() does block until there is data on the stream
-                await stream.tryNext();
-            }
-            catch (e) {
-                // Note: A timeout here is not handled as a ChangeStreamInvalidatedError, even though
-                // we possibly cannot recover from it.
-                throw mapChangeStreamError(e);
-            }
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
+        const filters = this.getSourceNamespaceFilters();
+        const stream = this.rawChangeStreamBatches({
+            lsn: lsn,
+            // maxAwaitTimeMS should never actually be used here
+            maxAwaitTimeMS: 0,
+            filters
+        });
+        for await (let _batch of stream) {
+            // We got a response from the aggregate command, so consider the LSN valid.
+            // Close the stream immediately.
+            break;
         }
     }
     async initialReplication(snapshotLsn) {
         const sourceTables = this.sync_rules.getSourceTables();
         await this.client.connect();
+        const tracer = new PerformanceTracer('MongoDB initial replication');
         const flushResult = await this.storage.startBatch({
             logger: this.logger,
             zeroLSN: MongoLSN.ZERO.comparable,
             defaultSchema: this.defaultDb.databaseName,
             storeCurrentData: false,
-            skipExistingRows: true
+            skipExistingRows: true,
+            tracer
         }, async (batch) => {
             if (snapshotLsn == null) {
                 // First replication attempt - get a snapshot and store the timestamp
@@ -328,14 +259,14 @@ export class ChangeStream {
             }
             for (let table of tablesWithStatus) {
                 await this.snapshotTable(batch, table);
-                await batch.markSnapshotDone([table], MongoLSN.ZERO.comparable);
+                await batch.markTableSnapshotDone([table]);
                 this.touch();
             }
             // The checkpoint here is a marker - we need to replicate up to at least this
             // point before the data can be considered consistent.
             // We could do this for each individual table, but may as well just do it once for the entire snapshot.
             const checkpoint = await createCheckpoint(this.client, this.defaultDb, STANDALONE_CHECKPOINT_ID);
-            await batch.markSnapshotDone([], checkpoint);
+            await batch.markAllSnapshotDone(checkpoint);
             // This will not create a consistent checkpoint yet, but will persist the op.
             // Actual checkpoint will be created when streaming replication caught up.
             await batch.commit(snapshotLsn);
@@ -412,81 +343,69 @@ export class ChangeStream {
         }
         return { $match: nsFilter, multipleDatabases };
     }
-    static *getQueryData(results) {
-        for (let row of results) {
-            yield constructAfterRecord(row);
-        }
-    }
     async snapshotTable(batch, table) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const totalEstimatedCount = await this.estimatedCountNumber(table);
-            let at = table.snapshotStatus?.replicatedCount ?? 0;
-            const db = this.client.db(table.schema);
-            const collection = db.collection(table.name);
-            const query = __addDisposableResource(env_3, new ChunkedSnapshotQuery({
-                collection,
-                key: table.snapshotStatus?.lastKey,
-                batchSize: this.snapshotChunkLength
-            }), true);
-            if (query.lastKey != null) {
-                this.logger.info(`Replicating ${table.qualifiedName} ${table.formatSnapshotProgress()} - resuming at _id > ${query.lastKey}`);
+        const rowsReplicatedMetric = this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED);
+        const bytesReplicatedMetric = this.metrics.getCounter(ReplicationMetric.DATA_REPLICATED_BYTES);
+        const chunksReplicatedMetric = this.metrics.getCounter(ReplicationMetric.CHUNKS_REPLICATED);
+        const totalEstimatedCount = await this.estimatedCountNumber(table);
+        let at = table.snapshotStatus?.replicatedCount ?? 0;
+        const db = this.client.db(table.schema);
+        const collection = db.collection(table.name);
+        await using query = new ChunkedSnapshotQuery({
+            collection,
+            key: table.snapshotStatus?.lastKey,
+            batchSize: this.snapshotChunkLength
+        });
+        if (query.lastKey != null) {
+            this.logger.info(`Replicating ${table.qualifiedName} ${table.formatSnapshotProgress()} - resuming at _id > ${query.lastKey}`);
+        }
+        else {
+            this.logger.info(`Replicating ${table.qualifiedName} ${table.formatSnapshotProgress()}`);
+        }
+        let lastBatch = performance.now();
+        let nextChunkPromise = query.nextChunk();
+        while (true) {
+            const { docs: docBatch, lastKey, bytes: chunkBytes } = await nextChunkPromise;
+            if (docBatch.length == 0) {
+                // No more data - stop iterating
+                break;
             }
-            else {
-                this.logger.info(`Replicating ${table.qualifiedName} ${table.formatSnapshotProgress()}`);
+            bytesReplicatedMetric.add(chunkBytes);
+            chunksReplicatedMetric.add(1);
+            if (this.abort_signal.aborted) {
+                throw new ReplicationAbortedError(`Aborted initial replication`, this.abort_signal.reason);
             }
-            let lastBatch = performance.now();
-            let nextChunkPromise = query.nextChunk();
-            while (true) {
-                const { docs: docBatch, lastKey } = await nextChunkPromise;
-                if (docBatch.length == 0) {
-                    // No more data - stop iterating
-                    break;
-                }
-                if (this.abort_signal.aborted) {
-                    throw new ReplicationAbortedError(`Aborted initial replication`);
-                }
-                // Pre-fetch next batch, so that we can read and write concurrently
-                nextChunkPromise = query.nextChunk();
-                for (let document of docBatch) {
-                    const record = this.constructAfterRecord(document);
-                    // This auto-flushes when the batch reaches its size limit
-                    await batch.save({
-                        tag: SaveOperationTag.INSERT,
-                        sourceTable: table,
-                        before: undefined,
-                        beforeReplicaId: undefined,
-                        after: record,
-                        afterReplicaId: document._id
-                    });
-                }
-                // Important: flush before marking progress
-                await batch.flush();
-                at += docBatch.length;
-                this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED).add(docBatch.length);
-                table = await batch.updateTableProgress(table, {
-                    lastKey,
-                    replicatedCount: at,
-                    totalEstimatedCount: totalEstimatedCount
+            // Pre-fetch next batch, so that we can read and write concurrently
+            nextChunkPromise = query.nextChunk();
+            for (let buffer of docBatch) {
+                const { row: record, replicaId: replicaId } = this.rawToSqliteRow(buffer);
+                // This auto-flushes when the batch reaches its size limit
+                await batch.save({
+                    tag: SaveOperationTag.INSERT,
+                    sourceTable: table,
+                    before: undefined,
+                    beforeReplicaId: undefined,
+                    after: record,
+                    afterReplicaId: replicaId
                 });
-                this.relationCache.update(table);
-                const duration = performance.now() - lastBatch;
-                lastBatch = performance.now();
-                this.logger.info(`Replicating ${table.qualifiedName} ${table.formatSnapshotProgress()} in ${duration.toFixed(0)}ms`);
-                this.touch();
             }
-            // In case the loop was interrupted, make sure we await the last promise.
-            await nextChunkPromise;
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            const result_3 = __disposeResources(env_3);
-            if (result_3)
-                await result_3;
+            // Important: flush before marking progress
+            await batch.flush();
+            at += docBatch.length;
+            rowsReplicatedMetric.add(docBatch.length);
+            table = await batch.updateTableProgress(table, {
+                lastKey,
+                replicatedCount: at,
+                totalEstimatedCount: totalEstimatedCount
+            });
+            this.relationCache.update(table);
+            const duration = performance.now() - lastBatch;
+            lastBatch = performance.now();
+            this.logger.info(`Replicating ${table.qualifiedName} ${table.formatSnapshotProgress()} in ${duration.toFixed(0)}ms`);
+            this.touch();
         }
+        // In case the loop was interrupted, make sure we await the last promise.
+        await nextChunkPromise;
     }
     async getRelation(batch, descriptor, options) {
         const existing = this.relationCache.get(descriptor);
@@ -550,7 +469,7 @@ export class ChangeStream {
         // Snapshot if:
         // 1. Snapshot is requested (false for initial snapshot, since that process handles it elsewhere)
         // 2. Snapshot is not already done, AND:
-        // 3. The table is used in sync rules.
+        // 3. The table is used in sync config.
         const shouldSnapshot = snapshot && !result.table.snapshotComplete && result.table.syncAny;
         if (shouldSnapshot) {
             this.logger.info(`New collection: ${descriptor.schema}.${descriptor.name}`);
@@ -558,29 +477,28 @@ export class ChangeStream {
             await batch.truncate([result.table]);
             await this.snapshotTable(batch, result.table);
             const no_checkpoint_before_lsn = await createCheckpoint(this.client, this.defaultDb, STANDALONE_CHECKPOINT_ID);
-            const [table] = await batch.markSnapshotDone([result.table], no_checkpoint_before_lsn);
+            const [table] = await batch.markTableSnapshotDone([result.table], no_checkpoint_before_lsn);
             return table;
         }
         return result.table;
     }
-    constructAfterRecord(document) {
-        const inputRow = constructAfterRecord(document);
-        return this.sync_rules.applyRowContext(inputRow);
-    }
     async writeChange(batch, table, change) {
         if (!table.syncAny) {
-            this.logger.debug(`Collection ${table.qualifiedName} not used in sync rules - skipping`);
+            this.logger.debug(`Collection ${table.qualifiedName} not used in sync config - skipping`);
             return null;
         }
         this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED).add(1);
         if (change.operationType == 'insert') {
-            const baseRecord = this.constructAfterRecord(change.fullDocument);
+            const { row: baseRecord, replicaId: _replicaId } = this.rawToSqliteRow(change.fullDocument);
             return await batch.save({
                 tag: SaveOperationTag.INSERT,
                 sourceTable: table,
                 before: undefined,
                 beforeReplicaId: undefined,
                 after: baseRecord,
+                // Same as _replicaId
+                // We specifically need to use the source _id, not the converted one in baseRecord,
+                // to preserve _id uniqueness properties.
                 afterReplicaId: change.documentKey._id
             });
         }
@@ -594,14 +512,14 @@ export class ChangeStream {
                     beforeReplicaId: change.documentKey._id
                 });
             }
-            const after = this.constructAfterRecord(change.fullDocument);
+            const { row: after, replicaId: _replicaId } = this.rawToSqliteRow(change.fullDocument);
             return await batch.save({
                 tag: SaveOperationTag.UPDATE,
                 sourceTable: table,
                 before: undefined,
                 beforeReplicaId: undefined,
                 after: after,
-                afterReplicaId: change.documentKey._id
+                afterReplicaId: change.documentKey._id // Same as _replicaId
             });
         }
         else if (change.operationType == 'delete') {
@@ -638,7 +556,7 @@ export class ChangeStream {
             }
             const { lastOpId } = await this.initialReplication(result.snapshotLsn);
             if (lastOpId != null) {
-                // Populate the cache _after_ initial replication, but _before_ we switch to this sync rules.
+                // Populate the cache _after_ initial replication, but _before_ we switch to this replication stream.
                 await this.storage.populatePersistentChecksumCache({
                     signal: this.abort_signal,
                     // No checkpoint yet, but we do have the opId.
@@ -660,17 +578,11 @@ export class ChangeStream {
             throw e;
         }
     }
-    openChangeStream(options) {
+    rawChangeStreamBatches(options) {
         const lastLsn = options.lsn ? MongoLSN.fromSerialized(options.lsn) : null;
         const startAfter = lastLsn?.timestamp;
         const resumeAfter = lastLsn?.resumeToken;
-        const filters = this.getSourceNamespaceFilters();
-        const pipeline = [
-            {
-                $match: filters.$match
-            },
-            { $changeStreamSplitLargeEvent: {} }
-        ];
+        const filters = options.filters;
         let fullDocument;
         if (this.usePostImages) {
             // 'read_only' or 'auto_configure'
@@ -683,10 +595,17 @@ export class ChangeStream {
         }
         const streamOptions = {
             showExpandedEvents: true,
-            maxAwaitTimeMS: options.maxAwaitTimeMs ?? this.maxAwaitTimeMS,
-            fullDocument: fullDocument,
-            maxTimeMS: this.changeStreamTimeout
+            fullDocument: fullDocument
         };
+        const pipeline = [
+            {
+                $changeStream: streamOptions
+            },
+            {
+                $match: filters.$match
+            },
+            { $changeStreamSplitLargeEvent: {} }
+        ];
         /**
          * Only one of these options can be supplied at a time.
          */
@@ -696,100 +615,106 @@ export class ChangeStream {
         else {
             // Legacy: We don't persist lsns without resumeTokens anymore, but we do still handle the
             // case if we have an old one.
+            // This is also relevant for getSnapshotLSN().
             streamOptions.startAtOperationTime = startAfter;
         }
-        let stream;
+        let watchDb;
         if (filters.multipleDatabases) {
-            // Requires readAnyDatabase@admin on Atlas
-            stream = this.client.watch(pipeline, streamOptions);
+            watchDb = this.client.db('admin');
+            streamOptions.allChangesForCluster = true;
         }
         else {
-            // Same general result, but requires less permissions than the above
-            stream = this.defaultDb.watch(pipeline, streamOptions);
+            watchDb = this.defaultDb;
         }
-        this.abort_signal.addEventListener('abort', () => {
-            stream.close();
+        return rawChangeStream(watchDb, pipeline, {
+            batchSize: options.batchSize ?? this.snapshotChunkLength,
+            maxAwaitTimeMS: options.maxAwaitTimeMS ?? this.maxAwaitTimeMS,
+            maxTimeMS: this.changeStreamTimeout,
+            signal: options.signal,
+            logger: this.logger,
+            tracer: options.tracer
         });
-        return {
-            stream,
-            filters,
-            [Symbol.asyncDispose]: async () => {
-                return stream.close();
-            }
-        };
+    }
+    rawToSqliteRow(row) {
+        return this.sourceRowConverter.rawToSqliteRow(row);
     }
     async streamChangesInternal() {
+        const transactionsReplicatedMetric = this.metrics.getCounter(ReplicationMetric.TRANSACTIONS_REPLICATED);
+        const bytesReplicatedMetric = this.metrics.getCounter(ReplicationMetric.DATA_REPLICATED_BYTES);
+        const chunksReplicatedMetric = this.metrics.getCounter(ReplicationMetric.CHUNKS_REPLICATED);
+        const tracer = new PerformanceTracer('MongoDB streaming replication');
         await this.storage.startBatch({
             logger: this.logger,
             zeroLSN: MongoLSN.ZERO.comparable,
             defaultSchema: this.defaultDb.databaseName,
             // We get a complete postimage for every change, so we don't need to store the current data.
-            storeCurrentData: false
+            storeCurrentData: false,
+            tracer
         }, async (batch) => {
-            const env_4 = { stack: [], error: void 0, hasError: false };
-            try {
-                const { resumeFromLsn } = batch;
-                if (resumeFromLsn == null) {
-                    throw new ReplicationAssertionError(`No LSN found to resume from`);
-                }
-                const lastLsn = MongoLSN.fromSerialized(resumeFromLsn);
-                const startAfter = lastLsn?.timestamp;
-                // It is normal for this to be a minute or two old when there is a low volume
-                // of ChangeStream events.
-                const tokenAgeSeconds = Math.round((Date.now() - timestampToDate(startAfter).getTime()) / 1000);
-                this.logger.info(`Resume streaming at ${startAfter?.inspect()} / ${lastLsn}  | Token age: ${tokenAgeSeconds}s`);
-                const streamManager = __addDisposableResource(env_4, this.openChangeStream({ lsn: resumeFromLsn }), true);
-                const { stream, filters } = streamManager;
+            const { resumeFromLsn } = batch;
+            if (resumeFromLsn == null) {
+                throw new ReplicationAssertionError(`No LSN found to resume from`);
+            }
+            const lastLsn = MongoLSN.fromSerialized(resumeFromLsn);
+            const startAfter = lastLsn?.timestamp;
+            let outerSpan = tracer.span('batch');
+            // It is normal for this to be a minute or two old when there is a low volume
+            // of ChangeStream events.
+            const tokenAgeSeconds = Math.round((Date.now() - timestampToDate(startAfter).getTime()) / 1000);
+            this.logger.info(`Resume streaming at ${startAfter?.inspect()} / ${lastLsn}  | Token age: ${tokenAgeSeconds}s`);
+            const filters = this.getSourceNamespaceFilters();
+            // This is closed when the for loop below returns/breaks/throws
+            const batchStream = this.rawChangeStreamBatches({
+                lsn: resumeFromLsn,
+                filters,
+                signal: this.abort_signal,
+                tracer
+            });
+            // Always start with a checkpoint.
+            // This helps us to clear errors when restarting, even if there is
+            // no data to replicate.
+            let waitForCheckpointLsn = await createCheckpoint(this.client, this.defaultDb, this.checkpointStreamId);
+            let splitDocument = null;
+            let flexDbNameWorkaroundLogged = false;
+            let lastEmptyResume = performance.now();
+            let lastTxnKey = null;
+            for await (let eventBatch of batchStream) {
+                const { events, resumeToken } = eventBatch;
+                using batchSpan = tracer.span('processing');
+                bytesReplicatedMetric.add(eventBatch.byteSize);
+                chunksReplicatedMetric.add(1);
                 if (this.abort_signal.aborted) {
-                    await stream.close();
-                    return;
+                    break;
                 }
-                // Always start with a checkpoint.
-                // This helps us to clear errors when restarting, even if there is
-                // no data to replicate.
-                let waitForCheckpointLsn = await createCheckpoint(this.client, this.defaultDb, this.checkpointStreamId);
-                let splitDocument = null;
-                let flexDbNameWorkaroundLogged = false;
-                let changesSinceLastCheckpoint = 0;
-                let lastEmptyResume = performance.now();
-                while (true) {
-                    if (this.abort_signal.aborted) {
-                        break;
+                this.touch();
+                if (events.length == 0) {
+                    // No changes in this batch, but we still want to keep the connection alive.
+                    // We do this by persisting a keepalive checkpoint.
+                    // If we don't update it on empty events, we do keep consistency, but resuming the stream
+                    // with old tokens may cause connection timeouts.
+                    if (waitForCheckpointLsn == null && performance.now() - lastEmptyResume > 60_000) {
+                        const { comparable: lsn, timestamp } = MongoLSN.fromResumeToken(resumeToken);
+                        await batch.keepalive(lsn);
+                        this.touch();
+                        lastEmptyResume = performance.now();
+                        // Log the token update. This helps as a general "replication is still active" message in the logs.
+                        // This token would typically be around 10s behind.
+                        this.logger.info(`Idle change stream. Persisted resumeToken for ${timestampToDate(timestamp).toISOString()}`);
+                        this.replicationLag.markStarted();
                     }
-                    const originalChangeDocument = await stream.tryNext().catch((e) => {
-                        throw mapChangeStreamError(e);
-                    });
-                    // The stream was closed, we will only ever receive `null` from it
-                    if (!originalChangeDocument && stream.closed) {
-                        break;
+                    // If we have no changes, we can just persist the keepalive.
+                    // This is throttled to once per minute.
+                    if (performance.now() - lastEmptyResume < 60_000) {
+                        continue;
                     }
+                }
+                this.touch();
+                for (let eventIndex = 0; eventIndex < events.length; eventIndex++) {
+                    const rawChangeDocument = events[eventIndex];
+                    const originalChangeDocument = parseChangeDocument(rawChangeDocument);
                     if (this.abort_signal.aborted) {
                         break;
                     }
-                    if (originalChangeDocument == null) {
-                        // We get a new null document after `maxAwaitTimeMS` if there were no other events.
-                        // In this case, stream.resumeToken is the resume token associated with the last response.
-                        // stream.resumeToken is not updated if stream.tryNext() returns data, while stream.next()
-                        // does update it.
-                        // From observed behavior, the actual resumeToken changes around once every 10 seconds.
-                        // If we don't update it on empty events, we do keep consistency, but resuming the stream
-                        // with old tokens may cause connection timeouts.
-                        // We throttle this further by only persisting a keepalive once a minute.
-                        // We add an additional check for waitForCheckpointLsn == null, to make sure we're not
-                        // doing a keepalive in the middle of a transaction.
-                        if (waitForCheckpointLsn == null && performance.now() - lastEmptyResume > 60_000) {
-                            const { comparable: lsn, timestamp } = MongoLSN.fromResumeToken(stream.resumeToken);
-                            await batch.keepalive(lsn);
-                            this.touch();
-                            lastEmptyResume = performance.now();
-                            // Log the token update. This helps as a general "replication is still active" message in the logs.
-                            // This token would typically be around 10s behind.
-                            this.logger.info(`Idle change stream. Persisted resumeToken for ${timestampToDate(timestamp).toISOString()}`);
-                            this.isStartingReplication = false;
-                        }
-                        continue;
-                    }
-                    this.touch();
                     if (startAfter != null && originalChangeDocument.clusterTime?.lte(startAfter)) {
                         continue;
                     }
@@ -843,15 +768,15 @@ export class ChangeStream {
                          * would process below.
                          *
                          * However we don't commit the LSN after collections are dropped.
-                         * The prevents the `startAfter` or `resumeToken` from advancing past the drop events.
+                         * This prevents the `startAfter` or `resumeToken` from advancing past the drop events.
                          * The stream also closes after the drop events.
                          * This causes an infinite loop of processing the collection drop events.
                          *
-                         * This check here invalidates the change stream if our `_checkpoints` collection
+                         * This check here invalidates the change stream if our `_powersync_checkpoints` collection
                          * is dropped. This allows for detecting when the DB is dropped.
                          */
                         if (changeDocument.operationType == 'drop') {
-                            throw new ChangeStreamInvalidatedError('Internal collections have been dropped', new Error('_checkpoints collection was dropped'));
+                            throw new ChangeStreamInvalidatedError('Internal collections have been dropped', new Error('_powersync_checkpoints collection was dropped'));
                         }
                         if (!(changeDocument.operationType == 'insert' ||
                             changeDocument.operationType == 'update' ||
@@ -867,7 +792,21 @@ export class ChangeStream {
                         // It may be useful to also throttle commits due to standalone checkpoints in the future.
                         // However, these typically have a much lower rate than batch checkpoints, so we don't do that for now.
                         const checkpointId = changeDocument.documentKey._id;
-                        if (!(checkpointId == STANDALONE_CHECKPOINT_ID || this.checkpointStreamId.equals(checkpointId))) {
+                        if (checkpointId == STANDALONE_CHECKPOINT_ID) {
+                            // Standalone / write checkpoint received.
+                            // When we are caught up, commit immediately to keep write checkpoint latency low.
+                            // Once there is already a batch checkpoint pending, or the driver has buffered more
+                            // change stream events, collapse standalone checkpoints into the normal batch
+                            // checkpoint flow to avoid commit churn under sustained load.
+                            const hasBufferedChanges = eventIndex < events.length - 1;
+                            if (waitForCheckpointLsn != null || hasBufferedChanges) {
+                                if (waitForCheckpointLsn == null) {
+                                    waitForCheckpointLsn = await createCheckpoint(this.client, this.defaultDb, this.checkpointStreamId);
+                                }
+                                continue;
+                            }
+                        }
+                        else if (!this.checkpointStreamId.equals(checkpointId)) {
                             continue;
                         }
                         const { comparable: lsn } = new MongoLSN({
@@ -885,11 +824,11 @@ export class ChangeStream {
                         if (waitForCheckpointLsn != null && lsn >= waitForCheckpointLsn) {
                             waitForCheckpointLsn = null;
                         }
-                        const didCommit = await batch.commit(lsn, { oldestUncommittedChange: this.oldestUncommittedChange });
-                        if (didCommit) {
-                            this.oldestUncommittedChange = null;
-                            this.isStartingReplication = false;
-                            changesSinceLastCheckpoint = 0;
+                        const { checkpointBlocked } = await batch.commit(lsn, {
+                            oldestUncommittedChange: this.replicationLag.oldestUncommittedChange
+                        });
+                        if (!checkpointBlocked) {
+                            this.replicationLag.markCommitted();
                         }
                     }
                     else if (changeDocument.operationType == 'insert' ||
@@ -904,28 +843,20 @@ export class ChangeStream {
                             // In most cases, we should not need to snapshot this. But if this is the first time we see the collection
                             // for whatever reason, then we do need to snapshot it.
                             // This may result in some duplicate operations when a collection is created for the first time after
-                            // sync rules was deployed.
+                            // sync config was deployed.
                             snapshot: true
                         });
                         if (table.syncAny) {
-                            if (this.oldestUncommittedChange == null && changeDocument.clusterTime != null) {
-                                this.oldestUncommittedChange = timestampToDate(changeDocument.clusterTime);
-                            }
-                            const flushResult = await this.writeChange(batch, table, changeDocument);
-                            changesSinceLastCheckpoint += 1;
-                            if (flushResult != null && changesSinceLastCheckpoint >= 20_000) {
-                                // When we are catching up replication after an initial snapshot, there may be a very long delay
-                                // before we do a commit(). In that case, we need to periodically persist the resume LSN, so
-                                // we don't restart from scratch if we restart replication.
-                                // The same could apply if we need to catch up on replication after some downtime.
-                                const { comparable: lsn } = new MongoLSN({
-                                    timestamp: changeDocument.clusterTime,
-                                    resume_token: changeDocument._id
-                                });
-                                this.logger.info(`Updating resume LSN to ${lsn} after ${changesSinceLastCheckpoint} changes`);
-                                await batch.setResumeLsn(lsn);
-                                changesSinceLastCheckpoint = 0;
+                            this.replicationLag.trackUncommittedChange(changeDocument.clusterTime == null ? null : timestampToDate(changeDocument.clusterTime));
+                            const transactionKeyValue = transactionKey(changeDocument);
+                            if (transactionKeyValue == null || lastTxnKey != transactionKeyValue) {
+                                // Very crude metric for counting transactions replicated.
+                                // We ignore operations other than basic CRUD, and ignore changes to _powersync_checkpoints.
+                                // Individual writes may not have a txnNumber, in which case we count them as separate transactions.
+                                lastTxnKey = transactionKeyValue;
+                                transactionsReplicatedMetric.add(1);
                             }
+                            await this.writeChange(batch, table, changeDocument);
                         }
                     }
                     else if (changeDocument.operationType == 'drop') {
@@ -959,30 +890,31 @@ export class ChangeStream {
                         });
                     }
                 }
-            }
-            catch (e_4) {
-                env_4.error = e_4;
-                env_4.hasError = true;
-            }
-            finally {
-                const result_4 = __disposeResources(env_4);
-                if (result_4)
-                    await result_4;
+                if (splitDocument == null) {
+                    // We flush and mark progress on every batch of data we receive.
+                    // Batches are generally large (64MB or 6000 events, whichever comes first),
+                    // so this is a good natural point to flush and mark progress.
+                    // We avoid this when splitDocument is set, since we cannot resume in the middle of a split event.
+                    const { comparable: lsn } = MongoLSN.fromResumeToken(resumeToken);
+                    await batch.flush({ oldestUncommittedChange: this.replicationLag.oldestUncommittedChange });
+                    // TODO: We should consider making this standard behavior of flush().
+                    await batch.setResumeLsn(lsn);
+                }
+                batchSpan.end();
+                const durations = outerSpan.end();
+                const duration = batchSpan.endAt - batchSpan.startAt;
+                this.logger.info(`Processed batch of ${events.length} changes / ${eventBatch.byteSize} bytes in ${duration}ms`, {
+                    count: events.length,
+                    bytes: eventBatch.byteSize,
+                    duration,
+                    t: durations
+                });
+                outerSpan = tracer.span('batch');
             }
         });
     }
-    async getReplicationLagMillis() {
-        if (this.oldestUncommittedChange == null) {
-            if (this.isStartingReplication) {
-                // We don't have anything to compute replication lag with yet.
-                return undefined;
-            }
-            else {
-                // We don't have any uncommitted changes, so replication is up-to-date.
-                return 0;
-            }
-        }
-        return Date.now() - this.oldestUncommittedChange.getTime();
+    getReplicationLagMillis() {
+        return this.replicationLag.getLagMillis();
     }
     lastTouchedAt = performance.now();
     touch() {
@@ -995,27 +927,13 @@ export class ChangeStream {
         }
     }
 }
-function mapChangeStreamError(e) {
-    if (isMongoNetworkTimeoutError(e)) {
-        // This typically has an unhelpful message like "connection 2 to 159.41.94.47:27017 timed out".
-        // We wrap the error to make it more useful.
-        throw new DatabaseConnectionError(ErrorCode.PSYNC_S1345, `Timeout while reading MongoDB ChangeStream`, e);
-    }
-    else if (isMongoServerError(e) && e.codeName == 'MaxTimeMSExpired') {
-        // maxTimeMS was reached. Example message:
-        // MongoServerError: Executor error during aggregate command on namespace: powersync_test_data.$cmd.aggregate :: caused by :: operation exceeded time limit
-        throw new DatabaseConnectionError(ErrorCode.PSYNC_S1345, `Timeout while reading MongoDB ChangeStream`, e);
-    }
-    else if (isMongoServerError(e) &&
-        e.codeName == 'NoMatchingDocument' &&
-        e.errmsg?.includes('post-image was not found')) {
-        throw new ChangeStreamInvalidatedError(e.errmsg, e);
-    }
-    else if (isMongoServerError(e) && e.hasErrorLabel('NonResumableChangeStreamError')) {
-        throw new ChangeStreamInvalidatedError(e.message, e);
-    }
-    else {
-        throw new DatabaseConnectionError(ErrorCode.PSYNC_S1346, `Error reading MongoDB ChangeStream`, e);
+/**
+ * Transaction key for a change stream event, used to detect transaction boundaries. Returns null if the event is not part of a transaction.
+ */
+function transactionKey(doc) {
+    if (doc.txnNumber == null || doc.lsid == null) {
+        return null;
     }
+    return `${doc.lsid.id.toString('hex')}:${doc.txnNumber}`;
 }
 //# sourceMappingURL=ChangeStream.js.map