@depup/mysql2 3.19.0-depup.0

package/lib/base/pool.js

@@ -0,0 +1,282 @@
+'use strict';
+
+const process = require('process');
+const SqlString = require('sql-escaper');
+const EventEmitter = require('events').EventEmitter;
+const PoolConnection = require('../pool_connection.js');
+const Queue = require('denque');
+const BaseConnection = require('./connection.js');
+const Errors = require('../constants/errors.js');
+
+// Source: https://github.com/go-sql-driver/mysql/blob/76c00e35a8d48f8f70f0e7dffe584692bd3fa612/packets.go#L598-L613
+function isReadOnlyError(err) {
+  if (!err || !err.errno) {
+    return false;
+  }
+  // 1792: ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION
+  // 1290: ER_OPTION_PREVENTS_STATEMENT (returned by Aurora during failover)
+  // 1836: ER_READ_ONLY_MODE
+  return (
+    err.errno === Errors.ER_OPTION_PREVENTS_STATEMENT ||
+    err.errno === Errors.ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION ||
+    err.errno === Errors.ER_READ_ONLY_MODE
+  );
+}
+
+function spliceConnection(queue, connection) {
+  const len = queue.length;
+  for (let i = 0; i < len; i++) {
+    if (queue.get(i) === connection) {
+      queue.removeOne(i);
+      break;
+    }
+  }
+}
+
+class BasePool extends EventEmitter {
+  constructor(options) {
+    super();
+    this.config = options.config;
+    this.config.connectionConfig.pool = this;
+    this._allConnections = new Queue();
+    this._freeConnections = new Queue();
+    this._connectionQueue = new Queue();
+    this._closed = false;
+    if (this.config.maxIdle < this.config.connectionLimit) {
+      // create idle connection timeout automatically release job
+      this._removeIdleTimeoutConnections();
+    }
+  }
+
+  getConnection(cb) {
+    if (this._closed) {
+      return process.nextTick(() => cb(new Error('Pool is closed.')));
+    }
+    let connection;
+    if (this._freeConnections.length > 0) {
+      connection = this._freeConnections.pop();
+      this.emit('acquire', connection);
+      return process.nextTick(() => cb(null, connection));
+    }
+    if (
+      this.config.connectionLimit === 0 ||
+      this._allConnections.length < this.config.connectionLimit
+    ) {
+      connection = new PoolConnection(this, {
+        config: this.config.connectionConfig,
+      });
+      this._allConnections.push(connection);
+      return connection.connect((err) => {
+        if (this._closed) {
+          return cb(new Error('Pool is closed.'));
+        }
+        if (err) {
+          return cb(err);
+        }
+        this.emit('connection', connection);
+        this.emit('acquire', connection);
+        return cb(null, connection);
+      });
+    }
+    if (!this.config.waitForConnections) {
+      return process.nextTick(() => cb(new Error('No connections available.')));
+    }
+    if (
+      this.config.queueLimit &&
+      this._connectionQueue.length >= this.config.queueLimit
+    ) {
+      return cb(new Error('Queue limit reached.'));
+    }
+    this.emit('enqueue');
+    return this._connectionQueue.push(cb);
+  }
+
+  releaseConnection(connection) {
+    let cb;
+    if (!connection._pool) {
+      // The connection has been removed from the pool and is no longer good.
+      if (this._connectionQueue.length) {
+        cb = this._connectionQueue.shift();
+        process.nextTick(this.getConnection.bind(this, cb));
+      }
+    } else if (this._connectionQueue.length) {
+      cb = this._connectionQueue.shift();
+      process.nextTick(cb.bind(null, null, connection));
+    } else {
+      this._freeConnections.push(connection);
+      this.emit('release', connection);
+    }
+  }
+
+  [Symbol.dispose]() {
+    if (!this._closed) {
+      this.end();
+    }
+  }
+
+  end(cb) {
+    this._closed = true;
+    clearTimeout(this._removeIdleTimeoutConnectionsTimer);
+    if (typeof cb !== 'function') {
+      cb = function (err) {
+        if (err) {
+          throw err;
+        }
+      };
+    }
+    let calledBack = false;
+    let closedConnections = 0;
+    let connection;
+    const endCB = function (err) {
+      if (calledBack) {
+        return;
+      }
+      if (err || ++closedConnections >= this._allConnections.length) {
+        calledBack = true;
+        cb(err);
+        return;
+      }
+    }.bind(this);
+    if (this._allConnections.length === 0) {
+      endCB();
+      return;
+    }
+    for (let i = 0; i < this._allConnections.length; i++) {
+      connection = this._allConnections.get(i);
+      connection._realEnd(endCB);
+    }
+  }
+
+  query(sql, values, cb) {
+    const cmdQuery = BaseConnection.createQuery(
+      sql,
+      values,
+      cb,
+      this.config.connectionConfig
+    );
+    if (typeof cmdQuery.namedPlaceholders === 'undefined') {
+      cmdQuery.namedPlaceholders =
+        this.config.connectionConfig.namedPlaceholders;
+    }
+    this.getConnection((err, conn) => {
+      if (err) {
+        if (typeof cmdQuery.onResult === 'function') {
+          cmdQuery.onResult(err);
+        } else {
+          cmdQuery.emit('error', err);
+        }
+        return;
+      }
+      try {
+        let queryError = null;
+        const origOnResult = cmdQuery.onResult;
+        if (origOnResult) {
+          cmdQuery.onResult = function (err, rows, fields) {
+            queryError = err || null;
+            origOnResult(err, rows, fields);
+          };
+        } else {
+          cmdQuery.once('error', (err) => {
+            queryError = err;
+          });
+        }
+        conn.query(cmdQuery).once('end', () => {
+          if (isReadOnlyError(queryError)) {
+            conn.destroy();
+          } else {
+            conn.release();
+          }
+        });
+      } catch (e) {
+        conn.release();
+        throw e;
+      }
+    });
+    return cmdQuery;
+  }
+
+  execute(sql, values, cb) {
+    // TODO construct execute command first here and pass it to connection.execute
+    // so that polymorphic arguments logic is there in one place
+    if (typeof values === 'function') {
+      cb = values;
+      values = [];
+    }
+    this.getConnection((err, conn) => {
+      if (err) {
+        return cb(err);
+      }
+      try {
+        conn
+          .execute(sql, values, (err, rows, fields) => {
+            if (isReadOnlyError(err)) {
+              conn.destroy();
+            }
+            cb(err, rows, fields);
+          })
+          .once('end', () => {
+            conn.release();
+          });
+      } catch (e) {
+        conn.release();
+        return cb(e);
+      }
+    });
+  }
+
+  _removeConnection(connection) {
+    // Remove connection from all connections
+    spliceConnection(this._allConnections, connection);
+    // Remove connection from free connections
+    spliceConnection(this._freeConnections, connection);
+    this.releaseConnection(connection);
+  }
+
+  _removeIdleTimeoutConnections() {
+    if (this._removeIdleTimeoutConnectionsTimer) {
+      clearTimeout(this._removeIdleTimeoutConnectionsTimer);
+    }
+
+    this._removeIdleTimeoutConnectionsTimer = setTimeout(() => {
+      try {
+        while (
+          this._freeConnections.length > this.config.maxIdle ||
+          (this._freeConnections.length > 0 &&
+            Date.now() - this._freeConnections.get(0).lastActiveTime >
+              this.config.idleTimeout)
+        ) {
+          if (this.config.connectionConfig.gracefulEnd) {
+            this._freeConnections.get(0).end();
+          } else {
+            this._freeConnections.get(0).destroy();
+          }
+        }
+      } finally {
+        this._removeIdleTimeoutConnections();
+      }
+    }, 1000);
+  }
+
+  format(sql, values) {
+    return SqlString.format(
+      sql,
+      values,
+      this.config.connectionConfig.stringifyObjects,
+      this.config.connectionConfig.timezone
+    );
+  }
+
+  escape(value) {
+    return SqlString.escape(
+      value,
+      this.config.connectionConfig.stringifyObjects,
+      this.config.connectionConfig.timezone
+    );
+  }
+
+  escapeId(value) {
+    return SqlString.escapeId(value, false);
+  }
+}
+
+module.exports = BasePool;

package/lib/base/pool_connection.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const BaseConnection = require('./connection.js');
+
+class BasePoolConnection extends BaseConnection {
+  constructor(pool, options) {
+    super(options);
+    this._pool = pool;
+    // The last active time of this connection
+    this.lastActiveTime = Date.now();
+    // When a fatal error occurs the connection's protocol ends, which will cause
+    // the connection to end as well, thus we only need to watch for the end event
+    // and we will be notified of disconnects.
+    // REVIEW: Moved to `once`
+    this.once('end', () => {
+      this._removeFromPool();
+    });
+    this.once('error', () => {
+      this._removeFromPool();
+    });
+  }
+
+  release() {
+    if (!this._pool || this._pool._closed) {
+      return;
+    }
+    // update last active time
+    this.lastActiveTime = Date.now();
+    this._pool.releaseConnection(this);
+  }
+
+  [Symbol.dispose]() {
+    this.release();
+  }
+
+  end(callback) {
+    if (this.config.gracefulEnd) {
+      this._removeFromPool();
+      super.end(callback);
+
+      return;
+    }
+
+    const err = new Error(
+      'Calling conn.end() to release a pooled connection is ' +
+        'deprecated. In next version calling conn.end() will be ' +
+        'restored to default conn.end() behavior. Use ' +
+        'conn.release() instead.'
+    );
+    this.emit('warn', err);
+    console.warn(err.message);
+    this.release();
+    if (typeof callback === 'function') {
+      callback();
+    }
+  }
+
+  destroy() {
+    this._removeFromPool();
+    super.destroy();
+  }
+
+  _removeFromPool() {
+    if (!this._pool || this._pool._closed) {
+      return;
+    }
+    const pool = this._pool;
+    this._pool = null;
+    pool._removeConnection(this);
+  }
+}
+
+BasePoolConnection.statementKey = BaseConnection.statementKey;
+module.exports = BasePoolConnection;
+
+// TODO: Remove this when we are removing PoolConnection#end
+BasePoolConnection.prototype._realEnd = BaseConnection.prototype.end;

package/lib/commands/auth_switch.js

@@ -0,0 +1,129 @@
+// This file was modified by Oracle on July 5, 2021.
+// Errors generated by asynchronous authentication plugins are now being
+// handled and subsequently emitted at the command level.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
+'use strict';
+
+const Packets = require('../packets/index.js');
+const sha256_password = require('../auth_plugins/sha256_password');
+const caching_sha2_password = require('../auth_plugins/caching_sha2_password.js');
+const mysql_native_password = require('../auth_plugins/mysql_native_password.js');
+const mysql_clear_password = require('../auth_plugins/mysql_clear_password.js');
+
+// Use Object.create(null) to avoid prototype pollution
+// This prevents server-controlled pluginName values like "toString" or "__proto__"
+// from resolving to prototype properties
+const standardAuthPlugins = Object.assign(Object.create(null), {
+  sha256_password: sha256_password({}),
+  caching_sha2_password: caching_sha2_password({}),
+  mysql_native_password: mysql_native_password({}),
+  mysql_clear_password: mysql_clear_password({}),
+});
+
+// Helper function to get auth plugin (custom or standard)
+function getAuthPlugin(pluginName, connection) {
+  const customPlugins = connection.config.authPlugins;
+
+  // Check custom plugins with hasOwnProperty for safety
+  if (
+    customPlugins &&
+    Object.prototype.hasOwnProperty.call(customPlugins, pluginName)
+  ) {
+    return customPlugins[pluginName];
+  }
+
+  // Safe to access standardAuthPlugins directly since it has no prototype
+  return standardAuthPlugins[pluginName];
+}
+
+function warnLegacyAuthSwitch() {
+  console.warn(
+    'WARNING! authSwitchHandler api is deprecated, please use new authPlugins api'
+  );
+}
+
+function authSwitchPluginError(error, command) {
+  // Authentication errors are fatal
+  error.code = 'AUTH_SWITCH_PLUGIN_ERROR';
+  error.fatal = true;
+
+  command.emit('error', error);
+}
+
+function authSwitchRequest(packet, connection, command) {
+  const { pluginName, pluginData } =
+    Packets.AuthSwitchRequest.fromPacket(packet);
+
+  // legacy plugin api don't allow to override mysql_native_password
+  // if pluginName is mysql_native_password it's using standard auth4.1 auth
+  if (
+    connection.config.authSwitchHandler &&
+    pluginName !== 'mysql_native_password'
+  ) {
+    const legacySwitchHandler = connection.config.authSwitchHandler;
+    warnLegacyAuthSwitch();
+    legacySwitchHandler({ pluginName, pluginData }, (err, data) => {
+      if (err) {
+        return authSwitchPluginError(err, command);
+      }
+      connection.writePacket(new Packets.AuthSwitchResponse(data).toPacket());
+    });
+    return;
+  }
+
+  const authPlugin = getAuthPlugin(pluginName, connection);
+  if (!authPlugin) {
+    throw new Error(
+      `Server requests authentication using unknown plugin ${pluginName}. See ${'TODO: add plugins doco here'} on how to configure or author authentication plugins.`
+    );
+  }
+  connection._authPlugin = authPlugin({ connection, command });
+  Promise.resolve(connection._authPlugin(pluginData))
+    .then((data) => {
+      if (data) {
+        connection.writePacket(new Packets.AuthSwitchResponse(data).toPacket());
+      }
+    })
+    .catch((err) => {
+      authSwitchPluginError(err, command);
+    });
+}
+
+function authSwitchRequestMoreData(packet, connection, command) {
+  const { data } = Packets.AuthSwitchRequestMoreData.fromPacket(packet);
+
+  if (connection.config.authSwitchHandler) {
+    const legacySwitchHandler = connection.config.authSwitchHandler;
+    warnLegacyAuthSwitch();
+    legacySwitchHandler({ pluginData: data }, (err, data) => {
+      if (err) {
+        return authSwitchPluginError(err, command);
+      }
+      connection.writePacket(new Packets.AuthSwitchResponse(data).toPacket());
+    });
+    return;
+  }
+
+  if (!connection._authPlugin) {
+    throw new Error(
+      'AuthPluginMoreData received but no auth plugin instance found'
+    );
+  }
+  Promise.resolve(connection._authPlugin(data))
+    .then((data) => {
+      if (data) {
+        connection.writePacket(new Packets.AuthSwitchResponse(data).toPacket());
+      }
+    })
+    .catch((err) => {
+      authSwitchPluginError(err, command);
+    });
+}
+
+module.exports = {
+  authSwitchRequest,
+  authSwitchRequestMoreData,
+  getAuthPlugin,
+  standardAuthPlugins,
+};

package/lib/commands/binlog_dump.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const Command = require('./command');
+const Packets = require('../packets');
+
+const eventParsers = [];
+
+class BinlogEventHeader {
+  constructor(packet) {
+    this.timestamp = packet.readInt32();
+    this.eventType = packet.readInt8();
+    this.serverId = packet.readInt32();
+    this.eventSize = packet.readInt32();
+    this.logPos = packet.readInt32();
+    this.flags = packet.readInt16();
+  }
+}
+
+class BinlogDump extends Command {
+  constructor(opts) {
+    super();
+    // this.onResult = callback;
+    this.opts = opts;
+  }
+
+  start(packet, connection) {
+    const newPacket = new Packets.BinlogDump(this.opts);
+    connection.writePacket(newPacket.toPacket(1));
+    return BinlogDump.prototype.binlogData;
+  }
+
+  binlogData(packet) {
+    // ok - continue consuming events
+    // error - error
+    // eof - end of binlog
+    if (packet.isEOF()) {
+      this.emit('eof');
+      return null;
+    }
+    // binlog event header
+    packet.readInt8();
+    const header = new BinlogEventHeader(packet);
+    const EventParser = eventParsers[header.eventType];
+    let event;
+    if (EventParser) {
+      event = new EventParser(packet);
+    } else {
+      event = {
+        name: 'UNKNOWN',
+      };
+    }
+    event.header = header;
+    this.emit('event', event);
+    return BinlogDump.prototype.binlogData;
+  }
+}
+
+class RotateEvent {
+  constructor(packet) {
+    this.pposition = packet.readInt32();
+    // TODO: read uint64 here
+    packet.readInt32(); // positionDword2
+    this.nextBinlog = packet.readString();
+    this.name = 'RotateEvent';
+  }
+}
+
+class FormatDescriptionEvent {
+  constructor(packet) {
+    this.binlogVersion = packet.readInt16();
+    this.serverVersion = packet.readString(50).replace(/\u0000.*/, ''); // eslint-disable-line no-control-regex
+    this.createTimestamp = packet.readInt32();
+    this.eventHeaderLength = packet.readInt8(); // should be 19
+    this.eventsLength = packet.readBuffer();
+    this.name = 'FormatDescriptionEvent';
+  }
+}
+
+class QueryEvent {
+  constructor(packet) {
+    const parseStatusVars = require('../packets/binlog_query_statusvars.js');
+    this.slaveProxyId = packet.readInt32();
+    this.executionTime = packet.readInt32();
+    const schemaLength = packet.readInt8();
+    this.errorCode = packet.readInt16();
+    const statusVarsLength = packet.readInt16();
+    const statusVars = packet.readBuffer(statusVarsLength);
+    this.schema = packet.readString(schemaLength);
+    packet.readInt8(); // should be zero
+    this.statusVars = parseStatusVars(statusVars);
+    this.query = packet.readString();
+    this.name = 'QueryEvent';
+  }
+}
+
+class XidEvent {
+  constructor(packet) {
+    this.binlogVersion = packet.readInt16();
+    this.xid = packet.readInt64();
+    this.name = 'XidEvent';
+  }
+}
+
+eventParsers[2] = QueryEvent;
+eventParsers[4] = RotateEvent;
+eventParsers[15] = FormatDescriptionEvent;
+eventParsers[16] = XidEvent;
+
+module.exports = BinlogDump;

package/lib/commands/change_user.js

@@ -0,0 +1,68 @@
+// This file was modified by Oracle on September 21, 2021.
+// The changes involve saving additional authentication factor passwords
+// in the command scope and enabling multi-factor authentication in the
+// client-side when the server supports it.
+// Modifications copyright (c) 2021, Oracle and/or its affiliates.
+
+'use strict';
+
+const Command = require('./command.js');
+const Packets = require('../packets/index.js');
+const ClientConstants = require('../constants/client');
+const ClientHandshake = require('./client_handshake.js');
+const CharsetToEncoding = require('../constants/charset_encodings.js');
+
+class ChangeUser extends Command {
+  constructor(options, callback) {
+    super();
+    this.onResult = callback;
+    this.user = options.user;
+    this.password = options.password;
+    // "password1" is an alias of "password"
+    this.password1 = options.password;
+    this.password2 = options.password2;
+    this.password3 = options.password3;
+    this.database = options.database;
+    this.passwordSha1 = options.passwordSha1;
+    this.charsetNumber = options.charsetNumber;
+    this.currentConfig = options.currentConfig;
+    this.authenticationFactor = 0;
+  }
+  start(packet, connection) {
+    const newPacket = new Packets.ChangeUser({
+      flags: connection.config.clientFlags,
+      user: this.user,
+      database: this.database,
+      charsetNumber: this.charsetNumber,
+      password: this.password,
+      passwordSha1: this.passwordSha1,
+      authPluginData1: connection._handshakePacket.authPluginData1,
+      authPluginData2: connection._handshakePacket.authPluginData2,
+    });
+    this.currentConfig.user = this.user;
+    this.currentConfig.password = this.password;
+    this.currentConfig.database = this.database;
+    this.currentConfig.charsetNumber = this.charsetNumber;
+    connection.clientEncoding = CharsetToEncoding[this.charsetNumber];
+    // clear prepared statements cache as all statements become invalid after changeUser
+    connection._statements.clear();
+    connection.writePacket(newPacket.toPacket());
+    // check if the server supports multi-factor authentication
+    const multiFactorAuthentication =
+      connection.serverCapabilityFlags &
+      ClientConstants.MULTI_FACTOR_AUTHENTICATION;
+    if (multiFactorAuthentication) {
+      // if the server supports multi-factor authentication, we enable it in
+      // the client
+      this.authenticationFactor = 1;
+    }
+    return ChangeUser.prototype.handshakeResult;
+  }
+}
+
+ChangeUser.prototype.handshakeResult =
+  ClientHandshake.prototype.handshakeResult;
+ChangeUser.prototype.calculateNativePasswordAuthToken =
+  ClientHandshake.prototype.calculateNativePasswordAuthToken;
+
+module.exports = ChangeUser;