@powersync/service-module-mongodb 0.0.0-dev-20260225093637 → 0.0.0-dev-20260313100403

package/test/src/change_stream_utils.ts

@@ -8,13 +8,14 @@ import {
   OplogEntry,
   ProtocolOpId,
   ReplicationCheckpoint,
+  storage,
   STORAGE_VERSION_CONFIG,
   SyncRulesBucketStorage,
   TestStorageOptions,
   updateSyncRulesFromYaml,
   utils
 } from '@powersync/service-core';
-import { METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
+import { bucketRequest, METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
 
 import { ChangeStream, ChangeStreamOptions } from '@module/replication/ChangeStream.js';
 import { MongoManager } from '@module/replication/MongoManager.js';
@@ -26,8 +27,9 @@ import { clearTestDb, TEST_CONNECTION_OPTIONS } from './util.js';
 export class ChangeStreamTestContext {
   private _walStream?: ChangeStream;
   private abortController = new AbortController();
-  private streamPromise?: Promise<void>;
+  private streamPromise?: Promise<PromiseSettledResult<void>>;
   private syncRulesId?: number;
+  private syncRulesContent?: storage.PersistedSyncRulesContent;
   public storage?: SyncRulesBucketStorage;
 
   /**
@@ -104,6 +106,7 @@ export class ChangeStreamTestContext {
       updateSyncRulesFromYaml(content, { validate: true, storageVersion: this.storageVersion })
     );
     this.syncRulesId = syncRules.id;
+    this.syncRulesContent = syncRules;
     this.storage = this.factory.getInstance(syncRules);
     return this.storage!;
   }
@@ -115,11 +118,19 @@ export class ChangeStreamTestContext {
     }
 
     this.syncRulesId = syncRules.id;
+    this.syncRulesContent = syncRules;
     this.storage = this.factory.getInstance(syncRules);
     return this.storage!;
   }
 
-  get walStream() {
+  private getSyncRulesContent(): storage.PersistedSyncRulesContent {
+    if (this.syncRulesContent == null) {
+      throw new Error('Sync rules not configured - call updateSyncRules() first');
+    }
+    return this.syncRulesContent;
+  }
+
+  get streamer() {
     if (this.storage == null) {
       throw new Error('updateSyncRules() first');
     }
@@ -141,7 +152,7 @@ export class ChangeStreamTestContext {
   }
 
   async replicateSnapshot() {
-    await this.walStream.initReplication();
+    await this.streamer.initReplication();
   }
 
   /**
@@ -153,19 +164,27 @@ export class ChangeStreamTestContext {
   async markSnapshotConsistent() {
     const checkpoint = await createCheckpoint(this.client, this.db, STANDALONE_CHECKPOINT_ID);
 
-    await this.storage!.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.keepalive(checkpoint);
-    });
+    await using writer = await this.storage!.createWriter(test_utils.BATCH_OPTIONS);
+    await writer.keepalive(checkpoint);
+    await writer.flush();
   }
 
   startStreaming() {
-    return (this.streamPromise = this.walStream.streamChanges());
+    this.streamPromise = this.streamer
+      .streamChanges()
+      .then(() => ({ status: 'fulfilled', value: undefined }) satisfies PromiseFulfilledResult<void>)
+      .catch((reason) => ({ status: 'rejected', reason }) satisfies PromiseRejectedResult);
+    return this.streamPromise;
   }
 
   async getCheckpoint(options?: { timeout?: number }) {
     let checkpoint = await Promise.race([
       getClientCheckpoint(this.client, this.db, this.factory, { timeout: options?.timeout ?? 15_000 }),
-      this.streamPromise
+      this.streamPromise?.then((e) => {
+        if (e.status == 'rejected') {
+          throw e.reason;
+        }
+      })
     ]);
     if (checkpoint == null) {
       // This indicates an issue with the test setup - streamingPromise completed instead
@@ -175,21 +194,10 @@ export class ChangeStreamTestContext {
     return checkpoint;
   }
 
-  private resolveBucketName(bucket: string) {
-    if (!this.versionedBuckets || /^\d+#/.test(bucket)) {
-      return bucket;
-    }
-    if (this.syncRulesId == null) {
-      throw new Error('Sync rules not configured - call updateSyncRules() first');
-    }
-    return `${this.syncRulesId}#${bucket}`;
-  }
-
   async getBucketsDataBatch(buckets: Record<string, InternalOpId>, options?: { timeout?: number }) {
     let checkpoint = await this.getCheckpoint(options);
-    const map = new Map<string, InternalOpId>(
-      Object.entries(buckets).map(([bucket, opId]) => [this.resolveBucketName(bucket), opId])
-    );
+    const syncRules = this.getSyncRulesContent();
+    const map = Object.entries(buckets).map(([bucket, start]) => bucketRequest(syncRules, bucket, start));
     return test_utils.fromAsync(this.storage!.getBucketDataBatch(checkpoint, map));
   }
 
@@ -198,9 +206,9 @@ export class ChangeStreamTestContext {
     if (typeof start == 'string') {
       start = BigInt(start);
     }
-    const resolvedBucket = this.resolveBucketName(bucket);
+    const syncRules = this.getSyncRulesContent();
     const checkpoint = await this.getCheckpoint(options);
-    const map = new Map<string, InternalOpId>([[resolvedBucket, start]]);
+    let map = [bucketRequest(syncRules, bucket, start)];
     let data: OplogEntry[] = [];
     while (true) {
       const batch = this.storage!.getBucketDataBatch(checkpoint, map);
@@ -210,19 +218,20 @@ export class ChangeStreamTestContext {
       if (batches.length == 0 || !batches[0]!.chunkData.has_more) {
         break;
       }
-      map.set(resolvedBucket, BigInt(batches[0]!.chunkData.next_after));
+      map = [bucketRequest(syncRules, bucket, BigInt(batches[0]!.chunkData.next_after))];
     }
     return data;
   }
 
   async getChecksums(buckets: string[], options?: { timeout?: number }): Promise<utils.ChecksumMap> {
     let checkpoint = await this.getCheckpoint(options);
-    const versionedBuckets = buckets.map((bucket) => this.resolveBucketName(bucket));
+    const syncRules = this.getSyncRulesContent();
+    const versionedBuckets = buckets.map((bucket) => bucketRequest(syncRules, bucket, 0n));
     const checksums = await this.storage!.getChecksums(checkpoint, versionedBuckets);
 
     const unversioned: utils.ChecksumMap = new Map();
     for (let i = 0; i < buckets.length; i++) {
-      unversioned.set(buckets[i], checksums.get(versionedBuckets[i])!);
+      unversioned.set(buckets[i], checksums.get(versionedBuckets[i].bucket)!);
     }
     return unversioned;
   }

package/test/src/env.ts

@@ -3,7 +3,7 @@ import { utils } from '@powersync/lib-services-framework';
 export const env = utils.collectEnvironmentVariables({
   MONGO_TEST_URL: utils.type.string.default('mongodb://localhost:27017/powersync_test'),
   MONGO_TEST_DATA_URL: utils.type.string.default('mongodb://localhost:27017/powersync_test_data'),
-  PG_STORAGE_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5431/powersync_storage_test'),
+  PG_STORAGE_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5432/powersync_storage_test'),
   CI: utils.type.boolean.default('false'),
   SLOW_TESTS: utils.type.boolean.default('false'),
   TEST_MONGO_STORAGE: utils.type.boolean.default('true'),

package/test/src/resume.test.ts

@@ -61,8 +61,9 @@ function defineResumeTest({ factory: factoryGenerator, storageVersion }: Storage
     context2.storage = factory.getInstance(activeContent!);
 
     // If this test times out, it likely didn't throw the expected error here.
-    const error = await context2.startStreaming().catch((ex) => ex);
+    const result = await context2.startStreaming();
     // The ChangeStreamReplicationJob will detect this and throw a ChangeStreamInvalidatedError
-    expect(error).toBeInstanceOf(ChangeStreamInvalidatedError);
+    expect(result.status).toEqual('rejected');
+    expect((result as PromiseRejectedResult).reason).toBeInstanceOf(ChangeStreamInvalidatedError);
   });
 }

package/test/src/util.ts

@@ -5,8 +5,8 @@ import * as postgres_storage from '@powersync/service-module-postgres-storage';
 import * as types from '@module/types/types.js';
 import {
   BSON_DESERIALIZE_DATA_OPTIONS,
-  CURRENT_STORAGE_VERSION,
-  LEGACY_STORAGE_VERSION,
+  SUPPORTED_STORAGE_VERSIONS,
+  TestStorageConfig,
   TestStorageFactory
 } from '@powersync/service-core';
 import { describe, TestOptions } from 'vitest';
@@ -24,11 +24,11 @@ export const INITIALIZED_MONGO_STORAGE_FACTORY = mongo_storage.test_utils.mongoT
   isCI: env.CI
 });
 
-export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestStorageFactoryGenerator({
+export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestSetup({
   url: env.PG_STORAGE_TEST_URL
 });
 
-const TEST_STORAGE_VERSIONS = [LEGACY_STORAGE_VERSION, CURRENT_STORAGE_VERSION];
+export const TEST_STORAGE_VERSIONS = SUPPORTED_STORAGE_VERSIONS;
 
 export interface StorageVersionTestContext {
   factory: TestStorageFactory;
@@ -36,12 +36,12 @@ export interface StorageVersionTestContext {
 }
 
 export function describeWithStorage(options: TestOptions, fn: (context: StorageVersionTestContext) => void) {
-  const describeFactory = (storageName: string, factory: TestStorageFactory) => {
+  const describeFactory = (storageName: string, config: TestStorageConfig) => {
     describe(`${storageName} storage`, options, function () {
       for (const storageVersion of TEST_STORAGE_VERSIONS) {
         describe(`storage v${storageVersion}`, function () {
           fn({
-            factory,
+            factory: config.factory,
             storageVersion
           });
         });