@powersync/service-module-mssql 0.0.1 → 0.1.0

package/src/replication/CDCStream.ts

@@ -13,13 +13,7 @@ import { getUuidReplicaIdentityBson, MetricsEngine, SourceEntityDescriptor, stor
 import { SqliteInputRow, SqliteRow, SqlSyncRules, TablePattern } from '@powersync/service-sync-rules';
 
 import { ReplicationMetric } from '@powersync/service-types';
-import {
-  BatchedSnapshotQuery,
-  IdSnapshotQuery,
-  MSSQLSnapshotQuery,
-  PrimaryKeyValue,
-  SimpleSnapshotQuery
-} from './MSSQLSnapshotQuery.js';
+import { BatchedSnapshotQuery, MSSQLSnapshotQuery, SimpleSnapshotQuery } from './MSSQLSnapshotQuery.js';
 import { MSSQLConnectionManager } from './MSSQLConnectionManager.js';
 import { getReplicationIdentityColumns, getTablesFromPattern, ResolvedTable } from '../utils/schema.js';
 import {
@@ -39,7 +33,7 @@ import { LSN } from '../common/LSN.js';
 import { MSSQLSourceTable } from '../common/MSSQLSourceTable.js';
 import { MSSQLSourceTableCache } from '../common/MSSQLSourceTableCache.js';
 import { CDCEventHandler, CDCPoller } from './CDCPoller.js';
-import { CDCPollingOptions } from '../types/types.js';
+import { AdditionalConfig } from '../types/types.js';
 
 export interface CDCStreamOptions {
   connections: MSSQLConnectionManager;
@@ -54,7 +48,7 @@ export interface CDCStreamOptions {
    */
   snapshotBatchSize?: number;
 
-  pollingOptions: CDCPollingOptions;
+  additionalConfig: AdditionalConfig;
 }
 
 export enum SnapshotStatus {
@@ -247,7 +241,11 @@ export class CDCStream {
       entity_descriptor: table,
       sync_rules: this.syncRules
     });
-    const captureInstance = await getCaptureInstance({ connectionManager: this.connections, tableName: resolved.table.name, schema: resolved.table.schema });
+    const captureInstance = await getCaptureInstance({
+      connectionManager: this.connections,
+      tableName: resolved.table.name,
+      schema: resolved.table.schema
+    });
     if (!captureInstance) {
       throw new ServiceAssertionError(
         `Missing capture instance for table ${toQualifiedTableName(resolved.table.schema, resolved.table.name)}`
@@ -282,18 +280,14 @@ export class CDCStream {
     return resolvedTable;
   }
 
-  private async snapshotTableInTx(
-    batch: storage.BucketStorageBatch,
-    table: MSSQLSourceTable,
-    limited?: PrimaryKeyValue[]
-  ): Promise<void> {
+  private async snapshotTableInTx(batch: storage.BucketStorageBatch, table: MSSQLSourceTable): Promise<void> {
     // Note: We use the "Read Committed" isolation level here, not snapshot isolation.
     // The data may change during the transaction, but that is compensated for in the streaming
     // replication afterward.
     const transaction = await this.connections.createTransaction();
     await transaction.begin(sql.ISOLATION_LEVEL.READ_COMMITTED);
     try {
-      await this.snapshotTable(batch, transaction, table, limited);
+      await this.snapshotTable(batch, transaction, table);
 
       // Get the current LSN.
       // The data will only be consistent once incremental replication has passed that point.
@@ -321,8 +315,7 @@ export class CDCStream {
   private async snapshotTable(
     batch: storage.BucketStorageBatch,
     transaction: sql.Transaction,
-    table: MSSQLSourceTable,
-    limited?: PrimaryKeyValue[]
+    table: MSSQLSourceTable
   ) {
     let totalEstimatedCount = table.sourceTable.snapshotStatus?.totalEstimatedCount;
     let replicatedCount = table.sourceTable.snapshotStatus?.replicatedCount ?? 0;
@@ -331,9 +324,7 @@ export class CDCStream {
     // We do streaming on two levels:
     // 1. Coarse select from the entire table, stream rows 1 by one
     // 2. Fine level: Stream batches of rows with each fetch call
-    if (limited) {
-      query = new IdSnapshotQuery(transaction, table, limited);
-    } else if (BatchedSnapshotQuery.supports(table)) {
+    if (BatchedSnapshotQuery.supports(table)) {
       // Single primary key - we can use the primary key for chunking
       const orderByKey = table.sourceTable.replicaIdColumns[0];
       query = new BatchedSnapshotQuery(
@@ -361,7 +352,6 @@ export class CDCStream {
     }
     await query.initialize();
 
-    let columns: sql.IColumnMetadata | null = null;
     let hasRemainingData = true;
     while (hasRemainingData) {
       // Fetch 10k at a time.
@@ -369,6 +359,7 @@ export class CDCStream {
       // and not spending too much time on each FETCH call.
       // We aim for a couple of seconds on each FETCH call.
       let batchReplicatedCount = 0;
+      let columns: sql.IColumnMetadata | null = null;
       const cursor = query.next();
       for await (const result of cursor) {
         if (columns == null && isIColumnMetadata(result)) {
@@ -400,30 +391,27 @@ export class CDCStream {
 
       // Important: flush before marking progress
       await batch.flush();
-      if (limited == null) {
-        let lastKey: Uint8Array | undefined;
-        if (query instanceof BatchedSnapshotQuery) {
-          lastKey = query.getLastKeySerialized();
-        }
-        if (lastCountTime < performance.now() - 10 * 60 * 1000) {
-          // Even though we're doing the snapshot inside a transaction, the transaction uses
-          // the default "Read Committed" isolation level. This means we can get new data
-          // within the transaction, so we re-estimate the count every 10 minutes when replicating
-          // large tables.
-          totalEstimatedCount = await this.estimatedCountNumber(table, transaction);
-          lastCountTime = performance.now();
-        }
-        const updatedSourceTable = await batch.updateTableProgress(table.sourceTable, {
-          lastKey: lastKey,
-          replicatedCount: replicatedCount,
-          totalEstimatedCount: totalEstimatedCount
-        });
-        this.tableCache.updateSourceTable(updatedSourceTable);
 
-        this.logger.info(`Replicating ${table.toQualifiedName()} ${table.sourceTable.formatSnapshotProgress()}`);
-      } else {
-        this.logger.info(`Replicating ${table.toQualifiedName()} ${replicatedCount}/${limited.length} for resnapshot`);
+      let lastKey: Uint8Array | undefined;
+      if (query instanceof BatchedSnapshotQuery) {
+        lastKey = query.getLastKeySerialized();
+      }
+      if (lastCountTime < performance.now() - 10 * 60 * 1000) {
+        // Even though we're doing the snapshot inside a transaction, the transaction uses
+        // the default "Read Committed" isolation level. This means we can get new data
+        // within the transaction, so we re-estimate the count every 10 minutes when replicating
+        // large tables.
+        totalEstimatedCount = await this.estimatedCountNumber(table, transaction);
+        lastCountTime = performance.now();
       }
+      const updatedSourceTable = await batch.updateTableProgress(table.sourceTable, {
+        lastKey: lastKey,
+        replicatedCount: replicatedCount,
+        totalEstimatedCount: totalEstimatedCount
+      });
+      this.tableCache.updateSourceTable(updatedSourceTable);
+
+      this.logger.info(`Replicating ${table.toQualifiedName()} ${table.sourceTable.formatSnapshotProgress()}`);
 
       if (this.abortSignal.aborted) {
         // We only abort after flushing
@@ -445,13 +433,12 @@ export class CDCStream {
    */
   async estimatedCountNumber(table: MSSQLSourceTable, transaction?: sql.Transaction): Promise<number> {
     const request = transaction ? transaction.request() : await this.connections.createRequest();
-    const { recordset: result } = await request.query(
+    const { recordset: result } = await request.input('tableName', table.toQualifiedName()).query(
       `SELECT SUM(row_count) AS total_rows
        FROM sys.dm_db_partition_stats
-       WHERE object_id = OBJECT_ID('${table.toQualifiedName()}')
+       WHERE object_id = OBJECT_ID(@tableName)
        AND index_id < 2;`
     );
-    // TODO Fallback query in case user does not have permission?
     return result[0].total_rows ?? -1;
   }
 
@@ -586,8 +573,8 @@ export class CDCStream {
           eventHandler,
           sourceTables,
           startLSN,
-          pollingOptions: this.options.pollingOptions,
-          logger: this.logger
+          logger: this.logger,
+          additionalConfig: this.options.additionalConfig
         });
 
         this.abortSignal.addEventListener(

package/src/replication/MSSQLConnectionManager.ts

@@ -31,7 +31,7 @@ export class MSSQLConnectionManager extends BaseObserver<MSSQLConnectionManagerL
       options: {
         appName: `powersync/${POWERSYNC_VERSION}`,
         encrypt: true, // Required for Azure
-        trustServerCertificate: options.trustServerCertificate
+        trustServerCertificate: options.additionalConfig.trustServerCertificate
       }
     });
   }

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/types/types.ts

@@ -63,21 +63,42 @@ export const DefaultAuthentication = t.object({
 });
 export type DefaultAuthentication = t.Decoded<typeof DefaultAuthentication>;
 
-export type AuthenticationType =
-  | DefaultAuthentication
-  | AzureActiveDirectoryPasswordAuthentication
-  | AzureActiveDirectoryServicePrincipalSecret;
+export const Authentication = DefaultAuthentication.or(AzureActiveDirectoryPasswordAuthentication).or(
+  AzureActiveDirectoryServicePrincipalSecret
+);
+export type Authentication = t.Decoded<typeof Authentication>;
 
-  
-export interface CDCPollingOptions {
+export const AdditionalConfig = t.object({
+  /**
+   * Interval in milliseconds to wait between polling cycles. Defaults to 1000 milliseconds.
+   */
+  pollingIntervalMs: t.number.optional(),
   /**
    * Maximum number of transactions to poll per polling cycle. Defaults to 10.
    */
-  batchSize: number;
+  pollingBatchSize: t.number.optional(),
+
   /**
-   * Interval in milliseconds to wait between polling cycles. Defaults to 1 second.
+   *  Whether to trust the server certificate. Set to true for local development and self-signed certificates.
+   *  Default is false.
    */
-  intervalMs: number;
+  trustServerCertificate: t.boolean.optional()
+});
+
+export interface AdditionalConfig {
+  /**
+   * Interval in milliseconds to wait between polling cycles. Defaults to 1000 milliseconds.
+   */
+  pollingIntervalMs: number;
+  /**
+   * Maximum number of transactions to poll per polling cycle. Defaults to 10.
+   */
+  pollingBatchSize: number;
+  /**
+   *  Whether to trust the server certificate. Set to true for local development and self-signed certificates.
+   *  Default is false.
+   */
+  trustServerCertificate: boolean;
 }
 
 export interface NormalizedMSSQLConnectionConfig {
@@ -91,16 +112,11 @@ export interface NormalizedMSSQLConnectionConfig {
   database: string;
   schema?: string;
 
-  authentication?: AuthenticationType;
-
-  cdcPollingOptions: CDCPollingOptions;
+  authentication?: Authentication;
 
-  /**  
-   *  Whether to trust the server certificate. Set to true for local development and self-signed certificates.
-   *  Default is false.
-  */
-  trustServerCertificate: boolean;
   lookup?: LookupFunction;
+
+  additionalConfig: AdditionalConfig;
 }
 
 export const MSSQLConnectionConfig = service_types.configFile.DataSourceConfig.and(
@@ -114,22 +130,10 @@ export const MSSQLConnectionConfig = service_types.configFile.DataSourceConfig.a
     hostname: t.string.optional(),
     port: service_types.configFile.portCodec.optional(),
 
-    authentication: DefaultAuthentication.or(AzureActiveDirectoryPasswordAuthentication)
-      .or(AzureActiveDirectoryServicePrincipalSecret)
-      .optional(),
-
-    cdcPollingOptions: t.object({
-      batchSize: t.number.optional(),
-      intervalMs: t.number.optional()
-    }).optional(),
-
-    /**  
-     *  Whether to trust the server certificate. Set to true for local development and self-signed certificates.
-     *  Default is false.
-     */
-    trustServerCertificate: t.boolean.optional(),
+    authentication: Authentication.optional(),
 
-    reject_ip_ranges: t.array(t.string).optional()
+    reject_ip_ranges: t.array(t.string).optional(),
+    additionalConfig: AdditionalConfig.optional()
   })
 );
 
@@ -203,19 +207,11 @@ export function normalizeConnectionConfig(options: MSSQLConnectionConfig): Norma
     lookup,
     authentication: options.authentication,
 
-    cdcPollingOptions: {
-      /**
-       * Maximum number of transactions to poll per polling cycle. Defaults to 10.
-       */
-      batchSize: options.cdcPollingOptions?.batchSize ?? 10,
-
-      /**
-       * Interval in milliseconds to wait between polling cycles. Defaults to 1 second.
-       */ 
-      intervalMs: options.cdcPollingOptions?.intervalMs ?? 1000,
-    },
-
-    trustServerCertificate: options.trustServerCertificate ?? false,
+    additionalConfig: {
+      pollingIntervalMs: options.additionalConfig?.pollingIntervalMs ?? 1000,
+      pollingBatchSize: options.additionalConfig?.pollingBatchSize ?? 10,
+      trustServerCertificate: options.additionalConfig?.trustServerCertificate ?? false
+    }
   } satisfies NormalizedMSSQLConnectionConfig;
 }
 

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 {
@@ -319,7 +330,7 @@ export function isIColumnMetadata(obj: any): obj is sql.IColumnMetadata {
     propertiesMatched =
       typeof property.index === 'number' &&
       typeof property.name === 'string' &&
-      typeof property.length === 'number' &&
+      (typeof property.length === 'number' || typeof property.length === 'undefined') &&
       (typeof property.type === 'function' || typeof property.type === 'object') &&
       typeof property.nullable === 'boolean' &&
       typeof property.caseSensitive === 'boolean' &&
@@ -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

@@ -1,16 +1,10 @@
 import { describe, expect, test } from 'vitest';
 import { METRICS_HELPER, putOp, removeOp } from '@powersync/service-core-tests';
 import { ReplicationMetric } from '@powersync/service-types';
-import {
-  createTestTable,
-  describeWithStorage,
-  INITIALIZED_MONGO_STORAGE_FACTORY,
-  insertTestData,
-  waitForPendingCDCChanges
-} from './util.js';
+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 = `
@@ -20,11 +14,9 @@ bucket_definitions:
       - SELECT id, description FROM "test_data"
 `;
 
-// describe('CDCStream tests', () => {
-//   describeWithStorage({ timeout: 20_000 }, defineCDCStreamTests);
-// });
-
-defineCDCStreamTests(INITIALIZED_MONGO_STORAGE_FACTORY);
+describe('CDCStream tests', () => {
+  describeWithStorage({ timeout: 20_000 }, defineCDCStreamTests);
+});
 
 function defineCDCStreamTests(factory: storage.TestStorageFactory) {
   test('Initial snapshot sync', async () => {
@@ -33,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;
@@ -77,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();
@@ -101,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();
@@ -128,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/CDCStreamTestContext.ts

@@ -12,7 +12,6 @@ import { clearTestDb, getClientCheckpoint, TEST_CONNECTION_OPTIONS } from './uti
 import { CDCStream, CDCStreamOptions } from '@module/replication/CDCStream.js';
 import { MSSQLConnectionManager } from '@module/replication/MSSQLConnectionManager.js';
 import timers from 'timers/promises';
-import { CDCPollingOptions } from '@module/types/types.js';
 
 /**
  * Tests operating on the change data capture need to configure the stream and manage asynchronous
@@ -110,10 +109,11 @@ export class CDCStreamTestContext implements AsyncDisposable {
       metrics: METRICS_HELPER.metricsEngine,
       connections: this.connectionManager,
       abortSignal: this.abortController.signal,
-      pollingOptions: {
-        batchSize: 10,
-        intervalMs: 1000
-      } satisfies CDCPollingOptions,
+      additionalConfig: {
+        pollingBatchSize: 10,
+        pollingIntervalMs: 1000,
+        trustServerCertificate: true
+      },
       ...this.cdcStreamOptions
     };
     this._cdcStream = new CDCStream(options);