@powersync/service-module-mssql 0.6.3 → 0.7.0

package/src/replication/CDCStream.ts

@@ -15,7 +15,7 @@ import {
   storage
 } from '@powersync/service-core';
 
-import { HydratedSyncRules, SqliteInputRow, SqliteRow, TablePattern } from '@powersync/service-sync-rules';
+import { HydratedSyncConfig, SqliteInputRow, SqliteRow, TablePattern } from '@powersync/service-sync-rules';
 
 import { ReplicationMetric } from '@powersync/service-types';
 import sql from 'mssql';
@@ -34,7 +34,12 @@ import {
   getLatestReplicatedLSN,
   isIColumnMetadata
 } from '../utils/mssql.js';
-import { getReplicationIdentityColumns, getTablesFromPattern, ResolvedTable } from '../utils/schema.js';
+import {
+  getReplicationIdentityColumns,
+  getTablesFromPattern,
+  ResolvedTable,
+  SourceTableChangeRef
+} from '../utils/schema.js';
 import { CDCEventHandler, CDCPoller, SchemaChange, SchemaChangeType } from './CDCPoller.js';
 import { MSSQLConnectionManager } from './MSSQLConnectionManager.js';
 import { BatchedSnapshotQuery, MSSQLSnapshotQuery, SimpleSnapshotQuery } from './MSSQLSnapshotQuery.js';
@@ -99,7 +104,7 @@ export class CDCDataExpiredError extends DatabaseConnectionError {
 }
 
 export class CDCStream {
-  private readonly syncRules: HydratedSyncRules;
+  private readonly syncRules: HydratedSyncConfig;
   private readonly storage: storage.SyncRulesBucketStorage;
   private readonly connections: MSSQLConnectionManager;
   private readonly abortSignal: AbortSignal;
@@ -202,6 +207,16 @@ export class CDCStream {
     const tables: MSSQLSourceTable[] = [];
     for (const matchedTable of matchedTables) {
       const captureInstanceDetails = captureInstances.get(matchedTable.objectId as number);
+      if (!captureInstanceDetails) {
+        // Match Postgres publication handling: If the source table cannot stream changes yet,
+        // don't resolve it into storage. Once CDC is enabled, the schema poller detects the
+        // new capture instance and resolves/snapshots it then.
+        this.logger.info(
+          `Skipping ${tablePattern.schema}.${matchedTable.name} - not enabled for CDC. This table will not be replicated until CDC is enabled for it.`
+        );
+        continue;
+      }
+
       // TODO: Check RLS settings for table
 
       const replicaIdColumns = await getReplicationIdentityColumns({
@@ -213,12 +228,13 @@ export class CDCStream {
       const table = await this.processTable(
         batch,
         {
+          connectionTag: this.connectionTag,
           name: matchedTable.name,
           schema: matchedTable.schema,
           objectId: matchedTable.objectId,
           replicaIdColumns: replicaIdColumns.columns
         },
-        captureInstanceDetails?.instances[0] ?? null,
+        captureInstanceDetails.instances[0],
         false
       );
 
@@ -236,14 +252,11 @@ export class CDCStream {
     if (!table.objectId && typeof table.objectId != 'number') {
       throw new ReplicationAssertionError(`objectId expected, got ${typeof table.objectId}`);
     }
-    const resolved = await this.storage.resolveTable({
-      group_id: this.groupId,
+    const resolved = await batch.resolveTables({
       connection_id: this.connectionId,
-      connection_tag: this.connectionTag,
-      entity_descriptor: table,
-      sync_rules: this.syncRules
+      source: table
     });
-    const resolvedTable = new MSSQLSourceTable(resolved.table);
+    const resolvedTable = new MSSQLSourceTable(table, resolved.tables);
 
     if (!captureInstance) {
       this.logger.warn(
@@ -259,30 +272,38 @@ export class CDCStream {
     await batch.drop(resolved.dropTables);
 
     // Snapshot if:
-    // 1. The table is in the sync rules and snapshot is requested, or not already done.
+    // 1. The table is in the sync config and snapshot is requested, or not already done.
     // 2. AND the table is enabled for CDC with a valid capture instance.
-    const shouldSnapshot =
-      snapshot && !resolved.table.snapshotComplete && resolved.table.syncAny && resolvedTable.enabledForCDC();
+    const snapshotCandidates = resolved.tables.filter(
+      (candidate) => snapshot && !candidate.snapshotComplete && candidate.syncAny
+    );
+    const shouldSnapshot = snapshotCandidates.length > 0 && resolvedTable.enabledForCDC();
 
     if (shouldSnapshot) {
-      // Truncate this table in case a previous snapshot was interrupted.
-      await batch.truncate([resolved.table]);
+      // Truncate tables in case a previous snapshot was interrupted.
+      await batch.truncate(snapshotCandidates);
 
-      // Start the snapshot inside a transaction.
-      await this.snapshotTableInTx(batch, resolvedTable);
+      // Start the snapshot(s) inside a transaction.
+      for (const candidate of snapshotCandidates) {
+        await this.snapshotTableInTx(batch, resolvedTable, candidate);
+      }
     }
 
     return resolvedTable;
   }
 
-  private async snapshotTableInTx(batch: storage.BucketStorageBatch, table: MSSQLSourceTable): Promise<void> {
+  private async snapshotTableInTx(
+    batch: storage.BucketStorageBatch,
+    physicalTable: MSSQLSourceTable,
+    sourceTable: storage.SourceTable
+  ): 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);
+      await this.snapshotTable(batch, transaction, physicalTable, sourceTable);
 
       // Get the current LSN.
       // The data will only be consistent once incremental replication has passed that point.
@@ -299,9 +320,9 @@ export class CDCStream {
       const postSnapshotLSN = await getLatestLSN(this.connections);
       // Side note: A ROLLBACK would probably also be fine here, since we only read in this transaction.
       await transaction.commit();
-      const [updatedSourceTable] = await batch.markTableSnapshotDone([table.sourceTable], postSnapshotLSN.toString());
+      const [updatedSourceTable] = await batch.markTableSnapshotDone([sourceTable], postSnapshotLSN.toString());
       this.logger.info(
-        `Snapshot of ${table.toQualifiedName()} completed. Post-snapshot LSN: ${postSnapshotLSN.toString()}`
+        `Snapshot of ${physicalTable.toQualifiedName()} completed. Post-snapshot LSN: ${postSnapshotLSN.toString()}`
       );
       this.tableCache.updateSourceTable(updatedSourceTable);
     } catch (e) {
@@ -313,39 +334,41 @@ export class CDCStream {
   private async snapshotTable(
     batch: storage.BucketStorageBatch,
     transaction: sql.Transaction,
-    table: MSSQLSourceTable
+    physicalTable: MSSQLSourceTable,
+    sourceTable: storage.SourceTable
   ) {
-    let totalEstimatedCount = table.sourceTable.snapshotStatus?.totalEstimatedCount;
-    let replicatedCount = table.sourceTable.snapshotStatus?.replicatedCount ?? 0;
+    let totalEstimatedCount = sourceTable.snapshotStatus?.totalEstimatedCount;
+    let replicatedCount = sourceTable.snapshotStatus?.replicatedCount ?? 0;
     let lastCountTime = 0;
     let query: MSSQLSnapshotQuery;
     // 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 (BatchedSnapshotQuery.supports(table)) {
+    if (BatchedSnapshotQuery.supports(sourceTable)) {
       // Single primary key - we can use the primary key for chunking
-      const orderByKey = table.sourceTable.replicaIdColumns[0];
+      const orderByKey = sourceTable.replicaIdColumns[0];
       query = new BatchedSnapshotQuery(
         transaction,
-        table,
+        physicalTable.toQualifiedName(),
+        sourceTable,
         this.snapshotBatchSize,
-        table.sourceTable.snapshotStatus?.lastKey ?? null
+        sourceTable.snapshotStatus?.lastKey ?? null
       );
-      if (table.sourceTable.snapshotStatus?.lastKey != null) {
+      if (sourceTable.snapshotStatus?.lastKey != null) {
         this.logger.info(
-          `Snapshotting ${table.toQualifiedName()} ${table.sourceTable.formatSnapshotProgress()} - resuming from ${orderByKey.name} > ${(query as BatchedSnapshotQuery).lastKey}`
+          `Snapshotting ${physicalTable.toQualifiedName()} ${sourceTable.formatSnapshotProgress()} - resuming from ${orderByKey.name} > ${(query as BatchedSnapshotQuery).lastKey}`
         );
       } else {
         this.logger.info(
-          `Snapshotting ${table.toQualifiedName()} ${table.sourceTable.formatSnapshotProgress()} - resumable`
+          `Snapshotting ${physicalTable.toQualifiedName()} ${sourceTable.formatSnapshotProgress()} - resumable`
         );
       }
     } else {
       // Fallback case - query the entire table
       this.logger.info(
-        `Snapshotting ${table.toQualifiedName()} ${table.sourceTable.formatSnapshotProgress()} - not resumable`
+        `Snapshotting ${physicalTable.toQualifiedName()} ${sourceTable.formatSnapshotProgress()} - not resumable`
       );
-      query = new SimpleSnapshotQuery(transaction, table);
+      query = new SimpleSnapshotQuery(transaction, physicalTable.toQualifiedName());
       replicatedCount = 0;
     }
     await query.initialize();
@@ -372,11 +395,11 @@ export class CDCStream {
           // This auto-flushes when the batch reaches its size limit
           await batch.save({
             tag: storage.SaveOperationTag.INSERT,
-            sourceTable: table.sourceTable,
+            sourceTable,
             before: undefined,
             beforeReplicaId: undefined,
             after: row,
-            afterReplicaId: getUuidReplicaIdentityBson(row, table.sourceTable.replicaIdColumns)
+            afterReplicaId: getUuidReplicaIdentityBson(row, sourceTable.replicaIdColumns)
           });
 
           replicatedCount++;
@@ -399,15 +422,16 @@ export class CDCStream {
         // 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);
+        totalEstimatedCount = await this.estimatedCountNumber(physicalTable, transaction);
         lastCountTime = performance.now();
       }
-      const updatedSourceTable = await batch.updateTableProgress(table.sourceTable, {
+      const updatedSourceTable = await batch.updateTableProgress(sourceTable, {
         lastKey: lastKey,
         replicatedCount: replicatedCount,
         totalEstimatedCount: totalEstimatedCount
       });
       this.tableCache.updateSourceTable(updatedSourceTable);
+      sourceTable = updatedSourceTable;
 
       if (this.abortSignal.aborted) {
         // We only abort after flushing
@@ -418,7 +442,7 @@ export class CDCStream {
       if (batchReplicatedCount < this.snapshotBatchSize) {
         hasRemainingData = false;
       } else {
-        this.logger.info(`Snapshotting ${table.toQualifiedName()} ${table.sourceTable.formatSnapshotProgress()}`);
+        this.logger.info(`Snapshotting ${physicalTable.toQualifiedName()} ${sourceTable.formatSnapshotProgress()}`);
       }
     }
   }
@@ -471,18 +495,19 @@ export class CDCStream {
             break;
           case SnapshotStatus.LIMITED_RESNAPSHOT:
             for (const table of specificTablesToResnapshot!) {
-              await batch.drop([table.sourceTable]);
+              await batch.drop(table.getReplicatedSourceTables());
               // Update table in the table cache
-              await this.processTable(batch, table.sourceTable, table.captureInstance, false);
+              await this.processTable(batch, table.ref, table.captureInstance, false);
             }
             break;
           default:
             throw new ReplicationAssertionError(`Unsupported snapshot status: ${status}`);
         }
 
-        const tablesToSnapshot: MSSQLSourceTable[] = [];
+        const tablesToSnapshot: { physicalTable: MSSQLSourceTable; sourceTable: storage.SourceTable }[] = [];
         for (const table of this.tableCache.getAll()) {
-          if (table.sourceTable.snapshotComplete) {
+          const sourceTablesToSnapshot = table.sourceTables.filter((sourceTable) => !sourceTable.snapshotComplete);
+          if (sourceTablesToSnapshot.length == 0) {
             this.logger.info(`Skipping table [${table.toQualifiedName()}] - snapshot already done.`);
             continue;
           }
@@ -493,22 +518,24 @@ export class CDCStream {
           }
 
           const count = await this.estimatedCountNumber(table);
-          const updatedSourceTable = await batch.updateTableProgress(table.sourceTable, {
-            totalEstimatedCount: count
-          });
-          this.tableCache.updateSourceTable(updatedSourceTable);
-          tablesToSnapshot.push(table);
+          for (const sourceTable of sourceTablesToSnapshot) {
+            const updatedSourceTable = await batch.updateTableProgress(sourceTable, {
+              totalEstimatedCount: count
+            });
+            this.tableCache.updateSourceTable(updatedSourceTable);
+            tablesToSnapshot.push({ physicalTable: table, sourceTable: updatedSourceTable });
+          }
         }
 
-        for (const table of tablesToSnapshot) {
-          await this.snapshotTableInTx(batch, table);
+        for (const { physicalTable, sourceTable } of tablesToSnapshot) {
+          await this.snapshotTableInTx(batch, physicalTable, sourceTable);
           this.touch();
         }
 
         // This will not create a consistent checkpoint yet, but will persist the op.
         // Actual checkpoint will be created when streaming replication caught up.
         const postSnapshotLSN = await getLatestLSN(this.connections);
-        await batch.markAllSnapshotDone(postSnapshotLSN.toString());
+        await batch.markSnapshotDone(postSnapshotLSN.toString());
         await batch.commit(snapshotLSN!);
 
         if (tablesToSnapshot.length > 0) {
@@ -546,7 +573,9 @@ export class CDCStream {
 
     if (status.snapshot_done && status.checkpoint_lsn) {
       const additionalTablesToSnapshot: Set<MSSQLSourceTable> = new Set();
-      const newTables = this.tableCache.getAll().filter((table) => !table.sourceTable.snapshotComplete);
+      const newTables = this.tableCache
+        .getAll()
+        .filter((table) => table.sourceTables.some((sourceTable) => !sourceTable.snapshotComplete));
       if (newTables.length > 0) {
         this.logger.info(
           `Detected new table(s) [${newTables.map((table) => table.toQualifiedName()).join(', ')}] that have not been snapshotted yet.`
@@ -637,39 +666,45 @@ export class CDCStream {
     return {
       onInsert: async (row: any, table: MSSQLSourceTable, columns: sql.IColumnMetadata) => {
         const afterRow = this.toSqliteRow(row, columns);
-        await batch.save({
-          tag: storage.SaveOperationTag.INSERT,
-          sourceTable: table.sourceTable,
-          before: undefined,
-          beforeReplicaId: undefined,
-          after: afterRow,
-          afterReplicaId: getUuidReplicaIdentityBson(afterRow, table.sourceTable.replicaIdColumns)
-        });
+        for (const sourceTable of table.getReplicatedSourceTables()) {
+          await batch.save({
+            tag: storage.SaveOperationTag.INSERT,
+            sourceTable,
+            before: undefined,
+            beforeReplicaId: undefined,
+            after: afterRow,
+            afterReplicaId: getUuidReplicaIdentityBson(afterRow, sourceTable.replicaIdColumns)
+          });
+        }
         this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED).add(1);
       },
       onUpdate: async (rowAfter: any, rowBefore: any, table: MSSQLSourceTable, columns: sql.IColumnMetadata) => {
         const beforeRow = this.toSqliteRow(rowBefore, columns);
         const afterRow = this.toSqliteRow(rowAfter, columns);
-        await batch.save({
-          tag: storage.SaveOperationTag.UPDATE,
-          sourceTable: table.sourceTable,
-          before: beforeRow,
-          beforeReplicaId: getUuidReplicaIdentityBson(beforeRow, table.sourceTable.replicaIdColumns),
-          after: afterRow,
-          afterReplicaId: getUuidReplicaIdentityBson(afterRow, table.sourceTable.replicaIdColumns)
-        });
+        for (const sourceTable of table.getReplicatedSourceTables()) {
+          await batch.save({
+            tag: storage.SaveOperationTag.UPDATE,
+            sourceTable,
+            before: beforeRow,
+            beforeReplicaId: getUuidReplicaIdentityBson(beforeRow, sourceTable.replicaIdColumns),
+            after: afterRow,
+            afterReplicaId: getUuidReplicaIdentityBson(afterRow, sourceTable.replicaIdColumns)
+          });
+        }
         this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED).add(1);
       },
       onDelete: async (row: any, table: MSSQLSourceTable, columns: sql.IColumnMetadata) => {
         const beforeRow = this.toSqliteRow(row, columns);
-        await batch.save({
-          tag: storage.SaveOperationTag.DELETE,
-          sourceTable: table.sourceTable,
-          before: beforeRow,
-          beforeReplicaId: getUuidReplicaIdentityBson(beforeRow, table.sourceTable.replicaIdColumns),
-          after: undefined,
-          afterReplicaId: undefined
-        });
+        for (const sourceTable of table.getReplicatedSourceTables()) {
+          await batch.save({
+            tag: storage.SaveOperationTag.DELETE,
+            sourceTable,
+            before: beforeRow,
+            beforeReplicaId: getUuidReplicaIdentityBson(beforeRow, sourceTable.replicaIdColumns),
+            after: undefined,
+            afterReplicaId: undefined
+          });
+        }
         this.metrics.getCounter(ReplicationMetric.ROWS_REPLICATED).add(1);
       },
       onCommit: async (lsn: string, transactionCount: number) => {
@@ -698,7 +733,8 @@ export class CDCStream {
         );
 
         // Old table needs to be cleaned up
-        await batch.drop([fromTable.sourceTable]);
+        const fromTables = fromTable.getReplicatedSourceTables();
+        await batch.drop(fromTables);
         this.tableCache.delete(fromTable.objectId);
 
         if (change.newTable) {
@@ -716,13 +752,13 @@ export class CDCStream {
         this.logger.info(
           `New CDC capture instance detected for table ${change.table!.toQualifiedName()}. Re-snapshotting table...`
         );
-        await batch.drop([change.table!.sourceTable]);
+        await batch.drop(change.table!.getReplicatedSourceTables());
         this.tableCache.delete(change.table!.objectId);
 
-        await this.handleCreateOrUpdateTable(batch, change.table!.sourceTable, change.newCaptureInstance!);
+        await this.handleCreateOrUpdateTable(batch, change.table!.ref, change.newCaptureInstance!);
         break;
       case SchemaChangeType.TABLE_DROP:
-        await batch.drop([change.table!.sourceTable]);
+        await batch.drop(change.table!.getReplicatedSourceTables());
         this.tableCache.delete(change.table!.objectId);
         break;
       case SchemaChangeType.MISSING_CAPTURE_INSTANCE:
@@ -745,7 +781,7 @@ export class CDCStream {
 
   private async handleCreateOrUpdateTable(
     batch: storage.BucketStorageBatch,
-    table: Omit<SourceEntityDescriptor, 'replicaIdColumns'>,
+    table: SourceTableChangeRef,
     captureInstance: CaptureInstance
   ): Promise<void> {
     const replicaIdColumns = await getReplicationIdentityColumns({
@@ -757,6 +793,7 @@ export class CDCStream {
     await this.processTable(
       batch,
       {
+        connectionTag: this.connectionTag,
         name: table.name,
         schema: table.schema,
         objectId: table.objectId,

package/src/replication/MSSQLSnapshotQuery.ts

@@ -1,7 +1,6 @@
 import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import { bson, ColumnDescriptor, SourceTable } from '@powersync/service-core';
 import sql from 'mssql';
-import { MSSQLSourceTable } from '../common/MSSQLSourceTable.js';
 import { MSSQLBaseType } from '../types/mssql-data-types.js';
 import { escapeIdentifier } from '../utils/mssql.js';
 
@@ -23,7 +22,7 @@ export interface MSSQLSnapshotQuery {
 export class SimpleSnapshotQuery implements MSSQLSnapshotQuery {
   public constructor(
     private readonly transaction: sql.Transaction,
-    private readonly table: MSSQLSourceTable
+    private readonly qualifiedTableName: string
   ) {}
 
   public async initialize(): Promise<void> {}
@@ -36,7 +35,7 @@ export class SimpleSnapshotQuery implements MSSQLSnapshotQuery {
       metadataRequest.on('error', reject);
     });
 
-    metadataRequest.query(`SELECT TOP(0) * FROM ${this.table.toQualifiedName()}`);
+    metadataRequest.query(`SELECT TOP(0) * FROM ${this.qualifiedTableName}`);
 
     const columnMetadata: sql.IColumnMetadata = await metadataPromise;
     yield columnMetadata;
@@ -44,7 +43,7 @@ export class SimpleSnapshotQuery implements MSSQLSnapshotQuery {
     const request = this.transaction.request();
     const stream = request.toReadableStream();
 
-    request.query(`SELECT * FROM ${this.table.toQualifiedName()}`);
+    request.query(`SELECT * FROM ${this.qualifiedTableName}`);
 
     // MSSQL only streams one row at a time
     for await (const row of stream) {
@@ -84,8 +83,7 @@ export class BatchedSnapshotQuery implements MSSQLSnapshotQuery {
     MSSQLBaseType.BIGINT
   ];
 
-  static supports(table: SourceTable | MSSQLSourceTable): boolean {
-    const sourceTable = table instanceof MSSQLSourceTable ? table.sourceTable : table;
+  static supports(sourceTable: SourceTable): boolean {
     if (sourceTable.replicaIdColumns.length != 1) {
       return false;
     }
@@ -99,11 +97,12 @@ export class BatchedSnapshotQuery implements MSSQLSnapshotQuery {
 
   public constructor(
     private readonly transaction: sql.Transaction,
-    private readonly table: MSSQLSourceTable,
+    private readonly qualifiedTableName: string,
+    sourceTable: SourceTable,
     private readonly batchSize: number = 10_000,
     lastKeySerialized: Uint8Array | null
   ) {
-    this.key = table.sourceTable.replicaIdColumns[0];
+    this.key = sourceTable.replicaIdColumns[0];
 
     if (lastKeySerialized != null) {
       this.lastKey = this.deserializeKey(lastKeySerialized);
@@ -126,7 +125,7 @@ export class BatchedSnapshotQuery implements MSSQLSnapshotQuery {
       metadataRequest.on('recordset', resolve);
       metadataRequest.on('error', reject);
     });
-    metadataRequest.query(`SELECT TOP(0) * FROM ${this.table.toQualifiedName()}`);
+    metadataRequest.query(`SELECT TOP(0) * FROM ${this.qualifiedTableName}`);
 
     const columnMetadata: sql.IColumnMetadata = await metadataPromise;
 
@@ -142,7 +141,7 @@ export class BatchedSnapshotQuery implements MSSQLSnapshotQuery {
     const request = this.transaction.request();
     const stream = request.toReadableStream();
     if (this.lastKey == null) {
-      request.query(`SELECT TOP(${this.batchSize}) * FROM ${this.table.toQualifiedName()} ORDER BY ${escapedKeyName}`);
+      request.query(`SELECT TOP(${this.batchSize}) * FROM ${this.qualifiedTableName} ORDER BY ${escapedKeyName}`);
     } else {
       if (this.key.typeId == null) {
         throw new Error(`typeId required for primary key ${this.key.name}`);
@@ -150,7 +149,7 @@ export class BatchedSnapshotQuery implements MSSQLSnapshotQuery {
       request
         .input('lastKey', this.lastKey)
         .query(
-          `SELECT TOP(${this.batchSize}) * FROM ${this.table.toQualifiedName()} WHERE ${escapedKeyName} > @lastKey ORDER BY ${escapedKeyName}`
+          `SELECT TOP(${this.batchSize}) * FROM ${this.qualifiedTableName} WHERE ${escapedKeyName} > @lastKey ORDER BY ${escapedKeyName}`
         );
     }
 

package/src/utils/mssql.ts

@@ -308,7 +308,7 @@ export async function getDebugTableInfo(options: GetDebugTableInfoOptions): Prom
   }
 
   const idColumns = idColumnsResult?.columns ?? [];
-  const sourceTable: sync_rules.SourceTableInterface = {
+  const sourceTable: sync_rules.SourceTableRef = {
     connectionTag: connectionManager.connectionTag,
     schema: schema,
     name: table.name

package/src/utils/schema.ts

@@ -1,5 +1,4 @@
 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';
@@ -139,7 +138,13 @@ export async function getReplicationIdentityColumns(
   };
 }
 
-export type ResolvedTable = Omit<SourceEntityDescriptor, 'replicaIdColumns'>;
+export interface SourceTableChangeRef {
+  objectId: number | string | undefined;
+  schema: string;
+  name: string;
+}
+
+export type ResolvedTable = SourceTableChangeRef;
 
 export async function getTablesFromPattern(
   connectionManager: MSSQLConnectionManager,

package/test/src/CDCStream.test.ts

@@ -143,7 +143,7 @@ function defineCDCStreamTests(config: storage.TestStorageConfig) {
     ]);
   });
 
-  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);
@@ -164,7 +164,7 @@ function defineCDCStreamTests(config: storage.TestStorageConfig) {
     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);
   });

package/test/src/CDCStreamTestContext.ts

@@ -86,7 +86,7 @@ export class CDCStreamTestContext implements AsyncDisposable {
   async loadNextSyncRules() {
     const syncRules = await this.factory.getNextSyncRulesContent();
     if (syncRules == null) {
-      throw new Error(`Next sync rules not available`);
+      throw new Error(`Next replication stream not available`);
     }
 
     this.syncRulesContent = syncRules;
@@ -97,7 +97,7 @@ export class CDCStreamTestContext implements AsyncDisposable {
   async loadActiveSyncRules() {
     const syncRules = await this.factory.getActiveSyncRulesContent();
     if (syncRules == null) {
-      throw new Error(`Active sync rules not available`);
+      throw new Error(`Active replication stream not available`);
     }
 
     this.syncRulesContent = syncRules;
@@ -107,7 +107,7 @@ export class CDCStreamTestContext implements AsyncDisposable {
 
   private getSyncRulesContent(): storage.PersistedSyncRulesContent {
     if (this.syncRulesContent == null) {
-      throw new Error('Sync rules not configured - call updateSyncRules() first');
+      throw new Error('Sync config not configured - call updateSyncRules() first');
     }
     return this.syncRulesContent;
   }

package/test/src/schema-changes.test.ts

@@ -339,9 +339,7 @@ function defineSchemaChangesTests(config: storage.TestStorageConfig) {
     await context.replicateSnapshot();
     await context.startStreaming();
 
-    const schemaSpy = vi.spyOn(context.cdcStream, 'handleSchemaChange');
     await enableCDCForTable({ connectionManager, table: 'test_data' });
-    await expectedSchemaChange(schemaSpy, SchemaChangeType.NEW_CAPTURE_INSTANCE);
 
     let data = await context.getBucketData('global[]');
     expect(data).toMatchObject([putOp('test_data', testData1)]);

package/test/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "extends": "../../../tsconfig.tests.json",
   "compilerOptions": {
-    "baseUrl": "./",
     "paths": {
       "@/*": ["../../../packages/service-core/src/*"],
       "@module/*": ["../src/*"],