@powersync/service-core-tests 0.12.0 → 0.12.2

package/dist/tests/{register-data-storage-tests.js → register-data-storage-data-tests.js}

@@ -51,10 +51,10 @@ 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 { DateTimeValue, ParameterLookup, RequestParameters } from '@powersync/service-sync-rules';
-import { expect, test, describe } from 'vitest';
+import { DateTimeValue } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
-export const TEST_TABLE = test_utils.makeTestTable('test', ['id']);
+import { TEST_TABLE } from './util.js';
 /**
  * Normalize data from OplogEntries for comparison in tests.
  * Tests typically expect the stringified result
@@ -70,331 +70,18 @@ const normalizeOplogData = (data) => {
  * ```TypeScript
  *
  * describe('store - mongodb', function () {
- *  registerDataStorageTests(MONGO_STORAGE_FACTORY);
+ *  registerDataStorageDataTests(MONGO_STORAGE_FACTORY);
  * });
  *
  * ```
  */
-export function registerDataStorageTests(generateStorageFactory) {
-    test('save and load parameters', async () => {
+export function registerDataStorageDataTests(generateStorageFactory) {
+    test('removing row', async () => {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             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 bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        id1: 'user3',
-                        id2: 'user4',
-                        group_id: 'group2a'
-                    },
-                    afterReplicaId: test_utils.rid('t2')
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        id1: 'user1',
-                        id2: 'user2',
-                        group_id: 'group1a'
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
-            });
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
-            expect(parameters).toEqual([
-                {
-                    group_id: 'group1a'
-                }
-            ]);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
-    });
-    test('it should use the latest version', async () => {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            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 bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        group_id: 'group1'
-                    },
-                    afterReplicaId: test_utils.rid('user1')
-                });
-                await batch.commit('1/1');
-            });
-            const checkpoint1 = await bucketStorage.getCheckpoint();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        group_id: 'group2'
-                    },
-                    afterReplicaId: test_utils.rid('user1')
-                });
-                await batch.commit('1/2');
-            });
-            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 checkpoint1.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
-            expect(parameters2).toEqual([
-                {
-                    group_id: 'group1'
-                }
-            ]);
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
-        }
-    });
-    test('it should use the latest version after updates', async () => {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            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 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
-                await batch.save({
-                    sourceTable: table,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'todo1',
-                        list_id: 'list1'
-                    },
-                    afterReplicaId: test_utils.rid('todo1')
-                });
-                await batch.save({
-                    sourceTable: table,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'todo2',
-                        list_id: 'list2'
-                    },
-                    afterReplicaId: test_utils.rid('todo2')
-                });
-                await batch.commit('1/1');
-            });
-            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,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 'todo2',
-                        list_id: 'list1'
-                    },
-                    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 checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([
-                ParameterLookup.normalized('mybucket', '1', ['list1']),
-                ParameterLookup.normalized('mybucket', '1', ['list2'])
-            ]);
-            expect(parameters.sort((a, b) => a.todo_id.localeCompare(b.todo_id))).toEqual([
-                {
-                    todo_id: 'todo1'
-                },
-                {
-                    todo_id: 'todo2'
-                }
-            ]);
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            const result_3 = __disposeResources(env_3);
-            if (result_3)
-                await result_3;
-        }
-    });
-    test('save and load parameters with different number types', async () => {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            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 bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        group_id: 'group1',
-                        n1: 314n,
-                        f2: 314,
-                        f3: 3.14
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
-            });
-            const TEST_PARAMS = { group_id: 'group1' };
-            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 checkpoint.getParameterSets([
-                ParameterLookup.normalized('mybucket', '1', [314, 314n, 3.14])
-            ]);
-            expect(parameters2).toEqual([TEST_PARAMS]);
-            const parameters3 = await checkpoint.getParameterSets([
-                ParameterLookup.normalized('mybucket', '1', [314n, 314, 3])
-            ]);
-            expect(parameters3).toEqual([]);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            const result_4 = __disposeResources(env_4);
-            if (result_4)
-                await result_4;
-        }
-    });
-    test('save and load parameters with large numbers', async () => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            // 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 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 bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        group_id: 'group1',
-                        n1: 1152921504606846976n // 2^60
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 't1',
-                        group_id: 'group1',
-                        // Simulate a TOAST value, even though it can't happen for values like this
-                        // in practice.
-                        n1: undefined
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
-            });
-            const TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters1 = await checkpoint.getParameterSets([
-                ParameterLookup.normalized('mybucket', '1', [1152921504606846976n])
-            ]);
-            expect(parameters1).toEqual([TEST_PARAMS]);
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            const result_5 = __disposeResources(env_5);
-            if (result_5)
-                await result_5;
-        }
-    });
-    test('removing row', async () => {
-        const env_6 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_6, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules({
-                content: `
 bucket_definitions:
   global:
     data:
@@ -444,261 +131,20 @@ bucket_definitions:
                 }
             ]);
         }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
-        }
-        finally {
-            const result_6 = __disposeResources(env_6);
-            if (result_6)
-                await result_6;
-        }
-    });
-    test('save and load parameters with workspaceId', async () => {
-        const env_7 = { stack: [], error: void 0, hasError: false };
-        try {
-            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace', ['id']);
-            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 = 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,
-                    after: {
-                        id: 'workspace1',
-                        userId: 'u1'
-                    },
-                    afterReplicaId: test_utils.rid('workspace1')
-                });
-                await batch.commit('1/1');
-            });
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = new RequestParameters({ sub: 'u1' }, {});
-            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 checkpoint.getParameterSets(lookups);
-            expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
-            const buckets = await sync_rules
-                .getBucketParameterQuerier(test_utils.querierOptions(parameters))
-                .querier.queryDynamicBucketDescriptions({
-                getParameterSets(lookups) {
-                    return checkpoint.getParameterSets(lookups);
-                }
-            });
-            expect(buckets).toEqual([
-                { bucket: 'by_workspace["workspace1"]', priority: 3, definition: 'by_workspace', inclusion_reasons: ['default'] }
-            ]);
-        }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
-        }
-        finally {
-            const result_7 = __disposeResources(env_7);
-            if (result_7)
-                await result_7;
-        }
-    });
-    test('save and load parameters with dynamic global buckets', async () => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
-            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 = 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,
-                    after: {
-                        id: 'workspace1',
-                        visibility: 'public'
-                    },
-                    afterReplicaId: test_utils.rid('workspace1')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace2',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace2')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace3',
-                        visibility: 'public'
-                    },
-                    afterReplicaId: test_utils.rid('workspace3')
-                });
-                await batch.commit('1/1');
-            });
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = new RequestParameters({ sub: 'unknown' }, {});
-            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 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(test_utils.querierOptions(parameters))
-                .querier.queryDynamicBucketDescriptions({
-                getParameterSets(lookups) {
-                    return checkpoint.getParameterSets(lookups);
-                }
-            });
-            buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
-            expect(buckets).toEqual([
-                {
-                    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) {
-            env_8.error = e_8;
-            env_8.hasError = true;
-        }
-        finally {
-            const result_8 = __disposeResources(env_8);
-            if (result_8)
-                await result_8;
-        }
-    });
-    test('multiple parameter queries', async () => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
-            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules({
-                content: `
-bucket_definitions:
-    by_workspace:
-      parameters:
-        - SELECT id as workspace_id FROM workspace WHERE
-          workspace.visibility = 'public'
-        - SELECT id as workspace_id FROM workspace WHERE
-            workspace.user_id = token_parameters.user_id
-      data: []
-    `
-            });
-            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,
-                    after: {
-                        id: 'workspace1',
-                        visibility: 'public'
-                    },
-                    afterReplicaId: test_utils.rid('workspace1')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace2',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace2')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace3',
-                        user_id: 'u1',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace3')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace4',
-                        user_id: 'u2',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace4')
-                });
-                await batch.commit('1/1');
-            });
-            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.bucketSources[0].parameterQueries[0];
-            const lookups1 = q1.getLookups(parameters);
-            expect(lookups1).toEqual([ParameterLookup.normalized('by_workspace', '1', [])]);
-            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.bucketSources[0].parameterQueries[1];
-            const lookups2 = q2.getLookups(parameters);
-            expect(lookups2).toEqual([ParameterLookup.normalized('by_workspace', '2', ['u1'])]);
-            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(test_utils.querierOptions(parameters))
-                .querier.queryDynamicBucketDescriptions({
-                getParameterSets(lookups) {
-                    return checkpoint.getParameterSets(lookups);
-                }
-            })).map((e) => e.bucket);
-            buckets.sort();
-            expect(buckets).toEqual(['by_workspace["workspace1"]', 'by_workspace["workspace3"]']);
-        }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
         finally {
-            const result_9 = __disposeResources(env_9);
-            if (result_9)
-                await result_9;
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
         }
     });
     test('changing client ids', async () => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
+        const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const factory = __addDisposableResource(env_10, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_2, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -757,20 +203,20 @@ bucket_definitions:
                 { op: 'PUT', object_id: 'client2' }
             ]);
         }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
         finally {
-            const result_10 = __disposeResources(env_10);
-            if (result_10)
-                await result_10;
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
         }
     });
     test('re-apply delete', async () => {
-        const env_11 = { stack: [], error: void 0, hasError: false };
+        const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const factory = __addDisposableResource(env_11, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_3, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -833,20 +279,20 @@ bucket_definitions:
                 }
             ]);
         }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
         }
         finally {
-            const result_11 = __disposeResources(env_11);
-            if (result_11)
-                await result_11;
+            const result_3 = __disposeResources(env_3);
+            if (result_3)
+                await result_3;
         }
     });
     test('re-apply update + delete', async () => {
-        const env_12 = { stack: [], error: void 0, hasError: false };
+        const env_4 = { stack: [], error: void 0, hasError: false };
         try {
-            const factory = __addDisposableResource(env_12, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_4, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -948,60 +394,18 @@ bucket_definitions:
                 }
             ]);
         }
-        catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
-        }
-        finally {
-            const result_12 = __disposeResources(env_12);
-            if (result_12)
-                await result_12;
-        }
-    });
-    test('truncate parameters', async () => {
-        const env_13 = { stack: [], error: void 0, hasError: false };
-        try {
-            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 bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        id1: 'user3',
-                        id2: 'user4',
-                        group_id: 'group2a'
-                    },
-                    afterReplicaId: test_utils.rid('t2')
-                });
-                await batch.truncate([TEST_TABLE]);
-            });
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([ParameterLookup.normalized('mybucket', '1', ['user1'])]);
-            expect(parameters).toEqual([]);
-        }
-        catch (e_13) {
-            env_13.error = e_13;
-            env_13.hasError = true;
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
         }
         finally {
-            const result_13 = __disposeResources(env_13);
-            if (result_13)
-                await result_13;
+            const result_4 = __disposeResources(env_4);
+            if (result_4)
+                await result_4;
         }
     });
     test('batch with overlapping replica ids', async () => {
-        const env_14 = { stack: [], error: void 0, hasError: false };
+        const env_5 = { stack: [], error: void 0, hasError: false };
         try {
             // This test checks that we get the correct output when processing rows with:
             // 1. changing replica ids
@@ -1010,7 +414,7 @@ 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 factory = __addDisposableResource(env_14, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_5, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -1141,18 +545,18 @@ bucket_definitions:
                 { op: 'PUT', object_id: 'test5', data: JSON.stringify({ id: 'test5', description: 'test5d' }) }
             ]);
         }
-        catch (e_14) {
-            env_14.error = e_14;
-            env_14.hasError = true;
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
         }
         finally {
-            const result_14 = __disposeResources(env_14);
-            if (result_14)
-                await result_14;
+            const result_5 = __disposeResources(env_5);
+            if (result_5)
+                await result_5;
         }
     });
     test('changed data with replica identity full', async () => {
-        const env_15 = { stack: [], error: void 0, hasError: false };
+        const env_6 = { stack: [], error: void 0, hasError: false };
         try {
             function rid2(id, description) {
                 return getUuidReplicaIdentityBson({ id, description }, [
@@ -1160,7 +564,7 @@ bucket_definitions:
                     { name: 'description', type: 'VARCHAR', typeId: 25 }
                 ]);
             }
-            const factory = __addDisposableResource(env_15, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_6, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -1249,18 +653,18 @@ bucket_definitions:
                 }
             ]);
         }
-        catch (e_15) {
-            env_15.error = e_15;
-            env_15.hasError = true;
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
         }
         finally {
-            const result_15 = __disposeResources(env_15);
-            if (result_15)
-                await result_15;
+            const result_6 = __disposeResources(env_6);
+            if (result_6)
+                await result_6;
         }
     });
     test('unchanged data with replica identity full', async () => {
-        const env_16 = { stack: [], error: void 0, hasError: false };
+        const env_7 = { stack: [], error: void 0, hasError: false };
         try {
             function rid2(id, description) {
                 return getUuidReplicaIdentityBson({ id, description }, [
@@ -1268,7 +672,7 @@ bucket_definitions:
                     { name: 'description', type: 'VARCHAR', typeId: 25 }
                 ]);
             }
-            const factory = __addDisposableResource(env_16, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_7, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -1350,24 +754,24 @@ bucket_definitions:
                 }
             ]);
         }
-        catch (e_16) {
-            env_16.error = e_16;
-            env_16.hasError = true;
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
         }
         finally {
-            const result_16 = __disposeResources(env_16);
-            if (result_16)
-                await result_16;
+            const result_7 = __disposeResources(env_7);
+            if (result_7)
+                await result_7;
         }
     });
     test('large batch', async () => {
-        const env_17 = { stack: [], error: void 0, hasError: false };
+        const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             // Test syncing a batch of data that is small in count,
             // 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 factory = __addDisposableResource(env_17, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_8, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -1447,21 +851,21 @@ bucket_definitions:
             expect(test_utils.getBatchData(batch3)).toEqual([]);
             expect(test_utils.getBatchMeta(batch3)).toEqual(null);
         }
-        catch (e_17) {
-            env_17.error = e_17;
-            env_17.hasError = true;
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
         }
         finally {
-            const result_17 = __disposeResources(env_17);
-            if (result_17)
-                await result_17;
+            const result_8 = __disposeResources(env_8);
+            if (result_8)
+                await result_8;
         }
     });
     test('long batch', async () => {
-        const env_18 = { stack: [], error: void 0, hasError: false };
+        const env_9 = { stack: [], error: void 0, hasError: false };
         try {
             // Test syncing a batch of data that is limited by count.
-            const factory = __addDisposableResource(env_18, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
 bucket_definitions:
@@ -1517,21 +921,21 @@ bucket_definitions:
             expect(test_utils.getBatchData(batch3)).toEqual([]);
             expect(test_utils.getBatchMeta(batch3)).toEqual(null);
         }
-        catch (e_18) {
-            env_18.error = e_18;
-            env_18.hasError = true;
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
         }
         finally {
-            const result_18 = __disposeResources(env_18);
-            if (result_18)
-                await result_18;
+            const result_9 = __disposeResources(env_9);
+            if (result_9)
+                await result_9;
         }
     });
     describe('batch has_more', () => {
         const setup = async (options) => {
-            const env_19 = { stack: [], error: void 0, hasError: false };
+            const env_10 = { stack: [], error: void 0, hasError: false };
             try {
-                const factory = __addDisposableResource(env_19, await generateStorageFactory(), true);
+                const factory = __addDisposableResource(env_10, await generateStorageFactory(), true);
                 const syncRules = await factory.updateSyncRules({
                     content: `
   bucket_definitions:
@@ -1566,14 +970,14 @@ bucket_definitions:
                     ['global2[]', 0n]
                 ]), options));
             }
-            catch (e_19) {
-                env_19.error = e_19;
-                env_19.hasError = true;
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
             }
             finally {
-                const result_19 = __disposeResources(env_19);
-                if (result_19)
-                    await result_19;
+                const result_10 = __disposeResources(env_10);
+                if (result_10)
+                    await result_10;
             }
         };
         test('batch has_more (1)', async () => {
@@ -1665,9 +1069,9 @@ bucket_definitions:
         });
     });
     test('empty storage metrics', async () => {
-        const env_20 = { stack: [], error: void 0, hasError: false };
+        const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_20, await generateStorageFactory({ dropAll: true }), true);
+            const f = __addDisposableResource(env_11, await generateStorageFactory({ dropAll: true }), true);
             const metrics = await f.getStorageMetrics();
             expect(metrics).toEqual({
                 operations_size_bytes: 0,
@@ -1682,353 +1086,23 @@ bucket_definitions:
             const metrics2 = await f.getStorageMetrics();
             expect(metrics2).toMatchSnapshot();
         }
-        catch (e_20) {
-            env_20.error = e_20;
-            env_20.hasError = true;
-        }
-        finally {
-            const result_20 = __disposeResources(env_20);
-            if (result_20)
-                await result_20;
-        }
-    });
-    test('invalidate cached parsed sync rules', async () => {
-        const env_21 = { stack: [], error: void 0, hasError: false };
-        try {
-            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 syncBucketStorage = bucketStorageFactory.getInstance(syncRules);
-            const parsedSchema1 = syncBucketStorage.getParsedSyncRules({
-                defaultSchema: 'public'
-            });
-            const parsedSchema2 = syncBucketStorage.getParsedSyncRules({
-                defaultSchema: 'public'
-            });
-            // These should be cached, this will be the same instance
-            expect(parsedSchema2).equals(parsedSchema1);
-            expect(parsedSchema1.getSourceTables()[0].schema).equals('public');
-            const parsedSchema3 = syncBucketStorage.getParsedSyncRules({
-                defaultSchema: 'databasename'
-            });
-            // The cache should not be used
-            expect(parsedSchema3).not.equals(parsedSchema2);
-            expect(parsedSchema3.getSourceTables()[0].schema).equals('databasename');
-        }
-        catch (e_21) {
-            env_21.error = e_21;
-            env_21.hasError = true;
-        }
-        finally {
-            const result_21 = __disposeResources(env_21);
-            if (result_21)
-                await result_21;
-        }
-    });
-    test('managed write checkpoints - checkpoint after write', async (context) => {
-        const env_22 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_22, await generateStorageFactory(), true);
-            const r = await factory.configureSyncRules({
-                content: `
-bucket_definitions:
-  mybucket:
-    data: []
-    `,
-                validate: false
-            });
-            const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            const abortController = new AbortController();
-            context.onTestFinished(() => abortController.abort());
-            const iter = bucketStorage
-                .watchCheckpointChanges({ user_id: 'user1', signal: abortController.signal })[Symbol.asyncIterator]();
-            const writeCheckpoint = await bucketStorage.createManagedWriteCheckpoint({
-                heads: { '1': '5/0' },
-                user_id: 'user1'
-            });
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('5/0');
-            });
-            const result = await iter.next();
-            expect(result).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                        checkpoint: 0n,
-                        lsn: '5/0'
-                    },
-                    writeCheckpoint: writeCheckpoint
-                }
-            });
-        }
-        catch (e_22) {
-            env_22.error = e_22;
-            env_22.hasError = true;
-        }
-        finally {
-            const result_22 = __disposeResources(env_22);
-            if (result_22)
-                await result_22;
-        }
-    });
-    test('managed write checkpoints - write after checkpoint', async (context) => {
-        const env_23 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_23, await generateStorageFactory(), true);
-            const r = await factory.configureSyncRules({
-                content: `
-bucket_definitions:
-  mybucket:
-    data: []
-    `,
-                validate: false
-            });
-            const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            const abortController = new AbortController();
-            context.onTestFinished(() => abortController.abort());
-            const iter = bucketStorage
-                .watchCheckpointChanges({ user_id: 'user1', signal: abortController.signal })[Symbol.asyncIterator]();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('5/0');
-            });
-            const result = await iter.next();
-            expect(result).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                        checkpoint: 0n,
-                        lsn: '5/0'
-                    },
-                    writeCheckpoint: null
-                }
-            });
-            const writeCheckpoint = await bucketStorage.createManagedWriteCheckpoint({
-                heads: { '1': '6/0' },
-                user_id: 'user1'
-            });
-            // We have to trigger a new keepalive after the checkpoint, at least to cover postgres storage.
-            // This is what is effetively triggered with RouteAPI.createReplicationHead().
-            // MongoDB storage doesn't explicitly need this anymore.
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('6/0');
-            });
-            let result2 = await iter.next();
-            if (result2.value?.base?.lsn == '5/0') {
-                // Events could arrive in a different order in some cases - this caters for it
-                result2 = await iter.next();
-            }
-            expect(result2).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                        checkpoint: 0n,
-                        lsn: '6/0'
-                    },
-                    writeCheckpoint: writeCheckpoint
-                }
-            });
-        }
-        catch (e_23) {
-            env_23.error = e_23;
-            env_23.hasError = true;
-        }
-        finally {
-            const result_23 = __disposeResources(env_23);
-            if (result_23)
-                await result_23;
-        }
-    });
-    test('custom write checkpoints - checkpoint after write', async (context) => {
-        const env_24 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_24, await generateStorageFactory(), true);
-            const r = await factory.configureSyncRules({
-                content: `
-bucket_definitions:
-  mybucket:
-    data: []
-    `,
-                validate: false
-            });
-            const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            bucketStorage.setWriteCheckpointMode(storage.WriteCheckpointMode.CUSTOM);
-            const abortController = new AbortController();
-            context.onTestFinished(() => abortController.abort());
-            const iter = bucketStorage
-                .watchCheckpointChanges({ user_id: 'user1', signal: abortController.signal })[Symbol.asyncIterator]();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.addCustomWriteCheckpoint({
-                    checkpoint: 5n,
-                    user_id: 'user1'
-                });
-                await batch.flush();
-                await batch.keepalive('5/0');
-            });
-            const result = await iter.next();
-            expect(result).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                        lsn: '5/0'
-                    },
-                    writeCheckpoint: 5n
-                }
-            });
-        }
-        catch (e_24) {
-            env_24.error = e_24;
-            env_24.hasError = true;
-        }
-        finally {
-            const result_24 = __disposeResources(env_24);
-            if (result_24)
-                await result_24;
-        }
-    });
-    test('custom write checkpoints - standalone checkpoint', async (context) => {
-        const env_25 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_25, await generateStorageFactory(), true);
-            const r = await factory.configureSyncRules({
-                content: `
-bucket_definitions:
-  mybucket:
-    data: []
-    `,
-                validate: false
-            });
-            const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            bucketStorage.setWriteCheckpointMode(storage.WriteCheckpointMode.CUSTOM);
-            const abortController = new AbortController();
-            context.onTestFinished(() => abortController.abort());
-            const iter = bucketStorage
-                .watchCheckpointChanges({ user_id: 'user1', signal: abortController.signal })[Symbol.asyncIterator]();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // Flush to clear state
-                await batch.flush();
-                await batch.addCustomWriteCheckpoint({
-                    checkpoint: 5n,
-                    user_id: 'user1'
-                });
-                await batch.flush();
-                await batch.keepalive('5/0');
-            });
-            const result = await iter.next();
-            expect(result).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                        lsn: '5/0'
-                    },
-                    writeCheckpoint: 5n
-                }
-            });
-        }
-        catch (e_25) {
-            env_25.error = e_25;
-            env_25.hasError = true;
-        }
-        finally {
-            const result_25 = __disposeResources(env_25);
-            if (result_25)
-                await result_25;
-        }
-    });
-    test('custom write checkpoints - write after checkpoint', async (context) => {
-        const env_26 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_26, await generateStorageFactory(), true);
-            const r = await factory.configureSyncRules({
-                content: `
-bucket_definitions:
-  mybucket:
-    data: []
-    `,
-                validate: false
-            });
-            const bucketStorage = factory.getInstance(r.persisted_sync_rules);
-            bucketStorage.setWriteCheckpointMode(storage.WriteCheckpointMode.CUSTOM);
-            const abortController = new AbortController();
-            context.onTestFinished(() => abortController.abort());
-            const iter = bucketStorage
-                .watchCheckpointChanges({ user_id: 'user1', signal: abortController.signal })[Symbol.asyncIterator]();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('5/0');
-            });
-            const result = await iter.next();
-            expect(result).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                        lsn: '5/0'
-                    },
-                    writeCheckpoint: null
-                }
-            });
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                batch.addCustomWriteCheckpoint({
-                    checkpoint: 6n,
-                    user_id: 'user1'
-                });
-                await batch.flush();
-                await batch.keepalive('6/0');
-            });
-            let result2 = await iter.next();
-            expect(result2).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                    // can be 5/0 or 6/0 - actual value not relevant for custom write checkpoints
-                    // lsn: '6/0'
-                    },
-                    writeCheckpoint: 6n
-                }
-            });
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                batch.addCustomWriteCheckpoint({
-                    checkpoint: 7n,
-                    user_id: 'user1'
-                });
-                await batch.flush();
-                await batch.keepalive('7/0');
-            });
-            let result3 = await iter.next();
-            expect(result3).toMatchObject({
-                done: false,
-                value: {
-                    base: {
-                    // can be 5/0, 6/0 or 7/0 - actual value not relevant for custom write checkpoints
-                    // lsn: '7/0'
-                    },
-                    writeCheckpoint: 7n
-                }
-            });
-        }
-        catch (e_26) {
-            env_26.error = e_26;
-            env_26.hasError = true;
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
         }
         finally {
-            const result_26 = __disposeResources(env_26);
-            if (result_26)
-                await result_26;
+            const result_11 = __disposeResources(env_11);
+            if (result_11)
+                await result_11;
         }
     });
     test('op_id initialization edge case', async () => {
-        const env_27 = { stack: [], error: void 0, hasError: false };
+        const env_12 = { stack: [], error: void 0, hasError: false };
         try {
             // 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 factory = __addDisposableResource(env_27, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_12, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules({
                 content: `
   bucket_definitions:
@@ -2068,20 +1142,20 @@ bucket_definitions:
             // we expect 0n and 1n, or 1n and 2n.
             expect(checkpoint2).toBeGreaterThan(checkpoint1);
         }
-        catch (e_27) {
-            env_27.error = e_27;
-            env_27.hasError = true;
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
         }
         finally {
-            const result_27 = __disposeResources(env_27);
-            if (result_27)
-                await result_27;
+            const result_12 = __disposeResources(env_12);
+            if (result_12)
+                await result_12;
         }
     });
     test('data with custom types', async () => {
-        const env_28 = { stack: [], error: void 0, hasError: false };
+        const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const factory = __addDisposableResource(env_28, await generateStorageFactory(), true);
+            const factory = __addDisposableResource(env_13, await generateStorageFactory(), true);
             const testValue = {
                 sourceTable: TEST_TABLE,
                 tag: storage.SaveOperationTag.INSERT,
@@ -2138,15 +1212,57 @@ bucket_definitions:
                 }
             ]);
         }
-        catch (e_28) {
-            env_28.error = e_28;
-            env_28.hasError = true;
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
+        }
+        finally {
+            const result_13 = __disposeResources(env_13);
+            if (result_13)
+                await result_13;
+        }
+    });
+    test('unchanged checksums', async () => {
+        const env_14 = { stack: [], error: void 0, hasError: false };
+        try {
+            const factory = __addDisposableResource(env_14, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules({
+                content: `
+bucket_definitions:
+  global:
+    data:
+      - SELECT client_id as id, description FROM "%"
+`
+            });
+            const bucketStorage = factory.getInstance(syncRules);
+            const sourceTable = TEST_TABLE;
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.commit('1/1');
+            });
+            const { checkpoint } = await bucketStorage.getCheckpoint();
+            const checksums = [...(await bucketStorage.getChecksums(checkpoint, ['global[]'])).values()];
+            expect(checksums).toEqual([{ bucket: 'global[]', checksum: 1917136889, count: 1 }]);
+            const checksums2 = [...(await bucketStorage.getChecksums(checkpoint + 1n, ['global[]'])).values()];
+            expect(checksums2).toEqual([{ bucket: 'global[]', checksum: 1917136889, count: 1 }]);
+        }
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
         }
         finally {
-            const result_28 = __disposeResources(env_28);
-            if (result_28)
-                await result_28;
+            const result_14 = __disposeResources(env_14);
+            if (result_14)
+                await result_14;
         }
     });
 }
-//# sourceMappingURL=register-data-storage-tests.js.map
+//# sourceMappingURL=register-data-storage-data-tests.js.map