@powersync/service-core-tests 0.0.0-dev-20241219091224

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

@@ -0,0 +1,1571 @@
+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 { getUuidReplicaIdentityBson, storage } from '@powersync/service-core';
+import { RequestParameters } from '@powersync/service-sync-rules';
+import { expect, test } from 'vitest';
+import * as test_utils from '../test-utils/test-utils-index.js';
+export const TEST_TABLE = test_utils.makeTestTable('test', ['id']);
+/**
+ * Normalize data from OplogEntries for comparison in tests.
+ * Tests typically expect the stringified result
+ */
+const normalizeOplogData = (data) => {
+    if (data != null && typeof data == 'object') {
+        return JSON.stringify(data);
+    }
+    return data;
+};
+/**
+ * @example
+ * ```TypeScript
+ *
+ * describe('store - mongodb', function () {
+ *  registerDataStorageTests(MONGO_STORAGE_FACTORY);
+ * });
+ *
+ * ```
+ */
+export function registerDataStorageTests(generateStorageFactory) {
+    test('save and load parameters', async () => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  mybucket:
+    parameters:
+      - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
+    data: [] 
+    `);
+            const factory = __addDisposableResource(env_1, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result = 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')
+                });
+            });
+            const parameters = await bucketStorage.getParameterSets(result.flushed_op, [['mybucket', '1', 'user1']]);
+            expect(parameters).toEqual([
+                {
+                    group_id: 'group1a'
+                }
+            ]);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    });
+    test('it should use the latest version', async () => {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  mybucket:
+    parameters:
+      - SELECT group_id FROM test WHERE id = token_parameters.user_id
+    data: [] 
+    `);
+            const factory = __addDisposableResource(env_2, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result1 = 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')
+                });
+            });
+            const result2 = 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')
+                });
+            });
+            const parameters = await bucketStorage.getParameterSets(result2.flushed_op, [['mybucket', '1', 'user1']]);
+            expect(parameters).toEqual([
+                {
+                    group_id: 'group2'
+                }
+            ]);
+            // Use the checkpoint to get older data if relevant
+            const parameters2 = await bucketStorage.getParameterSets(result1.flushed_op, [['mybucket', '1', 'user1']]);
+            expect(parameters2).toEqual([
+                {
+                    group_id: 'group1'
+                }
+            ]);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    });
+    test('it should use the latest version after updates', async () => {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  mybucket:
+    parameters:
+      - SELECT id AS todo_id
+        FROM todos
+        WHERE list_id IN token_parameters.list_id
+    data: [] 
+    `);
+            const factory = __addDisposableResource(env_3, await generateStorageFactory(), true);
+            const bucketStorage = __addDisposableResource(env_3, factory.getInstance(sync_rules), true);
+            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')
+                });
+            });
+            const result2 = 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')
+                });
+            });
+            // We specifically request the todo_ids for both lists.
+            // There removal operation for the association of `list2`::`todo2` should not interfere with the new
+            // association of `list1`::`todo2`
+            const parameters = await bucketStorage.getParameterSets(BigInt(result2.flushed_op).toString(), [
+                ['mybucket', '1', 'list1'],
+                ['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_1 = __disposeResources(env_3);
+            if (result_1)
+                await result_1;
+        }
+    });
+    test('save and load parameters with different number types', async () => {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  mybucket:
+    parameters:
+      - SELECT group_id FROM test WHERE n1 = token_parameters.n1 and f2 = token_parameters.f2 and f3 = token_parameters.f3
+    data: []
+    `);
+            const factory = __addDisposableResource(env_4, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result = 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')
+                });
+            });
+            const TEST_PARAMS = { group_id: 'group1' };
+            const checkpoint = result.flushed_op;
+            const parameters1 = await bucketStorage.getParameterSets(checkpoint, [['mybucket', '1', 314n, 314, 3.14]]);
+            expect(parameters1).toEqual([TEST_PARAMS]);
+            const parameters2 = await bucketStorage.getParameterSets(checkpoint, [['mybucket', '1', 314, 314n, 3.14]]);
+            expect(parameters2).toEqual([TEST_PARAMS]);
+            const parameters3 = await bucketStorage.getParameterSets(checkpoint, [['mybucket', '1', 314n, 314, 3]]);
+            expect(parameters3).toEqual([]);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_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 sync_rules = test_utils.testRules(`
+bucket_definitions:
+  mybucket:
+    parameters:
+      - SELECT group_id FROM test WHERE n1 = token_parameters.n1
+    data: []
+    `);
+            const factory = __addDisposableResource(env_5, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result = 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')
+                });
+            });
+            const TEST_PARAMS = { group_id: 'group1' };
+            const checkpoint = result.flushed_op;
+            const parameters1 = await bucketStorage.getParameterSets(checkpoint, [['mybucket', '1', 1152921504606846976n]]);
+            expect(parameters1).toEqual([TEST_PARAMS]);
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    });
+    test('removing row', async () => {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "%"
+`);
+            const factory = __addDisposableResource(env_6, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    beforeReplicaId: test_utils.rid('test1')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id,
+                    checksum: d.checksum
+                };
+            });
+            const c1 = 2871785649;
+            const c2 = 2872534815;
+            expect(data).toEqual([
+                { op: 'PUT', object_id: 'test1', checksum: c1 },
+                { op: 'REMOVE', object_id: 'test1', checksum: c2 }
+            ]);
+            const checksums = [...(await bucketStorage.getChecksums(checkpoint, ['global[]'])).values()];
+            expect(checksums).toEqual([
+                {
+                    bucket: 'global[]',
+                    checksum: (c1 + c2) & 0xffffffff,
+                    count: 2
+                }
+            ]);
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_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 sync_rules_content = test_utils.testRules(`
+bucket_definitions:
+    by_workspace:
+      parameters:
+        - SELECT id as workspace_id FROM workspace WHERE
+          workspace."userId" = token_parameters.user_id
+      data: []
+    `);
+            const sync_rules = sync_rules_content.parsed(test_utils.PARSE_OPTIONS).sync_rules;
+            const factory = __addDisposableResource(env_7, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules_content);
+            const result = 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')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const parameters = new RequestParameters({ sub: 'u1' }, {});
+            const q1 = sync_rules.bucket_descriptors[0].parameter_queries[0];
+            const lookups = q1.getLookups(parameters);
+            expect(lookups).toEqual([['by_workspace', '1', 'u1']]);
+            const parameter_sets = await bucketStorage.getParameterSets(checkpoint, lookups);
+            expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
+            const buckets = await sync_rules.queryBucketIds({
+                getParameterSets(lookups) {
+                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                },
+                parameters
+            });
+            expect(buckets).toEqual(['by_workspace["workspace1"]']);
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            __disposeResources(env_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 sync_rules_content = test_utils.testRules(`
+bucket_definitions:
+    by_public_workspace:
+      parameters:
+        - SELECT id as workspace_id FROM workspace WHERE
+          workspace.visibility = 'public'
+      data: []
+    `);
+            const sync_rules = sync_rules_content.parsed(test_utils.PARSE_OPTIONS).sync_rules;
+            const factory = __addDisposableResource(env_8, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules_content);
+            const result = 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')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const parameters = new RequestParameters({ sub: 'unknown' }, {});
+            const q1 = sync_rules.bucket_descriptors[0].parameter_queries[0];
+            const lookups = q1.getLookups(parameters);
+            expect(lookups).toEqual([['by_public_workspace', '1']]);
+            const parameter_sets = await bucketStorage.getParameterSets(checkpoint, 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.queryBucketIds({
+                getParameterSets(lookups) {
+                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                },
+                parameters
+            });
+            buckets.sort();
+            expect(buckets).toEqual(['by_public_workspace["workspace1"]', 'by_public_workspace["workspace3"]']);
+        }
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
+        }
+        finally {
+            __disposeResources(env_8);
+        }
+    });
+    test('multiple parameter queries', async () => {
+        const env_9 = { stack: [], error: void 0, hasError: false };
+        try {
+            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
+            const sync_rules_content = test_utils.testRules(`
+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 = sync_rules_content.parsed(test_utils.PARSE_OPTIONS).sync_rules;
+            const factory = __addDisposableResource(env_9, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules_content);
+            const result = 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')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const parameters = new RequestParameters({ sub: 'u1' }, {});
+            // Test intermediate values - could be moved to sync_rules.test.ts
+            const q1 = sync_rules.bucket_descriptors[0].parameter_queries[0];
+            const lookups1 = q1.getLookups(parameters);
+            expect(lookups1).toEqual([['by_workspace', '1']]);
+            const parameter_sets1 = await bucketStorage.getParameterSets(checkpoint, lookups1);
+            parameter_sets1.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+            expect(parameter_sets1).toEqual([{ workspace_id: 'workspace1' }]);
+            const q2 = sync_rules.bucket_descriptors[0].parameter_queries[1];
+            const lookups2 = q2.getLookups(parameters);
+            expect(lookups2).toEqual([['by_workspace', '2', 'u1']]);
+            const parameter_sets2 = await bucketStorage.getParameterSets(checkpoint, 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.queryBucketIds({
+                getParameterSets(lookups) {
+                    return bucketStorage.getParameterSets(checkpoint, lookups);
+                },
+                parameters
+            });
+            buckets.sort();
+            expect(buckets).toEqual(['by_workspace["workspace1"]', 'by_workspace["workspace3"]']);
+        }
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
+        }
+        finally {
+            __disposeResources(env_9);
+        }
+    });
+    test('changing client ids', async () => {
+        const env_10 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT client_id as id, description FROM "%"
+`);
+            const factory = __addDisposableResource(env_10, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const sourceTable = TEST_TABLE;
+            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        client_id: 'client1a',
+                        description: 'test1a'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    after: {
+                        id: 'test1',
+                        client_id: 'client1b',
+                        description: 'test1b'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test2',
+                        client_id: 'client2',
+                        description: 'test2'
+                    },
+                    afterReplicaId: test_utils.rid('test2')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id
+                };
+            });
+            expect(data).toEqual([
+                { op: 'PUT', object_id: 'client1a' },
+                { op: 'PUT', object_id: 'client1b' },
+                { op: 'REMOVE', object_id: 'client1a' },
+                { op: 'PUT', object_id: 'client2' }
+            ]);
+        }
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
+        }
+        finally {
+            __disposeResources(env_10);
+        }
+    });
+    test('re-apply delete', async () => {
+        const env_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "%"
+`);
+            const factory = __addDisposableResource(env_11, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+            });
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    beforeReplicaId: test_utils.rid('test1')
+                });
+            });
+            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    beforeReplicaId: test_utils.rid('test1')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id,
+                    checksum: d.checksum
+                };
+            });
+            const c1 = 2871785649;
+            const c2 = 2872534815;
+            expect(data).toEqual([
+                { op: 'PUT', object_id: 'test1', checksum: c1 },
+                { op: 'REMOVE', object_id: 'test1', checksum: c2 }
+            ]);
+            const checksums = [...(await bucketStorage.getChecksums(checkpoint, ['global[]'])).values()];
+            expect(checksums).toEqual([
+                {
+                    bucket: 'global[]',
+                    checksum: (c1 + c2) & 0xffffffff,
+                    count: 2
+                }
+            ]);
+        }
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            __disposeResources(env_11);
+        }
+    });
+    test('re-apply update + delete', async () => {
+        const env_12 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "%"
+`);
+            const factory = __addDisposableResource(env_12, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+            });
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    after: {
+                        id: 'test1',
+                        description: undefined
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    after: {
+                        id: 'test1',
+                        description: undefined
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    beforeReplicaId: test_utils.rid('test1')
+                });
+            });
+            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    after: {
+                        id: 'test1',
+                        description: undefined
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    after: {
+                        id: 'test1',
+                        description: undefined
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    beforeReplicaId: test_utils.rid('test1')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id,
+                    checksum: d.checksum
+                };
+            });
+            const c1 = 2871785649;
+            const c2 = 2872534815;
+            expect(data).toEqual([
+                { op: 'PUT', object_id: 'test1', checksum: c1 },
+                { op: 'PUT', object_id: 'test1', checksum: c1 },
+                { op: 'PUT', object_id: 'test1', checksum: c1 },
+                { op: 'REMOVE', object_id: 'test1', checksum: c2 }
+            ]);
+            const checksums = [...(await bucketStorage.getChecksums(checkpoint, ['global[]'])).values()];
+            expect(checksums).toEqual([
+                {
+                    bucket: 'global[]',
+                    checksum: (c1 + c1 + c1 + c2) & 0xffffffff,
+                    count: 4
+                }
+            ]);
+        }
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
+        }
+        finally {
+            __disposeResources(env_12);
+        }
+    });
+    test('truncate parameters', async () => {
+        const env_13 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  mybucket:
+    parameters:
+      - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
+    data: []
+    `);
+            const factory = __addDisposableResource(env_13, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            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 bucketStorage.getParameterSets(checkpoint, [['mybucket', '1', 'user1']]);
+            expect(parameters).toEqual([]);
+        }
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
+        }
+        finally {
+            __disposeResources(env_13);
+        }
+    });
+    test('batch with overlapping replica ids', async () => {
+        const env_14 = { stack: [], error: void 0, hasError: false };
+        try {
+            // This test checks that we get the correct output when processing rows with:
+            // 1. changing replica ids
+            // 2. overlapping with replica ids of other rows in the same transaction (at different times)
+            // If operations are not processing in input order, this breaks easily.
+            // It can break at two places:
+            // 1. Not getting the correct "current_data" state for each operation.
+            // 2. Output order not being correct.
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test"
+`);
+            const factory = __addDisposableResource(env_14, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            // Pre-setup
+            const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test2',
+                        description: 'test2a'
+                    },
+                    afterReplicaId: test_utils.rid('test2')
+                });
+            });
+            const checkpoint1 = result1?.flushed_op ?? '0';
+            // Test batch
+            const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                // b
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1b'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    before: {
+                        id: 'test1'
+                    },
+                    beforeReplicaId: test_utils.rid('test1'),
+                    after: {
+                        id: 'test2',
+                        description: 'test2b'
+                    },
+                    afterReplicaId: test_utils.rid('test2')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    before: {
+                        id: 'test2'
+                    },
+                    beforeReplicaId: test_utils.rid('test2'),
+                    after: {
+                        id: 'test3',
+                        description: 'test3b'
+                    },
+                    afterReplicaId: test_utils.rid('test3')
+                });
+                // c
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    after: {
+                        id: 'test2',
+                        description: 'test2c'
+                    },
+                    afterReplicaId: test_utils.rid('test2')
+                });
+                // d
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test4',
+                        description: 'test4d'
+                    },
+                    afterReplicaId: test_utils.rid('test4')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    before: {
+                        id: 'test4'
+                    },
+                    beforeReplicaId: test_utils.rid('test4'),
+                    after: {
+                        id: 'test5',
+                        description: 'test5d'
+                    },
+                    afterReplicaId: test_utils.rid('test5')
+                });
+            });
+            const checkpoint2 = result2.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint2, new Map([['global[]', checkpoint1]])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id,
+                    data: normalizeOplogData(d.data)
+                };
+            });
+            // Operations must be in this order
+            expect(data).toEqual([
+                // b
+                { op: 'PUT', object_id: 'test1', data: JSON.stringify({ id: 'test1', description: 'test1b' }) },
+                { op: 'REMOVE', object_id: 'test1', data: null },
+                { op: 'PUT', object_id: 'test2', data: JSON.stringify({ id: 'test2', description: 'test2b' }) },
+                { op: 'REMOVE', object_id: 'test2', data: null },
+                { op: 'PUT', object_id: 'test3', data: JSON.stringify({ id: 'test3', description: 'test3b' }) },
+                // c
+                { op: 'PUT', object_id: 'test2', data: JSON.stringify({ id: 'test2', description: 'test2c' }) },
+                // d
+                { op: 'PUT', object_id: 'test4', data: JSON.stringify({ id: 'test4', description: 'test4d' }) },
+                { op: 'REMOVE', object_id: 'test4', data: null },
+                { op: 'PUT', object_id: 'test5', data: JSON.stringify({ id: 'test5', description: 'test5d' }) }
+            ]);
+        }
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
+        }
+        finally {
+            __disposeResources(env_14);
+        }
+    });
+    test('changed data with replica identity full', async () => {
+        const env_15 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test"
+`);
+            function rid2(id, description) {
+                return getUuidReplicaIdentityBson({ id, description }, [
+                    { name: 'id', type: 'VARCHAR', typeId: 25 },
+                    { name: 'description', type: 'VARCHAR', typeId: 25 }
+                ]);
+            }
+            const factory = __addDisposableResource(env_15, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const sourceTable = test_utils.makeTestTable('test', ['id', 'description']);
+            // Pre-setup
+            const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    afterReplicaId: rid2('test1', 'test1a')
+                });
+            });
+            const checkpoint1 = result1?.flushed_op ?? '0';
+            const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                // Unchanged, but has a before id
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    before: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    beforeReplicaId: rid2('test1', 'test1a'),
+                    after: {
+                        id: 'test1',
+                        description: 'test1b'
+                    },
+                    afterReplicaId: rid2('test1', 'test1b')
+                });
+            });
+            const result3 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                // Delete
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    before: {
+                        id: 'test1',
+                        description: 'test1b'
+                    },
+                    beforeReplicaId: rid2('test1', 'test1b'),
+                    after: undefined
+                });
+            });
+            const checkpoint3 = result3.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint3, new Map([['global[]', checkpoint1]])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id,
+                    data: normalizeOplogData(d.data),
+                    subkey: d.subkey
+                };
+            });
+            // Operations must be in this order
+            expect(data).toEqual([
+                // 2
+                // The REMOVE is expected because the subkey changes
+                {
+                    op: 'REMOVE',
+                    object_id: 'test1',
+                    data: null,
+                    subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
+                },
+                {
+                    op: 'PUT',
+                    object_id: 'test1',
+                    data: JSON.stringify({ id: 'test1', description: 'test1b' }),
+                    subkey: '6544e3899293153fa7b38331/500e9b68-a2fd-51ff-9c00-313e2fb9f562'
+                },
+                // 3
+                {
+                    op: 'REMOVE',
+                    object_id: 'test1',
+                    data: null,
+                    subkey: '6544e3899293153fa7b38331/500e9b68-a2fd-51ff-9c00-313e2fb9f562'
+                }
+            ]);
+        }
+        catch (e_15) {
+            env_15.error = e_15;
+            env_15.hasError = true;
+        }
+        finally {
+            __disposeResources(env_15);
+        }
+    });
+    test('unchanged data with replica identity full', async () => {
+        const env_16 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "test"
+`);
+            function rid2(id, description) {
+                return getUuidReplicaIdentityBson({ id, description }, [
+                    { name: 'id', type: 'VARCHAR', typeId: 25 },
+                    { name: 'description', type: 'VARCHAR', typeId: 25 }
+                ]);
+            }
+            const factory = __addDisposableResource(env_16, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const sourceTable = test_utils.makeTestTable('test', ['id', 'description']);
+            // Pre-setup
+            const result1 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    afterReplicaId: rid2('test1', 'test1a')
+                });
+            });
+            const checkpoint1 = result1?.flushed_op ?? '0';
+            const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                // Unchanged, but has a before id
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.UPDATE,
+                    before: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    beforeReplicaId: rid2('test1', 'test1a'),
+                    after: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    afterReplicaId: rid2('test1', 'test1a')
+                });
+            });
+            const result3 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                // Delete
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.DELETE,
+                    before: {
+                        id: 'test1',
+                        description: 'test1a'
+                    },
+                    beforeReplicaId: rid2('test1', 'test1a'),
+                    after: undefined
+                });
+            });
+            const checkpoint3 = result3.flushed_op;
+            const batch = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint3, new Map([['global[]', checkpoint1]])));
+            const data = batch[0].batch.data.map((d) => {
+                return {
+                    op: d.op,
+                    object_id: d.object_id,
+                    data: normalizeOplogData(d.data),
+                    subkey: d.subkey
+                };
+            });
+            // Operations must be in this order
+            expect(data).toEqual([
+                // 2
+                {
+                    op: 'PUT',
+                    object_id: 'test1',
+                    data: JSON.stringify({ id: 'test1', description: 'test1a' }),
+                    subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
+                },
+                // 3
+                {
+                    op: 'REMOVE',
+                    object_id: 'test1',
+                    data: null,
+                    subkey: '6544e3899293153fa7b38331/740ba9f2-8b0f-53e3-bb17-5f38a9616f0e'
+                }
+            ]);
+        }
+        catch (e_16) {
+            env_16.error = e_16;
+            env_16.hasError = true;
+        }
+        finally {
+            __disposeResources(env_16);
+        }
+    });
+    test('large batch', async () => {
+        const env_17 = { 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 sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "%"
+`);
+            const factory = __addDisposableResource(env_17, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                const largeDescription = '0123456789'.repeat(1200000);
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test1',
+                        description: 'test1'
+                    },
+                    afterReplicaId: test_utils.rid('test1')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'large1',
+                        description: largeDescription
+                    },
+                    afterReplicaId: test_utils.rid('large1')
+                });
+                // Large enough to split the returned batch
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'large2',
+                        description: largeDescription
+                    },
+                    afterReplicaId: test_utils.rid('large2')
+                });
+                await batch.save({
+                    sourceTable,
+                    tag: storage.SaveOperationTag.INSERT,
+                    after: {
+                        id: 'test3',
+                        description: 'test3'
+                    },
+                    afterReplicaId: test_utils.rid('test3')
+                });
+            });
+            const checkpoint = result.flushed_op;
+            const options = {
+                chunkLimitBytes: 16 * 1024 * 1024
+            };
+            const batch1 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']]), options));
+            expect(test_utils.getBatchData(batch1)).toEqual([
+                { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
+                { op_id: '2', op: 'PUT', object_id: 'large1', checksum: 454746904 }
+            ]);
+            expect(test_utils.getBatchMeta(batch1)).toEqual({
+                after: '0',
+                has_more: true,
+                next_after: '2'
+            });
+            const batch2 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1[0].batch.next_after]]), options));
+            expect(test_utils.getBatchData(batch2)).toEqual([
+                { op_id: '3', op: 'PUT', object_id: 'large2', checksum: 1795508474 },
+                { op_id: '4', op: 'PUT', object_id: 'test3', checksum: 1359888332 }
+            ]);
+            expect(test_utils.getBatchMeta(batch2)).toEqual({
+                after: '2',
+                has_more: false,
+                next_after: '4'
+            });
+            const batch3 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2[0].batch.next_after]]), options));
+            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;
+        }
+        finally {
+            __disposeResources(env_17);
+        }
+    });
+    test('long batch', async () => {
+        const env_18 = { stack: [], error: void 0, hasError: false };
+        try {
+            // Test syncing a batch of data that is limited by count.
+            const sync_rules = test_utils.testRules(`
+bucket_definitions:
+  global:
+    data:
+      - SELECT id, description FROM "%"
+`);
+            const factory = __addDisposableResource(env_18, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                const sourceTable = TEST_TABLE;
+                for (let i = 1; i <= 6; i++) {
+                    await batch.save({
+                        sourceTable,
+                        tag: storage.SaveOperationTag.INSERT,
+                        after: {
+                            id: `test${i}`,
+                            description: `test${i}`
+                        },
+                        afterReplicaId: `test${i}`
+                    });
+                }
+            });
+            const checkpoint = result.flushed_op;
+            const batch1 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', '0']]), { limit: 4 }));
+            expect(test_utils.getBatchData(batch1)).toEqual([
+                { op_id: '1', op: 'PUT', object_id: 'test1', checksum: 2871785649 },
+                { op_id: '2', op: 'PUT', object_id: 'test2', checksum: 730027011 },
+                { op_id: '3', op: 'PUT', object_id: 'test3', checksum: 1359888332 },
+                { op_id: '4', op: 'PUT', object_id: 'test4', checksum: 2049153252 }
+            ]);
+            expect(test_utils.getBatchMeta(batch1)).toEqual({
+                after: '0',
+                has_more: true,
+                next_after: '4'
+            });
+            const batch2 = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', batch1.batch.next_after]]), {
+                limit: 4
+            }));
+            expect(test_utils.getBatchData(batch2)).toEqual([
+                { op_id: '5', op: 'PUT', object_id: 'test5', checksum: 3686902721 },
+                { op_id: '6', op: 'PUT', object_id: 'test6', checksum: 1974820016 }
+            ]);
+            expect(test_utils.getBatchMeta(batch2)).toEqual({
+                after: '4',
+                has_more: false,
+                next_after: '6'
+            });
+            const batch3 = await test_utils.fromAsync(bucketStorage.getBucketDataBatch(checkpoint, new Map([['global[]', batch2.batch.next_after]]), {
+                limit: 4
+            }));
+            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;
+        }
+        finally {
+            __disposeResources(env_18);
+        }
+    });
+    test('batch should be disposed automatically', async () => {
+        const env_19 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+      bucket_definitions:
+        global:
+          data: [] 
+          `);
+            const factory = __addDisposableResource(env_19, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            let isDisposed = false;
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                batch.registerListener({
+                    disposed: () => {
+                        isDisposed = true;
+                    }
+                });
+            });
+            expect(isDisposed).true;
+            isDisposed = false;
+            let errorCaught = false;
+            try {
+                await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                    batch.registerListener({
+                        disposed: () => {
+                            isDisposed = true;
+                        }
+                    });
+                    throw new Error(`Testing exceptions`);
+                });
+            }
+            catch (ex) {
+                errorCaught = true;
+                expect(ex.message.includes('Testing')).true;
+            }
+            expect(errorCaught).true;
+            expect(isDisposed).true;
+        }
+        catch (e_19) {
+            env_19.error = e_19;
+            env_19.hasError = true;
+        }
+        finally {
+            __disposeResources(env_19);
+        }
+    });
+    test('batch should be disposed automatically', async () => {
+        const env_20 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules = test_utils.testRules(`
+      bucket_definitions:
+        global:
+          data: [] 
+          `);
+            const factory = __addDisposableResource(env_20, await generateStorageFactory(), false);
+            const bucketStorage = factory.getInstance(sync_rules);
+            let isDisposed = false;
+            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                batch.registerListener({
+                    disposed: () => {
+                        isDisposed = true;
+                    }
+                });
+            });
+            expect(isDisposed).true;
+            isDisposed = false;
+            let errorCaught = false;
+            try {
+                await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
+                    batch.registerListener({
+                        disposed: () => {
+                            isDisposed = true;
+                        }
+                    });
+                    throw new Error(`Testing exceptions`);
+                });
+            }
+            catch (ex) {
+                errorCaught = true;
+                expect(ex.message.includes('Testing')).true;
+            }
+            expect(errorCaught).true;
+            expect(isDisposed).true;
+        }
+        catch (e_20) {
+            env_20.error = e_20;
+            env_20.hasError = true;
+        }
+        finally {
+            __disposeResources(env_20);
+        }
+    });
+    test('empty storage metrics', async () => {
+        const env_21 = { stack: [], error: void 0, hasError: false };
+        try {
+            const f = __addDisposableResource(env_21, await generateStorageFactory({ dropAll: true }), false);
+            const metrics = await f.getStorageMetrics();
+            expect(metrics).toEqual({
+                operations_size_bytes: 0,
+                parameters_size_bytes: 0,
+                replication_size_bytes: 0
+            });
+            const r = await f.configureSyncRules('bucket_definitions: {}');
+            const storage = f.getInstance(r.persisted_sync_rules);
+            await storage.autoActivate();
+            const metrics2 = await f.getStorageMetrics();
+            expect(metrics2).toEqual({
+                operations_size_bytes: 0,
+                parameters_size_bytes: 0,
+                replication_size_bytes: 0
+            });
+        }
+        catch (e_21) {
+            env_21.error = e_21;
+            env_21.hasError = true;
+        }
+        finally {
+            __disposeResources(env_21);
+        }
+    });
+    test('invalidate cached parsed sync rules', async () => {
+        const env_22 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sync_rules_content = test_utils.testRules(`
+bucket_definitions:
+    by_workspace:
+      parameters:
+        - SELECT id as workspace_id FROM workspace WHERE
+          workspace."userId" = token_parameters.user_id
+      data: []
+    `);
+            const bucketStorageFactory = __addDisposableResource(env_22, await generateStorageFactory(), false);
+            const syncBucketStorage = bucketStorageFactory.getInstance(sync_rules_content);
+            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_22) {
+            env_22.error = e_22;
+            env_22.hasError = true;
+        }
+        finally {
+            __disposeResources(env_22);
+        }
+    });
+}
+//# sourceMappingURL=register-data-storage-tests.js.map