@powersync/service-module-mongodb 0.0.0-dev-20260602073133 → 0.0.0-dev-20260909133214

package/test/src/change_stream_utils.ts

@@ -5,6 +5,7 @@ import {
   createCoreReplicationMetrics,
   initializeCoreReplicationMetrics,
   InternalOpId,
+  isBatchEnd,
   LEGACY_STORAGE_VERSION,
   OplogEntry,
   ProtocolOpId,
@@ -19,9 +20,15 @@ import {
 } from '@powersync/service-core';
 import { bucketRequest, METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
 
+import { SentinelLSN } from '@module/common/SentinelLSN.js';
 import { ChangeStream, ChangeStreamOptions } from '@module/replication/ChangeStream.js';
 import { MongoManager } from '@module/replication/MongoManager.js';
-import { createCheckpoint, STANDALONE_CHECKPOINT_ID } from '@module/replication/MongoRelation.js';
+import {
+  createCheckpoint,
+  createSentinelCheckpointLsn,
+  STANDALONE_CHECKPOINT_ID
+} from '@module/replication/MongoRelation.js';
+import { detectDocumentDb } from '@module/replication/replication-utils.js';
 import { NormalizedMongoConnectionConfig } from '@module/types/types.js';
 
 import { clearTestDb, TEST_CONNECTION_OPTIONS } from './util.js';
@@ -30,7 +37,7 @@ export class ChangeStreamTestContext {
   private _walStream?: ChangeStream;
   private abortController = new AbortController();
   private settledReplicationPromise?: Promise<PromiseSettledResult<void>>;
-  private syncRulesContent?: storage.PersistedSyncRulesContent;
+  private syncRulesContent?: storage.PersistedSyncConfigContent;
   public storage?: SyncRulesBucketStorage;
 
   /**
@@ -46,6 +53,11 @@ export class ChangeStreamTestContext {
       storageVersion?: number;
       mongoOptions?: Partial<NormalizedMongoConnectionConfig>;
       streamOptions?: Partial<ChangeStreamOptions>;
+      /**
+       * Optional override for tests that need to force a mode. By default the
+       * test context detects DocumentDB from the hello response.
+       */
+      documentDbMode?: boolean;
     }
   ) {
     const f = await factory({ doNotClear: options?.doNotClear });
@@ -56,15 +68,17 @@ export class ChangeStreamTestContext {
     }
 
     const storageVersion = options?.storageVersion ?? LEGACY_STORAGE_VERSION;
+    const documentDbMode = options?.documentDbMode ?? (await detectDocumentDb(connectionManager.db));
 
-    return new ChangeStreamTestContext(f, connectionManager, options?.streamOptions, storageVersion);
+    return new ChangeStreamTestContext(f, connectionManager, options?.streamOptions, storageVersion, documentDbMode);
   }
 
   constructor(
     public factory: BucketStorageFactory,
     public connectionManager: MongoManager,
     private streamOptions: Partial<ChangeStreamOptions> = {},
-    private storageVersion: number = LEGACY_STORAGE_VERSION
+    private storageVersion: number = LEGACY_STORAGE_VERSION,
+    private documentDbMode: boolean = false
   ) {
     createCoreReplicationMetrics(METRICS_HELPER.metricsEngine);
     initializeCoreReplicationMetrics(METRICS_HELPER.metricsEngine);
@@ -101,26 +115,37 @@ export class ChangeStreamTestContext {
   }
 
   async updateSyncRules(content: string) {
-    const syncRules = await this.factory.updateSyncRules(
+    const replicationStream = await this.factory.updateSyncRules(
       updateSyncRulesFromYaml(content, { validate: true, storageVersion: this.storageVersion })
     );
-    this.syncRulesContent = syncRules;
-    this.storage = this.factory.getInstance(syncRules);
+    this.syncRulesContent = replicationStream.syncConfigContent[0];
+    this.storage = this.factory.getInstance(replicationStream);
     return this.storage!;
   }
 
   async loadNextSyncRules() {
-    const syncRules = await this.factory.getNextSyncRulesContent();
-    if (syncRules == null) {
+    const syncConfig = await this.factory.getDeployingSyncConfig();
+    if (syncConfig == null) {
       throw new Error(`Next sync config not available`);
     }
 
-    this.syncRulesContent = syncRules;
-    this.storage = this.factory.getInstance(syncRules);
+    this.syncRulesContent = syncConfig.content;
+    this.storage = syncConfig.storage;
+    return this.storage!;
+  }
+
+  async loadActiveSyncRules() {
+    const syncConfig = await this.factory.getActiveSyncConfig();
+    if (syncConfig == null) {
+      throw new Error(`Active sync config not found`);
+    }
+
+    this.syncRulesContent = syncConfig.content;
+    this.storage = syncConfig.storage;
     return this.storage!;
   }
 
-  private getSyncRulesContent(): storage.PersistedSyncRulesContent {
+  private getSyncConfigContent(): storage.PersistedSyncConfigContent {
     if (this.syncRulesContent == null) {
       throw new Error('Sync config not configured - call updateSyncRules() first');
     }
@@ -143,6 +168,7 @@ export class ChangeStreamTestContext {
       // a long time to abort the stream.
       maxAwaitTimeMS: this.streamOptions?.maxAwaitTimeMS ?? 200,
       snapshotChunkLength: this.streamOptions?.snapshotChunkLength,
+      keepaliveIntervalMs: this.streamOptions?.keepaliveIntervalMs,
       storageHooks: this.streamOptions?.storageHooks,
       snapshotHooks: this.streamOptions?.snapshotHooks,
       logger: this.streamOptions?.logger
@@ -170,7 +196,24 @@ export class ChangeStreamTestContext {
    * would result in inconsistent data.
    */
   async markSnapshotConsistent() {
-    const checkpoint = await createCheckpoint(this.client, this.db, STANDALONE_CHECKPOINT_ID);
+    let checkpoint: string;
+    if (this.documentDbMode) {
+      const sentinelCheckpoint = SentinelLSN.fromSerialized(await createSentinelCheckpointLsn(this.client, this.db));
+      const status = await this.storage!.getStatus();
+      const resumeFrom = status.resumeLsn;
+      const resumeToken = resumeFrom ? SentinelLSN.fromSerialized(resumeFrom).resumeToken : null;
+
+      // This helper artificially marks the snapshot as consistent without
+      // waiting for the stream to observe the sentinel. Keep the sentinel as the
+      // comparable position, but carry forward the existing snapshot resume
+      // token so later DocumentDB streaming still resumes from a real token.
+      checkpoint = new SentinelLSN({
+        sentinel: sentinelCheckpoint.sentinel,
+        resume_token: resumeToken
+      }).comparable;
+    } else {
+      checkpoint = await createCheckpoint(this.db, STANDALONE_CHECKPOINT_ID);
+    }
 
     await using writer = await this.storage!.createWriter(test_utils.BATCH_OPTIONS);
     await writer.keepalive(checkpoint);
@@ -197,37 +240,65 @@ export class ChangeStreamTestContext {
 
   async getBucketsDataBatch(buckets: Record<string, InternalOpId>, options?: { timeout?: number }) {
     let checkpoint = await this.getCheckpoint(options);
-    const syncRules = this.getSyncRulesContent();
-    const map = Object.entries(buckets).map(([bucket, start]) => bucketRequest(syncRules, bucket, start));
+    const syncConfigContent = this.getSyncConfigContent();
+    const map = Object.entries(buckets).map(([bucket, start]) => bucketRequest(syncConfigContent, bucket, start));
     return test_utils.fromAsync(this.storage!.getBucketDataBatch(checkpoint, map));
   }
 
   async getBucketData(bucket: string, start?: ProtocolOpId | InternalOpId | undefined, options?: { timeout?: number }) {
+    const checkpoint = await this.getCheckpoint(options);
+    return this.getBucketDataAtCheckpoint(bucket, checkpoint, start);
+  }
+
+  async getBucketDataAtLatestCheckpoint(bucket: string, start?: ProtocolOpId | InternalOpId | undefined) {
+    if (this.storage == null) {
+      throw new Error('updateSyncRules() first');
+    }
+
+    const checkpoint = await this.storage.getCheckpoint();
+    return this.getBucketDataAtCheckpoint(bucket, checkpoint, start);
+  }
+
+  async getBucketDataAtCheckpoint(
+    bucket: string,
+    checkpoint: ReplicationCheckpoint,
+    start?: ProtocolOpId | InternalOpId | undefined
+  ) {
     start ??= 0n;
     if (typeof start == 'string') {
       start = BigInt(start);
     }
-    const syncRules = this.getSyncRulesContent();
-    const checkpoint = await this.getCheckpoint(options);
-    let map = [bucketRequest(syncRules, bucket, start)];
+    const syncConfigContent = this.getSyncConfigContent();
+    let map = [bucketRequest(syncConfigContent, bucket, start)];
     let data: OplogEntry[] = [];
     while (true) {
       const batch = this.storage!.getBucketDataBatch(checkpoint, map);
 
-      const batches = await test_utils.fromAsync(batch);
-      data = data.concat(batches[0]?.chunkData.data ?? []);
-      if (batches.length == 0 || !batches[0]!.chunkData.has_more) {
+      const chunks = await test_utils.fromAsync(batch);
+      if (chunks.length == 0) {
         break;
       }
-      map = [bucketRequest(syncRules, bucket, BigInt(batches[0]!.chunkData.next_after))];
+      for (let chunk of chunks) {
+        if (isBatchEnd(chunk)) {
+          if (!chunk.hasMore) {
+            return data;
+          }
+        } else {
+          data = data.concat(chunk.chunkData.data ?? []);
+          map = [bucketRequest(syncConfigContent, bucket, BigInt(chunk.chunkData.next_after))];
+          if (!chunk.chunkData.has_more) {
+            return data;
+          }
+        }
+      }
     }
     return data;
   }
 
   async getChecksums(buckets: string[], options?: { timeout?: number }): Promise<utils.ChecksumMap> {
     let checkpoint = await this.getCheckpoint(options);
-    const syncRules = this.getSyncRulesContent();
-    const versionedBuckets = buckets.map((bucket) => bucketRequest(syncRules, bucket, 0n));
+    const syncConfigContent = this.getSyncConfigContent();
+    const versionedBuckets = buckets.map((bucket) => bucketRequest(syncConfigContent, bucket, 0n));
     const checksums = await this.storage!.getChecksums(checkpoint, versionedBuckets);
 
     const unversioned: utils.ChecksumMap = new Map();
@@ -247,25 +318,42 @@ export async function getClientCheckpoint(
   client: mongo.MongoClient,
   db: mongo.Db,
   storageFactory: BucketStorageFactory,
-  options?: { timeout?: number }
-): Promise<InternalOpId> {
+  options?: { timeout?: number; documentDbMode?: boolean; storage?: SyncRulesBucketStorage }
+): Promise<ReplicationCheckpoint> {
   const start = Date.now();
-  const lsn = await createCheckpoint(client, db, STANDALONE_CHECKPOINT_ID);
+  const documentDbMode = options?.documentDbMode ?? (await detectDocumentDb(db));
+
+  const lsn = documentDbMode
+    ? await createSentinelCheckpointLsn(client, db)
+    : await createCheckpoint(db, STANDALONE_CHECKPOINT_ID);
   // This old API needs a persisted checkpoint id.
   // Since we don't use LSNs anymore, the only way to get that is to wait.
 
   const timeout = options?.timeout ?? 50_000;
+  // DocumentDB: the streaming loop skips standalone checkpoint events while a
+  // batch barrier is pending (see ChangeStream.ts), so a single sentinel bump
+  // can be missed on an idle stream with no later event to advance the
+  // checkpoint. Periodically re-bump the sentinel so a standalone event
+  // eventually commits past `lsn`, mirroring getSnapshotLsn's retry loop.
+  const NUDGE_INTERVAL_MS = 1000;
+  let lastNudge = Date.now();
   let lastCp: ReplicationCheckpoint | null = null;
 
   while (Date.now() - start < timeout) {
-    const storage = await storageFactory.getActiveStorage();
+    const storage = (await storageFactory.getActiveSyncConfig())?.storage;
     const cp = await storage?.getCheckpoint();
     if (cp != null) {
       lastCp = cp;
       if (cp.lsn && cp.lsn >= lsn) {
-        return cp.checkpoint;
+        return cp;
       }
     }
+
+    if (documentDbMode && Date.now() - lastNudge >= NUDGE_INTERVAL_MS) {
+      await createSentinelCheckpointLsn(client, db);
+      lastNudge = Date.now();
+    }
+
     await new Promise((resolve) => setTimeout(resolve, 30));
   }
 

package/test/src/checkpoint_retry.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test } from 'vitest';
+
+import { mongo } from '@powersync/lib-service-mongodb';
+
+import { MongoLSN } from '@module/common/MongoLSN.js';
+import { createCheckpoint } from '@module/replication/MongoRelation.js';
+import { DATABASE_TYPE, DatabaseType } from './DatabaseType.js';
+import { clearTestDb, connectMongoData, requireFailCommand } from './util.js';
+
+// This suite uses configureFailPoint to force retry timing. Azure DocumentDB
+// does not support configureFailPoint.
+describe.skipIf(DATABASE_TYPE == DatabaseType.DOCUMENTDB)('checkpoint retryable writes', () => {
+  test('returns the persisted checkpoint clusterTime after a retryable write', { repeats: 1 }, async (ctx) => {
+    // This test relies on very specific timing:
+    //
+    // 1. _powersync_checkpoints findAndModify command starts and is sent to the server
+    // 2. command is written to the server
+    // 3. _powersync_checkpoints findAndModify command fails with a retryable error (e.g. connection timeout)
+    // 4. command is retried
+    // 5. another write lands on the server, increasing the server's operationTime
+    // 6. command succeeds with a new operationTime, but without actually writing again (server de-duplicates based on transaction id)
+    //
+    // It is quite difficult to simulate this, even with failCommand. We currently rely on triggering a socket timeout for the first command,
+    // with another write happening right after that.
+
+    const TIMEOUT = 200;
+    const INSERT_COUNT = 5;
+
+    const { db, client } = await connectMongoData({
+      monitorCommands: true,
+      socketTimeoutMS: TIMEOUT,
+      maxPoolSize: 1
+    });
+
+    await using _client = { [Symbol.asyncDispose]: async () => await client.close() };
+    await client.connect();
+    await using failCommand = await requireFailCommand(client, ctx);
+
+    await clearTestDb(db);
+
+    const checkpointId = new mongo.ObjectId();
+    const advanceClusterTime = db.collection('_advance_cluster_time');
+
+    const changeStream = db.watch([], { maxAwaitTimeMS: TIMEOUT * 0.8 });
+    await using _changeStream = { [Symbol.asyncDispose]: async () => await changeStream.close() };
+
+    const checkpointEventPromise = waitForCheckpointEvent(changeStream, checkpointId, INSERT_COUNT).catch((e) =>
+      console.error(e)
+    );
+
+    const commandsStarted: mongo.CommandStartedEvent[] = [];
+
+    client.on('commandStarted', (event) => {
+      commandsStarted.push(event);
+    });
+
+    const DEBUG_COMMANDS = false;
+    if (DEBUG_COMMANDS) {
+      // For debugging: Log all commands
+      client.on('commandStarted', (event) => {
+        console.log('commandStarted:', event);
+      });
+
+      client.on('commandSucceeded', (event) => {
+        console.log('commandSucceeded:', event);
+      });
+
+      client.on('commandFailed', (event) => {
+        console.log('commandFailed:', event);
+      });
+    }
+
+    await failCommand.configure({
+      mode: { times: 1 },
+      data: {
+        failCommands: ['commitTransaction', 'findAndModify'],
+        blockConnection: true,
+        blockTimeMS: TIMEOUT
+      }
+    });
+    const returnedLsnPromise = createCheckpoint(db, checkpointId);
+
+    for (let i = 0; i < INSERT_COUNT; i++) {
+      await advanceClusterTime.insertOne({ at: new Date() });
+    }
+
+    const returnedLsn = await returnedLsnPromise;
+    const checkpointEvent = await checkpointEventPromise;
+    if (checkpointEvent == null) {
+      throw new Error('change stream failed');
+    }
+
+    const eventLsn = new MongoLSN({
+      timestamp: checkpointEvent.clusterTime!,
+      resume_token: checkpointEvent._id
+    }).comparable;
+
+    if (DEBUG_COMMANDS) {
+      const commands = commandsStarted
+        .filter((c) => ['findAndModify', 'insert'].includes(c.commandName))
+        .map((c) => c.commandName);
+      // In the failure case, we had findAndModify, insert, findAndModify, potentially with more inserts in between.
+      // With updated behavior, we only have a single findAndModify.
+      console.log('Command order:', commands);
+    }
+
+    expect(eventLsn >= returnedLsn).toBe(true);
+    expect(checkpointEvent.clusterTime).toEqual(MongoLSN.fromSerialized(returnedLsn).timestamp);
+  });
+});
+
+async function waitForCheckpointEvent(
+  changeStream: mongo.ChangeStream,
+  checkpointId: mongo.ObjectId,
+  insertCount: number
+): Promise<mongo.ChangeStreamDocument | null> {
+  let lastEvent: mongo.ChangeStreamDocument | null = null;
+  let seenInserts = 0;
+  for await (const event of changeStream) {
+    if (
+      (event.operationType == 'insert' || event.operationType == 'update' || event.operationType == 'replace') &&
+      checkpointId.equals(event.documentKey._id)
+    ) {
+      lastEvent = event;
+    } else if (event.operationType == 'insert' && event.ns.coll === '_advance_cluster_time') {
+      seenInserts++;
+      if (seenInserts >= insertCount) {
+        // We finish when we hit the expected number of inserts, since the number of checkpoint events are unknown.
+        break;
+      }
+    }
+  }
+  return lastEvent;
+}

package/test/src/config.test.ts

@@ -0,0 +1,34 @@
+import { normalizeConnectionConfig } from '@module/types/types.js';
+import { describe, expect, test } from 'vitest';
+
+const BASE_CONFIG = {
+  type: 'mongodb' as const,
+  uri: 'mongodb://localhost:27017/powersync_test'
+};
+
+describe('MongoDB connection config', () => {
+  test('defaults heartbeat_interval_seconds to 60 seconds', () => {
+    expect(normalizeConnectionConfig(BASE_CONFIG).heartbeat_interval_seconds).toBe(60);
+  });
+
+  test('defaults a null heartbeat_interval_seconds to 60 seconds', () => {
+    expect(
+      normalizeConnectionConfig({ ...BASE_CONFIG, heartbeat_interval_seconds: null }).heartbeat_interval_seconds
+    ).toBe(60);
+  });
+
+  test('allows the MongoDB maximum heartbeat interval', () => {
+    expect(
+      normalizeConnectionConfig({ ...BASE_CONFIG, heartbeat_interval_seconds: 60 }).heartbeat_interval_seconds
+    ).toBe(60);
+  });
+
+  test.each([0, 4, 61, Number.NaN, Number.POSITIVE_INFINITY])(
+    'rejects invalid heartbeat_interval_seconds: %s',
+    (heartbeat_interval_seconds) => {
+      expect(() => normalizeConnectionConfig({ ...BASE_CONFIG, heartbeat_interval_seconds })).toThrow(
+        'heartbeat_interval_seconds'
+      );
+    }
+  );
+});

package/test/src/documentdb_helpers.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, test } from 'vitest';
+
+import { SentinelLSN } from '@module/common/SentinelLSN.js';
+import { getEventTimestamp } from '@module/replication/checkpoints/CheckpointImplementation.js';
+import { createSentinelCheckpointLsn, SENTINEL_CHECKPOINT_ID } from '@module/replication/MongoRelation.js';
+import { CHECKPOINTS_COLLECTION } from '@module/replication/replication-utils.js';
+import { mongo } from '@powersync/lib-service-mongodb';
+import { connectMongoData } from './util.js';
+
+describe('DocumentDB helpers', () => {
+  describe('getEventTimestamp', () => {
+    // getEventTimestamp is used by the timestamp checkpoint implementation (standard
+    // MongoDB): it prefers clusterTime and falls back to second-precision wallTime.
+    // The DocumentDB sentinel implementation does not use it — DocumentDB LSNs are
+    // sentinel-counter based, not timestamp based.
+
+    test('returns clusterTime when present', () => {
+      const clusterTime = mongo.Timestamp.fromBits(1, 1700000000);
+      const event = { clusterTime, wallTime: new Date('2024-01-01T00:00:00Z') } as any;
+      expect(getEventTimestamp(event)).toEqual(clusterTime);
+    });
+
+    test('falls back to second-precision wallTime when clusterTime is absent', () => {
+      const wallTime = new Date('2024-06-15T12:00:00.789Z');
+      const result = getEventTimestamp({ wallTime } as any);
+      expect(result.getHighBitsUnsigned()).toEqual(Math.floor(wallTime.getTime() / 1000));
+      // Increment is always 0 — wallTime only has second resolution in this conversion.
+      expect(result.getLowBitsUnsigned()).toEqual(0);
+    });
+
+    test('throws when neither clusterTime nor wallTime is present', () => {
+      expect(() => getEventTimestamp({} as any)).toThrow();
+    });
+  });
+
+  describe('DocumentDB detection', () => {
+    // Detection logic: hello.internal?.documentdb_versions != null
+    const isDocumentDb = (hello: any) => hello.internal?.documentdb_versions != null;
+
+    test('hello with documentdb_versions — detected as DocumentDB', () => {
+      const hello = {
+        isWritablePrimary: true,
+        msg: 'isdbgrid',
+        internal: {
+          documentdb_versions: ['1.111-0', '1.112.0', '12.1-1']
+        }
+      };
+      expect(isDocumentDb(hello)).toBe(true);
+    });
+
+    test('standard hello response — not DocumentDB', () => {
+      const hello = {
+        isWritablePrimary: true,
+        setName: 'rs0',
+        hosts: ['localhost:27017']
+      };
+      expect(isDocumentDb(hello)).toBe(false);
+    });
+  });
+
+  describe('sentinel checkpoint format', () => {
+    test('sentinel counter is seeded at a timestamp value on creation', { timeout: 30_000 }, async () => {
+      // If a consumer deletes the sentinel checkpoint document in their
+      // source database, the re-created counter must not restart below
+      // already-committed LSNs. createSentinelCheckpointLsn seeds new counters at
+      // the current epoch seconds shifted into the high 32 bits (resembling a
+      // MongoDB timestamp), so the coordinate jumps forward instead of resetting.
+      const { client, db: sharedDb } = await connectMongoData();
+      // Use an isolated database: other test files run in parallel against the
+      // shared test database and both bump and clear the sentinel checkpoint
+      // document, which would make these exact assertions racy.
+      const db = client.db(`${sharedDb.databaseName}_seed_test`);
+      const seed = (epochMs: number) => (BigInt(Math.floor(epochMs / 1000)) << 32n) + 1n;
+      try {
+        const before = Date.now();
+        const first = SentinelLSN.fromSerialized(await createSentinelCheckpointLsn(client, db));
+        const after = Date.now();
+
+        // Seeded at (epoch_seconds << 32) + 1, not at 1.
+        expect(first.sentinel).toBeGreaterThanOrEqual(seed(before));
+        expect(first.sentinel).toBeLessThanOrEqual(seed(after));
+
+        // Subsequent calls increment normally.
+        const second = SentinelLSN.fromSerialized(await createSentinelCheckpointLsn(client, db));
+        expect(second.sentinel).toEqual(first.sentinel + 1n);
+
+        // Simulate a consumer deleting the document after the counter has
+        // accumulated increments: the re-created counter resumes ahead. The seed
+        // has second granularity, and in production the document lives from
+        // initial sync onward, so re-creation always lands in a later second;
+        // wait for the clock to advance to reproduce that here.
+        await new Promise((resolve) => setTimeout(resolve, 1_100));
+        await db.collection(CHECKPOINTS_COLLECTION).deleteOne({ _id: SENTINEL_CHECKPOINT_ID as any });
+        const recreated = SentinelLSN.fromSerialized(await createSentinelCheckpointLsn(client, db));
+        expect(recreated.sentinel).toBeGreaterThan(second.sentinel);
+      } finally {
+        await db.dropDatabase().catch(() => {});
+        await client.close();
+      }
+    });
+
+    test('createSentinelCheckpointLsn stamps stream_id on the sentinel document', async () => {
+      // A batch barrier passes the stream's checkpointStreamId, which is stamped
+      // on the shared sentinel document so the stream can recognise its own
+      // barriers (and ignore other streams') by content.
+      const { client, db } = await connectMongoData();
+      try {
+        const barrierId = new mongo.ObjectId();
+        await createSentinelCheckpointLsn(client, db, barrierId);
+
+        const doc = await db.collection(CHECKPOINTS_COLLECTION).findOne({ _id: SENTINEL_CHECKPOINT_ID as any });
+        expect(barrierId.equals(doc!.stream_id)).true;
+      } finally {
+        await client.close();
+      }
+    });
+  });
+
+  // Note: the DocumentDB keepalive does not build an LSN from Date.now() — it bumps
+  // the shared sentinel via createSentinelCheckpointLsn and commits when the bump's
+  // own event is observed. The only Date.now()-derived value is the sentinel
+  // counter seed, which is covered by the 'sentinel counter is seeded at a
+  // timestamp value on creation' test above.
+});