@powersync/service-core-tests 0.10.3 → 0.11.0

package/dist/tests/register-data-storage-tests.js

@@ -79,16 +79,18 @@ export function registerDataStorageTests(generateStorageFactory) {
     test('save and load parameters', async () => {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_1, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
-    data: [] 
-    `);
-            const factory = __addDisposableResource(env_1, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    data: []
+    `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: TEST_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -111,10 +113,10 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('t1')
                 });
+                await batch.commit('1/1');
             });
-            const parameters = await bucketStorage.getParameterSets(result.flushed_op, [
-                ParameterLookup.normalized('mybucket', '1', ['user1'])
-            ]);
+            const checkpoint = await bucketStorage.getCheckpoint();
+            const parameters = await checkpoint.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
             expect(parameters).toEqual([
                 {
                     group_id: 'group1a'
@@ -134,16 +136,18 @@ bucket_definitions:
     test('it should use the latest version', async () => {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_2, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id = token_parameters.user_id
-    data: [] 
-    `);
-            const factory = __addDisposableResource(env_2, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    data: []
+    `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: TEST_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -153,8 +157,10 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('user1')
                 });
+                await batch.commit('1/1');
             });
-            const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+            const checkpoint1 = await bucketStorage.getCheckpoint();
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: TEST_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -164,19 +170,17 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('user1')
                 });
+                await batch.commit('1/2');
             });
-            const parameters = await bucketStorage.getParameterSets(result2.flushed_op, [
-                ParameterLookup.normalized('mybucket', '1', ['user1'])
-            ]);
+            const checkpoint2 = await bucketStorage.getCheckpoint();
+            const parameters = await checkpoint2.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
             expect(parameters).toEqual([
                 {
                     group_id: 'group2'
                 }
             ]);
             // Use the checkpoint to get older data if relevant
-            const parameters2 = await bucketStorage.getParameterSets(result1.flushed_op, [
-                ParameterLookup.normalized('mybucket', '1', ['user1'])
-            ]);
+            const parameters2 = await checkpoint1.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
             expect(parameters2).toEqual([
                 {
                     group_id: 'group1'
@@ -196,17 +200,19 @@ bucket_definitions:
     test('it should use the latest version after updates', async () => {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_3, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT id AS todo_id
         FROM todos
         WHERE list_id IN token_parameters.list_id
-    data: [] 
-    `);
-            const factory = __addDisposableResource(env_3, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+    data: []
+    `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             const table = test_utils.makeTestTable('todos', ['id', 'list_id']);
             await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 // Create two todos which initially belong to different lists
@@ -228,8 +234,9 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('todo2')
                 });
+                await batch.commit('1/1');
             });
-            const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 // Update the second todo item to now belong to list 1
                 await batch.save({
                     sourceTable: table,
@@ -240,11 +247,13 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('todo2')
                 });
+                await batch.commit('1/1');
             });
             // We specifically request the todo_ids for both lists.
             // There removal operation for the association of `list2`::`todo2` should not interfere with the new
             // association of `list1`::`todo2`
-            const parameters = await bucketStorage.getParameterSets(result2.flushed_op, [
+            const checkpoint = await bucketStorage.getCheckpoint();
+            const parameters = await checkpoint.getParameterSets([
                 ParameterLookup.normalized('mybucket', '1', ['list1']),
                 ParameterLookup.normalized('mybucket', '1', ['list2'])
             ]);
@@ -270,16 +279,18 @@ bucket_definitions:
     test('save and load parameters with different number types', async () => {
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_4, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1 and f2 = token_parameters.f2 and f3 = token_parameters.f3
     data: []
-    `);
-            const factory = __addDisposableResource(env_4, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: TEST_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -292,18 +303,19 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('t1')
                 });
+                await batch.commit('1/1');
             });
             const TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = result.flushed_op;
-            const parameters1 = await bucketStorage.getParameterSets(checkpoint, [
+            const checkpoint = await bucketStorage.getCheckpoint();
+            const parameters1 = await checkpoint.getParameterSets([
                 ParameterLookup.normalized('mybucket', '1', [314n, 314, 3.14])
             ]);
             expect(parameters1).toEqual([TEST_PARAMS]);
-            const parameters2 = await bucketStorage.getParameterSets(checkpoint, [
+            const parameters2 = await checkpoint.getParameterSets([
                 ParameterLookup.normalized('mybucket', '1', [314, 314n, 3.14])
             ]);
             expect(parameters2).toEqual([TEST_PARAMS]);
-            const parameters3 = await bucketStorage.getParameterSets(checkpoint, [
+            const parameters3 = await checkpoint.getParameterSets([
                 ParameterLookup.normalized('mybucket', '1', [314n, 314, 3])
             ]);
             expect(parameters3).toEqual([]);
@@ -324,16 +336,18 @@ bucket_definitions:
             // This ensures serialization / deserialization of "current_data" is done correctly.
             // This specific case tested here cannot happen with postgres in practice, but we still
             // test this to ensure correct deserialization.
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_5, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1
     data: []
-    `);
-            const factory = __addDisposableResource(env_5, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: TEST_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -356,10 +370,11 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('t1')
                 });
+                await batch.commit('1/1');
             });
             const TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = result.flushed_op;
-            const parameters1 = await bucketStorage.getParameterSets(checkpoint, [
+            const checkpoint = await bucketStorage.getCheckpoint();
+            const parameters1 = await checkpoint.getParameterSets([
                 ParameterLookup.normalized('mybucket', '1', [1152921504606846976n])
             ]);
             expect(parameters1).toEqual([TEST_PARAMS]);
@@ -377,15 +392,17 @@ bucket_definitions:
     test('removing row', async () => {
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_6, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
-`);
-            const factory = __addDisposableResource(env_6, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 await batch.save({
                     sourceTable,
@@ -401,8 +418,9 @@ bucket_definitions:
                     tag: storage.SaveOperationTag.DELETE,
                     beforeReplicaId: test_utils.rid('test1')
                 });
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const { checkpoint } = await bucketStorage.getCheckpoint();
             const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', 0n]])));
             const data = batch[0].chunkData.data.map((d) => {
                 return {
@@ -440,18 +458,20 @@ bucket_definitions:
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
             const WORKSPACE_TABLE = test_utils.makeTestTable('workspace', ['id']);
-            const sync_rules_content = test_utils.testRules(`
+            const factory = __addDisposableResource(env_7, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
     by_workspace:
       parameters:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace."userId" = token_parameters.user_id
       data: []
-    `);
-            const sync_rules = sync_rules_content.parsed(test_utils.PARSE_OPTIONS).sync_rules;
-            const factory = __addDisposableResource(env_7, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules_content);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    `
+            });
+            const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).sync_rules;
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: WORKSPACE_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -461,17 +481,18 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('workspace1')
                 });
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = new RequestParameters({ sub: 'u1' }, {});
             const q1 = sync_rules.bucketDescriptors[0].parameterQueries[0];
             const lookups = q1.getLookups(parameters);
             expect(lookups).toEqual([ParameterLookup.normalized('by_workspace', '1', ['u1'])]);
-            const parameter_sets = await bucketStorage.getParameterSets(checkpoint, lookups);
+            const parameter_sets = await checkpoint.getParameterSets(lookups);
             expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
             const buckets = await sync_rules.getBucketParameterQuerier(parameters).queryDynamicBucketDescriptions({
                 getParameterSets(lookups) {
-                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                    return checkpoint.getParameterSets(lookups);
                 }
             });
             expect(buckets).toEqual([{ bucket: 'by_workspace["workspace1"]', priority: 3 }]);
@@ -490,18 +511,20 @@ bucket_definitions:
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
-            const sync_rules_content = test_utils.testRules(`
+            const factory = __addDisposableResource(env_8, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
     by_public_workspace:
       parameters:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace.visibility = 'public'
       data: []
-    `);
-            const sync_rules = sync_rules_content.parsed(test_utils.PARSE_OPTIONS).sync_rules;
-            const factory = __addDisposableResource(env_8, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules_content);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    `
+            });
+            const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).sync_rules;
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: WORKSPACE_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -529,18 +552,19 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('workspace3')
                 });
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = new RequestParameters({ sub: 'unknown' }, {});
             const q1 = sync_rules.bucketDescriptors[0].parameterQueries[0];
             const lookups = q1.getLookups(parameters);
             expect(lookups).toEqual([ParameterLookup.normalized('by_public_workspace', '1', [])]);
-            const parameter_sets = await bucketStorage.getParameterSets(checkpoint, lookups);
+            const parameter_sets = await checkpoint.getParameterSets(lookups);
             parameter_sets.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
             expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
             const buckets = await sync_rules.getBucketParameterQuerier(parameters).queryDynamicBucketDescriptions({
                 getParameterSets(lookups) {
-                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                    return checkpoint.getParameterSets(lookups);
                 }
             });
             buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
@@ -563,7 +587,9 @@ bucket_definitions:
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
             const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
-            const sync_rules_content = test_utils.testRules(`
+            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
     by_workspace:
       parameters:
@@ -572,11 +598,11 @@ bucket_definitions:
         - SELECT id as workspace_id FROM workspace WHERE
             workspace.user_id = token_parameters.user_id
       data: []
-    `);
-            const sync_rules = sync_rules_content.parsed(test_utils.PARSE_OPTIONS).sync_rules;
-            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules_content);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+    `
+            });
+            const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).sync_rules;
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: WORKSPACE_TABLE,
                     tag: storage.SaveOperationTag.INSERT,
@@ -615,26 +641,27 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('workspace4')
                 });
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = new RequestParameters({ sub: 'u1' }, {});
             // Test intermediate values - could be moved to sync_rules.test.ts
             const q1 = sync_rules.bucketDescriptors[0].parameterQueries[0];
             const lookups1 = q1.getLookups(parameters);
             expect(lookups1).toEqual([ParameterLookup.normalized('by_workspace', '1', [])]);
-            const parameter_sets1 = await bucketStorage.getParameterSets(checkpoint, lookups1);
+            const parameter_sets1 = await checkpoint.getParameterSets(lookups1);
             parameter_sets1.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
             expect(parameter_sets1).toEqual([{ workspace_id: 'workspace1' }]);
             const q2 = sync_rules.bucketDescriptors[0].parameterQueries[1];
             const lookups2 = q2.getLookups(parameters);
             expect(lookups2).toEqual([ParameterLookup.normalized('by_workspace', '2', ['u1'])]);
-            const parameter_sets2 = await bucketStorage.getParameterSets(checkpoint, lookups2);
+            const parameter_sets2 = await checkpoint.getParameterSets(lookups2);
             parameter_sets2.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
             expect(parameter_sets2).toEqual([{ workspace_id: 'workspace3' }]);
             // Test final values - the important part
             const buckets = (await sync_rules.getBucketParameterQuerier(parameters).queryDynamicBucketDescriptions({
                 getParameterSets(lookups) {
-                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                    return checkpoint.getParameterSets(lookups);
                 }
             })).map((e) => e.bucket);
             buckets.sort();
@@ -653,16 +680,18 @@ bucket_definitions:
     test('changing client ids', async () => {
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_10, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT client_id as id, description FROM "%"
-`);
-            const factory = __addDisposableResource(env_10, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             const sourceTable = TEST_TABLE;
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable,
                     tag: storage.SaveOperationTag.INSERT,
@@ -693,8 +722,9 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('test2')
                 });
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const { checkpoint } = await bucketStorage.getCheckpoint();
             const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', 0n]])));
             const data = batch[0].chunkData.data.map((d) => {
                 return {
@@ -722,14 +752,16 @@ bucket_definitions:
     test('re-apply delete', async () => {
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_11, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
-`);
-            const factory = __addDisposableResource(env_11, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 await batch.save({
@@ -749,8 +781,9 @@ bucket_definitions:
                     tag: storage.SaveOperationTag.DELETE,
                     beforeReplicaId: test_utils.rid('test1')
                 });
+                await batch.commit('1/1');
             });
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 await batch.save({
                     sourceTable,
@@ -758,7 +791,7 @@ bucket_definitions:
                     beforeReplicaId: test_utils.rid('test1')
                 });
             });
-            const checkpoint = result.flushed_op;
+            const { checkpoint } = await bucketStorage.getCheckpoint();
             const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', 0n]])));
             const data = batch[0].chunkData.data.map((d) => {
                 return {
@@ -795,14 +828,16 @@ bucket_definitions:
     test('re-apply update + delete', async () => {
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_12, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
-`);
-            const factory = __addDisposableResource(env_12, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 await batch.save({
@@ -840,8 +875,9 @@ bucket_definitions:
                     tag: storage.SaveOperationTag.DELETE,
                     beforeReplicaId: test_utils.rid('test1')
                 });
+                await batch.commit('1/1');
             });
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 await batch.save({
                     sourceTable,
@@ -866,8 +902,9 @@ bucket_definitions:
                     tag: storage.SaveOperationTag.DELETE,
                     beforeReplicaId: test_utils.rid('test1')
                 });
+                await batch.commit('2/1');
             });
-            const checkpoint = result.flushed_op;
+            const { checkpoint } = await bucketStorage.getCheckpoint();
             const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', 0n]])));
             const data = batch[0].chunkData.data.map((d) => {
                 return {
@@ -906,15 +943,17 @@ bucket_definitions:
     test('truncate parameters', async () => {
         const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_13, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
-    `);
-            const factory = __addDisposableResource(env_13, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+    `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 await batch.save({
                     sourceTable: TEST_TABLE,
@@ -929,10 +968,8 @@ bucket_definitions:
                 });
                 await batch.truncate([TEST_TABLE]);
             });
-            const { checkpoint } = await bucketStorage.getCheckpoint();
-            const parameters = await bucketStorage.getParameterSets(checkpoint, [
-                ParameterLookup.normalized('mybucket', '1', ['user1'])
-            ]);
+            const checkpoint = await bucketStorage.getCheckpoint();
+            const parameters = await checkpoint.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
             expect(parameters).toEqual([]);
         }
         catch (e_13) {
@@ -955,14 +992,16 @@ bucket_definitions:
             // It can break at two places:
             // 1. Not getting the correct "current_data" state for each operation.
             // 2. Output order not being correct.
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_14, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "test"
-`);
-            const factory = __addDisposableResource(env_14, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             // Pre-setup
             const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
@@ -1097,12 +1136,6 @@ bucket_definitions:
     test('changed data with replica identity full', async () => {
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
-bucket_definitions:
-  global:
-    data:
-      - SELECT id, description FROM "test"
-`);
             function rid2(id, description) {
                 return getUuidReplicaIdentityBson({ id, description }, [
                     { name: 'id', type: 'VARCHAR', typeId: 25 },
@@ -1110,7 +1143,15 @@ bucket_definitions:
                 ]);
             }
             const factory = __addDisposableResource(env_15, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+            const syncRules = await factory.updateSyncRules({
+                content: `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test"
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             const sourceTable = test_utils.makeTestTable('test', ['id', 'description']);
             // Pre-setup
             const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
@@ -1203,12 +1244,6 @@ bucket_definitions:
     test('unchanged data with replica identity full', async () => {
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules = test_utils.testRules(`
-bucket_definitions:
-  global:
-    data:
-      - SELECT id, description FROM "test"
-`);
             function rid2(id, description) {
                 return getUuidReplicaIdentityBson({ id, description }, [
                     { name: 'id', type: 'VARCHAR', typeId: 25 },
@@ -1216,7 +1251,15 @@ bucket_definitions:
                 ]);
             }
             const factory = __addDisposableResource(env_16, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+            const syncRules = await factory.updateSyncRules({
+                content: `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test"
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             const sourceTable = test_utils.makeTestTable('test', ['id', 'description']);
             // Pre-setup
             const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
@@ -1306,15 +1349,17 @@ bucket_definitions:
             // but large enough in size to be split over multiple returned batches.
             // The specific batch splits is an implementation detail of the storage driver,
             // and the test will have to updated when other implementations are added.
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_17, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
-`);
-            const factory = __addDisposableResource(env_17, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 const largeDescription = '0123456789'.repeat(12_000_00);
                 await batch.save({
@@ -1354,8 +1399,9 @@ bucket_definitions:
                     },
                     afterReplicaId: test_utils.rid('test3')
                 });
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const { checkpoint } = await bucketStorage.getCheckpoint();
             const options = {
                 chunkLimitBytes: 16 * 1024 * 1024
             };
@@ -1397,15 +1443,17 @@ bucket_definitions:
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
             // Test syncing a batch of data that is limited by count.
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_18, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
 bucket_definitions:
   global:
     data:
       - SELECT id, description FROM "%"
-`);
-            const factory = __addDisposableResource(env_18, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
-            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                 const sourceTable = TEST_TABLE;
                 for (let i = 1; i <= 6; i++) {
                     await batch.save({
@@ -1418,8 +1466,9 @@ bucket_definitions:
                         afterReplicaId: `test${i}`
                     });
                 }
+                await batch.commit('1/1');
             });
-            const checkpoint = result.flushed_op;
+            const { checkpoint } = await bucketStorage.getCheckpoint();
             const batch1 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', 0n]]), { limit: 4 }));
             expect(test_utils.getBatchData(batch1)).toEqual([
                 { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
@@ -1464,7 +1513,9 @@ bucket_definitions:
         const setup = async (options) => {
             const env_19 = { stack: [], error: void 0, hasError: false };
             try {
-                const sync_rules = test_utils.testRules(`
+                const factory = __addDisposableResource(env_19, await generateStorageFactory(), true);
+                const syncRules = await factory.updateSyncRules({
+                    content: `
   bucket_definitions:
     global1:
       data:
@@ -1472,10 +1523,10 @@ bucket_definitions:
     global2:
       data:
         - SELECT id, description FROM test WHERE bucket = 'global2'
-  `);
-                const factory = __addDisposableResource(env_19, await generateStorageFactory(), true);
-                const bucketStorage = factory.getInstance(sync_rules);
-                const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+  `
+                });
+                const bucketStorage = factory.getInstance(syncRules);
+                await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
                     const sourceTable = TEST_TABLE;
                     for (let i = 1; i <= 10; i++) {
                         await batch.save({
@@ -1489,8 +1540,9 @@ bucket_definitions:
                             afterReplicaId: `test${i}`
                         });
                     }
+                    await batch.commit('1/1');
                 });
-                const checkpoint = result.flushed_op;
+                const { checkpoint } = await bucketStorage.getCheckpoint();
                 return await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([
                     ['global1[]', 0n],
                     ['global2[]', 0n]
@@ -1606,7 +1658,9 @@ bucket_definitions:
             });
             const r = await f.configureSyncRules({ content: 'bucket_definitions: {}', validate: false });
             const storage = f.getInstance(r.persisted_sync_rules);
-            await storage.autoActivate();
+            await storage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                await batch.keepalive('1/0');
+            });
             const metrics2 = await f.getStorageMetrics();
             expect(metrics2).toMatchSnapshot();
         }
@@ -1623,16 +1677,18 @@ bucket_definitions:
     test('invalidate cached parsed sync rules', async () => {
         const env_21 = { stack: [], error: void 0, hasError: false };
         try {
-            const sync_rules_content = test_utils.testRules(`
+            const bucketStorageFactory = __addDisposableResource(env_21, await generateStorageFactory(), true);
+            const syncRules = await bucketStorageFactory.updateSyncRules({
+                content: `
 bucket_definitions:
     by_workspace:
       parameters:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace."userId" = token_parameters.user_id
       data: []
-    `);
-            const bucketStorageFactory = __addDisposableResource(env_21, await generateStorageFactory(), true);
-            const syncBucketStorage = bucketStorageFactory.getInstance(sync_rules_content);
+    `
+            });
+            const syncBucketStorage = bucketStorageFactory.getInstance(syncRules);
             const parsedSchema1 = syncBucketStorage.getParsedSyncRules({
                 defaultSchema: 'public'
             });
@@ -1667,12 +1723,11 @@ bucket_definitions:
                 content: `
 bucket_definitions:
   mybucket:
-    data: [] 
+    data: []
     `,
                 validate: false
             });
             const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            await bucketStorage.autoActivate();
             const abortController = new AbortController();
             context.onTestFinished(() => abortController.abort());
             const iter = bucketStorage
@@ -1719,7 +1774,6 @@ bucket_definitions:
                 validate: false
             });
             const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            await bucketStorage.autoActivate();
             const abortController = new AbortController();
             context.onTestFinished(() => abortController.abort());
             const iter = bucketStorage
@@ -1787,7 +1841,6 @@ bucket_definitions:
                 validate: false
             });
             const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            await bucketStorage.autoActivate();
             bucketStorage.setWriteCheckpointMode(storage.WriteCheckpointMode.CUSTOM);
             const abortController = new AbortController();
             context.onTestFinished(() => abortController.abort());
@@ -1835,7 +1888,6 @@ bucket_definitions:
                 validate: false
             });
             const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            await bucketStorage.autoActivate();
             bucketStorage.setWriteCheckpointMode(storage.WriteCheckpointMode.CUSTOM);
             const abortController = new AbortController();
             context.onTestFinished(() => abortController.abort());
@@ -1885,7 +1937,6 @@ bucket_definitions:
                 validate: false
             });
             const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            await bucketStorage.autoActivate();
             bucketStorage.setWriteCheckpointMode(storage.WriteCheckpointMode.CUSTOM);
             const abortController = new AbortController();
             context.onTestFinished(() => abortController.abort());
@@ -1959,15 +2010,17 @@ bucket_definitions:
             // Test syncing a batch of data that is small in count,
             // but large enough in size to be split over multiple returned chunks.
             // Similar to the above test, but splits over 1MB chunks.
-            const sync_rules = test_utils.testRules(`
+            const factory = __addDisposableResource(env_27, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
   bucket_definitions:
     global:
       data:
         - SELECT id FROM test
         - SELECT id FROM test_ignore WHERE false
-  `);
-            const factory = __addDisposableResource(env_27, await generateStorageFactory(), true);
-            const bucketStorage = factory.getInstance(sync_rules);
+  `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
             const sourceTable = test_utils.makeTestTable('test', ['id']);
             const sourceTableIgnore = test_utils.makeTestTable('test_ignore', ['id']);
             const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {