@powersync/service-core-tests 0.15.1 → 0.15.3

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

@@ -1,55 +1,3 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 import { CURRENT_STORAGE_VERSION, JwtPayload, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
 import { RequestParameters, ScopedParameterLookup } from '@powersync/service-sync-rules';
 import { expect, test } from 'vitest';
@@ -71,131 +19,105 @@ export function registerDataStorageParameterTests(config) {
     const storageVersion = config.storageVersion ?? CURRENT_STORAGE_VERSION;
     const MYBUCKET_1 = parameterLookupScope('mybucket', '1');
     test('save and load parameters', async () => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_1, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
     `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_1, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't2',
-                    id1: 'user3',
-                    id2: 'user4',
-                    group_id: 'group2a'
-                },
-                afterReplicaId: test_utils.rid('t2')
-            });
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    id1: 'user1',
-                    id2: 'user2',
-                    group_id: 'group1a'
-                },
-                afterReplicaId: test_utils.rid('t1')
-            });
-            await writer.commit('1/1');
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(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;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't2',
+                id1: 'user3',
+                id2: 'user4',
+                group_id: 'group2a'
+            },
+            afterReplicaId: test_utils.rid('t2')
+        });
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                id1: 'user1',
+                id2: 'user2',
+                group_id: 'group1a'
+            },
+            afterReplicaId: test_utils.rid('t1')
+        });
+        await writer.commit('1/1');
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
+        expect(parameters).toEqual([
+            {
+                group_id: 'group1a'
+            }
+        ]);
     });
     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(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id = token_parameters.user_id
     data: []
     `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_2, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'user1',
-                    group_id: 'group1'
-                },
-                afterReplicaId: test_utils.rid('user1')
-            });
-            await writer.commit('1/1');
-            const checkpoint1 = await bucketStorage.getCheckpoint();
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'user1',
-                    group_id: 'group2'
-                },
-                afterReplicaId: test_utils.rid('user1')
-            });
-            await writer.commit('1/2');
-            const checkpoint2 = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint2.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-            expect(parameters).toEqual([
-                {
-                    group_id: 'group2'
-                }
-            ]);
-            // Use the checkpoint to get older data if relevant
-            const parameters2 = await checkpoint1.getParameterSets([ScopedParameterLookup.direct(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;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'user1',
+                group_id: 'group1'
+            },
+            afterReplicaId: test_utils.rid('user1')
+        });
+        await writer.commit('1/1');
+        const checkpoint1 = await bucketStorage.getCheckpoint();
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'user1',
+                group_id: 'group2'
+            },
+            afterReplicaId: test_utils.rid('user1')
+        });
+        await writer.commit('1/2');
+        const checkpoint2 = await bucketStorage.getCheckpoint();
+        const parameters = await checkpoint2.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
+        expect(parameters).toEqual([
+            {
+                group_id: 'group2'
+            }
+        ]);
+        // Use the checkpoint to get older data if relevant
+        const parameters2 = await checkpoint1.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
+        expect(parameters2).toEqual([
+            {
+                group_id: 'group1'
+            }
+        ]);
     });
     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(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
@@ -204,186 +126,150 @@ bucket_definitions:
         WHERE list_id IN token_parameters.list_id
     data: []
     `, { storageVersion }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_3, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const table = await test_utils.resolveTestTable(writer, 'todos', ['id', 'list_id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            // Create two todos which initially belong to different lists
-            await writer.save({
-                sourceTable: table,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'todo1',
-                    list_id: 'list1'
-                },
-                afterReplicaId: test_utils.rid('todo1')
-            });
-            await writer.save({
-                sourceTable: table,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'todo2',
-                    list_id: 'list2'
-                },
-                afterReplicaId: test_utils.rid('todo2')
-            });
-            await writer.commit('1/1');
-            // Update the second todo item to now belong to list 1
-            await writer.save({
-                sourceTable: table,
-                tag: storage.SaveOperationTag.UPDATE,
-                after: {
-                    id: 'todo2',
-                    list_id: 'list1'
-                },
-                afterReplicaId: test_utils.rid('todo2')
-            });
-            await writer.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([
-                ScopedParameterLookup.direct(MYBUCKET_1, ['list1']),
-                ScopedParameterLookup.direct(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;
-        }
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const table = await test_utils.resolveTestTable(writer, 'todos', ['id', 'list_id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        // Create two todos which initially belong to different lists
+        await writer.save({
+            sourceTable: table,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'todo1',
+                list_id: 'list1'
+            },
+            afterReplicaId: test_utils.rid('todo1')
+        });
+        await writer.save({
+            sourceTable: table,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'todo2',
+                list_id: 'list2'
+            },
+            afterReplicaId: test_utils.rid('todo2')
+        });
+        await writer.commit('1/1');
+        // Update the second todo item to now belong to list 1
+        await writer.save({
+            sourceTable: table,
+            tag: storage.SaveOperationTag.UPDATE,
+            after: {
+                id: 'todo2',
+                list_id: 'list1'
+            },
+            afterReplicaId: test_utils.rid('todo2')
+        });
+        await writer.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([
+            ScopedParameterLookup.direct(MYBUCKET_1, ['list1']),
+            ScopedParameterLookup.direct(MYBUCKET_1, ['list2'])
+        ]);
+        expect(parameters.sort((a, b) => a.todo_id.localeCompare(b.todo_id))).toEqual([
+            {
+                todo_id: 'todo1'
+            },
+            {
+                todo_id: 'todo2'
+            }
+        ]);
     });
     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(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 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: []
     `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_4, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    group_id: 'group1',
-                    n1: 314n,
-                    f2: 314,
-                    f3: 3.14
-                },
-                afterReplicaId: test_utils.rid('t1')
-            });
-            await writer.commit('1/1');
-            const TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters1 = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3.14])
-            ]);
-            expect(parameters1).toEqual([TEST_PARAMS]);
-            const parameters2 = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(MYBUCKET_1, [314, 314n, 3.14])
-            ]);
-            expect(parameters2).toEqual([TEST_PARAMS]);
-            const parameters3 = await checkpoint.getParameterSets([ScopedParameterLookup.direct(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;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                group_id: 'group1',
+                n1: 314n,
+                f2: 314,
+                f3: 3.14
+            },
+            afterReplicaId: test_utils.rid('t1')
+        });
+        await writer.commit('1/1');
+        const TEST_PARAMS = { group_id: 'group1' };
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters1 = await checkpoint.getParameterSets([
+            ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3.14])
+        ]);
+        expect(parameters1).toEqual([TEST_PARAMS]);
+        const parameters2 = await checkpoint.getParameterSets([
+            ScopedParameterLookup.direct(MYBUCKET_1, [314, 314n, 3.14])
+        ]);
+        expect(parameters2).toEqual([TEST_PARAMS]);
+        const parameters3 = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3])]);
+        expect(parameters3).toEqual([]);
     });
     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(updateSyncRulesFromYaml(`
+        // 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.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1
     data: []
     `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_5, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't1',
-                    group_id: 'group1',
-                    n1: 1152921504606846976n // 2^60
-                },
-                afterReplicaId: test_utils.rid('t1')
-            });
-            await writer.save({
-                sourceTable: testTable,
-                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 writer.commit('1/1');
-            const TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters1 = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(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;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't1',
+                group_id: 'group1',
+                n1: 1152921504606846976n // 2^60
+            },
+            afterReplicaId: test_utils.rid('t1')
+        });
+        await writer.save({
+            sourceTable: testTable,
+            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 writer.commit('1/1');
+        const TEST_PARAMS = { group_id: 'group1' };
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters1 = await checkpoint.getParameterSets([
+            ScopedParameterLookup.direct(MYBUCKET_1, [1152921504606846976n])
+        ]);
+        expect(parameters1).toEqual([TEST_PARAMS]);
     });
     test('save and load parameters with workspaceId', async () => {
-        const env_6 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_6, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_workspace:
       parameters:
@@ -391,58 +277,46 @@ bucket_definitions:
           workspace."userId" = token_parameters.user_id
       data: []
     `, {
-                storageVersion
-            }));
-            const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_6, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace1',
-                    userId: 'u1'
-                },
-                afterReplicaId: test_utils.rid('workspace1')
-            });
-            await writer.commit('1/1');
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
-            const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
-            const buckets = await querier.queryDynamicBucketDescriptions({
-                async getParameterSets(lookups) {
-                    expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), ['u1'])]);
-                    const parameter_sets = await checkpoint.getParameterSets(lookups);
-                    expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
-                    return parameter_sets;
-                }
-            });
-            expect(buckets).toEqual([
-                {
-                    bucket: bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
-                    priority: 3,
-                    definition: 'by_workspace',
-                    inclusion_reasons: ['default']
-                }
-            ]);
-        }
-        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;
-        }
+            storageVersion
+        }));
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace1',
+                userId: 'u1'
+            },
+            afterReplicaId: test_utils.rid('workspace1')
+        });
+        await writer.commit('1/1');
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), ['u1'])]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups);
+                expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toEqual([
+            {
+                bucket: bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
+                priority: 3,
+                definition: 'by_workspace',
+                inclusion_reasons: ['default']
+            }
+        ]);
     });
     test('save and load parameters with dynamic global buckets', async () => {
-        const env_7 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_7, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_public_workspace:
       parameters:
@@ -450,84 +324,72 @@ bucket_definitions:
           workspace.visibility = 'public'
       data: []
     `, {
-                storageVersion
-            }));
-            const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_7, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', undefined, config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace1',
-                    visibility: 'public'
-                },
-                afterReplicaId: test_utils.rid('workspace1')
-            });
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace2',
-                    visibility: 'private'
-                },
-                afterReplicaId: test_utils.rid('workspace2')
-            });
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace3',
-                    visibility: 'public'
-                },
-                afterReplicaId: test_utils.rid('workspace3')
-            });
-            await writer.commit('1/1');
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = new RequestParameters(new JwtPayload({ sub: 'unknown' }), {});
-            const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
-            const buckets = await querier.queryDynamicBucketDescriptions({
-                async getParameterSets(lookups) {
-                    expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('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' }]);
-                    return parameter_sets;
-                }
-            });
-            buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
-            expect(buckets).toEqual([
-                {
-                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace1"]').bucket,
-                    priority: 3,
-                    definition: 'by_public_workspace',
-                    inclusion_reasons: ['default']
-                },
-                {
-                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace3"]').bucket,
-                    priority: 3,
-                    definition: 'by_public_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;
-        }
+            storageVersion
+        }));
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', undefined, config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace1',
+                visibility: 'public'
+            },
+            afterReplicaId: test_utils.rid('workspace1')
+        });
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace2',
+                visibility: 'private'
+            },
+            afterReplicaId: test_utils.rid('workspace2')
+        });
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace3',
+                visibility: 'public'
+            },
+            afterReplicaId: test_utils.rid('workspace3')
+        });
+        await writer.commit('1/1');
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'unknown' }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('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' }]);
+                return parameter_sets;
+            }
+        });
+        buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
+        expect(buckets).toEqual([
+            {
+                bucket: bucketRequest(syncRules, 'by_public_workspace["workspace1"]').bucket,
+                priority: 3,
+                definition: 'by_public_workspace',
+                inclusion_reasons: ['default']
+            },
+            {
+                bucket: bucketRequest(syncRules, 'by_public_workspace["workspace3"]').bucket,
+                priority: 3,
+                definition: 'by_public_workspace',
+                inclusion_reasons: ['default']
+            }
+        ]);
     });
     test('multiple parameter queries', async () => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_8, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_workspace:
       parameters:
@@ -537,138 +399,114 @@ bucket_definitions:
             workspace.user_id = token_parameters.user_id
       data: []
     `, {
-                storageVersion
-            }));
-            const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_8, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', undefined, config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace1',
-                    visibility: 'public'
-                },
-                afterReplicaId: test_utils.rid('workspace1')
-            });
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace2',
-                    visibility: 'private'
-                },
-                afterReplicaId: test_utils.rid('workspace2')
-            });
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace3',
-                    user_id: 'u1',
-                    visibility: 'private'
-                },
-                afterReplicaId: test_utils.rid('workspace3')
-            });
-            await writer.save({
-                sourceTable: workspaceTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 'workspace4',
-                    user_id: 'u2',
-                    visibility: 'private'
-                },
-                afterReplicaId: test_utils.rid('workspace4')
-            });
-            await writer.commit('1/1');
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
-            // Test intermediate values - could be moved to sync_rules.test.ts
-            const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
-            // Test final values - the important part
-            const foundLookups = [];
-            const parameter_sets = [];
-            const buckets = (await querier.queryDynamicBucketDescriptions({
-                async getParameterSets(lookups) {
-                    foundLookups.push(...lookups);
-                    const output = await checkpoint.getParameterSets(lookups);
-                    parameter_sets.push(...output);
-                    return output;
-                }
-            })).map((e) => e.bucket);
-            expect(foundLookups).toEqual([
-                ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), []),
-                ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '2'), ['u1'])
-            ]);
-            parameter_sets.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-            expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
-            buckets.sort();
-            expect(buckets).toEqual([
-                bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
-                bucketRequest(syncRules, 'by_workspace["workspace3"]').bucket
-            ]);
-        }
-        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;
-        }
+            storageVersion
+        }));
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', undefined, config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace1',
+                visibility: 'public'
+            },
+            afterReplicaId: test_utils.rid('workspace1')
+        });
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace2',
+                visibility: 'private'
+            },
+            afterReplicaId: test_utils.rid('workspace2')
+        });
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace3',
+                user_id: 'u1',
+                visibility: 'private'
+            },
+            afterReplicaId: test_utils.rid('workspace3')
+        });
+        await writer.save({
+            sourceTable: workspaceTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'workspace4',
+                user_id: 'u2',
+                visibility: 'private'
+            },
+            afterReplicaId: test_utils.rid('workspace4')
+        });
+        await writer.commit('1/1');
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
+        // Test intermediate values - could be moved to sync_rules.test.ts
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        // Test final values - the important part
+        const foundLookups = [];
+        const parameter_sets = [];
+        const buckets = (await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                foundLookups.push(...lookups);
+                const output = await checkpoint.getParameterSets(lookups);
+                parameter_sets.push(...output);
+                return output;
+            }
+        })).map((e) => e.bucket);
+        expect(foundLookups).toEqual([
+            ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), []),
+            ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '2'), ['u1'])
+        ]);
+        parameter_sets.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+        expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
+        buckets.sort();
+        expect(buckets).toEqual([
+            bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
+            bucketRequest(syncRules, 'by_workspace["workspace3"]').bucket
+        ]);
     });
     test('truncate parameters', async () => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
     `, {
-                storageVersion
-            }));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_9, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    id: 't2',
-                    id1: 'user3',
-                    id2: 'user4',
-                    group_id: 'group2a'
-                },
-                afterReplicaId: test_utils.rid('t2')
-            });
-            await writer.truncate([testTable]);
-            await writer.flush();
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-            expect(parameters).toEqual([]);
-        }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
-        }
-        finally {
-            const result_9 = __disposeResources(env_9);
-            if (result_9)
-                await result_9;
-        }
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 't2',
+                id1: 'user3',
+                id2: 'user4',
+                group_id: 'group2a'
+            },
+            afterReplicaId: test_utils.rid('t2')
+        });
+        await writer.truncate([testTable]);
+        await writer.flush();
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
+        expect(parameters).toEqual([]);
     });
     test('invalidate cached parsed sync rules', async () => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
-        try {
-            const bucketStorageFactory = __addDisposableResource(env_10, await generateStorageFactory(), true);
-            const syncRules = await bucketStorageFactory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using bucketStorageFactory = await generateStorageFactory();
+        const syncRules = await bucketStorageFactory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_workspace:
       parameters:
@@ -676,40 +514,28 @@ bucket_definitions:
           workspace."userId" = token_parameters.user_id
       data: []
     `, {
-                storageVersion
-            }));
-            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_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
-        }
-        finally {
-            const result_10 = __disposeResources(env_10);
-            if (result_10)
-                await result_10;
-        }
+            storageVersion
+        }));
+        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');
     });
     test('sync streams smoke test', async () => {
-        const env_11 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_11, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 config:
   edition: 3
 
@@ -719,39 +545,29 @@ streams:
       SELECT data.* FROM test AS data, test AS param
       WHERE data.foo = param.bar AND param.baz = auth.user_id()
     `));
-            const bucketStorage = factory.getInstance(syncRules);
-            const writer = __addDisposableResource(env_11, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
-            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
-            await writer.markAllSnapshotDone('1/1');
-            await writer.save({
-                sourceTable: testTable,
-                tag: storage.SaveOperationTag.INSERT,
-                after: {
-                    baz: 'baz',
-                    bar: 'bar'
-                },
-                afterReplicaId: test_utils.rid('t1')
-            });
-            await writer.commit('1/1');
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(parameterLookupScope('lookup', '0'), ['baz'])
-            ]);
-            expect(parameters).toEqual([
-                {
-                    '0': 'bar'
-                }
-            ]);
-        }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
-        }
-        finally {
-            const result_11 = __disposeResources(env_11);
-            if (result_11)
-                await result_11;
-        }
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: testTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                baz: 'baz',
+                bar: 'bar'
+            },
+            afterReplicaId: test_utils.rid('t1')
+        });
+        await writer.commit('1/1');
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = await checkpoint.getParameterSets([
+            ScopedParameterLookup.direct(parameterLookupScope('lookup', '0'), ['baz'])
+        ]);
+        expect(parameters).toEqual([
+            {
+                '0': 'bar'
+            }
+        ]);
     });
 }
 //# sourceMappingURL=register-data-storage-parameter-tests.js.map