@powersync/service-module-mssql 0.0.0-dev-20260225160713 → 0.0.0-dev-20260511080634

package/src/replication/MSSQLSnapshotQuery.ts

@@ -1,9 +1,9 @@
-import { bson, ColumnDescriptor, SourceTable } from '@powersync/service-core';
 import { ServiceAssertionError } from '@powersync/lib-services-framework';
-import { MSSQLBaseType } from '../types/mssql-data-types.js';
+import { bson, ColumnDescriptor, SourceTable } from '@powersync/service-core';
 import sql from 'mssql';
-import { escapeIdentifier } from '../utils/mssql.js';
 import { MSSQLSourceTable } from '../common/MSSQLSourceTable.js';
+import { MSSQLBaseType } from '../types/mssql-data-types.js';
+import { escapeIdentifier } from '../utils/mssql.js';
 
 export interface MSSQLSnapshotQuery {
   initialize(): Promise<void>;

package/src/types/types.ts

@@ -4,31 +4,10 @@ import { LookupFunction } from 'node:net';
 import * as t from 'ts-codec';
 import * as urijs from 'uri-js';
 
+export const DEFAULT_POLLING_BATCH_SIZE = 10;
+export const DEFAULT_POLLING_INTERVAL_MS = 1000;
 export const MSSQL_CONNECTION_TYPE = 'mssql' as const;
 
-export const AzureActiveDirectoryPasswordAuthentication = t.object({
-  type: t.literal('azure-active-directory-password'),
-  options: t.object({
-    /**
-     * A user need to provide `userName` associate to their account.
-     */
-    userName: t.string,
-    /**
-     * A user need to provide `password` associate to their account.
-     */
-    password: t.string,
-    /**
-     * A client id to use.
-     */
-    clientId: t.string,
-    /**
-     * Azure tenant ID
-     */
-    tenantId: t.string
-  })
-});
-export type AzureActiveDirectoryPasswordAuthentication = t.Decoded<typeof AzureActiveDirectoryPasswordAuthentication>;
-
 export const AzureActiveDirectoryServicePrincipalSecret = t.object({
   type: t.literal('azure-active-directory-service-principal-secret'),
   options: t.object({
@@ -63,9 +42,7 @@ export const DefaultAuthentication = t.object({
 });
 export type DefaultAuthentication = t.Decoded<typeof DefaultAuthentication>;
 
-export const Authentication = DefaultAuthentication.or(AzureActiveDirectoryPasswordAuthentication).or(
-  AzureActiveDirectoryServicePrincipalSecret
-);
+export const Authentication = DefaultAuthentication.or(AzureActiveDirectoryServicePrincipalSecret);
 export type Authentication = t.Decoded<typeof Authentication>;
 
 export const AdditionalConfig = t.object({
@@ -208,8 +185,8 @@ export function normalizeConnectionConfig(options: MSSQLConnectionConfig): Norma
     authentication: options.authentication,
 
     additionalConfig: {
-      pollingIntervalMs: options.additionalConfig?.pollingIntervalMs ?? 1000,
-      pollingBatchSize: options.additionalConfig?.pollingBatchSize ?? 10,
+      pollingIntervalMs: options.additionalConfig?.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS,
+      pollingBatchSize: options.additionalConfig?.pollingBatchSize ?? DEFAULT_POLLING_BATCH_SIZE,
       trustServerCertificate: options.additionalConfig?.trustServerCertificate ?? false
     }
   } satisfies NormalizedMSSQLConnectionConfig;

package/src/utils/deadlock.ts

@@ -0,0 +1,44 @@
+import { logger } from '@powersync/lib-services-framework';
+import timers from 'timers/promises';
+
+const MSSQL_DEADLOCK_RETRIES = 5;
+const MSSQL_DEADLOCK_BACKOFF_FACTOR = 2;
+const MSSQL_DEADLOCK_RETRY_DELAY_MS = 200;
+
+/**
+ * Retries the given async function if it fails with a SQL Server deadlock error (1205).
+ * Deadlocks, while uncommon, can occur when CDC altering functions are being called whilst actively replicating
+ * using CDC functions.
+ *
+ * If the error is not a deadlock or all retries are exhausted, the error is re-thrown.
+ */
+export async function retryOnDeadlock<T>(fn: () => Promise<T>, operationName: string): Promise<T> {
+  let lastError: Error | null = null;
+  for (let attempt = 0; attempt <= MSSQL_DEADLOCK_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isDeadlockError(error) || attempt === MSSQL_DEADLOCK_RETRIES) {
+        throw error;
+      }
+      const delay = MSSQL_DEADLOCK_RETRY_DELAY_MS * Math.pow(MSSQL_DEADLOCK_BACKOFF_FACTOR, attempt);
+      logger.warn(
+        `Deadlock detected during ${operationName} (attempt ${attempt + 1}/${MSSQL_DEADLOCK_RETRIES}). Retrying in ${delay}ms...`
+      );
+      await timers.setTimeout(delay);
+    }
+  }
+
+  throw lastError;
+}
+
+export function isDeadlockError(error: unknown): boolean {
+  if (error != null && typeof error === 'object' && 'number' in error) {
+    // SQL Server deadlock victim error number.
+    // When SQL Server detects a deadlock, it chooses one of the participating transactions
+    // as the "deadlock victim" and terminates it with error 1205.
+    return (error as { number: unknown }).number === 1205;
+  }
+  return false;
+}

package/src/utils/mssql.ts

@@ -1,14 +1,21 @@
+import { logger } from '@powersync/lib-services-framework';
+import * as sync_rules from '@powersync/service-sync-rules';
+import { SqlSyncRules, TablePattern } from '@powersync/service-sync-rules';
+import * as service_types from '@powersync/service-types';
 import sql from 'mssql';
 import { coerce, gte } from 'semver';
-import { logger } from '@powersync/lib-services-framework';
-import { MSSQLConnectionManager } from '../replication/MSSQLConnectionManager.js';
+import { CaptureInstance } from '../common/CaptureInstance.js';
 import { LSN } from '../common/LSN.js';
-import { CaptureInstance, MSSQLSourceTable } from '../common/MSSQLSourceTable.js';
+import { MSSQLSourceTable } from '../common/MSSQLSourceTable.js';
+import { MSSQLConnectionManager } from '../replication/MSSQLConnectionManager.js';
 import { MSSQLParameter } from '../types/mssql-data-types.js';
-import { SqlSyncRules, TablePattern } from '@powersync/service-sync-rules';
-import { getReplicationIdentityColumns, ReplicationIdentityColumnsResult, ResolvedTable } from './schema.js';
-import * as service_types from '@powersync/service-types';
-import * as sync_rules from '@powersync/service-sync-rules';
+import { retryOnDeadlock } from './deadlock.js';
+import {
+  getPendingSchemaChanges,
+  getReplicationIdentityColumns,
+  ReplicationIdentityColumnsResult,
+  ResolvedTable
+} from './schema.js';
 
 export const POWERSYNC_CHECKPOINTS_TABLE = '_powersync_checkpoints';
 
@@ -78,16 +85,16 @@ export async function checkSourceConfiguration(connectionManager: MSSQLConnectio
   }
 
   // 4) Check if the _powersync_checkpoints table is correctly configured
-  const checkpointTableErrors = await ensurePowerSyncCheckpointsTable(connectionManager);
+  const checkpointTableErrors = await checkPowerSyncCheckpointsTable(connectionManager);
   errors.push(...checkpointTableErrors);
 
   return errors;
 }
 
-export async function ensurePowerSyncCheckpointsTable(connectionManager: MSSQLConnectionManager): Promise<string[]> {
+export async function checkPowerSyncCheckpointsTable(connectionManager: MSSQLConnectionManager): Promise<string[]> {
   const errors: string[] = [];
   try {
-    // check if the dbo_powersync_checkpoints table exists
+    // Check if the table exists
     const { recordset: checkpointsResult } = await connectionManager.query(
       `
     SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName;
@@ -97,45 +104,22 @@ export async function ensurePowerSyncCheckpointsTable(connectionManager: MSSQLCo
         { 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({
-        connectionManager,
-        table: POWERSYNC_CHECKPOINTS_TABLE,
-        schema: connectionManager.schema
-      });
-      if (!isEnabled) {
-        // Enable CDC on the table
-        await enableCDCForTable({
-          connectionManager,
-          table: POWERSYNC_CHECKPOINTS_TABLE
-        });
-      }
-      return errors;
+    if (checkpointsResult.length === 0) {
+      throw new Error(`The ${POWERSYNC_CHECKPOINTS_TABLE} table does not exist. Please create it.`);
     }
-  } catch (error) {
-    errors.push(`Failed ensure ${POWERSYNC_CHECKPOINTS_TABLE} table is correctly configured: ${error}`);
-  }
-
-  // Try to create the table
-  try {
-    await connectionManager.query(`
-  CREATE TABLE ${toQualifiedTableName(connectionManager.schema, POWERSYNC_CHECKPOINTS_TABLE)} (
-    id INT IDENTITY PRIMARY KEY,
-    last_updated DATETIME NOT NULL DEFAULT (GETDATE())
-  )`);
-  } catch (error) {
-    errors.push(`Failed to create ${POWERSYNC_CHECKPOINTS_TABLE} table: ${error}`);
-  }
-
-  try {
-    // Enable CDC on the table if not already enabled
-    await enableCDCForTable({
+    // Check if CDC is enabled
+    const isEnabled = await isTableEnabledForCDC({
       connectionManager,
-      table: POWERSYNC_CHECKPOINTS_TABLE
+      table: POWERSYNC_CHECKPOINTS_TABLE,
+      schema: connectionManager.schema
     });
+    if (!isEnabled) {
+      throw new Error(
+        `The ${POWERSYNC_CHECKPOINTS_TABLE} table exists but is not enabled for CDC. Please enable CDC on this table.`
+      );
+    }
   } catch (error) {
-    errors.push(`Failed to enable CDC on ${POWERSYNC_CHECKPOINTS_TABLE} table: ${error}`);
+    errors.push(`Failed ensure ${POWERSYNC_CHECKPOINTS_TABLE} table is correctly configured: ${error}`);
   }
 
   return errors;
@@ -165,36 +149,9 @@ export interface IsTableEnabledForCDCOptions {
 export async function isTableEnabledForCDC(options: IsTableEnabledForCDCOptions): Promise<boolean> {
   const { connectionManager, table, schema } = options;
 
-  const { recordset: checkResult } = await connectionManager.query(
-    `
-      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 = @tableName
-      `,
-    [
-      { name: 'schema', type: sql.VarChar(sql.MAX), value: schema },
-      { name: 'tableName', type: sql.VarChar(sql.MAX), value: table }
-    ]
-  );
-  return checkResult.length > 0;
-}
-
-export interface EnableCDCForTableOptions {
-  connectionManager: MSSQLConnectionManager;
-  table: string;
-}
-
-export async function enableCDCForTable(options: EnableCDCForTableOptions): Promise<void> {
-  const { connectionManager, table } = options;
+  const captureInstance = await getCaptureInstance({ connectionManager, table: { schema, name: table } });
 
-  await connectionManager.execute('sys.sp_cdc_enable_table', [
-    { name: 'source_schema', value: connectionManager.schema },
-    { name: 'source_name', value: table },
-    { name: 'role_name', value: 'NULL' },
-    { name: 'supports_net_changes', value: 1 }
-  ]);
+  return captureInstance != null;
 }
 
 /**
@@ -216,23 +173,28 @@ export interface IsWithinRetentionThresholdOptions {
 }
 
 /**
- *  Checks that CDC the specified checkpoint LSN is within the retention threshold for all specified tables.
+ *  Checks that the given checkpoint LSN is still within the retention threshold of the source table capture instances.
  *  CDC periodically cleans up old data up to the retention threshold. If replication has been stopped for too long it is
  *  possible for the checkpoint LSN to be older than the minimum LSN in the CDC tables. In such a case we need to perform a new snapshot.
  *  @param options
  */
-export async function isWithinRetentionThreshold(options: IsWithinRetentionThresholdOptions): Promise<boolean> {
+export async function checkRetentionThresholds(
+  options: IsWithinRetentionThresholdOptions
+): Promise<MSSQLSourceTable[]> {
   const { checkpointLSN, tables, connectionManager } = options;
+  const tablesOutsideRetentionThreshold: MSSQLSourceTable[] = [];
   for (const table of tables) {
-    const minLSN = await getMinLSN(connectionManager, table.captureInstance);
-    if (minLSN > checkpointLSN) {
-      logger.warn(
-        `The checkpoint LSN:[${checkpointLSN}] is older than the minimum LSN:[${minLSN}] for table ${table.sourceTable.qualifiedName}. This indicates that the checkpoint LSN is outside of the retention window.`
-      );
-      return false;
+    if (table.enabledForCDC()) {
+      const minLSN = await getMinLSN(connectionManager, table.captureInstance!.name);
+      if (minLSN > checkpointLSN) {
+        logger.warn(
+          `The checkpoint LSN:[${checkpointLSN}] is older than the minimum LSN:[${minLSN}] for table ${table.toQualifiedName()}. This indicates that the checkpoint LSN is outside of the retention window.`
+        );
+        tablesOutsideRetentionThreshold.push(table);
+      }
     }
   }
-  return true;
+  return tablesOutsideRetentionThreshold;
 }
 
 export async function getMinLSN(connectionManager: MSSQLConnectionManager, captureInstance: string): Promise<LSN> {
@@ -252,43 +214,6 @@ export async function incrementLSN(lsn: LSN, connectionManager: MSSQLConnectionM
   return LSN.fromBinary(result[0].incremented_lsn);
 }
 
-export interface GetCaptureInstanceOptions {
-  connectionManager: MSSQLConnectionManager;
-  tableName: string;
-  schema: string;
-}
-
-export async function getCaptureInstance(options: GetCaptureInstanceOptions): Promise<CaptureInstance | null> {
-  const { connectionManager, tableName, schema } = options;
-  const { recordset: result } = await connectionManager.query(
-    `
-      SELECT
-        ct.capture_instance,
-        OBJECT_SCHEMA_NAME(ct.[object_id]) AS cdc_schema
-      FROM
-        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
-        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;
-  }
-
-  return {
-    name: result[0].capture_instance,
-    schema: result[0].cdc_schema
-  };
-}
-
 /**
  *  Return the LSN of the latest transaction recorded in the transaction log
  *  @param connectionManager
@@ -406,18 +331,28 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
     selectError = { level: 'fatal', message: e.message };
   }
 
-  // Check if CDC is enabled for the table
   let cdcError: service_types.ReplicationError | null = null;
+  let schemaDriftError: service_types.ReplicationError | null = null;
   try {
-    const isEnabled = await isTableEnabledForCDC({
+    const captureInstanceDetails = await getCaptureInstance({
       connectionManager: connectionManager,
-      table: table.name,
-      schema: schema
+      table: {
+        schema: schema,
+        name: table.name
+      }
     });
-    if (!isEnabled) {
+    if (captureInstanceDetails == null) {
       cdcError = {
-        level: 'fatal',
-        message: `CDC is not enabled for table ${toQualifiedTableName(schema, table.name)}. Enable CDC with: sys.sp_cdc_enable_table @source_schema = '${schema}', @source_name = '${table.name}', @role_name = NULL, @supports_net_changes = 1`
+        level: 'warning',
+        message: `CDC is not enabled for table ${toQualifiedTableName(schema, table.name)}. Please enable CDC on the table to capture changes.`
+      };
+    }
+
+    if (captureInstanceDetails && captureInstanceDetails.instances[0].pendingSchemaChanges.length > 0) {
+      schemaDriftError = {
+        level: 'warning',
+        message: `Source table ${toQualifiedTableName(schema, table.name)} has schema changes not reflected in the CDC capture instance. Please disable and re-enable CDC on the source table to update the capture instance schema.
+        Pending schema changes: ${captureInstanceDetails.instances[0].pendingSchemaChanges.join(', \n')}`
       };
     }
   } catch (e) {
@@ -433,6 +368,106 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
     replication_id: idColumns.map((c) => c.name),
     data_queries: syncData,
     parameter_queries: syncParameters,
-    errors: [idColumnsError, selectError, cdcError].filter((error) => error != null) as service_types.ReplicationError[]
+    errors: [idColumnsError, selectError, cdcError, schemaDriftError].filter(
+      (error) => error != null
+    ) as service_types.ReplicationError[]
+  };
+}
+
+// Describes the capture instances linked to a source table.
+export interface CaptureInstanceDetails {
+  sourceTable: {
+    schema: string;
+    name: string;
+    objectId: number;
+  };
+
+  /**
+   *  The capture instances for the source table.
+   *  The instances are sorted by create date in descending order.
+   */
+  instances: CaptureInstance[];
+}
+
+export interface GetCaptureInstancesOptions {
+  connectionManager: MSSQLConnectionManager;
+  table?: {
+    schema: string;
+    name: string;
+  };
+}
+
+export async function getCaptureInstances(
+  options: GetCaptureInstancesOptions
+): Promise<Map<number, CaptureInstanceDetails>> {
+  return retryOnDeadlock(async () => {
+    const { connectionManager, table } = options;
+    const instances = new Map<number, CaptureInstanceDetails>();
+
+    const { recordset: results } = table
+      ? await connectionManager.execute('sys.sp_cdc_help_change_data_capture', [
+          { name: 'source_schema', value: table.schema },
+          { name: 'source_name', value: table.name }
+        ])
+      : await connectionManager.execute('sys.sp_cdc_help_change_data_capture', []);
+
+    if (results.length === 0) {
+      return new Map<number, CaptureInstanceDetails>();
+    }
+
+    for (const row of results) {
+      const instance: CaptureInstance = {
+        name: row.capture_instance,
+        objectId: row.object_id,
+        minLSN: LSN.fromBinary(row.start_lsn),
+        createDate: new Date(row.create_date),
+        pendingSchemaChanges: []
+      };
+
+      instance.pendingSchemaChanges = await getPendingSchemaChanges({
+        connectionManager: connectionManager,
+        captureInstanceName: instance.name
+      });
+
+      const sourceTable = {
+        schema: row.source_schema,
+        name: row.source_table,
+        objectId: row.source_object_id
+      };
+
+      // There can only ever be 2 capture instances active at any given time for a source table.
+      if (instances.has(row.source_object_id)) {
+        if (instance.createDate > instances.get(row.source_object_id)!.instances[0].createDate) {
+          instances.get(row.source_object_id)!.instances.unshift(instance);
+        } else {
+          instances.get(row.source_object_id)!.instances.push(instance);
+        }
+      } else {
+        instances.set(row.source_object_id, {
+          instances: [instance],
+          sourceTable
+        });
+      }
+    }
+
+    return instances;
+  }, 'getCaptureInstances');
+}
+
+export interface GetCaptureInstanceOptions {
+  connectionManager: MSSQLConnectionManager;
+  table: {
+    schema: string;
+    name: string;
   };
 }
+export async function getCaptureInstance(options: GetCaptureInstanceOptions): Promise<CaptureInstanceDetails | null> {
+  const { connectionManager, table } = options;
+  const instances = await getCaptureInstances({ connectionManager, table });
+
+  if (instances.size === 0) {
+    return null;
+  }
+
+  return instances.values().next().value!;
+}

package/src/utils/schema.ts

@@ -1,8 +1,9 @@
+import { logger } from '@powersync/lib-services-framework';
 import { SourceEntityDescriptor } from '@powersync/service-core';
 import { TablePattern } from '@powersync/service-sync-rules';
+import sql from 'mssql';
 import { MSSQLConnectionManager } from '../replication/MSSQLConnectionManager.js';
 import { MSSQLColumnDescriptor } from '../types/mssql-data-types.js';
-import sql from 'mssql';
 
 export interface GetColumnsOptions {
   connectionManager: MSSQLConnectionManager;
@@ -198,3 +199,45 @@ export async function getTablesFromPattern(
     });
   }
 }
+
+export interface GetPendingSchemaChangesOptions {
+  connectionManager: MSSQLConnectionManager;
+  captureInstanceName: string;
+}
+
+/**
+ *  Returns the DDL commands that have been applied to the source table since the capture instance was created.
+ */
+export async function getPendingSchemaChanges(options: GetPendingSchemaChangesOptions): Promise<string[]> {
+  const { connectionManager, captureInstanceName } = options;
+
+  try {
+    const { recordset: results } = await connectionManager.execute('sys.sp_cdc_get_ddl_history', [
+      { name: 'capture_instance', type: sql.VarChar(sql.MAX), value: captureInstanceName }
+    ]);
+    return results.map((row) => row.ddl_command);
+  } catch (e) {
+    if (isObjectNotExistError(e)) {
+      // Defensive check to cover the case where the capture instance metadata is temporarily unavailable.
+      logger.warn(`Unable to retrieve schema changes for capture instance: [${captureInstanceName}].`);
+      return [];
+    }
+    throw e;
+  }
+}
+
+function isObjectNotExistError(error: unknown): boolean {
+  if (error != null && typeof error === 'object' && 'number' in error) {
+    // SQL Server Object does not exist or access is denied error number.
+    return (error as { number: unknown }).number === 22981;
+  }
+  return false;
+}
+
+export async function tableExists(tableId: number, connectionManager: MSSQLConnectionManager): Promise<boolean> {
+  const { recordset: results } = await connectionManager.query(`SELECT 1 FROM sys.tables WHERE object_id = @tableId`, [
+    { name: 'tableId', type: sql.Int, value: tableId }
+  ]);
+
+  return results.length > 0;
+}

package/test/src/CDCStream.test.ts

@@ -1,11 +1,11 @@
-import { describe, expect, test } from 'vitest';
+import { getLatestLSN } from '@module/utils/mssql.js';
+import { storage } from '@powersync/service-core';
 import { METRICS_HELPER, putOp, removeOp } from '@powersync/service-core-tests';
 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 { getLatestLSN } from '@module/utils/mssql.js';
 import sql from 'mssql';
+import { describe, expect, test } from 'vitest';
+import { CDCStreamTestContext } from './CDCStreamTestContext.js';
+import { createTestTable, describeWithStorage, insertTestData, waitForPendingCDCChanges } from './util.js';
 
 const BASIC_SYNC_RULES = `
 bucket_definitions:
@@ -18,7 +18,9 @@ describe('CDCStream tests', () => {
   describeWithStorage({ timeout: 20_000 }, defineCDCStreamTests);
 });
 
-function defineCDCStreamTests(factory: storage.TestStorageFactory) {
+function defineCDCStreamTests(config: storage.TestStorageConfig) {
+  const { factory } = config;
+
   test('Initial snapshot sync', async () => {
     await using context = await CDCStreamTestContext.open(factory);
     const { connectionManager } = context;
@@ -141,7 +143,7 @@ function defineCDCStreamTests(factory: storage.TestStorageFactory) {
     ]);
   });
 
-  test('Replication for tables not in the sync rules are ignored', async () => {
+  test('Replication for tables not in the sync config are ignored', async () => {
     await using context = await CDCStreamTestContext.open(factory);
     const { connectionManager } = context;
     await context.updateSyncRules(BASIC_SYNC_RULES);
@@ -162,7 +164,7 @@ function defineCDCStreamTests(factory: storage.TestStorageFactory) {
     const endRowCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.ROWS_REPLICATED)) ?? 0;
     const endTxCount = (await METRICS_HELPER.getMetricValueForTests(ReplicationMetric.TRANSACTIONS_REPLICATED)) ?? 0;
 
-    // There was a transaction, but it is not counted since it is not for a table in the sync rules
+    // There was a transaction, but it is not counted since it is not for a table in the sync config
     expect(endRowCount - startRowCount).toEqual(0);
     expect(endTxCount - startTxCount).toEqual(0);
   });