@vlasky/zongji 0.5.9 → 0.6.0

package/index.js

@@ -1,355 +1,527 @@
-const mysql = require('@vlasky/mysql');
-const util = require('util');
-const EventEmitter = require('events').EventEmitter;
-const initBinlogClass = require('./lib/sequence/binlog');
+import mysql from 'mysql2';
+import { EventEmitter } from 'events';
+import initBinlogClass from './lib/sequence/binlog.js';
 
 const ConnectionConfigMap = {
   'Connection': obj => obj.config,
   'Pool': obj => obj.config.connectionConfig,
 };
 
-const TableInfoQueryTemplate = `SELECT 
-  COLUMN_NAME, COLLATION_NAME, CHARACTER_SET_NAME, 
-  COLUMN_COMMENT, COLUMN_TYPE 
-  FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='%s' AND TABLE_NAME='%s' 
+const TableInfoQueryTemplate = `SELECT
+  COLUMN_NAME, COLLATION_NAME, CHARACTER_SET_NAME,
+  COLUMN_COMMENT, COLUMN_TYPE
+  FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='%s' AND TABLE_NAME='%s'
   ORDER BY ORDINAL_POSITION`;
 
-function ZongJi(dsn) {
-  EventEmitter.call(this);
+// Simple format function to replace %s placeholders
+function formatSql(template, ...args) {
+  let i = 0;
+  return template.replace(/%s/g, () => args[i++]);
+}
 
-  this._options({});
-  this._filters({});
-  this.ctrlCallbacks = [];
-  this.tableMap = {};
-  this.ready = false;
-  this.useChecksum = false;
+class ZongJi extends EventEmitter {
+  constructor(dsn) {
+    super();
 
-  this._establishConnection(dsn);
-}
+    this._pendingErrors = [];
+    this.on('newListener', (event) => {
+      if (event !== 'error' || this._pendingErrors.length === 0) {
+        return;
+      }
+      const pending = this._pendingErrors.slice();
+      this._pendingErrors.length = 0;
+      process.nextTick(() => {
+        pending.forEach(err => this.emit('error', err));
+      });
+    });
 
-util.inherits(ZongJi, EventEmitter);
-
-// dsn - can be one instance of Connection or Pool / object / url string
-ZongJi.prototype._establishConnection = function(dsn) {
-  const createConnection = (options) => {
-    let connection = mysql.createConnection(options);
-    connection.on('error', this.emit.bind(this, 'error'));
-    connection.on('unhandledError', this.emit.bind(this, 'error'));
-    // don't need to call connection.connect() here
-    // we use implicitly established connection
-    // see https://github.com/mysqljs/mysql#establishing-connections
-    return connection;
-  };
-
-  const configFunc = ConnectionConfigMap[dsn.constructor.name];
-  let binlogDsn;
-
-  if (typeof dsn === 'object' && configFunc) {
-    // dsn is a pool or connection object
-    let conn = dsn; // reuse as ctrlConnection
-    this.ctrlConnection = conn;
+    this._options({});
+    this._filters({});
+    this.ctrlCallbacks = [];
+    this.tableMap = {};
+    this.ready = false;
+    this.stopped = false;
+    this.useChecksum = false;
+
+    this._dsn = dsn;
+    this.ctrlConnection = null;
+    this.connection = null;
     this.ctrlConnectionOwner = false;
-    binlogDsn = Object.assign({}, configFunc(conn));
   }
 
-  if (!binlogDsn) {
-    // assuming that the object passed is the connection settings
-    this.ctrlConnectionOwner = true;
-    this.ctrlConnection = createConnection(dsn);
-    binlogDsn = dsn;
+  // dsn - can be one instance of Connection or Pool / object / url string
+  _establishConnection(dsn) {
+    const createConnection = (options) => {
+      const emitError = (err) => {
+        if (this.listenerCount('error') === 0) {
+          this._pendingErrors.push(err);
+          return;
+        }
+        this.emit('error', err);
+      };
+      let connection = mysql.createConnection(options);
+      connection.on('error', emitError);
+      // don't need to call connection.connect() here
+      // we use implicitly established connection
+      // see https://github.com/mysqljs/mysql#establishing-connections
+      return connection;
+    };
+
+    const configFunc = ConnectionConfigMap[dsn.constructor.name];
+    let binlogDsn;
+    const sanitizeConnectionOptions = (options) => {
+      if (!options) return options;
+      const cleaned = Object.assign({}, options);
+      delete cleaned.maxPacketSize;
+      delete cleaned.clientFlags;
+      return cleaned;
+    };
+
+    if (typeof dsn === 'object' && configFunc) {
+      // dsn is a pool or connection object
+      let conn = dsn; // reuse as ctrlConnection
+      this.ctrlConnection = conn;
+      this.ctrlConnectionOwner = false;
+      binlogDsn = sanitizeConnectionOptions(configFunc(conn));
+    }
+
+    if (!binlogDsn) {
+      // assuming that the object passed is the connection settings
+      this.ctrlConnectionOwner = true;
+      this.ctrlConnection = createConnection(dsn);
+      binlogDsn = dsn;
+    }
+
+    this.connection = createConnection(binlogDsn);
   }
 
-  this.connection = createConnection(binlogDsn);
-};
+  _isChecksumEnabled(next) {
+    const SelectChecksumParamSql = 'select @@GLOBAL.binlog_checksum as checksum';
+    const SetChecksumSql = 'set @master_binlog_checksum=@@global.binlog_checksum';
 
-ZongJi.prototype._isChecksumEnabled = function(next) {
-  const SelectChecksumParamSql = 'select @@GLOBAL.binlog_checksum as checksum';
-  const SetChecksumSql = 'set @master_binlog_checksum=@@global.binlog_checksum';
+    let done = false;
+    const finish = (err, enabled) => {
+      if (done) return;
+      done = true;
+      next(err, enabled);
+    };
 
-  const query = (conn, sql) => {
-    return new Promise(
-      (resolve, reject) => {
-        conn.query(sql, (err, result) => {
-          if (err) {
+    const isConnectionReady = (conn) => {
+      return conn &&
+        conn.state !== 'disconnected' &&
+        !conn._fatalError &&
+        !conn._protocolError &&
+        !conn._closing;
+    };
+
+    const query = (conn, sql) => {
+      if (!isConnectionReady(conn)) {
+        return Promise.resolve(null);
+      }
+      return new Promise(
+        (resolve, reject) => {
+          try {
+            conn.query(sql, (err, result) => {
+            if (err) {
+              reject(err);
+            }
+            else {
+              resolve(result);
+            }
+            });
+          } catch (err) {
             reject(err);
           }
-          else {
-            resolve(result);
-          }
-        });
-      }
-    );
-  };
+        }
+      );
+    };
 
-  let checksumEnabled = true;
+    let checksumEnabled = true;
 
-  query(this.ctrlConnection, SelectChecksumParamSql)
-    .then(rows => {
-      if (rows[0].checksum === 'NONE') {
-        checksumEnabled = false;
-        return query(this.connection, 'SELECT 1');
-      }
+    query(this.ctrlConnection, SelectChecksumParamSql)
+      .then(rows => {
+        if (!rows) {
+          checksumEnabled = false;
+          return null;
+        }
+        if (rows[0].checksum === 'NONE') {
+          checksumEnabled = false;
+          return query(this.connection, 'SELECT 1');
+        }
 
-      if (checksumEnabled) {
-        return query(this.connection, SetChecksumSql);
-      }
-    })
-    .catch(err => {
-      if (err.toString().match(/ER_UNKNOWN_SYSTEM_VARIABLE/)) {
-        checksumEnabled = false;
-        // a simple query to open this.connection
-        return query(this.connection, 'SELECT 1');
+        if (checksumEnabled) {
+          return query(this.connection, SetChecksumSql);
+        }
+      })
+      .catch(err => {
+        if (err.toString().match(/ER_UNKNOWN_SYSTEM_VARIABLE/)) {
+          checksumEnabled = false;
+          // a simple query to open this.connection
+          return query(this.connection, 'SELECT 1');
+        }
+        else {
+          return finish(err);
+        }
+      })
+      .then(() => {
+        finish(null, checksumEnabled);
+      })
+      .catch(err => {
+        finish(err);
+      });
+  }
+
+  _findBinlogEnd(next) {
+    this.ctrlConnection.query('SHOW BINARY LOGS', (err, rows) => {
+      if (err) {
+        // Errors should be emitted
+        next(err);
       }
       else {
-        next(err);
+        next(null, rows.length > 0 ? rows[rows.length - 1] : null);
       }
-    })
-    .then(() => {
-      next(null, checksumEnabled);
     });
-};
-
-ZongJi.prototype._findBinlogEnd = function(next) {
-  this.ctrlConnection.query('SHOW BINARY LOGS', (err, rows) => {
-    if (err) {
-      // Errors should be emitted
-      next(err);
-    }
-    else {
-      next(null, rows.length > 0 ? rows[rows.length - 1] : null);
-    }
-  });
-};
+  }
 
-ZongJi.prototype._fetchTableInfo = function(tableMapEvent, next) {
-  const sql = util.format(TableInfoQueryTemplate,
-    tableMapEvent.schemaName, tableMapEvent.tableName);
+  _fetchTableInfo(tableMapEvent, next) {
+    const sql = formatSql(TableInfoQueryTemplate,
+      tableMapEvent.schemaName, tableMapEvent.tableName);
 
-  this.ctrlConnection.query(sql, (err, rows) => {
-    if (err) {
-      // Errors should be emitted
-      this.emit('error', err);
-      // This is a fatal error, no additional binlog events will be
-      // processed since next() will never be called
+    if (!this.ctrlConnection ||
+        this.ctrlConnection.state === 'disconnected' ||
+        this.ctrlConnection._fatalError ||
+        this.ctrlConnection._protocolError ||
+        this.ctrlConnection._closing) {
       return;
     }
 
-    if (rows.length === 0) {
-      this.emit('error', new Error(
-        'Insufficient permissions to access: ' +
-        tableMapEvent.schemaName + '.' + tableMapEvent.tableName));
-      // This is a fatal error, no additional binlog events will be
-      // processed since next() will never be called
-      return;
-    }
+    try {
+      this.ctrlConnection.query(sql, (err, rows) => {
+      if (err) {
+        // Errors should be emitted
+        this.emit('error', err);
+        // This is a fatal error, no additional binlog events will be
+        // processed since next() will never be called
+        return;
+      }
 
-    this.tableMap[tableMapEvent.tableId] = {
-      columnSchemas: rows,
-      parentSchema: tableMapEvent.schemaName,
-      tableName: tableMapEvent.tableName
-    };
+      if (rows.length === 0) {
+        this.emit('error', new Error(
+          'Insufficient permissions to access: ' +
+          tableMapEvent.schemaName + '.' + tableMapEvent.tableName));
+        // This is a fatal error, no additional binlog events will be
+        // processed since next() will never be called
+        return;
+      }
 
-    next();
-  });
-};
+      this.tableMap[tableMapEvent.tableId] = {
+        columnSchemas: rows,
+        parentSchema: tableMapEvent.schemaName,
+        tableName: tableMapEvent.tableName
+      };
+
+      next();
+      });
+    } catch (err) {
+      this.emit('error', err);
+    }
+  }
 
-// #_options will reset all the options.
-ZongJi.prototype._options = function({
-  serverId,
-  filename,
-  position,
-  startAtEnd,
-}) {
-  this.options = {
+  // #_options will reset all the options.
+  /** @param {object} [options] */
+  _options({
     serverId,
     filename,
     position,
     startAtEnd,
-  };
-};
+  } = {}) {
+    this.options = {
+      serverId,
+      filename,
+      position,
+      startAtEnd,
+    };
+  }
 
-// #_filters will reset all the filters.
-ZongJi.prototype._filters = function({
-  includeEvents,
-  excludeEvents,
-  includeSchema,
-  excludeSchema,
-}) {
-  this.filters = {
+  // #_filters will reset all the filters.
+  /** @param {object} [options] */
+  _filters({
     includeEvents,
     excludeEvents,
     includeSchema,
     excludeSchema,
-  };
-};
-
-ZongJi.prototype.get = function(name) {
-  let result;
-  if (typeof name === 'string') {
-    result = this.options[name];
+  } = {}) {
+    this.filters = {
+      includeEvents,
+      excludeEvents,
+      includeSchema,
+      excludeSchema,
+    };
   }
-  else if (Array.isArray(name)) {
-    result = name.reduce(
-      (acc, cur) => {
-        acc[cur] = this.options[cur];
-        return acc;
-      },
-      {}
-    );
+
+  get(name) {
+    let result;
+    if (typeof name === 'string') {
+      result = this.options[name];
+    }
+    else if (Array.isArray(name)) {
+      result = name.reduce(
+        (acc, cur) => {
+          acc[cur] = this.options[cur];
+          return acc;
+        },
+        {}
+      );
+    }
+
+    return result;
   }
 
-  return result;
-};
+  // @options contains a list options
+  // - `serverId` unique identifier
+  // - `filename`, `position` the position of binlog to begin with
+  // - `startAtEnd` if true, will update filename / position automatically
+  // - `includeEvents`, `excludeEvents`, `includeSchema`, `excludeSchema` filter different binlog events bubbling
+  start(options = {}) {
+    // If already running, just update filters (for pause/resume) and return
+    if (this.ready && !this.stopped) {
+      this._filters(options);
+      return;
+    }
 
-// @options contains a list options
-// - `serverId` unique identifier
-// - `filename`, `position` the position of binlog to beigin with
-// - `startAtEnd` if true, will update filename / postion automatically
-// - `includeEvents`, `excludeEvents`, `includeSchema`, `exludeSchema` filter different binlog events bubbling
-ZongJi.prototype.start = function(options = {}) {
+    this.stopped = false;
 
-  this._options(options);
-  this._filters(options);
+    if (!this.connection || !this.ctrlConnection) {
+      this._establishConnection(this._dsn);
+    }
 
-  const testChecksum = (resolve, reject) => {
-    this._isChecksumEnabled((err, checksumEnabled) => {
-      if (err) {
-        reject(err);
-      }
-      else {
-        this.useChecksum = checksumEnabled;
-        resolve();
-      }
-    });
-  };
+    this._options(options);
+    this._filters(options);
+
+    const testChecksum = (resolve, reject) => {
+      this._isChecksumEnabled((err, checksumEnabled) => {
+        if (err) {
+          reject(err);
+        }
+        else {
+          this.useChecksum = checksumEnabled;
+          resolve();
+        }
+      });
+    };
 
 
-  const findBinlogEnd = (resolve, reject) => {
-    this._findBinlogEnd((err, result) => {
-      if (err) {
-        return reject(err);
+    const findBinlogEnd = (resolve, reject) => {
+      this._findBinlogEnd((err, result) => {
+        if (err) {
+          return reject(err);
+        }
+
+        if (result) {
+          this._options(
+            Object.assign({}, options, {
+              filename: result.Log_name,
+              position: result.File_size,
+            })
+          );
+        }
+
+        resolve();
+      });
+    };
+
+    const binlogHandler = (error, event) => {
+      if (error) {
+        return this.emit('error', error);
       }
 
-      if (result) {
-        this._options(
-          Object.assign({}, options, {
-            filename: result.Log_name,
-            position: result.File_size,
-          })
-        );
+      // Ignore events if connection has been stopped
+      if (this.stopped || !this.connection) return;
+
+      // Do not emit events that have been filtered out
+      if (event === undefined || event._filtered === true) return;
+
+      switch (event.getTypeName()) {
+        case 'TableMap': {
+          const tableMap = this.tableMap[event.tableId];
+          if (!tableMap || tableMap.tableName !== event.tableName || tableMap.columns.length !== event.columnCount) {
+            if (!this.connection) return;
+            this.connection.pause();
+            this._fetchTableInfo(event, () => {
+              // merge the column info with metadata
+              event.updateColumnInfo();
+              this.emit('binlog', event);
+              if (this.connection) this.connection.resume();
+            });
+            return;
+          }
+          break;
+        }
+        case 'Rotate':
+          if (this.options.filename !== event.binlogName) {
+            this.options.filename = event.binlogName;
+          }
+          break;
       }
+      this.options.position = event.nextPosition;
+      this.emit('binlog', event);
+    };
 
-      resolve();
-    });
-  };
+    let promises = [new Promise(testChecksum)];
 
-  const binlogHandler = (error, event) => {
-    if (error) {
-      return this.emit('error', error);
+    if (this.options.startAtEnd) {
+      promises.push(new Promise(findBinlogEnd));
     }
 
-    // Do not emit events that have been filtered out
-    if (event === undefined || event._filtered === true) return;
-
-    switch (event.getTypeName()) {
-      case 'TableMap': {
-        const tableMap = this.tableMap[event.tableId];
-        if (!tableMap || tableMap.tableName !== event.tableName || tableMap.columns.length !== event.columnCount) {
-          this.connection.pause();
-          this._fetchTableInfo(event, () => {
-            // merge the column info with metadata
-            event.updateColumnInfo();
-            this.emit('binlog', event);
-            this.connection.resume();
-          });
+    Promise.all(promises)
+      .then(() => {
+        // Check if stop() was called while promises were pending
+        if (this.stopped) {
           return;
         }
-        break;
-      }
-      case 'Rotate':
-        if (this.options.filename !== event.binlogName) {
-          this.options.filename = event.binlogName;
+
+        this.BinlogClass = initBinlogClass(this);
+        this.ready = true;
+        this.emit('ready');
+
+        // Final check right before addCommand - connection may have been destroyed
+        if (this.stopped) {
+          return;
         }
-        break;
-    }
-    this.options.position = event.nextPosition;
-    this.emit('binlog', event);
-  };
 
-  let promises = [new Promise(testChecksum)];
+        // When compression is enabled, patch handlePacket to sync sequence ID.
+        // MySQL resets inner packet sequence IDs within compressed chunks for
+        // binlog streams, causing mysql2's sequence validation to emit warnings.
+        // By syncing the expected sequence ID to match the incoming packet, we
+        // prevent these harmless warnings. This is safe because binlog events
+        // track position independently (binlog file + position / GTID).
+        // Only applied when compression is enabled to preserve normal error
+        // detection for uncompressed connections.
+        if (this.connection.config && this.connection.config.compress) {
+          // @ts-ignore - internal mysql2 API
+          const originalHandlePacket = this.connection.handlePacket.bind(this.connection);
+          // @ts-ignore - internal mysql2 API
+          this.connection.handlePacket = function(packet) {
+            if (packet && typeof packet.sequenceId !== 'undefined') {
+              this.sequenceId = packet.sequenceId;
+            }
+            return originalHandlePacket(packet);
+          };
+        }
 
-  if (this.options.startAtEnd) {
-    promises.push(new Promise(findBinlogEnd));
-  }
+        // @ts-ignore - internal mysql2 API
+        this.connection.addCommand(new this.BinlogClass(binlogHandler));
+      })
+      .catch(err => {
+        this.emit('error', err);
+      });
 
-  Promise.all(promises)
-    .then(() => {
-      this.BinlogClass = initBinlogClass(this);
-      this.ready = true;
-      this.emit('ready');
+  }
 
-      this.connection._protocol._enqueue(
-        new this.BinlogClass(binlogHandler)
-      );
-    })
-    .catch(err => {
-      this.emit('error', err);
-    });
+  stop() {
+    this.stopped = true;
+    this.ready = false;
 
-};
+    if (!this.connection && !this.ctrlConnection) {
+      this.emit('stopped');
+      return;
+    }
 
-ZongJi.prototype.stop = function() {
-  // Binary log connection does not end with destroy()
-  this.connection.destroy();
-  this.ctrlConnection.query(
-    'KILL ' + this.connection.threadId,
-    () => {
-      if (this.ctrlConnectionOwner) {
+    // Binary log connection does not end with destroy()
+    let connectionThreadId = null;
+    if (this.connection) {
+      connectionThreadId = this.connection.threadId;
+      this.connection.destroy();
+      // @ts-ignore - internal mysql2 API
+      if (this.connection.stream && typeof this.connection.stream.unref === 'function') {
+        // @ts-ignore - internal mysql2 API
+        this.connection.stream.unref();
+      }
+      this.connection = null;
+    }
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      if (this.ctrlConnectionOwner && this.ctrlConnection) {
         this.ctrlConnection.destroy();
+        // @ts-ignore - internal mysql2 API
+        if (this.ctrlConnection.stream && typeof this.ctrlConnection.stream.unref === 'function') {
+          // @ts-ignore - internal mysql2 API
+          this.ctrlConnection.stream.unref();
+        }
+        this.ctrlConnection = null;
       }
       this.emit('stopped');
+    };
+
+    if (!this.ctrlConnection ||
+        this.ctrlConnection.state === 'disconnected' ||
+        this.ctrlConnection._fatalError ||
+        this.ctrlConnection._protocolError ||
+        this.ctrlConnection._closing) {
+      this.ctrlConnection = null;
+      return finish();
     }
-  );
-};
 
-// It includes every events by default.
-ZongJi.prototype._skipEvent = function(name) {
-  const includes = this.filters.includeEvents;
-  const excludes = this.filters.excludeEvents;
+    if (!connectionThreadId) {
+      return finish();
+    }
+
+    const killTimeout = setTimeout(finish, 1000);
+    try {
+      this.ctrlConnection.query(
+        'KILL ' + connectionThreadId,
+        () => {
+          clearTimeout(killTimeout);
+          finish();
+        }
+      );
+    } catch {
+      clearTimeout(killTimeout);
+      finish();
+    }
+  }
 
-  let included = (includes === undefined) ||
-    (Array.isArray(includes) && (includes.indexOf(name) > -1));
-  let excluded = Array.isArray(excludes) && (excludes.indexOf(name) > -1);
+  // It includes every events by default.
+  _skipEvent(name) {
+    const includes = this.filters.includeEvents;
+    const excludes = this.filters.excludeEvents;
 
-  return excluded || !included;
-};
+    let included = (includes === undefined) ||
+      (Array.isArray(includes) && (includes.indexOf(name) > -1));
+    let excluded = Array.isArray(excludes) && (excludes.indexOf(name) > -1);
+
+    return excluded || !included;
+  }
 
-// It doesn't skip any schema by default.
-ZongJi.prototype._skipSchema = function(database, table) {
-  const includes = this.filters.includeSchema;
-  const excludes = this.filters.excludeSchema || {};
+  // It doesn't skip any schema by default.
+  _skipSchema(database, table) {
+    const includes = this.filters.includeSchema;
+    const excludes = this.filters.excludeSchema || {};
 
-  let included = (includes === undefined) ||
-    (
-      (database in includes) &&
+    let included = (includes === undefined) ||
       (
-        includes[database] === true ||
+        (database in includes) &&
         (
-          Array.isArray(includes[database]) &&
-          includes[database].indexOf(table) > -1
+          includes[database] === true ||
+          (
+            Array.isArray(includes[database]) &&
+            includes[database].indexOf(table) > -1
+          )
         )
-      )
-    );
-  let excluded = (database in excludes) &&
-    (
-      excludes[database] === true ||
+      );
+    let excluded = (database in excludes) &&
       (
-        Array.isArray(excludes[database]) &&
-        excludes[database].indexOf(table) > -1
-      )
-    );
+        excludes[database] === true ||
+        (
+          Array.isArray(excludes[database]) &&
+          excludes[database].indexOf(table) > -1
+        )
+      );
 
-  return excluded || !included;
-};
+    return excluded || !included;
+  }
+}
 
-module.exports = ZongJi;
+export default ZongJi;