@powersync/service-core-tests 0.10.4 → 0.12.0

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

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { getUuidReplicaIdentityBson, storage } from '@powersync/service-core';
-import { ParameterLookup, RequestParameters } from '@powersync/service-sync-rules';
+import { DateTimeValue, ParameterLookup, RequestParameters } from '@powersync/service-sync-rules';
 import { expect, test, describe } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
 export const TEST_TABLE = test_utils.makeTestTable('test', ['id']);
@@ -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,20 +481,25 @@ 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 q1 = sync_rules.bucketSources[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({
+            const buckets = await sync_rules
+                .getBucketParameterQuerier(test_utils.querierOptions(parameters))
+                .querier.queryDynamicBucketDescriptions({
                 getParameterSets(lookups) {
-                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                    return checkpoint.getParameterSets(lookups);
                 }
             });
-            expect(buckets).toEqual([{ bucket: 'by_workspace["workspace1"]', priority: 3 }]);
+            expect(buckets).toEqual([
+                { bucket: 'by_workspace["workspace1"]', priority: 3, definition: 'by_workspace', inclusion_reasons: ['default'] }
+            ]);
         }
         catch (e_7) {
             env_7.error = e_7;
@@ -490,18 +515,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,24 +556,37 @@ 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 q1 = sync_rules.bucketSources[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({
+            const buckets = await sync_rules
+                .getBucketParameterQuerier(test_utils.querierOptions(parameters))
+                .querier.queryDynamicBucketDescriptions({
                 getParameterSets(lookups) {
-                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                    return checkpoint.getParameterSets(lookups);
                 }
             });
             buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
             expect(buckets).toEqual([
-                { bucket: 'by_public_workspace["workspace1"]', priority: 3 },
-                { bucket: 'by_public_workspace["workspace3"]', priority: 3 }
+                {
+                    bucket: 'by_public_workspace["workspace1"]',
+                    priority: 3,
+                    definition: 'by_public_workspace',
+                    inclusion_reasons: ['default']
+                },
+                {
+                    bucket: 'by_public_workspace["workspace3"]',
+                    priority: 3,
+                    definition: 'by_public_workspace',
+                    inclusion_reasons: ['default']
+                }
             ]);
         }
         catch (e_8) {
@@ -563,7 +603,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 +614,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 +657,29 @@ 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 q1 = sync_rules.bucketSources[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 q2 = sync_rules.bucketSources[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({
+            const buckets = (await sync_rules
+                .getBucketParameterQuerier(test_utils.querierOptions(parameters))
+                .querier.queryDynamicBucketDescriptions({
                 getParameterSets(lookups) {
-                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                    return checkpoint.getParameterSets(lookups);
                 }
             })).map((e) => e.bucket);
             buckets.sort();
@@ -653,16 +698,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 +740,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 +770,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 +799,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 +809,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 +846,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 +893,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 +920,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 +961,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 +986,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 +1010,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 +1154,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 +1161,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 +1262,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 +1269,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 +1367,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 +1417,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 +1461,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 +1484,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 +1531,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 +1541,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 +1558,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 +1676,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 +1695,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 +1741,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 +1792,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 +1859,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 +1906,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 +1955,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 +2028,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) => {
@@ -2007,5 +2078,75 @@ bucket_definitions:
                 await result_27;
         }
     });
+    test('data with custom types', async () => {
+        const env_28 = { stack: [], error: void 0, hasError: false };
+        try {
+            const factory = __addDisposableResource(env_28, await generateStorageFactory(), true);
+            const testValue = {
+                sourceTable: TEST_TABLE,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    description: new DateTimeValue('2025-08-28T11:30:00')
+                },
+                afterReplicaId: test_utils.rid('t1')
+            };
+            {
+                // First, deploy old sync rules and row with date time value
+                const syncRules = await factory.updateSyncRules({
+                    content: `
+  bucket_definitions:
+    global:
+      data:
+        - SELECT id, description FROM test
+  `
+                });
+                const bucketStorage = factory.getInstance(syncRules);
+                await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                    await batch.save(testValue);
+                    await batch.commit('1/1');
+                });
+                const { checkpoint } = await bucketStorage.getCheckpoint();
+                const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', 0n]])));
+                expect(batch[0].chunkData.data).toMatchObject([
+                    {
+                        data: '{"id":"t1","description":"2025-08-28 11:30:00"}'
+                    }
+                ]);
+            }
+            const syncRules = await factory.updateSyncRules({
+                content: `
+  bucket_definitions:
+    global:
+      data:
+        - SELECT id, description FROM test
+  
+  config:
+    edition: 2
+  `
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                await batch.save(testValue);
+                await batch.commit('1/2');
+            });
+            const { checkpoint } = await bucketStorage.getCheckpoint();
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['2#global[]', 0n]])));
+            expect(batch[0].chunkData.data).toMatchObject([
+                {
+                    data: '{"id":"t1","description":"2025-08-28T11:30:00"}'
+                }
+            ]);
+        }
+        catch (e_28) {
+            env_28.error = e_28;
+            env_28.hasError = true;
+        }
+        finally {
+            const result_28 = __disposeResources(env_28);
+            if (result_28)
+                await result_28;
+        }
+    });
 }
 //# sourceMappingURL=register-data-storage-tests.js.map