@powersync/service-module-mssql 0.0.1

package/test/src/CDCStream_resumable_snapshot.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from 'vitest';
+import { env } from './env.js';
+import { createTestTable, createTestTableWithBasicId, describeWithStorage, waitForPendingCDCChanges } from './util.js';
+import { TestStorageFactory } from '@powersync/service-core';
+import { METRICS_HELPER } from '@powersync/service-core-tests';
+import { ReplicationMetric } from '@powersync/service-types';
+import * as timers from 'node:timers/promises';
+import { ReplicationAbortedError } from '@powersync/lib-services-framework';
+import { CDCStreamTestContext } from './CDCStreamTestContext.js';
+import { getLatestReplicatedLSN } from '@module/utils/mssql.js';
+
+describe.skipIf(!(env.CI || env.SLOW_TESTS))('batch replication', function () {
+  describeWithStorage({ timeout: 240_000 }, function (factory) {
+    test('resuming initial replication (1)', async () => {
+      // Stop early - likely to not include deleted row in first replication attempt.
+      await testResumingReplication(factory, 2000);
+    });
+    test('resuming initial replication (2)', async () => {
+      // Stop late - likely to include deleted row in first replication attempt.
+      await testResumingReplication(factory, 8000);
+    });
+  });
+});
+
+async function testResumingReplication(factory: TestStorageFactory, stopAfter: number) {
+  // This tests interrupting and then resuming initial replication.
+  // We interrupt replication after test_data1 has fully replicated, and
+  // test_data2 has partially replicated.
+  // This test relies on interval behavior that is not 100% deterministic:
+  // 1. We attempt to abort initial replication once a certain number of
+  //    rows have been replicated, but this is not exact. Our only requirement
+  //    is that we have not fully replicated test_data2 yet.
+  // 2. Order of replication is not deterministic, so which specific rows
+  //    have been / have not been replicated at that point is not deterministic.
+  //    We do allow for some variation in the test results to account for this.
+
+  await using context = await CDCStreamTestContext.open(factory, { cdcStreamOptions: { snapshotBatchSize: 1000 } });
+
+  await context.updateSyncRules(`bucket_definitions:
+  global:
+    data:
+      - SELECT * FROM test_data1
+      - SELECT * FROM test_data2`);
+  const { connectionManager } = context;
+
+  await createTestTableWithBasicId(connectionManager, 'test_data1');
+  await createTestTableWithBasicId(connectionManager, 'test_data2');
+
+  let beforeLSN = await getLatestReplicatedLSN(connectionManager);
+  await connectionManager.query(`INSERT INTO test_data1(description) SELECT 'value' FROM GENERATE_SERIES(1, 1000, 1)`);
+  await connectionManager.query(`INSERT INTO test_data2(description) SELECT 'value' FROM GENERATE_SERIES(1, 10000, 1)`);
+
+  await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+  const p = context.replicateSnapshot();
+
+  let done = false;
+
+  const startRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
+  try {
+    (async () => {
+      while (!done) {
+        const count =
+          ((await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0) - startRowCount;
+
+        if (count >= stopAfter) {
+          break;
+        }
+        await timers.setTimeout(1);
+      }
+      // This interrupts initial replication
+      await context.dispose();
+    })();
+    // This confirms that initial replication was interrupted
+    const error = await p.catch((e) => e);
+    expect(error).toBeInstanceOf(ReplicationAbortedError);
+    done = true;
+  } finally {
+    done = true;
+  }
+
+  // Bypass the usual "clear db on factory open" step.
+  await using context2 = await CDCStreamTestContext.open(factory, {
+    doNotClear: true,
+    cdcStreamOptions: { snapshotBatchSize: 1000 }
+  });
+
+  beforeLSN = await getLatestReplicatedLSN(context2.connectionManager);
+  // This delete should be using one of the ids already replicated
+  const {
+    recordset: [id1]
+  } = await context2.connectionManager.query(`DELETE TOP (1) FROM test_data2 OUTPUT DELETED.id`);
+  // This update should also be using one of the ids already replicated
+  const {
+    recordset: [id2]
+  } = await context2.connectionManager.query(
+    `UPDATE test_data2 SET description = 'update1' OUTPUT INSERTED.id WHERE id = (SELECT TOP 1 id FROM test_data2)`
+  );
+  const {
+    recordset: [id3]
+  } = await context2.connectionManager.query(
+    `INSERT INTO test_data2(description) OUTPUT INSERTED.id VALUES ('insert1')`
+  );
+  await waitForPendingCDCChanges(beforeLSN, context2.connectionManager);
+
+  await context2.loadNextSyncRules();
+  await context2.replicateSnapshot();
+
+  await context2.startStreaming();
+  const data = await context2.getBucketData('global[]', undefined, {});
+
+  const deletedRowOps = data.filter((row) => row.object_type == 'test_data2' && row.object_id === String(id1));
+  const updatedRowOps = data.filter((row) => row.object_type == 'test_data2' && row.object_id === String(id2));
+  const insertedRowOps = data.filter((row) => row.object_type == 'test_data2' && row.object_id === String(id3));
+
+  if (deletedRowOps.length != 0) {
+    // The deleted row was part of the first replication batch,
+    // so it is removed by streaming replication.
+    expect(deletedRowOps.length).toEqual(2);
+    expect(deletedRowOps[1].op).toEqual('REMOVE');
+  } else {
+    // The deleted row was not part of the first replication batch,
+    // so it's not in the resulting ops at all.
+  }
+
+  expect(updatedRowOps.length).toEqual(2);
+  // description for the first op could be 'foo' or 'update1'.
+  // We only test the final version.
+  expect(JSON.parse(updatedRowOps[1].data as string).description).toEqual('update1');
+
+  expect(insertedRowOps.length).toEqual(2);
+  expect(JSON.parse(insertedRowOps[0].data as string).description).toEqual('insert1');
+  expect(JSON.parse(insertedRowOps[1].data as string).description).toEqual('insert1');
+
+  // 1000 of test_data1 during first replication attempt.
+  // N >= 1000 of test_data2 during first replication attempt.
+  // 10000 - N - 1 + 1 of test_data2 during second replication attempt.
+  // An additional update during streaming replication (2x total for this row).
+  // An additional insert during streaming replication (2x total for this row).
+  // If the deleted row was part of the first replication batch, it's removed by streaming replication.
+  // This adds 2 ops.
+  // We expect this to be 11002 for stopAfter: 2000, and 11004 for stopAfter: 8000.
+  // However, this is not deterministic.
+  const expectedCount = 11002 + deletedRowOps.length;
+  expect(data.length).toEqual(expectedCount);
+
+  const replicatedCount =
+    ((await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0) - startRowCount;
+
+  // With resumable replication, there should be no need to re-replicate anything.
+  expect(replicatedCount).toEqual(expectedCount);
+}

package/test/src/env.ts

@@ -0,0 +1,11 @@
+import { utils } from '@powersync/lib-services-framework';
+
+export const env = utils.collectEnvironmentVariables({
+  MSSQL_TEST_URI: utils.type.string.default(`mssql://sa:321strong_ROOT_password@localhost:1433/powersync`),
+  MONGO_TEST_URL: utils.type.string.default('mongodb://localhost:27017/powersync_test'),
+  CI: utils.type.boolean.default('false'),
+  SLOW_TESTS: utils.type.boolean.default('false'),
+  PG_STORAGE_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5431/powersync_storage_test'),
+  TEST_MONGO_STORAGE: utils.type.boolean.default('true'),
+  TEST_POSTGRES_STORAGE: utils.type.boolean.default('true')
+});

package/test/src/mssql-to-sqlite.test.ts

@@ -0,0 +1,474 @@
+import { SqliteInputRow } from '@powersync/service-sync-rules';
+import { afterAll, beforeEach, describe, expect, test } from 'vitest';
+import { clearTestDb, createUpperCaseUUID, TEST_CONNECTION_OPTIONS, waitForPendingCDCChanges } from './util.js';
+import { CDCToSqliteRow, toSqliteInputRow } from '@module/common/mssqls-to-sqlite.js';
+import { MSSQLConnectionManager } from '@module/replication/MSSQLConnectionManager.js';
+import {
+  enableCDCForTable,
+  getCaptureInstance,
+  getLatestReplicatedLSN,
+  getMinLSN,
+  toQualifiedTableName
+} from '@module/utils/mssql.js';
+import sql from 'mssql';
+
+describe('MSSQL Data Types Tests', () => {
+  const connectionManager = new MSSQLConnectionManager(TEST_CONNECTION_OPTIONS, {});
+
+  beforeEach(async () => {
+    await clearTestDb(connectionManager);
+    await setupTestTable();
+  });
+  afterAll(async () => {
+    await connectionManager.end();
+  });
+
+  async function setupTestTable() {
+    await connectionManager.query(`
+      CREATE TABLE ${connectionManager.schema}.test_data (
+        id INT IDENTITY(1,1) PRIMARY KEY,
+        tinyint_col TINYINT,
+        smallint_col SMALLINT,
+        int_col INT,
+        bigint_col BIGINT,
+        float_col FLOAT,
+        real_col REAL,
+        decimal_col DECIMAL(10,2),
+        numeric_col NUMERIC(10,2),
+        money_col MONEY,
+        smallmoney_col SMALLMONEY,
+        bit_col BIT,
+        
+        date_col DATE,
+        datetime_col DATETIME,
+        datetime2_col DATETIME2(6),
+        smalldatetime_col SMALLDATETIME,
+        datetimeoffset_col DATETIMEOFFSET(3),
+        time_col TIME(6),
+        
+        char_col CHAR(10),
+        varchar_col VARCHAR(255),
+        varchar_max_col VARCHAR(MAX),
+        nchar_col NCHAR(15),
+        nvarchar_col NVARCHAR(255),
+        nvarchar_max_col NVARCHAR(MAX),
+        text_col TEXT,
+        ntext_col NTEXT,
+        
+        binary_col BINARY(16),
+        varbinary_col VARBINARY(256),
+        varbinary_max_col VARBINARY(MAX),
+        image_col IMAGE,
+        
+        uniqueidentifier_col UNIQUEIDENTIFIER,
+        xml_col XML,
+        json_col NVARCHAR(MAX),
+        
+        hierarchyid_col HIERARCHYID,
+        geometry_col GEOMETRY,
+        geography_col GEOGRAPHY
+      )
+    `);
+
+    await enableCDCForTable({ connectionManager, table: 'test_data' });
+  }
+
+  test('Number types mappings', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    await connectionManager.query(`
+      INSERT INTO ${connectionManager.schema}.test_data(
+        tinyint_col,
+        smallint_col,
+        int_col,
+        bigint_col,
+        float_col,
+        real_col,
+        decimal_col,
+        numeric_col,
+        money_col,
+        smallmoney_col,
+        bit_col
+      ) VALUES (
+        255,                 -- TINYINT maximum value
+        32767,               -- SMALLINT maximum value
+        2147483647,          -- INT maximum value
+        9223372036854775807, -- BIGINT maximum value
+        3.1415926535,        -- FLOAT example
+        3.14,                -- REAL example
+        12345.67,            -- DECIMAL(10,2) example
+        12345.67,            -- NUMERIC(10,2) example
+        12345.67,            -- MONEY example
+        123.45,              -- SMALLMONEY example
+        1                    -- BIT value
+      )
+    `);
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    const expectedResult: SqliteInputRow = {
+      tinyint_col: 255,
+      smallint_col: 32767,
+      int_col: 2147483647,
+      bigint_col: 9223372036854775807n,
+      float_col: 3.1415926535,
+      real_col: expect.closeTo(3.14, 2),
+      decimal_col: 12345.67,
+      numeric_col: 12345.67,
+      money_col: 12345.67,
+      smallmoney_col: 123.45,
+      bit_col: 1
+    };
+    expect(databaseRows[0]).toMatchObject(expectedResult);
+    expect(replicatedRows[0]).toMatchObject(expectedResult);
+  });
+
+  test('Character types mappings', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    await connectionManager.query(`
+      INSERT INTO [${connectionManager.schema}].test_data (
+        char_col,
+        varchar_col,
+        varchar_max_col,
+        nchar_col,
+        nvarchar_col,
+        nvarchar_max_col,
+        text_col,
+        ntext_col
+      ) VALUES (
+        'CharData',               -- CHAR(10) with padding spaces
+        'Variable character data',-- VARCHAR(255)
+        'Variable character data MAX', -- VARCHAR(MAX)
+        N'UnicodeChar',           -- NCHAR(15)
+        N'Variable Unicode data', -- NVARCHAR(255)
+        N'Variable Unicode data MAX', -- NVARCHAR(MAX)
+        'TextData',               -- TEXT
+        N'UnicodeTextData'        -- NTEXT
+      )
+    `);
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+    const expectedResult = {
+      char_col: 'CharData  ', // CHAR pads with spaces up to the defined length (10)
+      varchar_col: 'Variable character data',
+      varchar_max_col: 'Variable character data MAX',
+      nchar_col: 'UnicodeChar    ', // NCHAR pads with spaces up to the defined length (15)
+      nvarchar_col: 'Variable Unicode data',
+      nvarchar_max_col: 'Variable Unicode data MAX',
+      text_col: 'TextData',
+      ntext_col: 'UnicodeTextData'
+    };
+
+    expect(databaseRows[0]).toMatchObject(expectedResult);
+    expect(replicatedRows[0]).toMatchObject(expectedResult);
+  });
+
+  test('Binary types mappings', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const binaryData = Buffer.from('BinaryData');
+    await connectionManager.query(
+      `
+      INSERT INTO [${connectionManager.schema}].test_data (
+        binary_col,
+        varbinary_col,
+        varbinary_max_col,
+        image_col
+      ) VALUES (
+        @binary_col,
+        @varbinary_col,
+        @varbinary_max_col,
+        @image_col
+      )
+    `,
+      [
+        { name: 'binary_col', type: sql.Binary, value: binaryData },
+        { name: 'varbinary_col', type: sql.VarBinary, value: binaryData },
+        { name: 'varbinary_max_col', type: sql.VarBinary(sql.MAX), value: binaryData },
+        { name: 'image_col', type: sql.Image, value: binaryData }
+      ]
+    );
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    const expectedBinary = new Uint8Array(binaryData);
+    const expectedBinaryPadded = new Uint8Array(16);
+    expectedBinaryPadded.set(expectedBinary.slice(0, 16), 0);
+
+    const expectedResult: SqliteInputRow = {
+      binary_col: expectedBinaryPadded,
+      varbinary_col: expectedBinary,
+      varbinary_max_col: expectedBinary,
+      image_col: expectedBinary
+    };
+
+    expect(databaseRows[0]).toMatchObject(expectedResult);
+    expect(replicatedRows[0]).toMatchObject(expectedResult);
+  });
+
+  test('Date types mappings', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const testDate = new Date('2023-03-06T15:47:00.000Z');
+    await connectionManager.query(
+      `
+      INSERT INTO [${connectionManager.schema}].test_data(
+        date_col, 
+        datetime_col, 
+        datetime2_col, 
+        smalldatetime_col,
+        time_col
+      )
+      VALUES (
+        @date_col,
+        @datetime_col,
+        @datetime2_col,
+        @smalldatetime_col,
+        @time_col
+      )
+    `,
+      [
+        { name: 'date_col', type: sql.Date, value: testDate },
+        { name: 'datetime_col', type: sql.DateTime, value: testDate },
+        { name: 'datetime2_col', type: sql.DateTime2(6), value: testDate },
+        { name: 'smalldatetime_col', type: sql.SmallDateTime, value: testDate },
+        { name: 'time_col', type: sql.Time(6), value: testDate }
+      ]
+    );
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+    const expectedResult = {
+      date_col: '2023-03-06',
+      datetime_col: '2023-03-06T15:47:00.000Z',
+      datetime2_col: '2023-03-06T15:47:00.000Z',
+      smalldatetime_col: '2023-03-06T15:47:00.000Z',
+      time_col: '15:47:00.000'
+    };
+
+    expect(databaseRows[0]).toMatchObject(expectedResult);
+    expect(replicatedRows[0]).toMatchObject(expectedResult);
+  });
+
+  test('Date types edge cases mappings', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+
+    await connectionManager.query(`
+      INSERT INTO [${connectionManager.schema}].test_data(datetime2_col) 
+      VALUES ('0001-01-01 00:00:00.000')
+    `);
+    await connectionManager.query(`
+      INSERT INTO [${connectionManager.schema}].test_data(datetime2_col) 
+      VALUES ('9999-12-31 23:59:59.999')
+    `);
+    await connectionManager.query(`
+      INSERT INTO [${connectionManager.schema}].test_data(datetime_col) 
+      VALUES ('1753-01-01 00:00:00')
+    `);
+    await connectionManager.query(`
+      INSERT INTO [${connectionManager.schema}].test_data(datetime_col) 
+      VALUES ('9999-12-31 23:59:59.997')
+    `);
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const expectedResults = [
+      { datetime2_col: '0001-01-01T00:00:00.000Z' },
+      { datetime2_col: '9999-12-31T23:59:59.999Z' },
+      { datetime_col: '1753-01-01T00:00:00.000Z' },
+      { datetime_col: '9999-12-31T23:59:59.997Z' }
+    ];
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    for (let i = 0; i < expectedResults.length; i++) {
+      expect(databaseRows[i]).toMatchObject(expectedResults[i]);
+      expect(replicatedRows[i]).toMatchObject(expectedResults[i]);
+    }
+  });
+
+  test('DateTimeOffset type mapping', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    // DateTimeOffset preserves timezone information
+    await connectionManager.query(`
+      INSERT INTO [${connectionManager.schema}].test_data(datetimeoffset_col) 
+      VALUES ('2023-03-06 15:47:00.000 +05:00')
+    `);
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const expectedResult = {
+      datetimeoffset_col: '2023-03-06T10:47:00.000Z' // Converted to UTC
+    };
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    // Note: The driver converts DateTimeOffset to Date, which incorporates the timezone offset which is then represented in UTC.
+    expect(databaseRows[0]).toMatchObject(expectedResult);
+    expect(replicatedRows[0]).toMatchObject(expectedResult);
+  });
+
+  test('UniqueIdentifier type mapping', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+
+    const testGuid = createUpperCaseUUID();
+    await connectionManager.query(
+      `
+      INSERT INTO [${connectionManager.schema}].test_data(uniqueidentifier_col) 
+      VALUES (@guid)
+    `,
+      [{ name: 'guid', type: sql.UniqueIdentifier, value: testGuid }]
+    );
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    // GUIDs are returned as strings
+    expect(databaseRows[0].uniqueidentifier_col).toBe(testGuid);
+    expect(replicatedRows[0].uniqueidentifier_col).toBe(testGuid);
+  });
+
+  test('JSON type mapping', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const expectedJSON = { name: 'John Doe', age: 30, married: true };
+    await connectionManager.query(
+      `
+      INSERT INTO [${connectionManager.schema}].test_data(json_col) 
+      VALUES (@json)
+    `,
+      [{ name: 'json', type: sql.NVarChar(sql.MAX), value: JSON.stringify(expectedJSON) }]
+    );
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    const actualDBJSONValue = JSON.parse(databaseRows[0].json_col as string);
+    const actualReplicatedJSONValue = JSON.parse(replicatedRows[0].json_col as string);
+    expect(actualDBJSONValue).toEqual(expectedJSON);
+    expect(actualReplicatedJSONValue).toEqual(expectedJSON);
+  });
+
+  test('XML type mapping', async () => {
+    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const xmlData = '<root><item>value</item></root>';
+    await connectionManager.query(
+      `
+      INSERT INTO [${connectionManager.schema}].test_data(xml_col) 
+      VALUES (@xml)
+    `,
+      [{ name: 'xml', type: sql.Xml, value: xmlData }]
+    );
+    await waitForPendingCDCChanges(beforeLSN, connectionManager);
+
+    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+    const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+
+    expect(databaseRows[0].xml_col).toBe(xmlData);
+    expect(replicatedRows[0].xml_col).toBe(xmlData);
+  });
+
+  // TODO: Update test when properly converting spatial types
+  // test('Spatial types mappings', async () => {
+  //   const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+  //   // Geometry and Geography types are stored as binary/WKT strings
+  //   await connectionManager.query(`
+  //     INSERT INTO [${connectionManager.schema}].test_data(geometry_col, geography_col)
+  //     VALUES (
+  //       geometry::STGeomFromText('POINT(1 2)', 0),
+  //       geography::STGeomFromText('POINT(1 2)', 4326)
+  //     )
+  //   `);
+  //   await waitForPendingCDCChanges(beforeLSN, connectionManager);
+  //
+  //   const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+  //   const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+  //
+  //   // The driver currently returns spatial types as non standard objects. We just convert them to JSON strings for now
+  //   expect(databaseRows[0].geometry_col).toBeDefined();
+  //   expect(databaseRows[0].geography_col).toBeDefined();
+  //   expect(replicatedRows[0].geometry_col).toBeDefined();
+  //   expect(replicatedRows[0].geography_col).toBeDefined();
+  // });
+
+  // TODO: Enable when HierarchyID type is properly supported
+  // test('HierarchyID type mapping', async () => {
+  //   const hierarchyid = '/1/';
+  //   const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+  //   await connectionManager.query(`
+  //     INSERT INTO [${connectionManager.schema}].test_data(hierarchyid_col)
+  //     VALUES (@hierarchyid)
+  //   `,
+  //     [{ name: 'hierarchyid', type: sql.VarChar, value: hierarchyid }]
+  //   );
+  //   await waitForPendingCDCChanges(beforeLSN, connectionManager);
+  //
+  //   const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+  //   const replicatedRows = await getReplicatedRows(connectionManager, 'test_data');
+  //
+  //   const expectedBinary = new Uint8Array(Buffer.from(hierarchyid));
+  //
+  //   expect(databaseRows[0].hierarchyid_col).toEqual(expectedBinary);
+  //   expect(replicatedRows[0].hierarchyid_col).toEqual(expectedBinary);
+  // });
+});
+
+async function getDatabaseRows(
+  connectionManager: MSSQLConnectionManager,
+  tableName: string
+): Promise<SqliteInputRow[]> {
+  const { recordset: rows } = await connectionManager.query(
+    `SELECT * FROM ${toQualifiedTableName(connectionManager.schema, tableName)}`
+  );
+  return rows.map((row) => {
+    const converted = toSqliteInputRow(row, rows.columns);
+    // Exclude id column from results
+    const { id, ...rest } = converted;
+    return rest;
+  });
+}
+
+/**
+ * Return all the updates from the CDC stream for the table.
+ */
+async function getReplicatedRows(
+  connectionManager: MSSQLConnectionManager,
+  tableName: string
+): Promise<SqliteInputRow[]> {
+  const endLSN = await getLatestReplicatedLSN(connectionManager);
+
+  const captureInstance = await getCaptureInstance({
+    connectionManager,
+    schema: connectionManager.schema,
+    tableName
+  });
+  if (!captureInstance) {
+    throw new Error(`No CDC capture instance found for table ${tableName}`);
+  }
+
+  const startLSN = await getMinLSN(connectionManager, captureInstance.name);
+  // Query CDC changes
+  const { recordset: results } = await connectionManager.query(
+    `
+      SELECT * FROM ${captureInstance.schema}.fn_cdc_get_all_changes_${captureInstance.name}(@from_lsn, @to_lsn, 'all update old') ORDER BY __$start_lsn, __$seqval
+  `,
+    [
+      { name: 'from_lsn', type: sql.VarBinary, value: startLSN.toBinary() },
+      { name: 'to_lsn', type: sql.VarBinary, value: endLSN.toBinary() }
+    ]
+  );
+
+  return results
+    .filter((row) => row.__$operation === 2) // Only INSERT operations
+    .map((row) => {
+      const converted = CDCToSqliteRow({ row, columns: results.columns });
+      // Exclude id column from results
+      const { id, ...rest } = converted;
+      return rest;
+    });
+}

package/test/src/setup.ts

@@ -0,0 +1,12 @@
+import { container } from '@powersync/lib-services-framework';
+import { METRICS_HELPER } from '@powersync/service-core-tests';
+import { beforeAll, beforeEach } from 'vitest';
+
+beforeAll(async () => {
+  // Executes for every test file
+  container.registerDefaults();
+});
+
+beforeEach(async () => {
+  METRICS_HELPER.resetMetrics();
+});