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

package/src/common/mysql-to-sqlite.ts

@@ -1,9 +1,9 @@
+import { ColumnDefinition, TableMapEntry } from '@powersync/mysql-zongji';
+import { ColumnDescriptor } from '@powersync/service-core';
+import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
 import * as sync_rules from '@powersync/service-sync-rules';
 import { ExpressionType } from '@powersync/service-sync-rules';
-import { ColumnDescriptor } from '@powersync/service-core';
 import mysql from 'mysql2';
-import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
-import { ColumnDefinition, TableMapEntry } from '@powersync/mysql-zongji';
 
 export enum ADDITIONAL_MYSQL_TYPES {
   DATETIME2 = 18,

package/src/common/schema-utils.ts

@@ -1,7 +1,7 @@
-import mysqlPromise from 'mysql2/promise';
-import * as mysql_utils from '../utils/mysql-utils.js';
 import { ColumnDescriptor } from '@powersync/service-core';
 import { TablePattern } from '@powersync/service-sync-rules';
+import mysqlPromise from 'mysql2/promise';
+import * as mysql_utils from '../utils/mysql-utils.js';
 
 export interface GetColumnsOptions {
   connection: mysqlPromise.Connection;

package/src/module/MySQLModule.ts

@@ -8,13 +8,13 @@ import {
 } from '@powersync/service-core';
 
 import { MySQLRouteAPIAdapter } from '../api/MySQLRouteAPIAdapter.js';
+import { checkSourceConfiguration } from '../common/check-source-configuration.js';
 import { BinLogReplicator } from '../replication/BinLogReplicator.js';
+import { MySQLConnectionManager } from '../replication/MySQLConnectionManager.js';
+import { MySQLConnectionManagerFactory } from '../replication/MySQLConnectionManagerFactory.js';
 import { MySQLErrorRateLimiter } from '../replication/MySQLErrorRateLimiter.js';
 import * as types from '../types/types.js';
-import { MySQLConnectionManagerFactory } from '../replication/MySQLConnectionManagerFactory.js';
 import { MySQLConnectionConfig } from '../types/types.js';
-import { checkSourceConfiguration } from '../common/check-source-configuration.js';
-import { MySQLConnectionManager } from '../replication/MySQLConnectionManager.js';
 
 export class MySQLModule extends replication.ReplicationModule<types.MySQLConnectionConfig> {
   constructor() {

package/src/replication/BinLogReplicationJob.ts

@@ -1,4 +1,4 @@
-import { container, logger as defaultLogger } from '@powersync/lib-services-framework';
+import { container } from '@powersync/lib-services-framework';
 import { POWERSYNC_VERSION, replication } from '@powersync/service-core';
 import { BinLogStream } from './BinLogStream.js';
 import { MySQLConnectionManagerFactory } from './MySQLConnectionManagerFactory.js';
@@ -13,7 +13,7 @@ export class BinLogReplicationJob extends replication.AbstractReplicationJob {
 
   constructor(options: BinLogReplicationJobOptions) {
     super(options);
-    this.logger = defaultLogger.child({ prefix: `[powersync_${this.options.storage.group_id}] ` });
+    this.logger = options.storage.logger;
     this.connectionFactory = options.connectionFactory;
   }
 
@@ -88,7 +88,7 @@ export class BinLogReplicationJob extends replication.AbstractReplicationJob {
     }
   }
 
-  async getReplicationLagMillis(): Promise<number | undefined> {
+  getReplicationLagMillis(): number | undefined {
     return this.lastStream?.getReplicationLagMillis();
   }
 }

package/src/replication/BinLogReplicator.ts

@@ -1,7 +1,7 @@
 import { replication, storage } from '@powersync/service-core';
+import { MySQLModule } from '../module/MySQLModule.js';
 import { BinLogReplicationJob } from './BinLogReplicationJob.js';
 import { MySQLConnectionManagerFactory } from './MySQLConnectionManagerFactory.js';
-import { MySQLModule } from '../module/MySQLModule.js';
 
 export interface BinLogReplicatorOptions extends replication.AbstractReplicatorOptions {
   connectionFactory: MySQLConnectionManagerFactory;
@@ -38,29 +38,4 @@ export class BinLogReplicator extends replication.AbstractReplicator<BinLogRepli
   async testConnection() {
     return await MySQLModule.testConnection(this.connectionFactory.connectionConfig);
   }
-
-  async getReplicationLagMillis(): Promise<number | undefined> {
-    const lag = await super.getReplicationLagMillis();
-    if (lag != null) {
-      return lag;
-    }
-
-    // Booting or in an error loop. Check last active replication status.
-    // This includes sync rules in an ERROR state.
-    const content = await this.storage.getActiveSyncRulesContent();
-    if (content == null) {
-      return undefined;
-    }
-    // Measure the lag from the last commit or keepalive timestamp.
-    // This is not 100% accurate since it is the commit time in the storage db rather than
-    // the source db, but it's the best we currently have for mysql.
-    const checkpointTs = content.last_checkpoint_ts?.getTime() ?? 0;
-    const keepaliveTs = content.last_keepalive_ts?.getTime() ?? 0;
-    const latestTs = Math.max(checkpointTs, keepaliveTs);
-    if (latestTs != 0) {
-      return Date.now() - latestTs;
-    }
-
-    return undefined;
-  }
 }

package/src/replication/BinLogStream.ts

@@ -1,6 +1,6 @@
 import {
-  Logger,
   logger as defaultLogger,
+  Logger,
   ReplicationAbortedError,
   ReplicationAssertionError
 } from '@powersync/lib-services-framework';
@@ -12,6 +12,7 @@ import {
   getUuidReplicaIdentityBson,
   InternalOpId,
   MetricsEngine,
+  ReplicationLagTracker,
   SourceTable,
   storage
 } from '@powersync/service-core';
@@ -19,10 +20,10 @@ import mysql from 'mysql2';
 import mysqlPromise from 'mysql2/promise';
 
 import { TableMapEntry } from '@powersync/mysql-zongji';
+import { ReplicationMetric } from '@powersync/service-types';
 import * as common from '../common/common-index.js';
 import { createRandomServerId, qualifiedMySQLTable } from '../utils/mysql-utils.js';
 import { MySQLConnectionManager } from './MySQLConnectionManager.js';
-import { ReplicationMetric } from '@powersync/service-types';
 import { BinLogEventHandler, BinLogListener, Row, SchemaChange, SchemaChangeType } from './zongji/BinLogListener.js';
 
 export interface BinLogStreamOptions {
@@ -74,16 +75,7 @@ export class BinLogStream {
 
   private tableCache = new Map<string | number, storage.SourceTable>();
 
-  /**
-   * Time of the oldest uncommitted change, according to the source db.
-   * This is used to determine the replication lag.
-   */
-  private oldestUncommittedChange: Date | null = null;
-  /**
-   * Keep track of whether we have done a commit or keepalive yet.
-   * We can only compute replication lag if isStartingReplication == false, or oldestUncommittedChange is present.
-   */
-  isStartingReplication = true;
+  private replicationLag = new ReplicationLagTracker();
 
   constructor(private options: BinLogStreamOptions) {
     this.logger = options.logger ?? defaultLogger;
@@ -122,6 +114,10 @@ export class BinLogStream {
     return this.abortSignal.aborted;
   }
 
+  get isStartingReplication() {
+    return this.replicationLag.isStartingReplication;
+  }
+
   get defaultSchema() {
     return this.connections.databaseName;
   }
@@ -143,7 +139,7 @@ export class BinLogStream {
     // Snapshot if:
     // 1. Snapshot is requested (false for initial snapshot, since that process handles it elsewhere)
     // 2. Snapshot is not done yet, AND:
-    // 3. The table is used in sync rules.
+    // 3. The table is used in sync config.
     const shouldSnapshot = snapshot && !result.table.snapshotComplete && result.table.syncAny;
 
     if (shouldSnapshot) {
@@ -170,7 +166,7 @@ export class BinLogStream {
       } finally {
         connection.release();
       }
-      const [table] = await batch.markSnapshotDone([result.table], gtid.comparable);
+      const [table] = await batch.markTableSnapshotDone([result.table], gtid.comparable);
       return table;
     }
 
@@ -268,17 +264,19 @@ export class BinLogStream {
           logger: this.logger,
           zeroLSN: common.ReplicatedGTID.ZERO.comparable,
           defaultSchema: this.defaultSchema,
-          storeCurrentData: true
+          storeCurrentData: false
         },
         async (batch) => {
           for (let tablePattern of sourceTables) {
             const tables = await this.getQualifiedTableNames(batch, tablePattern);
             for (let table of tables) {
               await this.snapshotTable(connection as mysql.Connection, batch, table);
-              await batch.markSnapshotDone([table], headGTID.comparable);
+              await batch.markTableSnapshotDone([table], headGTID.comparable);
               await framework.container.probes.touch();
             }
           }
+          const snapshotDoneGtid = await common.readExecutedGtid(promiseConnection);
+          await batch.markAllSnapshotDone(snapshotDoneGtid.comparable);
           await batch.commit(headGTID.comparable);
         }
       );
@@ -293,7 +291,7 @@ export class BinLogStream {
     }
 
     if (lastOp != null) {
-      // Populate the cache _after_ initial replication, but _before_ we switch to this sync rules.
+      // Populate the cache _after_ initial replication, but _before_ we switch to this replication stream.
       await this.storage.populatePersistentChecksumCache({
         // No checkpoint yet, but we do have the opId.
         maxOpId: lastOp,
@@ -322,7 +320,10 @@ export class BinLogStream {
 
     for await (let row of stream) {
       if (this.stopped) {
-        throw new ReplicationAbortedError('Abort signal received - initial replication interrupted.');
+        throw new ReplicationAbortedError(
+          'Abort signal received - initial replication interrupted.',
+          this.abortSignal.reason
+        );
       }
 
       if (columns == null) {
@@ -378,7 +379,7 @@ export class BinLogStream {
           logger: this.logger,
           zeroLSN: common.ReplicatedGTID.ZERO.comparable,
           defaultSchema: this.defaultSchema,
-          storeCurrentData: true
+          storeCurrentData: false
         },
         async (batch) => {
           for (let tablePattern of sourceTables) {
@@ -414,7 +415,7 @@ export class BinLogStream {
 
     if (!this.stopped) {
       await this.storage.startBatch(
-        { zeroLSN: common.ReplicatedGTID.ZERO.comparable, defaultSchema: this.defaultSchema, storeCurrentData: true },
+        { zeroLSN: common.ReplicatedGTID.ZERO.comparable, defaultSchema: this.defaultSchema, storeCurrentData: false },
         async (batch) => {
           const binlogEventHandler = this.createBinlogEventHandler(batch);
           const binlogListener = new BinLogListener({
@@ -467,26 +468,25 @@ export class BinLogStream {
         });
       },
       onKeepAlive: async (lsn: string) => {
-        const didCommit = await batch.keepalive(lsn);
-        if (didCommit) {
-          this.oldestUncommittedChange = null;
+        const { checkpointBlocked } = await batch.keepalive(lsn);
+        if (!checkpointBlocked) {
+          this.replicationLag.clearUncommittedChange();
         }
       },
       onCommit: async (lsn: string) => {
         this.metrics.getCounter(ReplicationMetric.TRANSACTIONS_REPLICATED).add(1);
-        const didCommit = await batch.commit(lsn, { oldestUncommittedChange: this.oldestUncommittedChange });
-        if (didCommit) {
-          this.oldestUncommittedChange = null;
-          this.isStartingReplication = false;
+        const { checkpointBlocked } = await batch.commit(lsn, {
+          oldestUncommittedChange: this.replicationLag.oldestUncommittedChange
+        });
+        if (!checkpointBlocked) {
+          this.replicationLag.markCommitted();
         }
       },
       onTransactionStart: async (options) => {
-        if (this.oldestUncommittedChange == null) {
-          this.oldestUncommittedChange = options.timestamp;
-        }
+        this.replicationLag.trackUncommittedChange(options.timestamp);
       },
       onRotate: async () => {
-        this.isStartingReplication = false;
+        this.replicationLag.markStarted();
       },
       onSchemaChange: async (change: SchemaChange) => {
         await this.handleSchemaChange(batch, change);
@@ -504,7 +504,7 @@ export class BinLogStream {
         await batch.drop([fromTable]);
         this.tableCache.delete(fromTableId);
       }
-      // The new table matched a table in the sync rules
+      // The new table matched a table in the sync config
       if (change.newTable) {
         await this.handleCreateOrUpdateTable(batch, change.newTable!, change.schema);
       }
@@ -577,7 +577,7 @@ export class BinLogStream {
 
     let table = this.tableCache.get(tableId);
     if (table == null) {
-      // This is an insert for a new table that matches a table in the sync rules
+      // This is an insert for a new table that matches a table in the sync config
       // We need to create the table in the storage and cache it.
       table = await this.handleCreateOrUpdateTable(batch, msg.tableEntry.tableName, msg.tableEntry.parentSchema);
     }
@@ -654,17 +654,8 @@ export class BinLogStream {
     }
   }
 
-  async getReplicationLagMillis(): Promise<number | undefined> {
-    if (this.oldestUncommittedChange == null) {
-      if (this.isStartingReplication) {
-        // We don't have anything to compute replication lag with yet.
-        return undefined;
-      } else {
-        // We don't have any uncommitted changes, so replication is up to date.
-        return 0;
-      }
-    }
-    return Date.now() - this.oldestUncommittedChange.getTime();
+  getReplicationLagMillis(): number | undefined {
+    return this.replicationLag.getLagMillis();
   }
 
   async tryRollback(promiseConnection: mysqlPromise.Connection) {

package/src/replication/MySQLConnectionManager.ts

@@ -1,9 +1,9 @@
-import { NormalizedMySQLConnectionConfig } from '../types/types.js';
-import mysqlPromise from 'mysql2/promise';
-import mysql, { FieldPacket, RowDataPacket } from 'mysql2';
-import * as mysql_utils from '../utils/mysql-utils.js';
 import { BaseObserver, logger } from '@powersync/lib-services-framework';
 import { ZongJi } from '@powersync/mysql-zongji';
+import mysql, { FieldPacket, RowDataPacket } from 'mysql2';
+import mysqlPromise from 'mysql2/promise';
+import { NormalizedMySQLConnectionConfig } from '../types/types.js';
+import * as mysql_utils from '../utils/mysql-utils.js';
 
 export interface MySQLConnectionManagerListener {
   onEnded(): void;

package/src/replication/MySQLConnectionManagerFactory.ts

@@ -1,7 +1,7 @@
 import { logger } from '@powersync/lib-services-framework';
 import mysql from 'mysql2/promise';
-import { MySQLConnectionManager } from './MySQLConnectionManager.js';
 import { ResolvedConnectionConfig } from '../types/types.js';
+import { MySQLConnectionManager } from './MySQLConnectionManager.js';
 
 export class MySQLConnectionManagerFactory {
   private readonly connectionManagers = new Set<MySQLConnectionManager>();

package/src/replication/zongji/BinLogListener.ts

@@ -1,10 +1,7 @@
-import * as common from '../../common/common-index.js';
-import async from 'async';
-import { BinLogEvent, BinLogQueryEvent, StartOptions, TableMapEntry, ZongJi } from '@powersync/mysql-zongji';
-import * as zongji_utils from './zongji-utils.js';
 import { Logger, logger as defaultLogger } from '@powersync/lib-services-framework';
-import { MySQLConnectionManager } from '../MySQLConnectionManager.js';
-import timers from 'timers/promises';
+import { BinLogEvent, BinLogQueryEvent, StartOptions, TableMapEntry, ZongJi } from '@powersync/mysql-zongji';
+import { TablePattern } from '@powersync/service-sync-rules';
+import async from 'async';
 import pkg, {
   AST,
   BaseFrom,
@@ -13,6 +10,8 @@ import pkg, {
   RenameStatement,
   TruncateStatement
 } from 'node-sql-parser';
+import timers from 'timers/promises';
+import * as common from '../../common/common-index.js';
 import {
   isAlterTable,
   isColumnExpression,
@@ -25,7 +24,8 @@ import {
   isTruncate,
   matchedSchemaChangeQuery
 } from '../../utils/parser-utils.js';
-import { TablePattern } from '@powersync/service-sync-rules';
+import { MySQLConnectionManager } from '../MySQLConnectionManager.js';
+import * as zongji_utils from './zongji-utils.js';
 
 const { Parser } = pkg;
 
@@ -445,8 +445,8 @@ export class BinLogListener {
     } catch (error) {
       if (matchedSchemaChangeQuery(query, Object.values(this.databaseFilter))) {
         this.logger.warn(
-          `Failed to parse query: [${query}]. 
-      Please review for the schema changes and manually redeploy the sync rules if required.`
+          `Failed to parse query: [${query}].
+Please review for the schema changes and manually redeploy the sync config if required.`
         );
       }
       return [];
@@ -537,7 +537,7 @@ export class BinLogListener {
   }
 
   private createDatabaseFilter(sourceTables: TablePattern[]): { [schema: string]: (table: string) => boolean } {
-    // Group sync rule tables by schema
+    // Group sync config tables by schema
     const schemaMap = new Map<string, TablePattern[]>();
     for (const table of sourceTables) {
       if (!schemaMap.has(table.schema)) {

package/src/replication/zongji/zongji-utils.ts

@@ -1,14 +1,14 @@
 import {
   BinLogEvent,
   BinLogGTIDLogEvent,
-  BinLogRowEvent,
+  BinLogHeartbeatEvent,
+  BinLogHeartbeatEvent_V2,
+  BinLogQueryEvent,
   BinLogRotationEvent,
-  BinLogTableMapEvent,
+  BinLogRowEvent,
   BinLogRowUpdateEvent,
-  BinLogXidEvent,
-  BinLogQueryEvent,
-  BinLogHeartbeatEvent,
-  BinLogHeartbeatEvent_V2
+  BinLogTableMapEvent,
+  BinLogXidEvent
 } from '@powersync/mysql-zongji';
 
 export function eventIsGTIDLog(event: BinLogEvent): event is BinLogGTIDLogEvent {

package/src/utils/mysql-utils.ts

@@ -1,9 +1,9 @@
 import { logger } from '@powersync/lib-services-framework';
+import { SourceEntityDescriptor } from '@powersync/service-core';
 import mysql from 'mysql2';
 import mysqlPromise from 'mysql2/promise';
-import * as types from '../types/types.js';
 import { coerce, gte, satisfies } from 'semver';
-import { SourceEntityDescriptor } from '@powersync/service-core';
+import * as types from '../types/types.js';
 
 export type RetriedQueryOptions = {
   connection: mysqlPromise.Connection;
@@ -63,7 +63,7 @@ export function createPool(config: types.NormalizedMySQLConnectionConfig, option
 }
 
 /**
- *  Return a random server id for a given sync rule id.
+ *  Return a random server id for a given replication stream id.
  *  Expected format is: <syncRuleId>00<random number>
  *  The max value for server id in MySQL is 2^32 - 1.
  *  We use the GTID format to keep track of our position in the binlog, no state is kept by the MySQL server, therefore

package/src/utils/parser-utils.ts

@@ -1,4 +1,4 @@
-import { Alter, AST, Create, Drop, TruncateStatement, RenameStatement, DropIndexStatement } from 'node-sql-parser';
+import { Alter, AST, Create, Drop, DropIndexStatement, RenameStatement, TruncateStatement } from 'node-sql-parser';
 
 // We ignore create table statements, since even in the worst case we will pick up the changes when row events for that
 // table are received.

package/test/src/BinLogListener.test.ts

@@ -1,6 +1,10 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { BinLogListener, SchemaChange, SchemaChangeType } from '@module/replication/zongji/BinLogListener.js';
 import { MySQLConnectionManager } from '@module/replication/MySQLConnectionManager.js';
+import { BinLogListener, SchemaChange, SchemaChangeType } from '@module/replication/zongji/BinLogListener.js';
+import { getMySQLVersion, qualifiedMySQLTable, satisfiesVersion } from '@module/utils/mysql-utils.js';
+import { TablePattern } from '@powersync/service-sync-rules';
+import crypto from 'crypto';
+import { v4 as uuid } from 'uuid';
+import { afterAll, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import {
   clearTestDb,
   createBinlogListener,
@@ -8,12 +12,8 @@ import {
   TEST_CONNECTION_OPTIONS,
   TestBinLogEventHandler
 } from './util.js';
-import { v4 as uuid } from 'uuid';
-import { getMySQLVersion, qualifiedMySQLTable, satisfiesVersion } from '@module/utils/mysql-utils.js';
-import crypto from 'crypto';
-import { TablePattern } from '@powersync/service-sync-rules';
 
-describe('BinlogListener tests', () => {
+describe('BinlogListener tests', { timeout: 60_000 }, () => {
   const MAX_QUEUE_CAPACITY_MB = 1;
   const BINLOG_LISTENER_CONNECTION_OPTIONS = {
     ...TEST_CONNECTION_OPTIONS,
@@ -73,14 +73,14 @@ describe('BinlogListener tests', () => {
     await binLogListener.start();
 
     // Wait for listener to stop due to queue reaching capacity
-    await vi.waitFor(() => expect(stopSpy).toHaveBeenCalled(), { timeout: 5000 });
+    await vi.waitFor(() => expect(stopSpy).toHaveBeenCalled(), { timeout: 10_000 });
 
     expect(binLogListener.isQueueOverCapacity()).toBeTruthy();
     // Resume event processing
     eventHandler.unpause!();
     const restartSpy = vi.spyOn(binLogListener, 'start');
 
-    await vi.waitFor(() => expect(eventHandler.rowsWritten).equals(ROW_COUNT), { timeout: 5000 });
+    await vi.waitFor(() => expect(eventHandler.rowsWritten).equals(ROW_COUNT), { timeout: 10_000 });
     await binLogListener.stop();
     // Confirm resume was called after unpausing
     expect(restartSpy).toHaveBeenCalled();
@@ -106,7 +106,7 @@ describe('BinlogListener tests', () => {
   test('Keepalive event', async () => {
     binLogListener.options.keepAliveInactivitySeconds = 1;
     await binLogListener.start();
-    await vi.waitFor(() => expect(eventHandler.lastKeepAlive).toBeDefined(), { timeout: 10000 });
+    await vi.waitFor(() => expect(eventHandler.lastKeepAlive).toBeDefined(), { timeout: 10_000 });
     await binLogListener.stop();
     expect(eventHandler.lastKeepAlive).toEqual(binLogListener.options.startGTID.comparable);
   });
@@ -114,7 +114,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Rename table', async () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_DATA RENAME test_DATA_new`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -133,7 +133,7 @@ describe('BinlogListener tests', () => {
     test_DATA TO test_DATA_new,
     test_DATA_new TO test_DATA
     `);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(2), { timeout: 5000 });
+    await waitForSchemaChanges(2);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -156,7 +156,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Truncate table', async () => {
     await binLogListener.start();
     await connectionManager.query(`TRUNCATE TABLE test_DATA`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -169,8 +169,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Drop table', async () => {
     await binLogListener.start();
     await connectionManager.query(`DROP TABLE test_DATA`);
-    await connectionManager.query(`CREATE TABLE test_DATA (id CHAR(36) PRIMARY KEY, description MEDIUMTEXT)`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -183,7 +182,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Drop column', async () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_DATA DROP COLUMN description`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -196,7 +195,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Add column', async () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_DATA ADD COLUMN new_column VARCHAR(255)`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -209,7 +208,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Modify column', async () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_DATA MODIFY COLUMN description TEXT`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -222,7 +221,7 @@ describe('BinlogListener tests', () => {
   test('Schema change event: Rename column via change statement', async () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_DATA CHANGE COLUMN description description_new MEDIUMTEXT`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+    await waitForSchemaChanges(1);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -237,7 +236,7 @@ describe('BinlogListener tests', () => {
     if (!isMySQL57) {
       await binLogListener.start();
       await connectionManager.query(`ALTER TABLE test_DATA RENAME COLUMN description TO description_new`);
-      await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
+      await waitForSchemaChanges(1);
       await binLogListener.stop();
       assertSchemaChange(
         eventHandler.schemaChanges[0],
@@ -254,7 +253,7 @@ describe('BinlogListener tests', () => {
     await connectionManager.query(
       `ALTER TABLE test_DATA DROP COLUMN description, ADD COLUMN new_description TEXT, MODIFY COLUMN id VARCHAR(50)`
     );
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(3), { timeout: 5000 });
+    await waitForSchemaChanges(3);
     await binLogListener.stop();
     assertSchemaChange(
       eventHandler.schemaChanges[0],
@@ -289,7 +288,7 @@ describe('BinlogListener tests', () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_constraints ADD PRIMARY KEY (id)`);
     await connectionManager.query(`ALTER TABLE test_constraints DROP PRIMARY KEY`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(2), { timeout: 5000 });
+    await waitForSchemaChanges(2);
     await binLogListener.stop();
     // Event for the add
     assertSchemaChange(
@@ -318,7 +317,7 @@ describe('BinlogListener tests', () => {
     await binLogListener.start();
     await connectionManager.query(`ALTER TABLE test_constraints ADD UNIQUE (description)`);
     await connectionManager.query(`ALTER TABLE test_constraints DROP INDEX description`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(2), { timeout: 5000 });
+    await waitForSchemaChanges(2);
     await binLogListener.stop();
     // Event for the creation
     assertSchemaChange(
@@ -347,7 +346,7 @@ describe('BinlogListener tests', () => {
     await binLogListener.start();
     await connectionManager.query(`CREATE UNIQUE INDEX description_idx ON test_constraints (description)`);
     await connectionManager.query(`DROP INDEX description_idx ON test_constraints`);
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(2), { timeout: 5000 });
+    await waitForSchemaChanges(2);
     await binLogListener.stop();
     // Event for the creation
     assertSchemaChange(
@@ -398,7 +397,7 @@ describe('BinlogListener tests', () => {
 
     await binLogListener.start();
 
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(4), { timeout: 5000 });
+    await waitForSchemaChanges(4);
     await binLogListener.stop();
     expect(eventHandler.schemaChanges[0].type).toBe(SchemaChangeType.ALTER_TABLE_COLUMN);
     expect(eventHandler.schemaChanges[1].type).toBe(SchemaChangeType.REPLICATION_IDENTITY);
@@ -464,14 +463,26 @@ describe('BinlogListener tests', () => {
     await insertRows(connectionManager, 1);
     // multi_schema database insert into test_DATA_multi
     await connectionManager.query(`INSERT INTO ${testTable}(id, description) VALUES('${uuid()}','test')`);
+    // Wait for both row entries to appear on the binlog. This avoids a rare race condition in MySQL 5.7
+    // where the drop table can hang if run immediately after the table was locked by an insert
+    await vi.waitFor(() => expect(eventHandler.rowsWritten).equals(2), { timeout: 5000 });
+
     await connectionManager.query(`DROP TABLE ${testTable}`);
+    await waitForSchemaChanges(1);
 
-    await vi.waitFor(() => expect(eventHandler.schemaChanges.length).toBe(1), { timeout: 5000 });
     await binLogListener.stop();
     expect(eventHandler.rowsWritten).toBe(2);
     assertSchemaChange(eventHandler.schemaChanges[0], SchemaChangeType.DROP_TABLE, 'multi_schema', 'test_DATA_multi');
   });
 
+  async function waitForSchemaChanges(count: number) {
+    try {
+      await vi.waitFor(() => expect(eventHandler.schemaChanges.length).equals(count), { timeout: 30_000 });
+    } catch (error) {
+      throw new Error(`Timeout while waiting for [${count}] schema changes.`);
+    }
+  }
+
   function assertSchemaChange(
     change: SchemaChange,
     type: SchemaChangeType,