@depup/mysql2 3.19.0-depup.0

package/lib/commands/prepare.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const Packets = require('../packets/index.js');
+const Command = require('./command.js');
+const CloseStatement = require('./close_statement.js');
+const Execute = require('./execute.js');
+
+class PreparedStatementInfo {
+  constructor(query, id, columns, parameters, connection) {
+    this.query = query;
+    this.id = id;
+    this.columns = columns;
+    this.parameters = parameters;
+    this.rowParser = null;
+    this._connection = connection;
+  }
+
+  close() {
+    return this._connection.addCommand(new CloseStatement(this.id));
+  }
+
+  execute(parameters, callback) {
+    if (typeof parameters === 'function') {
+      callback = parameters;
+      parameters = [];
+    }
+    return this._connection.addCommand(
+      new Execute({ statement: this, values: parameters }, callback)
+    );
+  }
+}
+
+class Prepare extends Command {
+  constructor(options, callback) {
+    super();
+    this.query = options.sql;
+    this.onResult = callback;
+    this.id = 0;
+    this.fieldCount = 0;
+    this.parameterCount = 0;
+    this.fields = [];
+    this.parameterDefinitions = [];
+    this.options = options;
+  }
+
+  start(packet, connection) {
+    const Connection = connection.constructor;
+    this.key = Connection.statementKey(this.options);
+    const statement = connection._statements.get(this.key);
+    if (statement) {
+      if (this.onResult) {
+        this.onResult(null, statement);
+      }
+      return null;
+    }
+    const cmdPacket = new Packets.PrepareStatement(
+      this.query,
+      connection.config.charsetNumber,
+      this.options.values
+    );
+    connection.writePacket(cmdPacket.toPacket(1));
+    return Prepare.prototype.prepareHeader;
+  }
+
+  prepareHeader(packet, connection) {
+    const header = new Packets.PreparedStatementHeader(packet);
+    this.id = header.id;
+    this.fieldCount = header.fieldCount;
+    this.parameterCount = header.parameterCount;
+    if (this.parameterCount > 0) {
+      return Prepare.prototype.readParameter;
+    }
+    if (this.fieldCount > 0) {
+      return Prepare.prototype.readField;
+    }
+    return this.prepareDone(connection);
+  }
+
+  readParameter(packet, connection) {
+    // there might be scenarios when mysql server reports more parameters than
+    // are actually present in the array of parameter definitions.
+    // if EOF packet is received we switch to "read fields" state if there are
+    // any fields reported by the server, otherwise we finish the command.
+    if (packet.isEOF()) {
+      if (this.fieldCount > 0) {
+        return Prepare.prototype.readField;
+      }
+      return this.prepareDone(connection);
+    }
+    const def = new Packets.ColumnDefinition(packet, connection.clientEncoding);
+    this.parameterDefinitions.push(def);
+    if (this.parameterDefinitions.length === this.parameterCount) {
+      return Prepare.prototype.parametersEOF;
+    }
+    return this.readParameter;
+  }
+
+  readField(packet, connection) {
+    if (packet.isEOF()) {
+      return this.prepareDone(connection);
+    }
+    const def = new Packets.ColumnDefinition(packet, connection.clientEncoding);
+    this.fields.push(def);
+    if (this.fields.length === this.fieldCount) {
+      return Prepare.prototype.fieldsEOF;
+    }
+    return Prepare.prototype.readField;
+  }
+
+  parametersEOF(packet, connection) {
+    if (!packet.isEOF()) {
+      return connection.protocolError('Expected EOF packet after parameters');
+    }
+    if (this.fieldCount > 0) {
+      return Prepare.prototype.readField;
+    }
+    return this.prepareDone(connection);
+  }
+
+  fieldsEOF(packet, connection) {
+    if (!packet.isEOF()) {
+      return connection.protocolError('Expected EOF packet after fields');
+    }
+    return this.prepareDone(connection);
+  }
+
+  prepareDone(connection) {
+    const statement = new PreparedStatementInfo(
+      this.query,
+      this.id,
+      this.fields,
+      this.parameterDefinitions,
+      connection
+    );
+    connection._statements.set(this.key, statement);
+    if (this.onResult) {
+      this.onResult(null, statement);
+    }
+    return null;
+  }
+}
+
+module.exports = Prepare;

package/lib/commands/query.js

@@ -0,0 +1,361 @@
+'use strict';
+
+const process = require('process');
+const Timers = require('timers');
+
+const Readable = require('stream').Readable;
+
+const Command = require('./command.js');
+const Packets = require('../packets/index.js');
+const getTextParser = require('../parsers/text_parser.js');
+const staticParser = require('../parsers/static_text_parser.js');
+const ServerStatus = require('../constants/server_status.js');
+
+const EmptyPacket = new Packets.Packet(0, Buffer.allocUnsafe(4), 0, 4);
+
+// http://dev.mysql.com/doc/internals/en/com-query.html
+class Query extends Command {
+  constructor(options, callback) {
+    super();
+    this.sql = options.sql;
+    this.values = options.values;
+    this._queryOptions = options;
+    this.namedPlaceholders = options.namedPlaceholders || false;
+    this.onResult = callback;
+    this.timeout = options.timeout;
+    this.queryTimeout = null;
+    this._fieldCount = 0;
+    this._rowParser = null;
+    this._fields = [];
+    this._rows = [];
+    this._receivedFieldsCount = 0;
+    this._resultIndex = 0;
+    this._localStream = null;
+    this._unpipeStream = function () {};
+    this._streamFactory = options.infileStreamFactory;
+    this._connection = null;
+  }
+
+  then() {
+    const err =
+      "You have tried to call .then(), .catch(), or invoked await on the result of query that is not a promise, which is a programming error. Try calling con.promise().query(), or require('mysql2/promise') instead of 'mysql2' for a promise-compatible version of the query interface. To learn how to use async/await or Promises check out documentation at https://sidorares.github.io/node-mysql2/docs#using-promise-wrapper, or the mysql2 documentation at https://sidorares.github.io/node-mysql2/docs/documentation/promise-wrapper";
+
+    console.log(err);
+    throw new Error(err);
+  }
+
+  /* eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }] */
+  start(_packet, connection) {
+    if (connection.config.debug) {
+      console.log('        Sending query command: %s', this.sql);
+    }
+    this._connection = connection;
+    this.options = Object.assign({}, connection.config, this._queryOptions);
+    this._setTimeout();
+
+    const cmdPacket = new Packets.Query(
+      this.sql,
+      connection.config.charsetNumber
+    );
+    connection.writePacket(cmdPacket.toPacket(1));
+    return Query.prototype.resultsetHeader;
+  }
+
+  done() {
+    this._unpipeStream();
+    // if all ready timeout, return null directly
+    if (this.timeout && !this.queryTimeout) {
+      return null;
+    }
+    // else clear timer
+    if (this.queryTimeout) {
+      Timers.clearTimeout(this.queryTimeout);
+      this.queryTimeout = null;
+    }
+    if (this.onResult) {
+      let rows, fields;
+      if (this._resultIndex === 0) {
+        rows = this._rows[0];
+        fields = this._fields[0];
+      } else {
+        rows = this._rows;
+        fields = this._fields;
+      }
+      if (fields) {
+        process.nextTick(() => {
+          this.onResult(null, rows, fields);
+        });
+      } else {
+        process.nextTick(() => {
+          this.onResult(null, rows);
+        });
+      }
+    }
+    return null;
+  }
+
+  doneInsert(rs) {
+    if (this._localStreamError) {
+      if (this.onResult) {
+        this.onResult(this._localStreamError, rs);
+      } else {
+        this.emit('error', this._localStreamError);
+      }
+      return null;
+    }
+    this._rows.push(rs);
+    this._fields.push(void 0);
+    this.emit('fields', void 0);
+    this.emit('result', rs);
+    if (rs.serverStatus & ServerStatus.SERVER_MORE_RESULTS_EXISTS) {
+      this._resultIndex++;
+      return this.resultsetHeader;
+    }
+    return this.done();
+  }
+
+  resultsetHeader(packet, connection) {
+    const rs = new Packets.ResultSetHeader(packet, connection);
+    this._fieldCount = rs.fieldCount;
+    if (connection.config.debug) {
+      console.log(
+        `        Resultset header received, expecting ${rs.fieldCount} column definition packets`
+      );
+    }
+    if (this._fieldCount === 0) {
+      return this.doneInsert(rs);
+    }
+    if (this._fieldCount === null) {
+      return this._streamLocalInfile(connection, rs.infileName);
+    }
+    this._receivedFieldsCount = 0;
+    this._rows.push([]);
+    this._fields.push([]);
+    return this.readField;
+  }
+
+  _streamLocalInfile(connection, path) {
+    if (this._streamFactory) {
+      this._localStream = this._streamFactory(path);
+    } else {
+      this._localStreamError = new Error(
+        `As a result of LOCAL INFILE command server wants to read ${path} file, but as of v2.0 you must provide streamFactory option returning ReadStream.`
+      );
+      connection.writePacket(EmptyPacket);
+      return this.infileOk;
+    }
+
+    const onConnectionError = () => {
+      this._unpipeStream();
+    };
+    const onDrain = () => {
+      this._localStream.resume();
+    };
+    const onPause = () => {
+      this._localStream.pause();
+    };
+    const onData = function (data) {
+      const dataWithHeader = Buffer.allocUnsafe(data.length + 4);
+      data.copy(dataWithHeader, 4);
+      connection.writePacket(
+        new Packets.Packet(0, dataWithHeader, 0, dataWithHeader.length)
+      );
+    };
+    const onEnd = () => {
+      connection.removeListener('error', onConnectionError);
+      connection.writePacket(EmptyPacket);
+    };
+    const onError = (err) => {
+      this._localStreamError = err;
+      connection.removeListener('error', onConnectionError);
+      connection.writePacket(EmptyPacket);
+    };
+    this._unpipeStream = () => {
+      connection.stream.removeListener('pause', onPause);
+      connection.stream.removeListener('drain', onDrain);
+      this._localStream.removeListener('data', onData);
+      this._localStream.removeListener('end', onEnd);
+      this._localStream.removeListener('error', onError);
+    };
+    connection.stream.on('pause', onPause);
+    connection.stream.on('drain', onDrain);
+    this._localStream.on('data', onData);
+    this._localStream.on('end', onEnd);
+    this._localStream.on('error', onError);
+    connection.once('error', onConnectionError);
+    return this.infileOk;
+  }
+
+  readField(packet, connection) {
+    this._receivedFieldsCount++;
+    // Often there is much more data in the column definition than in the row itself
+    // If you set manually _fields[0] to array of ColumnDefinition's (from previous call)
+    // you can 'cache' result of parsing. Field packets still received, but ignored in that case
+    // this is the reason _receivedFieldsCount exist (otherwise we could just use current length of fields array)
+    if (this._fields[this._resultIndex].length !== this._fieldCount) {
+      const field = new Packets.ColumnDefinition(
+        packet,
+        connection.clientEncoding
+      );
+      this._fields[this._resultIndex].push(field);
+      if (connection.config.debug) {
+        console.log('        Column definition:');
+        console.log(`          name: ${field.name}`);
+        console.log(`          type: ${field.columnType}`);
+        console.log(`         flags: ${field.flags}`);
+      }
+    }
+    // last field received
+    if (this._receivedFieldsCount === this._fieldCount) {
+      const fields = this._fields[this._resultIndex];
+      this.emit('fields', fields);
+      if (this.options.disableEval) {
+        this._rowParser = staticParser(fields, this.options, connection.config);
+      } else {
+        this._rowParser = new (getTextParser(
+          fields,
+          this.options,
+          connection.config
+        ))(fields);
+      }
+      return Query.prototype.fieldsEOF;
+    }
+    return Query.prototype.readField;
+  }
+
+  fieldsEOF(packet, connection) {
+    // check EOF
+    if (!packet.isEOF()) {
+      return connection.protocolError('Expected EOF packet');
+    }
+    return this.row;
+  }
+
+  row(packet, _connection) {
+    if (packet.isEOF()) {
+      const status = packet.eofStatusFlags();
+      const moreResults = status & ServerStatus.SERVER_MORE_RESULTS_EXISTS;
+      if (moreResults) {
+        this._resultIndex++;
+        return Query.prototype.resultsetHeader;
+      }
+      return this.done();
+    }
+    let row;
+    try {
+      row = this._rowParser.next(
+        packet,
+        this._fields[this._resultIndex],
+        this.options
+      );
+    } catch (err) {
+      this._localStreamError = err;
+      return this.doneInsert(null);
+    }
+    if (this.onResult) {
+      this._rows[this._resultIndex].push(row);
+    } else {
+      this.emit('result', row, this._resultIndex);
+    }
+    return Query.prototype.row;
+  }
+
+  infileOk(packet, connection) {
+    const rs = new Packets.ResultSetHeader(packet, connection);
+    return this.doneInsert(rs);
+  }
+
+  stream(options) {
+    options = options || Object.create(null);
+    options.objectMode = true;
+
+    const stream = new Readable({
+      ...options,
+      emitClose: true,
+      autoDestroy: true,
+      read: () => {
+        this._connection && this._connection.resume();
+      },
+    });
+
+    // Prevent a breaking change for users that rely on `end` event
+    stream.once('close', () => {
+      if (!stream.readableEnded) {
+        stream.emit('end');
+      }
+    });
+
+    const onResult = (row, index) => {
+      if (stream.destroyed) return;
+
+      if (!stream.push(row)) {
+        this._connection && this._connection.pause();
+      }
+
+      stream.emit('result', row, index); // replicate old emitter
+    };
+
+    const onFields = (fields) => {
+      if (stream.destroyed) return;
+
+      stream.emit('fields', fields); // replicate old emitter
+    };
+
+    const onEnd = () => {
+      if (stream.destroyed) return;
+
+      stream.push(null); // pushing null, indicating EOF
+    };
+
+    const onError = (err) => {
+      stream.destroy(err);
+    };
+
+    stream._destroy = (err, cb) => {
+      this._connection && this._connection.resume();
+
+      this.removeListener('result', onResult);
+      this.removeListener('fields', onFields);
+      this.removeListener('end', onEnd);
+      this.removeListener('error', onError);
+
+      cb(err); // Pass on any errors
+    };
+
+    this.on('result', onResult);
+    this.on('fields', onFields);
+    this.on('end', onEnd);
+    this.on('error', onError);
+
+    return stream;
+  }
+
+  _setTimeout() {
+    if (this.timeout) {
+      const timeoutHandler = this._handleTimeoutError.bind(this);
+      this.queryTimeout = Timers.setTimeout(timeoutHandler, this.timeout);
+    }
+  }
+
+  _handleTimeoutError() {
+    if (this.queryTimeout) {
+      Timers.clearTimeout(this.queryTimeout);
+      this.queryTimeout = null;
+    }
+
+    const err = new Error('Query inactivity timeout');
+    err.errorno = 'PROTOCOL_SEQUENCE_TIMEOUT';
+    err.code = 'PROTOCOL_SEQUENCE_TIMEOUT';
+    err.syscall = 'query';
+
+    if (this.onResult) {
+      this.onResult(err);
+    } else {
+      this.emit('error', err);
+    }
+  }
+}
+
+Query.prototype.catch = Query.prototype.then;
+
+module.exports = Query;

package/lib/commands/quit.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Command = require('./command.js');
+const CommandCode = require('../constants/commands.js');
+const Packet = require('../packets/packet.js');
+
+class Quit extends Command {
+  constructor(callback) {
+    super();
+    this.onResult = callback;
+  }
+
+  start(packet, connection) {
+    connection._closing = true;
+    const quit = new Packet(
+      0,
+      Buffer.from([1, 0, 0, 0, CommandCode.QUIT]),
+      0,
+      5
+    );
+    if (this.onResult) {
+      this.onResult();
+    }
+    connection.writePacket(quit);
+    return null;
+  }
+}
+
+module.exports = Quit;

package/lib/commands/register_slave.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const Command = require('./command');
+const Packets = require('../packets');
+
+class RegisterSlave extends Command {
+  constructor(opts, callback) {
+    super();
+    this.onResult = callback;
+    this.opts = opts;
+  }
+
+  start(packet, connection) {
+    const newPacket = new Packets.RegisterSlave(this.opts);
+    connection.writePacket(newPacket.toPacket(1));
+    return RegisterSlave.prototype.registerResponse;
+  }
+
+  registerResponse() {
+    if (this.onResult) {
+      process.nextTick(this.onResult.bind(this));
+    }
+    return null;
+  }
+}
+
+module.exports = RegisterSlave;