@powersync/service-module-mssql 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @powersync/service-module-mssql
 
+## 0.6.0
+
+### Minor Changes
+
+- 8d5d7ee: Added schema change detection and handling for the SQL Server adapter
+
+### Patch Changes
+
+- Updated dependencies [224c35e]
+- Updated dependencies [acf1486]
+- Updated dependencies [391c5ef]
+- Updated dependencies [7ee87d4]
+- Updated dependencies [99de8be]
+- Updated dependencies [8d5d7ee]
+- Updated dependencies [9daf965]
+- Updated dependencies [4c92c24]
+- Updated dependencies [3d230c2]
+- Updated dependencies [206633f]
+- Updated dependencies [3a0627e]
+- Updated dependencies [275fd5f]
+- Updated dependencies [7ce1b8e]
+  - @powersync/service-sync-rules@0.34.0
+  - @powersync/service-core@1.20.2
+  - @powersync/service-errors@0.4.1
+  - @powersync/lib-services-framework@0.9.1
+
 ## 0.5.0
 
 ### Minor Changes

package/dist/common/CaptureInstance.d.ts

@@ -0,0 +1,14 @@
+import { LSN } from './LSN.js';
+export interface CaptureInstance {
+    name: string;
+    /**
+     *  Object ID for the capture instance table
+     */
+    objectId: number;
+    minLSN: LSN;
+    createDate: Date;
+    /**
+     * DDL commands that have been applied to the source table but are not reflected in the capture instance.
+     */
+    pendingSchemaChanges: string[];
+}

package/dist/common/CaptureInstance.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CaptureInstance.js.map

package/dist/common/CaptureInstance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaptureInstance.js","sourceRoot":"","sources":["../../src/common/CaptureInstance.ts"],"names":[],"mappings":""}

package/dist/common/MSSQLSourceTable.d.ts

@@ -1,25 +1,27 @@
 import { SourceTable } from '@powersync/service-core';
-export interface CaptureInstance {
-    name: string;
-    schema: string;
-}
-export interface MSSQLSourceTableOptions {
+import { CaptureInstance } from './CaptureInstance.js';
+/**
+ *  The cdc schema in SQL Server is reserved and created when enabling CDC on a database.
+ */
+export declare const CDC_SCHEMA = "cdc";
+export declare class MSSQLSourceTable {
     sourceTable: SourceTable;
     /**
      *  The unique name of the CDC capture instance for this table
      */
-    captureInstance: CaptureInstance;
-}
-export declare class MSSQLSourceTable {
-    private options;
-    constructor(options: MSSQLSourceTableOptions);
-    get sourceTable(): SourceTable;
+    captureInstance: CaptureInstance | null;
+    constructor(sourceTable: SourceTable);
     updateSourceTable(updated: SourceTable): void;
-    get captureInstance(): string;
-    get cdcSchema(): string;
-    get CTTable(): string;
+    enabledForCDC(): boolean;
+    setCaptureInstance(captureInstance: CaptureInstance): void;
+    clearCaptureInstance(): void;
     get allChangesFunction(): string;
     get netChangesFunction(): string;
+    /**
+     *  Return the object ID of the source table.
+     *  Object IDs in SQL Server are always numbers.
+     */
+    get objectId(): number;
     /**
      *  Escapes this source table's name and schema for use in MSSQL queries.
      */

package/dist/common/MSSQLSourceTable.js

@@ -1,29 +1,48 @@
-import { escapeIdentifier, toQualifiedTableName } from '../utils/mssql.js';
+import { toQualifiedTableName } from '../utils/mssql.js';
+import { ServiceAssertionError } from '@powersync/service-errors';
+/**
+ *  The cdc schema in SQL Server is reserved and created when enabling CDC on a database.
+ */
+export const CDC_SCHEMA = 'cdc';
 export class MSSQLSourceTable {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    get sourceTable() {
-        return this.options.sourceTable;
+    sourceTable;
+    /**
+     *  The unique name of the CDC capture instance for this table
+     */
+    captureInstance = null;
+    constructor(sourceTable) {
+        this.sourceTable = sourceTable;
     }
     updateSourceTable(updated) {
-        this.options.sourceTable = updated;
+        this.sourceTable = updated;
     }
-    get captureInstance() {
-        return this.options.captureInstance.name;
+    enabledForCDC() {
+        return this.captureInstance !== null;
     }
-    get cdcSchema() {
-        return this.options.captureInstance.schema;
+    setCaptureInstance(captureInstance) {
+        this.captureInstance = captureInstance;
     }
-    get CTTable() {
-        return `${escapeIdentifier(this.cdcSchema)}.${this.captureInstance}_CT`;
+    clearCaptureInstance() {
+        this.captureInstance = null;
     }
     get allChangesFunction() {
-        return `${escapeIdentifier(this.cdcSchema)}.fn_cdc_get_all_changes_${this.captureInstance}`;
+        if (!this.captureInstance) {
+            throw new ServiceAssertionError(`No capture instance set for table: ${this.sourceTable.name}`);
+        }
+        return `${CDC_SCHEMA}.fn_cdc_get_all_changes_${this.captureInstance.name}`;
     }
     get netChangesFunction() {
-        return `${escapeIdentifier(this.cdcSchema)}.fn_cdc_get_net_changes_${this.captureInstance}`;
+        if (!this.captureInstance) {
+            throw new ServiceAssertionError(`No capture instance set for table: ${this.sourceTable.name}`);
+        }
+        return `${CDC_SCHEMA}.fn_cdc_get_net_changes_${this.captureInstance.name}`;
+    }
+    /**
+     *  Return the object ID of the source table.
+     *  Object IDs in SQL Server are always numbers.
+     */
+    get objectId() {
+        return this.sourceTable.objectId;
     }
     /**
      *  Escapes this source table's name and schema for use in MSSQL queries.

package/dist/common/MSSQLSourceTable.js.map

@@ -1 +1 @@
-{"version":3,"file":"MSSQLSourceTable.js","sourceRoot":"","sources":["../../src/common/MSSQLSourceTable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAe3E,MAAM,OAAO,gBAAgB;IACP;IAApB,YAAoB,OAAgC;QAAhC,YAAO,GAAP,OAAO,CAAyB;IAAG,CAAC;IAExD,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;IAClC,CAAC;IAED,iBAAiB,CAAC,OAAoB;QACpC,IAAI,CAAC,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC;IACrC,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC;IAC3C,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC;IAC7C,CAAC;IAED,IAAI,OAAO;QACT,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,eAAe,KAAK,CAAC;IAC1E,CAAC;IAED,IAAI,kBAAkB;QACpB,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,2BAA2B,IAAI,CAAC,eAAe,EAAE,CAAC;IAC9F,CAAC;IAED,IAAI,kBAAkB;QACpB,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,2BAA2B,IAAI,CAAC,eAAe,EAAE,CAAC;IAC9F,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,oBAAoB,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9E,CAAC;CACF"}
+{"version":3,"file":"MSSQLSourceTable.js","sourceRoot":"","sources":["../../src/common/MSSQLSourceTable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGlE;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,CAAC;AAEhC,MAAM,OAAO,gBAAgB;IAMR;IALnB;;OAEG;IACI,eAAe,GAA2B,IAAI,CAAC;IAEtD,YAAmB,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;IAAG,CAAC;IAE/C,iBAAiB,CAAC,OAAoB;QACpC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;IAC7B,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,eAAe,KAAK,IAAI,CAAC;IACvC,CAAC;IAED,kBAAkB,CAAC,eAAgC;QACjD,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACzC,CAAC;IAED,oBAAoB;QAClB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED,IAAI,kBAAkB;QACpB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,MAAM,IAAI,qBAAqB,CAAC,sCAAsC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;QACjG,CAAC;QACD,OAAO,GAAG,UAAU,2BAA2B,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAC7E,CAAC;IAED,IAAI,kBAAkB;QACpB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,MAAM,IAAI,qBAAqB,CAAC,sCAAsC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;QACjG,CAAC;QACD,OAAO,GAAG,UAAU,2BAA2B,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;IAC7E,CAAC;IAED;;;OAGG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,QAAkB,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,oBAAoB,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9E,CAAC;CACF"}

package/dist/replication/CDCPoller.d.ts

@@ -4,44 +4,55 @@ import { MSSQLSourceTable } from '../common/MSSQLSourceTable.js';
 import { LSN } from '../common/LSN.js';
 import sql from 'mssql';
 import { AdditionalConfig } from '../types/types.js';
-/**
- *  Schema changes that are detectable by inspecting query events.
- *  Create table statements are not included here, since new tables are automatically detected when row events
- *  are received for them.
- */
+import { TablePattern } from '@powersync/service-sync-rules';
+import { CaptureInstance } from '../common/CaptureInstance.js';
+import { SourceEntityDescriptor } from '@powersync/service-core';
 export declare enum SchemaChangeType {
-    RENAME_TABLE = "Rename Table",
-    DROP_TABLE = "Drop Table",
-    TRUNCATE_TABLE = "Truncate Table",
-    ALTER_TABLE_COLUMN = "Alter Table Column",
-    REPLICATION_IDENTITY = "Alter Replication Identity"
+    TABLE_RENAME = "table_rename",
+    TABLE_DROP = "table_drop",
+    TABLE_CREATE = "table_create",
+    TABLE_COLUMN_CHANGES = "table_column_changes",
+    NEW_CAPTURE_INSTANCE = "new_capture_instance",
+    MISSING_CAPTURE_INSTANCE = "missing_capture_instance"
 }
 export interface SchemaChange {
     type: SchemaChangeType;
     /**
-     *  The table that the schema change applies to.
+     *  The table that the schema change applies to. Populated for table drops, renames, new capture instances, and DDL changes.
      */
-    table: string;
-    schema: string;
+    table?: MSSQLSourceTable;
     /**
-     *  Populated for table renames if the newTable was matched by the DatabaseFilter
+     *  Populated for new tables or renames, but only if the new table matches a sync rule source table.
      */
-    newTable?: string;
+    newTable?: Omit<SourceEntityDescriptor, 'replicaIdColumns'>;
+    newCaptureInstance?: CaptureInstance;
 }
 export interface CDCEventHandler {
-    onInsert: (row: any, table: MSSQLSourceTable, collumns: sql.IColumnMetadata) => Promise<void>;
-    onUpdate: (rowAfter: any, rowBefore: any, table: MSSQLSourceTable, collumns: sql.IColumnMetadata) => Promise<void>;
-    onDelete: (row: any, table: MSSQLSourceTable, collumns: sql.IColumnMetadata) => Promise<void>;
+    onInsert: (row: any, table: MSSQLSourceTable, columns: sql.IColumnMetadata) => Promise<void>;
+    onUpdate: (rowAfter: any, rowBefore: any, table: MSSQLSourceTable, columns: sql.IColumnMetadata) => Promise<void>;
+    onDelete: (row: any, table: MSSQLSourceTable, columns: sql.IColumnMetadata) => Promise<void>;
     onCommit: (lsn: string, transactionCount: number) => Promise<void>;
     onSchemaChange: (change: SchemaChange) => Promise<void>;
 }
+export declare const DEFAULT_SCHEMA_CHECK_INTERVAL_MS = 60000;
 export interface CDCPollerOptions {
     connectionManager: MSSQLConnectionManager;
     eventHandler: CDCEventHandler;
-    sourceTables: MSSQLSourceTable[];
+    /** CDC enabled source tables from the sync rules to replicate */
+    getReplicatedTables: () => MSSQLSourceTable[];
+    /** All table patterns from the sync rules. Can contain tables that need to be replicated
+     *  but do not yet have CDC enabled
+     */
+    sourceTables: TablePattern[];
     startLSN: LSN;
     logger?: Logger;
     additionalConfig: AdditionalConfig;
+    /**
+     * Interval in milliseconds between schema change checks.
+     * Schema checks also run immediately after a recoverable error during polling
+     * (e.g. a dropped capture instance).
+     */
+    schemaCheckIntervalMs?: number;
 }
 /**
  *
@@ -53,15 +64,26 @@ export declare class CDCPoller {
     private currentLSN;
     private logger;
     private listenerError;
+    private captureInstances;
     private isStopped;
     private isStopping;
     private isPolling;
+    private lastSchemaCheckTime;
     constructor(options: CDCPollerOptions);
     private get pollingBatchSize();
     private get pollingIntervalMs();
-    private get sourceTables();
+    private get schemaCheckIntervalMs();
+    private get replicatedTables();
     stop(): Promise<void>;
     replicateUntilStopped(): Promise<void>;
     private poll;
     private pollTable;
+    private shouldCheckSchema;
+    /**
+     * Checks the given table for pending schema changes that can lead to inconsistencies in the replicated data if not handled.
+     * Returns the SchemaChange if any are found, null otherwise.
+     */
+    private checkForSchemaChanges;
+    private checkForNewTables;
+    private tableMatchesSyncRules;
 }

package/dist/replication/CDCPoller.js

@@ -1,8 +1,10 @@
-import { logger as defaultLogger, ReplicationAssertionError } from '@powersync/lib-services-framework';
+import { DatabaseQueryError, ErrorCode, logger as defaultLogger, ReplicationAssertionError } from '@powersync/lib-services-framework';
 import timers from 'timers/promises';
 import { LSN } from '../common/LSN.js';
 import sql from 'mssql';
-import { getMinLSN, incrementLSN } from '../utils/mssql.js';
+import { getCaptureInstances, incrementLSN, toQualifiedTableName } from '../utils/mssql.js';
+import { isDeadlockError } from '../utils/deadlock.js';
+import { tableExists } from '../utils/schema.js';
 var Operation;
 (function (Operation) {
     Operation[Operation["DELETE"] = 1] = "DELETE";
@@ -10,19 +12,16 @@ var Operation;
     Operation[Operation["UPDATE_BEFORE"] = 3] = "UPDATE_BEFORE";
     Operation[Operation["UPDATE_AFTER"] = 4] = "UPDATE_AFTER";
 })(Operation || (Operation = {}));
-/**
- *  Schema changes that are detectable by inspecting query events.
- *  Create table statements are not included here, since new tables are automatically detected when row events
- *  are received for them.
- */
 export var SchemaChangeType;
 (function (SchemaChangeType) {
-    SchemaChangeType["RENAME_TABLE"] = "Rename Table";
-    SchemaChangeType["DROP_TABLE"] = "Drop Table";
-    SchemaChangeType["TRUNCATE_TABLE"] = "Truncate Table";
-    SchemaChangeType["ALTER_TABLE_COLUMN"] = "Alter Table Column";
-    SchemaChangeType["REPLICATION_IDENTITY"] = "Alter Replication Identity";
+    SchemaChangeType["TABLE_RENAME"] = "table_rename";
+    SchemaChangeType["TABLE_DROP"] = "table_drop";
+    SchemaChangeType["TABLE_CREATE"] = "table_create";
+    SchemaChangeType["TABLE_COLUMN_CHANGES"] = "table_column_changes";
+    SchemaChangeType["NEW_CAPTURE_INSTANCE"] = "new_capture_instance";
+    SchemaChangeType["MISSING_CAPTURE_INSTANCE"] = "missing_capture_instance";
 })(SchemaChangeType || (SchemaChangeType = {}));
+export const DEFAULT_SCHEMA_CHECK_INTERVAL_MS = 60_000;
 /**
  *
  */
@@ -33,9 +32,11 @@ export class CDCPoller {
     currentLSN;
     logger;
     listenerError;
+    captureInstances;
     isStopped = false;
     isStopping = false;
     isPolling = false;
+    lastSchemaCheckTime = 0;
     constructor(options) {
         this.options = options;
         this.logger = options.logger ?? defaultLogger;
@@ -43,6 +44,7 @@ export class CDCPoller {
         this.eventHandler = options.eventHandler;
         this.currentLSN = options.startLSN;
         this.listenerError = null;
+        this.captureInstances = new Map();
     }
     get pollingBatchSize() {
         return this.options.additionalConfig.pollingBatchSize;
@@ -50,8 +52,11 @@ export class CDCPoller {
     get pollingIntervalMs() {
         return this.options.additionalConfig.pollingIntervalMs;
     }
-    get sourceTables() {
-        return this.options.sourceTables;
+    get schemaCheckIntervalMs() {
+        return this.options.schemaCheckIntervalMs ?? DEFAULT_SCHEMA_CHECK_INTERVAL_MS;
+    }
+    get replicatedTables() {
+        return this.options.getReplicatedTables();
     }
     async stop() {
         if (!(this.isStopped || this.isStopping)) {
@@ -68,15 +73,38 @@ export class CDCPoller {
                 throw new ReplicationAssertionError('A polling cycle is already in progress.');
             }
             try {
+                if (this.shouldCheckSchema()) {
+                    this.captureInstances = await getCaptureInstances({ connectionManager: this.connectionManager });
+                    const schemaChanges = await this.checkForSchemaChanges();
+                    for (const schemaChange of schemaChanges) {
+                        await this.eventHandler.onSchemaChange(schemaChange);
+                    }
+                    this.lastSchemaCheckTime = Date.now();
+                    this.logger.debug(`Schema change check complete. Schema changes found: ${schemaChanges.map((c) => c.type).join(', ')}`);
+                }
                 const hasChanges = await this.poll();
                 if (!hasChanges) {
-                    // No changes found, wait before next poll
+                    // No changes found, wait before polling again
                     await timers.setTimeout(this.pollingIntervalMs);
                 }
                 // If changes were found, poll immediately again (no wait)
             }
             catch (error) {
                 if (!(this.isStopped || this.isStopping)) {
+                    // Recoverable errors
+                    if (error instanceof DatabaseQueryError) {
+                        this.logger.warn(error.message);
+                        // Force schema check on next iteration to detect breaking changes
+                        this.lastSchemaCheckTime = 0;
+                        continue;
+                    }
+                    // Deadlock errors are transient — even if all retries within retryOnDeadlock were
+                    // exhausted, we should not crash the poller. Instead, log and retry the entire cycle.
+                    if (isDeadlockError(error)) {
+                        this.logger.warn(`Deadlock persisted after all retry attempts during CDC polling cycle. Will retry on next cycle: ${error.message}`);
+                        continue;
+                    }
+                    // Non-recoverable errors
                     this.listenerError = error;
                     this.logger.error('Error during CDC polling:', error);
                     this.stop();
@@ -110,15 +138,18 @@ export class CDCPoller {
             const endLSN = LSN.fromBinary(results[results.length - 1].start_lsn);
             this.logger.info(`Polling bounds are ${startLSN} -> ${endLSN} spanning ${results.length} transaction(s).`);
             let transactionCount = 0;
-            for (const table of this.sourceTables) {
-                const tableTransactionCount = await this.pollTable(table, { startLSN, endLSN });
-                // We poll for batch size transactions, but these include transactions not applicable to our Source Tables.
-                // Each Source Table may or may not have transactions that are applicable to it, so just keep track of the highest number of transactions processed for any Source Table.
-                if (tableTransactionCount > transactionCount) {
-                    transactionCount = tableTransactionCount;
+            this.logger.debug(`Currently replicating tables: ${this.replicatedTables.map((table) => table.toQualifiedName()).join(', ')}`);
+            for (const table of this.replicatedTables) {
+                if (table.enabledForCDC()) {
+                    const tableTransactionCount = await this.pollTable(table, { startLSN, endLSN });
+                    // We poll for batch size transactions, but these include transactions not applicable to our Source Tables.
+                    // Each Source Table may or may not have transactions that are applicable to it, so just keep track of the highest number of transactions processed for any Source Table.
+                    if (tableTransactionCount > transactionCount) {
+                        transactionCount = tableTransactionCount;
+                    }
                 }
             }
-            this.logger.info(`Processed ${results.length} transaction(s), including ${transactionCount} Source Table transaction(s).`);
+            this.logger.info(`Processed ${results.length} transaction(s), including ${transactionCount} Source Table transaction(s). Commited LSN: ${endLSN.toString()}`);
             // Call eventHandler.onCommit() with toLSN after processing all tables
             await this.eventHandler.onCommit(endLSN.toString(), transactionCount);
             this.currentLSN = endLSN;
@@ -131,57 +162,166 @@ export class CDCPoller {
     }
     async pollTable(table, bounds) {
         // Ensure that the startLSN is not before the minimum LSN for the table
-        const minLSN = await getMinLSN(this.connectionManager, table.captureInstance);
+        const minLSN = this.captureInstances.get(table.objectId).instances[0].minLSN;
         if (minLSN > bounds.endLSN) {
             return 0;
         }
         else if (minLSN >= bounds.startLSN) {
             bounds.startLSN = minLSN;
         }
-        const { recordset: results } = await this.connectionManager.query(`
+        try {
+            const { recordset: results } = await this.connectionManager.query(`
         SELECT * FROM ${table.allChangesFunction}(@from_lsn, @to_lsn, 'all update old') ORDER BY __$start_lsn, __$seqval
     `, [
-            { name: 'from_lsn', type: sql.VarBinary, value: bounds.startLSN.toBinary() },
-            { name: 'to_lsn', type: sql.VarBinary, value: bounds.endLSN.toBinary() }
-        ]);
-        let transactionCount = 0;
-        let updateBefore = null;
-        let lastTransactionLSN = null;
-        for (const row of results) {
-            const transactionLSN = LSN.fromBinary(row.__$start_lsn);
-            switch (row.__$operation) {
-                case Operation.DELETE:
-                    await this.eventHandler.onDelete(row, table, results.columns);
-                    this.logger.info(`Processed DELETE row LSN: ${transactionLSN}`);
-                    break;
-                case Operation.INSERT:
-                    await this.eventHandler.onInsert(row, table, results.columns);
-                    this.logger.info(`Processed INSERT row LSN: ${transactionLSN}`);
-                    break;
-                case Operation.UPDATE_BEFORE:
-                    updateBefore = row;
-                    this.logger.debug(`Processed UPDATE, before row LSN: ${transactionLSN}`);
-                    break;
-                case Operation.UPDATE_AFTER:
-                    if (updateBefore === null) {
-                        throw new ReplicationAssertionError('Missing before image for update event.');
+                { name: 'from_lsn', type: sql.VarBinary, value: bounds.startLSN.toBinary() },
+                { name: 'to_lsn', type: sql.VarBinary, value: bounds.endLSN.toBinary() }
+            ]);
+            let transactionCount = 0;
+            let updateBefore = null;
+            let lastTransactionLSN = null;
+            for (const row of results) {
+                const transactionLSN = LSN.fromBinary(row.__$start_lsn);
+                switch (row.__$operation) {
+                    case Operation.DELETE:
+                        await this.eventHandler.onDelete(row, table, results.columns);
+                        this.logger.info(`Processed DELETE row LSN: ${transactionLSN}`);
+                        break;
+                    case Operation.INSERT:
+                        await this.eventHandler.onInsert(row, table, results.columns);
+                        this.logger.info(`Processed INSERT row LSN: ${transactionLSN}`);
+                        break;
+                    case Operation.UPDATE_BEFORE:
+                        updateBefore = row;
+                        this.logger.debug(`Processed UPDATE, before row LSN: ${transactionLSN}`);
+                        break;
+                    case Operation.UPDATE_AFTER:
+                        if (updateBefore === null) {
+                            throw new ReplicationAssertionError('Missing before image for update event.');
+                        }
+                        await this.eventHandler.onUpdate(row, updateBefore, table, results.columns);
+                        updateBefore = null;
+                        this.logger.info(`Processed UPDATE row LSN: ${transactionLSN}`);
+                        break;
+                    default:
+                        this.logger.warn(`Unknown operation type [${row.__$operation}] encountered in CDC changes.`);
+                }
+                // Increment transaction count when we encounter a new transaction LSN (except for UPDATE_BEFORE rows)
+                if (transactionLSN != lastTransactionLSN) {
+                    lastTransactionLSN = transactionLSN;
+                    if (row.__$operation !== Operation.UPDATE_BEFORE) {
+                        transactionCount++;
+                    }
+                }
+            }
+            return transactionCount;
+        }
+        catch (error) {
+            // This Covers both deleted tables and capture instances
+            if (error.message.includes(`Invalid object name`)) {
+                throw new DatabaseQueryError(ErrorCode.PSYNC_S1601, `Capture instance for table ${table.toQualifiedName()} is no longer available.`, error);
+            }
+            throw error;
+        }
+    }
+    shouldCheckSchema() {
+        return Date.now() - this.lastSchemaCheckTime >= this.schemaCheckIntervalMs;
+    }
+    /**
+     * Checks the given table for pending schema changes that can lead to inconsistencies in the replicated data if not handled.
+     * Returns the SchemaChange if any are found, null otherwise.
+     */
+    async checkForSchemaChanges() {
+        const schemaChanges = [];
+        const newTables = this.checkForNewTables();
+        for (const table of newTables) {
+            this.logger.info(`New table ${toQualifiedTableName(table.sourceTable.schema, table.sourceTable.name)} matching the sync rules has been created. Handling schema change...`);
+            schemaChanges.push({
+                type: SchemaChangeType.TABLE_CREATE,
+                newTable: {
+                    name: table.sourceTable.name,
+                    schema: table.sourceTable.schema,
+                    objectId: table.sourceTable.objectId
+                },
+                newCaptureInstance: table.instances[0]
+            });
+        }
+        for (const table of this.replicatedTables) {
+            const exists = await tableExists(table.objectId, this.connectionManager);
+            if (!exists) {
+                this.logger.info(`Table ${table.toQualifiedName()} has been dropped. Handling schema change...`);
+                schemaChanges.push({
+                    type: SchemaChangeType.TABLE_DROP,
+                    table
+                });
+                continue;
+            }
+            const captureInstanceDetails = this.captureInstances.get(table.objectId);
+            if (!captureInstanceDetails) {
+                if (table.enabledForCDC()) {
+                    // Table had a capture instance but no longer does.
+                    schemaChanges.push({
+                        type: SchemaChangeType.MISSING_CAPTURE_INSTANCE,
+                        table
+                    });
+                }
+                continue;
+            }
+            const latestCaptureInstance = captureInstanceDetails.instances[0];
+            // If the table is not enabled for CDC or the capture instance is different, we need to re-snapshot the source table
+            if (!table.enabledForCDC() || table.captureInstance.objectId !== latestCaptureInstance.objectId) {
+                schemaChanges.push({
+                    type: SchemaChangeType.NEW_CAPTURE_INSTANCE,
+                    table,
+                    newCaptureInstance: latestCaptureInstance
+                });
+                continue;
+            }
+            // One of the replicated tables has been renamed
+            if (table.sourceTable.name !== captureInstanceDetails.sourceTable.name) {
+                const newTable = this.tableMatchesSyncRules(captureInstanceDetails.sourceTable.schema, captureInstanceDetails.sourceTable.name)
+                    ? {
+                        name: captureInstanceDetails.sourceTable.name,
+                        schema: captureInstanceDetails.sourceTable.schema,
+                        objectId: captureInstanceDetails.sourceTable.objectId
                     }
-                    await this.eventHandler.onUpdate(row, updateBefore, table, results.columns);
-                    updateBefore = null;
-                    this.logger.info(`Processed UPDATE row LSN: ${transactionLSN}`);
-                    break;
-                default:
-                    this.logger.warn(`Unknown operation type [${row.__$operation}] encountered in CDC changes.`);
+                    : undefined;
+                schemaChanges.push({
+                    type: SchemaChangeType.TABLE_RENAME,
+                    table,
+                    newTable,
+                    newCaptureInstance: latestCaptureInstance
+                });
+                continue;
+            }
+            if (latestCaptureInstance.pendingSchemaChanges.length > 0) {
+                schemaChanges.push({
+                    type: SchemaChangeType.TABLE_COLUMN_CHANGES,
+                    table,
+                    newCaptureInstance: latestCaptureInstance
+                });
             }
-            // Increment transaction count when we encounter a new transaction LSN (except for UPDATE_BEFORE rows)
-            if (transactionLSN != lastTransactionLSN) {
-                lastTransactionLSN = transactionLSN;
-                if (row.__$operation !== Operation.UPDATE_BEFORE) {
-                    transactionCount++;
+        }
+        return schemaChanges;
+    }
+    checkForNewTables() {
+        const newTables = [];
+        for (const [objectId, captureInstanceDetails] of this.captureInstances.entries()) {
+            // If a source table is not in the replicated tables array, but a capture instance exists for it, it is potentially a new table to replicate.
+            if (!this.replicatedTables.some((table) => table.objectId === objectId)) {
+                // Check if the new table matches any of the sync rules source tables.
+                if (this.tableMatchesSyncRules(captureInstanceDetails.sourceTable.schema, captureInstanceDetails.sourceTable.name)) {
+                    newTables.push(captureInstanceDetails);
                 }
             }
         }
-        return transactionCount;
+        return newTables;
+    }
+    tableMatchesSyncRules(schema, tableName) {
+        return this.options.sourceTables.some((tablePattern) => tablePattern.matches({
+            connectionTag: this.connectionManager.connectionTag,
+            schema: schema,
+            name: tableName
+        }));
     }
 }
 //# sourceMappingURL=CDCPoller.js.map