@powersync/service-module-mssql 0.0.0-dev-20251202102946 → 0.0.0-dev-20251208145829

package/src/replication/MSSQLSnapshotQuery.ts

@@ -1,5 +1,4 @@
 import { bson, ColumnDescriptor, SourceTable } from '@powersync/service-core';
-import { SqliteValue } from '@powersync/service-sync-rules';
 import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import { MSSQLBaseType } from '../types/mssql-data-types.js';
 import sql from 'mssql';
@@ -15,8 +14,6 @@ export interface MSSQLSnapshotQuery {
   next(): AsyncIterableIterator<sql.IColumnMetadata | sql.IRecordSet<any>>;
 }
 
-export type PrimaryKeyValue = Record<string, SqliteValue>;
-
 /**
  * Snapshot query using a plain SELECT * FROM table
  *
@@ -177,54 +174,3 @@ export class BatchedSnapshotQuery implements MSSQLSnapshotQuery {
     return decoded[this.key.name];
   }
 }
-
-/**
- * This performs a snapshot query using a list of primary keys.
- *
- * This is not used for general snapshots, but is used when we need to re-fetch specific rows
- * during streaming replication.
- */
-export class IdSnapshotQuery implements MSSQLSnapshotQuery {
-  static supports(table: SourceTable | MSSQLSourceTable) {
-    // We have the same requirements as BatchedSnapshotQuery.
-    // This is typically only used as a fallback when ChunkedSnapshotQuery
-    // skipped some rows.
-    return BatchedSnapshotQuery.supports(table);
-  }
-
-  public constructor(
-    private readonly transaction: sql.Transaction,
-    private readonly table: MSSQLSourceTable,
-    private readonly keys: PrimaryKeyValue[]
-  ) {}
-
-  public async initialize(): Promise<void> {
-    // No-op
-  }
-
-  public async *next(): AsyncIterableIterator<sql.IColumnMetadata | sql.IRecordSet<any>> {
-    const metadataRequest = this.transaction.request();
-    metadataRequest.stream = true;
-    const metadataPromise = new Promise<sql.IColumnMetadata>((resolve, reject) => {
-      metadataRequest.on('recordset', resolve);
-      metadataRequest.on('error', reject);
-    });
-    metadataRequest.query(`SELECT TOP(0) * FROM ${this.table.toQualifiedName()}`);
-    const columnMetadata: sql.IColumnMetadata = await metadataPromise;
-    yield columnMetadata;
-
-    const keyDefinition = this.table.sourceTable.replicaIdColumns[0];
-    const ids = this.keys.map((record) => record[keyDefinition.name]);
-
-    const request = this.transaction.request();
-    const stream = request.toReadableStream();
-    request
-      .input('ids', ids)
-      .query(`SELECT * FROM ${this.table.toQualifiedName()} WHERE ${escapeIdentifier(keyDefinition.name)} = @ids`);
-
-    // MSSQL only streams one row at a time
-    for await (const row of stream) {
-      yield row;
-    }
-  }
-}

package/src/utils/mssql.ts

@@ -89,8 +89,11 @@ export async function ensurePowerSyncCheckpointsTable(connectionManager: MSSQLCo
   try {
     // check if the dbo_powersync_checkpoints table exists
     const { recordset: checkpointsResult } = await connectionManager.query(`
-    SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${connectionManager.schema}' AND TABLE_NAME = '${POWERSYNC_CHECKPOINTS_TABLE}';
-  `);
+    SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName;
+  `, [
+    { name: 'schema', type: sql.VarChar(sql.MAX), value: connectionManager.schema },
+    { name: 'tableName', type: sql.VarChar(sql.MAX), value: POWERSYNC_CHECKPOINTS_TABLE },
+  ]);
     if (checkpointsResult.length > 0) {
       // Table already exists, check if CDC is enabled
       const isEnabled = await isTableEnabledForCDC({
@@ -114,7 +117,7 @@ export async function ensurePowerSyncCheckpointsTable(connectionManager: MSSQLCo
   // Try to create the table
   try {
     await connectionManager.query(`
-  CREATE TABLE ${connectionManager.schema}.${POWERSYNC_CHECKPOINTS_TABLE} (
+  CREATE TABLE ${escapeIdentifier(connectionManager.schema)}.${escapeIdentifier(POWERSYNC_CHECKPOINTS_TABLE)} (
     id INT IDENTITY PRIMARY KEY,
     last_updated DATETIME NOT NULL DEFAULT (GETDATE())
   )`);
@@ -137,7 +140,7 @@ export async function ensurePowerSyncCheckpointsTable(connectionManager: MSSQLCo
 
 export async function createCheckpoint(connectionManager: MSSQLConnectionManager): Promise<void> {
   await connectionManager.query(`
-    MERGE ${connectionManager.schema}.${POWERSYNC_CHECKPOINTS_TABLE} AS target
+    MERGE ${escapeIdentifier(connectionManager.schema)}.${escapeIdentifier(POWERSYNC_CHECKPOINTS_TABLE)} AS target
     USING (SELECT 1 AS id) AS source
     ON target.id = source.id
     WHEN MATCHED THEN 
@@ -164,10 +167,12 @@ export async function isTableEnabledForCDC(options: IsTableEnabledForCDCOptions)
       SELECT 1 FROM cdc.change_tables ct
          JOIN sys.tables    AS tbl ON tbl.object_id = ct.source_object_id
          JOIN sys.schemas   AS sch ON sch.schema_id = tbl.schema_id
-      WHERE sch.name = '${schema}'
-        AND tbl.name = '${table}'
-      `
-  );
+      WHERE sch.name = @schema
+        AND tbl.name = @tableName
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: schema },
+        { name: 'tableName', type: sql.VarChar(sql.MAX), value: table },
+      ]);
   return checkResult.length > 0;
 }
 
@@ -227,7 +232,8 @@ export async function isWithinRetentionThreshold(options: IsWithinRetentionThres
 
 export async function getMinLSN(connectionManager: MSSQLConnectionManager, captureInstance: string): Promise<LSN> {
   const { recordset: result } = await connectionManager.query(
-    `SELECT sys.fn_cdc_get_min_lsn('${captureInstance}') AS min_lsn`
+    `SELECT sys.fn_cdc_get_min_lsn(@captureInstance) AS min_lsn`,
+    [{ name: 'captureInstance', type: sql.VarChar(sql.MAX), value: captureInstance }]
   );
   const rawMinLSN: Buffer = result[0].min_lsn;
   return LSN.fromBinary(rawMinLSN);
@@ -258,11 +264,13 @@ export async function getCaptureInstance(options: GetCaptureInstanceOptions): Pr
         sys.tables tbl
           INNER JOIN sys.schemas sch ON tbl.schema_id = sch.schema_id
           INNER JOIN cdc.change_tables ct ON ct.source_object_id = tbl.object_id
-      WHERE sch.name = '${schema}'
-        AND tbl.name = '${tableName}'
+      WHERE sch.name = @schema
+        AND tbl.name = @tableName
         AND ct.end_lsn IS NULL;
-      `
-  );
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: schema },
+        { name: 'tableName', type: sql.VarChar(sql.MAX), value: tableName },
+      ]);
 
   if (result.length === 0) {
     return null;
@@ -301,7 +309,10 @@ export async function getLatestReplicatedLSN(connectionManager: MSSQLConnectionM
  *  @param identifier
  */
 export function escapeIdentifier(identifier: string): string {
-  return `[${identifier}]`;
+  // 1. Replace existing closing brackets ] with ]] to escape them
+  // 2. Replace dots . with ].[ to handle qualified names
+  // 3. Wrap the whole result in [ ]
+  return `[${identifier.replace(/]/g, ']]').replace(/\./g, '].[')}]`;
 }
 
 export function toQualifiedTableName(schema: string, tableName: string): string {
@@ -383,7 +394,9 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
 
   let selectError: service_types.ReplicationError | null = null;
   try {
-    await connectionManager.query(`SELECT TOP 1 * FROM ${toQualifiedTableName(schema, table.name)}`);
+    await connectionManager.query(`SELECT TOP 1 * FROM @tableName`, [
+      { name: 'tableName', type: sql.VarChar(sql.MAX), value: toQualifiedTableName(schema, table.name) },
+    ]);
   } catch (e) {
     selectError = { level: 'fatal', message: e.message };
   }

package/src/utils/schema.ts

@@ -2,7 +2,7 @@ import { SourceEntityDescriptor } from '@powersync/service-core';
 import { TablePattern } from '@powersync/service-sync-rules';
 import { MSSQLConnectionManager } from '../replication/MSSQLConnectionManager.js';
 import { MSSQLColumnDescriptor } from '../types/mssql-data-types.js';
-import { escapeIdentifier } from './mssql.js';
+import sql from 'mssql';
 
 export interface GetColumnsOptions {
   connectionManager: MSSQLConnectionManager;
@@ -23,10 +23,13 @@ async function getColumns(options: GetColumnsOptions): Promise<MSSQLColumnDescri
         JOIN sys.tables AS tbl ON tbl.object_id = col.object_id
         JOIN sys.schemas AS sch ON sch.schema_id = tbl.schema_id
         JOIN sys.types AS typ ON typ.user_type_id = col.user_type_id
-      WHERE sch.name = '${schema}'
-        AND tbl.name = '${tableName}'
+      WHERE sch.name = @schema
+        AND tbl.name = @tableName
       ORDER BY col.column_id;
-      `);
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: schema },
+        { name: 'tableName', type: sql.VarChar(sql.MAX), value: tableName },
+      ]);
 
   return columnResults.map((row) => {
     return {
@@ -65,10 +68,13 @@ export async function getReplicationIdentityColumns(
         JOIN sys.index_columns  AS idx_col ON idx_col.object_id = idx.object_id AND idx_col.index_id = idx.index_id
         JOIN sys.columns        AS col ON col.object_id  = idx_col.object_id AND col.column_id  = idx_col.column_id
         JOIN sys.types          AS typ ON typ.user_type_id = col.user_type_id
-      WHERE sch.name = '${schema}'
-        AND tbl.name = '${tableName}'
+      WHERE sch.name = @schema
+        AND tbl.name = @tableName
       ORDER BY idx_col.key_ordinal;
-      `);
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: schema },
+        { name: 'tableName', type: sql.VarChar(sql.MAX), value: tableName },
+      ]);
 
   if (primaryKeyColumns.length > 0) {
     return {
@@ -95,10 +101,13 @@ export async function getReplicationIdentityColumns(
         JOIN sys.index_columns   AS idx_col ON idx_col.object_id = idx.object_id AND idx_col.index_id = idx.index_id
         JOIN sys.columns         AS col ON col.object_id  = idx_col.object_id AND col.column_id  = idx_col.column_id
         JOIN sys.types           AS typ ON typ.user_type_id = col.user_type_id
-      WHERE sch.name = '${schema}'
-        AND tbl.name = '${tableName}'
+      WHERE sch.name = @schema
+        AND tbl.name = @tableName
       ORDER BY idx_col.key_ordinal;
-      `);
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: schema },
+        { name: 'tableName', type: sql.VarChar(sql.MAX), value: tableName },
+      ]);
 
   if (uniqueKeyColumns.length > 0) {
     return {
@@ -134,9 +143,12 @@ export async function getTablesFromPattern(
           tbl.object_id AS object_id
         FROM sys.tables tbl
           JOIN sys.schemas sch ON tbl.schema_id = sch.schema_id
-        WHERE sch.name = '${tablePattern.schema}'
-          AND tbl.name LIKE '${tablePattern.tablePattern}'
-      `);
+        WHERE sch.name = @schema
+          AND tbl.name LIKE @tablePattern
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: tablePattern.schema },
+        { name: 'tablePattern', type: sql.VarChar(sql.MAX), value: tablePattern.tablePattern },
+      ]);
 
     return tableResults
       .map((row) => {
@@ -156,10 +168,12 @@ export async function getTablesFromPattern(
           tbl.object_id AS object_id
         FROM sys.tables tbl
           JOIN sys.schemas sch ON tbl.schema_id = sch.schema_id
-        WHERE sch.name = '${tablePattern.schema}'
-          AND tbl.name = '${tablePattern.name}'
-      `
-    );
+          WHERE sch.name = @schema
+          AND tbl.name = @tablePattern
+      `, [
+        { name: 'schema', type: sql.VarChar(sql.MAX), value: tablePattern.schema },
+        { name: 'tablePattern', type: sql.VarChar(sql.MAX), value: tablePattern.tablePattern },
+      ]);
 
     return tableResults.map((row) => {
       return {

package/test/src/CDCStream.test.ts

@@ -4,7 +4,7 @@ import { ReplicationMetric } from '@powersync/service-types';
 import { createTestTable, describeWithStorage, insertTestData, waitForPendingCDCChanges } from './util.js';
 import { storage } from '@powersync/service-core';
 import { CDCStreamTestContext } from './CDCStreamTestContext.js';
-import { getLatestReplicatedLSN } from '@module/utils/mssql.js';
+import { getLatestLSN } from '@module/utils/mssql.js';
 import sql from 'mssql';
 
 const BASIC_SYNC_RULES = `
@@ -25,7 +25,7 @@ function defineCDCStreamTests(factory: storage.TestStorageFactory) {
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
     await createTestTable(connectionManager, 'test_data');
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const testData = await insertTestData(connectionManager, 'test_data');
     await waitForPendingCDCChanges(beforeLSN, connectionManager);
     const startRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
@@ -69,7 +69,7 @@ function defineCDCStreamTests(factory: storage.TestStorageFactory) {
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
     await createTestTable(connectionManager, 'test_data');
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const testData = await insertTestData(connectionManager, 'test_data');
     await waitForPendingCDCChanges(beforeLSN, connectionManager);
     await context.replicateSnapshot();
@@ -93,7 +93,7 @@ function defineCDCStreamTests(factory: storage.TestStorageFactory) {
     await context.updateSyncRules(BASIC_SYNC_RULES);
 
     await createTestTable(connectionManager, 'test_data');
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const testData = await insertTestData(connectionManager, 'test_data');
     await waitForPendingCDCChanges(beforeLSN, connectionManager);
     await context.replicateSnapshot();
@@ -120,8 +120,8 @@ function defineCDCStreamTests(factory: storage.TestStorageFactory) {
     await createTestTable(connectionManager, 'test_data_1');
     await createTestTable(connectionManager, 'test_data_2');
 
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
     const testData11 = await insertTestData(connectionManager, 'test_data_1');
+    const beforeLSN = await getLatestLSN(connectionManager);
     const testData21 = await insertTestData(connectionManager, 'test_data_2');
     await waitForPendingCDCChanges(beforeLSN, connectionManager);
 

package/test/src/CDCStream_resumable_snapshot.test.ts

@@ -7,7 +7,7 @@ import { ReplicationMetric } from '@powersync/service-types';
 import * as timers from 'node:timers/promises';
 import { logger, ReplicationAbortedError } from '@powersync/lib-services-framework';
 import { CDCStreamTestContext } from './CDCStreamTestContext.js';
-import { getLatestReplicatedLSN } from '@module/utils/mssql.js';
+import { getLatestLSN } from '@module/utils/mssql.js';
 
 describe.skipIf(!(env.CI || env.SLOW_TESTS))('batch replication', function () {
   describeWithStorage({ timeout: 240_000 }, function (factory) {
@@ -47,7 +47,7 @@ async function testResumingReplication(factory: TestStorageFactory, stopAfter: n
   await createTestTableWithBasicId(connectionManager, 'test_data2');
 
   await connectionManager.query(`INSERT INTO test_data1(description) SELECT 'value' FROM GENERATE_SERIES(1, 1000, 1)`);
-  let beforeLSN = await getLatestReplicatedLSN(connectionManager);
+  let beforeLSN = await getLatestLSN(connectionManager);
   await connectionManager.query(`INSERT INTO test_data2(description) SELECT 'value' FROM GENERATE_SERIES(1, 10000, 1)`);
   await waitForPendingCDCChanges(beforeLSN, connectionManager);
 
@@ -99,7 +99,7 @@ async function testResumingReplication(factory: TestStorageFactory, stopAfter: n
   );
   const id2 = updateResult.id;
   logger.info(`Updated row with id: ${id2}`);
-  beforeLSN = await getLatestReplicatedLSN(context2.connectionManager);
+  beforeLSN = await getLatestLSN(context2.connectionManager);
   const {
     recordset: [insertResult]
   } = await context2.connectionManager.query(

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

@@ -1,11 +1,13 @@
-import { SqliteInputRow } from '@powersync/service-sync-rules';
+import { SQLITE_TRUE, 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,
+  escapeIdentifier,
   getCaptureInstance,
+  getLatestLSN,
   getLatestReplicatedLSN,
   getMinLSN,
   toQualifiedTableName
@@ -25,7 +27,7 @@ describe('MSSQL Data Types Tests', () => {
 
   async function setupTestTable() {
     await connectionManager.query(`
-      CREATE TABLE ${connectionManager.schema}.test_data (
+      CREATE TABLE ${escapeIdentifier(connectionManager.schema)}.test_data (
         id INT IDENTITY(1,1) PRIMARY KEY,
         tinyint_col TINYINT,
         smallint_col SMALLINT,
@@ -74,9 +76,9 @@ describe('MSSQL Data Types Tests', () => {
   }
 
   test('Number types mappings', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     await connectionManager.query(`
-      INSERT INTO ${connectionManager.schema}.test_data(
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(
         tinyint_col,
         smallint_col,
         int_col,
@@ -118,16 +120,16 @@ describe('MSSQL Data Types Tests', () => {
       numeric_col: 12345.67,
       money_col: 12345.67,
       smallmoney_col: 123.45,
-      bit_col: 1
+      bit_col: SQLITE_TRUE
     };
     expect(databaseRows[0]).toMatchObject(expectedResult);
     expect(replicatedRows[0]).toMatchObject(expectedResult);
   });
 
   test('Character types mappings', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     await connectionManager.query(`
-      INSERT INTO [${connectionManager.schema}].test_data (
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data (
         char_col,
         varchar_col,
         varchar_max_col,
@@ -167,11 +169,11 @@ describe('MSSQL Data Types Tests', () => {
   });
 
   test('Binary types mappings', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const binaryData = Buffer.from('BinaryData');
     await connectionManager.query(
       `
-      INSERT INTO [${connectionManager.schema}].test_data (
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data (
         binary_col,
         varbinary_col,
         varbinary_max_col,
@@ -211,11 +213,11 @@ describe('MSSQL Data Types Tests', () => {
   });
 
   test('Date types mappings', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const testDate = new Date('2023-03-06T15:47:00.000Z');
     await connectionManager.query(
       `
-      INSERT INTO [${connectionManager.schema}].test_data(
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(
         date_col, 
         datetime_col, 
         datetime2_col, 
@@ -256,20 +258,20 @@ describe('MSSQL Data Types Tests', () => {
 
   test('Date types edge cases mappings', async () => {
     await connectionManager.query(`
-      INSERT INTO [${connectionManager.schema}].test_data(datetime2_col) 
+      INSERT INTO ${escapeIdentifier(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) 
+      INSERT INTO ${escapeIdentifier(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) 
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(datetime_col) 
       VALUES ('1753-01-01 00:00:00')
     `);
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     await connectionManager.query(`
-      INSERT INTO [${connectionManager.schema}].test_data(datetime_col) 
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(datetime_col) 
       VALUES ('9999-12-31 23:59:59.997')
     `);
     await waitForPendingCDCChanges(beforeLSN, connectionManager);
@@ -291,10 +293,10 @@ describe('MSSQL Data Types Tests', () => {
   });
 
   test('DateTimeOffset type mapping', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     // DateTimeOffset preserves timezone information
     await connectionManager.query(`
-      INSERT INTO [${connectionManager.schema}].test_data(datetimeoffset_col) 
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(datetimeoffset_col) 
       VALUES ('2023-03-06 15:47:00.000 +05:00')
     `);
     await waitForPendingCDCChanges(beforeLSN, connectionManager);
@@ -312,12 +314,12 @@ describe('MSSQL Data Types Tests', () => {
   });
 
   test('UniqueIdentifier type mapping', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
 
     const testGuid = createUpperCaseUUID();
     await connectionManager.query(
       `
-      INSERT INTO [${connectionManager.schema}].test_data(uniqueidentifier_col) 
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(uniqueidentifier_col) 
       VALUES (@guid)
     `,
       [{ name: 'guid', type: sql.UniqueIdentifier, value: testGuid }]
@@ -333,11 +335,11 @@ describe('MSSQL Data Types Tests', () => {
   });
 
   test('JSON type mapping', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const expectedJSON = { name: 'John Doe', age: 30, married: true };
     await connectionManager.query(
       `
-      INSERT INTO [${connectionManager.schema}].test_data(json_col) 
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(json_col) 
       VALUES (@json)
     `,
       [{ name: 'json', type: sql.NVarChar(sql.MAX), value: JSON.stringify(expectedJSON) }]
@@ -354,11 +356,11 @@ describe('MSSQL Data Types Tests', () => {
   });
 
   test('XML type mapping', async () => {
-    const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+    const beforeLSN = await getLatestLSN(connectionManager);
     const xmlData = '<root><item>value</item></root>';
     await connectionManager.query(
       `
-      INSERT INTO [${connectionManager.schema}].test_data(xml_col) 
+      INSERT INTO ${escapeIdentifier(connectionManager.schema)}.test_data(xml_col) 
       VALUES (@xml)
     `,
       [{ name: 'xml', type: sql.Xml, value: xmlData }]
@@ -374,7 +376,7 @@ describe('MSSQL Data Types Tests', () => {
 
   // TODO: Update test when properly converting spatial types
   // test('Spatial types mappings', async () => {
-  //   const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+  //   const beforeLSN = await getLatestLSN(connectionManager);
   //   // Geometry and Geography types are stored as binary/WKT strings
   //   await connectionManager.query(`
   //     INSERT INTO [${connectionManager.schema}].test_data(geometry_col, geography_col)
@@ -398,7 +400,7 @@ describe('MSSQL Data Types Tests', () => {
   // TODO: Enable when HierarchyID type is properly supported
   // test('HierarchyID type mapping', async () => {
   //   const hierarchyid = '/1/';
-  //   const beforeLSN = await getLatestReplicatedLSN(connectionManager);
+  //   const beforeLSN = await getLatestLSN(connectionManager);
   //   await connectionManager.query(`
   //     INSERT INTO [${connectionManager.schema}].test_data(hierarchyid_col)
   //     VALUES (@hierarchyid)

package/test/src/util.ts

@@ -8,7 +8,7 @@ import * as postgres_storage from '@powersync/service-module-postgres-storage';
 import { describe, TestOptions } from 'vitest';
 import { env } from './env.js';
 import { MSSQLConnectionManager } from '@module/replication/MSSQLConnectionManager.js';
-import { createCheckpoint, enableCDCForTable, getLatestLSN } from '@module/utils/mssql.js';
+import { createCheckpoint, enableCDCForTable, escapeIdentifier, getLatestLSN } from '@module/utils/mssql.js';
 import sql from 'mssql';
 import { v4 as uuid } from 'uuid';
 import { LSN } from '@module/common/LSN.js';
@@ -66,6 +66,16 @@ export async function clearTestDb(connectionManager: MSSQLConnectionManager) {
   }
 }
 
+export async function resetTestTable(connectionManager: MSSQLConnectionManager, tableName: string) {
+  await connectionManager.execute('sys.sp_cdc_disable_table', [
+    { name: 'source_schema', value: connectionManager.schema },
+    { name: 'source_name', value: tableName },
+    { name: 'capture_instance', value: 'all' }
+  ]);
+
+  await connectionManager.query(`DROP TABLE [${tableName}]`);
+}
+
 /**
  *  Create a new database for testing and enables CDC on it.
  *  @param connectionManager
@@ -84,7 +94,7 @@ export async function createTestDb(connectionManager: MSSQLConnectionManager, db
 
 export async function createTestTable(connectionManager: MSSQLConnectionManager, tableName: string): Promise<void> {
   await connectionManager.query(`
-    CREATE TABLE ${connectionManager.schema}.${tableName} (
+    CREATE TABLE ${escapeIdentifier(connectionManager.schema)}.${escapeIdentifier(tableName)} (
       id UNIQUEIDENTIFIER PRIMARY KEY,
       description VARCHAR(MAX)
     )
@@ -97,7 +107,7 @@ export async function createTestTableWithBasicId(
   tableName: string
 ): Promise<void> {
   await connectionManager.query(`
-    CREATE TABLE ${connectionManager.schema}.${tableName} (
+    CREATE TABLE ${escapeIdentifier(connectionManager.schema)}.${escapeIdentifier(tableName)} (
       id INT IDENTITY(1,1) PRIMARY KEY,
       description VARCHAR(MAX)
     )
@@ -114,7 +124,7 @@ export async function insertTestData(connectionManager: MSSQLConnectionManager,
   const description = `description_${id}`;
   await connectionManager.query(
     `
-    INSERT INTO ${connectionManager.schema}.${tableName} (id, description) VALUES (@id, @description)
+    INSERT INTO ${escapeIdentifier(connectionManager.schema)}.${escapeIdentifier(tableName)} (id, description) VALUES (@id, @description)
   `,
     [
       { name: 'id', type: sql.UniqueIdentifier, value: id },
@@ -141,8 +151,8 @@ export async function waitForPendingCDCChanges(
     );
 
     if (result.length === 0) {
-      logger.info(`CDC changes pending. Waiting for 500ms...`);
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      logger.info(`CDC changes pending. Waiting for 200ms...`);
+      await new Promise((resolve) => setTimeout(resolve, 200));
     } else {
       logger.info(`Found LSN: ${LSN.fromBinary(result[0].start_lsn).toString()}`);
       return;