node-server-dev 3.1.5 → 3.1.6

package/dist/esm/package/mysql2/lib/constants/field_flags.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// Manually extracted from mysql-5.5.23/include/mysql_com.h
+exports.NOT_NULL = 1; /* Field can't be NULL */
+exports.PRI_KEY = 2; /* Field is part of a primary key */
+exports.UNIQUE_KEY = 4; /* Field is part of a unique key */
+exports.MULTIPLE_KEY = 8; /* Field is part of a key */
+exports.BLOB = 16; /* Field is a blob */
+exports.UNSIGNED = 32; /* Field is unsigned */
+exports.ZEROFILL = 64; /* Field is zerofill */
+exports.BINARY = 128; /* Field is binary   */
+
+/* The following are only sent to new clients */
+exports.ENUM = 256; /* field is an enum */
+exports.AUTO_INCREMENT = 512; /* field is a autoincrement field */
+exports.TIMESTAMP = 1024; /* Field is a timestamp */
+exports.SET = 2048; /* field is a set */
+exports.NO_DEFAULT_VALUE = 4096; /* Field doesn't have default value */
+exports.ON_UPDATE_NOW = 8192; /* Field is set to NOW on UPDATE */
+exports.NUM = 32768; /* Field is num (for clients) */

package/dist/esm/package/mysql2/lib/constants/server_status.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Manually extracted from mysql-5.5.23/include/mysql_com.h
+
+/**
+  Is raised when a multi-statement transaction
+  has been started, either explicitly, by means
+  of BEGIN or COMMIT AND CHAIN, or
+  implicitly, by the first transactional
+  statement, when autocommit=off.
+*/
+exports.SERVER_STATUS_IN_TRANS = 1;
+exports.SERVER_STATUS_AUTOCOMMIT = 2; /* Server in auto_commit mode */
+exports.SERVER_MORE_RESULTS_EXISTS = 8; /* Multi query - next query exists */
+exports.SERVER_QUERY_NO_GOOD_INDEX_USED = 16;
+exports.SERVER_QUERY_NO_INDEX_USED = 32;
+/**
+  The server was able to fulfill the clients request and opened a
+  read-only non-scrollable cursor for a query. This flag comes
+  in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands.
+*/
+exports.SERVER_STATUS_CURSOR_EXISTS = 64;
+/**
+  This flag is sent when a read-only cursor is exhausted, in reply to
+  COM_STMT_FETCH command.
+*/
+exports.SERVER_STATUS_LAST_ROW_SENT = 128;
+exports.SERVER_STATUS_DB_DROPPED = 256; /* A database was dropped */
+exports.SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512;
+/**
+  Sent to the client if after a prepared statement reprepare
+  we discovered that the new statement returns a different
+  number of result set columns.
+*/
+exports.SERVER_STATUS_METADATA_CHANGED = 1024;
+exports.SERVER_QUERY_WAS_SLOW = 2048;
+
+/**
+  To mark ResultSet containing output parameter values.
+*/
+exports.SERVER_PS_OUT_PARAMS = 4096;
+
+exports.SERVER_STATUS_IN_TRANS_READONLY = 0x2000; // in a read-only transaction
+exports.SERVER_SESSION_STATE_CHANGED = 0x4000;

package/dist/esm/package/mysql2/lib/constants/session_track.js

@@ -0,0 +1,11 @@
+'use strict';
+
+exports.SYSTEM_VARIABLES = 0;
+exports.SCHEMA = 1;
+exports.STATE_CHANGE = 2;
+exports.STATE_GTIDS = 3;
+exports.TRANSACTION_CHARACTERISTICS = 4;
+exports.TRANSACTION_STATE = 5;
+
+exports.FIRST_KEY = exports.SYSTEM_VARIABLES;
+exports.LAST_KEY = exports.TRANSACTION_STATE;

package/dist/esm/package/mysql2/lib/constants/ssl_profiles.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const awsCaBundle = require('aws-ssl-profiles');
+
+/**
+ * @deprecated
+ * Please, use [**aws-ssl-profiles**](https://github.com/mysqljs/aws-ssl-profiles).
+ */
+exports['Amazon RDS'] = {
+  ca: awsCaBundle.ca,
+};

package/dist/esm/package/mysql2/lib/constants/types.js

@@ -0,0 +1,64 @@
+'use strict';
+
+module.exports = {
+  0x00: 'DECIMAL', // aka DECIMAL
+  0x01: 'TINY', // aka TINYINT, 1 byte
+  0x02: 'SHORT', // aka SMALLINT, 2 bytes
+  0x03: 'LONG', // aka INT, 4 bytes
+  0x04: 'FLOAT', // aka FLOAT, 4-8 bytes
+  0x05: 'DOUBLE', // aka DOUBLE, 8 bytes
+  0x06: 'NULL', // NULL (used for prepared statements, I think)
+  0x07: 'TIMESTAMP', // aka TIMESTAMP
+  0x08: 'LONGLONG', // aka BIGINT, 8 bytes
+  0x09: 'INT24', // aka MEDIUMINT, 3 bytes
+  0x0a: 'DATE', // aka DATE
+  0x0b: 'TIME', // aka TIME
+  0x0c: 'DATETIME', // aka DATETIME
+  0x0d: 'YEAR', // aka YEAR, 1 byte (don't ask)
+  0x0e: 'NEWDATE', // aka ?
+  0x0f: 'VARCHAR', // aka VARCHAR (?)
+  0x10: 'BIT', // aka BIT, 1-8 byte
+  0xf5: 'JSON',
+  0xf6: 'NEWDECIMAL', // aka DECIMAL
+  0xf7: 'ENUM', // aka ENUM
+  0xf8: 'SET', // aka SET
+  0xf9: 'TINY_BLOB', // aka TINYBLOB, TINYTEXT
+  0xfa: 'MEDIUM_BLOB', // aka MEDIUMBLOB, MEDIUMTEXT
+  0xfb: 'LONG_BLOB', // aka LONGBLOG, LONGTEXT
+  0xfc: 'BLOB', // aka BLOB, TEXT
+  0xfd: 'VAR_STRING', // aka VARCHAR, VARBINARY
+  0xfe: 'STRING', // aka CHAR, BINARY
+  0xff: 'GEOMETRY', // aka GEOMETRY
+};
+
+// Manually extracted from mysql-5.5.23/include/mysql_com.h
+// some more info here: http://dev.mysql.com/doc/refman/5.5/en/c-api-prepared-statement-type-codes.html
+module.exports.DECIMAL = 0x00; // aka DECIMAL (http://dev.mysql.com/doc/refman/5.0/en/precision-math-decimal-changes.html)
+module.exports.TINY = 0x01; // aka TINYINT, 1 byte
+module.exports.SHORT = 0x02; // aka SMALLINT, 2 bytes
+module.exports.LONG = 0x03; // aka INT, 4 bytes
+module.exports.FLOAT = 0x04; // aka FLOAT, 4-8 bytes
+module.exports.DOUBLE = 0x05; // aka DOUBLE, 8 bytes
+module.exports.NULL = 0x06; // NULL (used for prepared statements, I think)
+module.exports.TIMESTAMP = 0x07; // aka TIMESTAMP
+module.exports.LONGLONG = 0x08; // aka BIGINT, 8 bytes
+module.exports.INT24 = 0x09; // aka MEDIUMINT, 3 bytes
+module.exports.DATE = 0x0a; // aka DATE
+module.exports.TIME = 0x0b; // aka TIME
+module.exports.DATETIME = 0x0c; // aka DATETIME
+module.exports.YEAR = 0x0d; // aka YEAR, 1 byte (don't ask)
+module.exports.NEWDATE = 0x0e; // aka ?
+module.exports.VARCHAR = 0x0f; // aka VARCHAR (?)
+module.exports.BIT = 0x10; // aka BIT, 1-8 byte
+module.exports.VECTOR = 0xf2;
+module.exports.JSON = 0xf5;
+module.exports.NEWDECIMAL = 0xf6; // aka DECIMAL
+module.exports.ENUM = 0xf7; // aka ENUM
+module.exports.SET = 0xf8; // aka SET
+module.exports.TINY_BLOB = 0xf9; // aka TINYBLOB, TINYTEXT
+module.exports.MEDIUM_BLOB = 0xfa; // aka MEDIUMBLOB, MEDIUMTEXT
+module.exports.LONG_BLOB = 0xfb; // aka LONGBLOG, LONGTEXT
+module.exports.BLOB = 0xfc; // aka BLOB, TEXT
+module.exports.VAR_STRING = 0xfd; // aka VARCHAR, VARBINARY
+module.exports.STRING = 0xfe; // aka CHAR, BINARY
+module.exports.GEOMETRY = 0xff; // aka GEOMETRY

package/dist/esm/package/mysql2/lib/create_connection.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const Connection = require('./connection.js');
+const ConnectionConfig = require('./connection_config.js');
+
+function createConnection(opts) {
+  return new Connection({ config: new ConnectionConfig(opts) });
+}
+
+module.exports = createConnection;

package/dist/esm/package/mysql2/lib/create_pool.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const Pool = require('./pool.js');
+const PoolConfig = require('./pool_config.js');
+
+function createPool(config) {
+  return new Pool({ config: new PoolConfig(config) });
+}
+
+module.exports = createPool;

package/dist/esm/package/mysql2/lib/create_pool_cluster.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const PoolCluster = require('./pool_cluster.js');
+
+function createPoolCluster(config) {
+  return new PoolCluster(config);
+}
+
+module.exports = createPoolCluster;

package/dist/esm/package/mysql2/lib/helpers.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/*
+
+  this seems to be not only shorter, but faster than
+  string.replace(/\\/g, '\\\\').
+            replace(/\u0008/g, '\\b').
+            replace(/\t/g, '\\t').
+            replace(/\n/g, '\\n').
+            replace(/\f/g, '\\f').
+            replace(/\r/g, '\\r').
+            replace(/'/g, '\\\'').
+            replace(/"/g, '\\"');
+  or string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
+  see http://jsperf.com/string-escape-regexp-vs-json-stringify
+  */
+function srcEscape(str) {
+  return JSON.stringify({
+    [str]: 1,
+  }).slice(1, -3);
+}
+
+exports.srcEscape = srcEscape;
+
+let highlightFn;
+let cardinalRecommended = false;
+try {
+  // the purpose of this is to prevent projects using Webpack from displaying a warning during runtime if cardinal is not a dependency
+  const REQUIRE_TERMINATOR = '';
+  highlightFn = require(`cardinal${REQUIRE_TERMINATOR}`).highlight;
+} catch (err) {
+  highlightFn = (text) => {
+    if (!cardinalRecommended) {
+      // eslint-disable-next-line no-console
+      console.log('For nicer debug output consider install cardinal@^2.0.0');
+      cardinalRecommended = true;
+    }
+    return text;
+  };
+}
+
+/**
+ * Prints debug message with code frame, will try to use `cardinal` if available.
+ */
+function printDebugWithCode(msg, code) {
+  // eslint-disable-next-line no-console
+  console.log(`\n\n${msg}:\n`);
+  // eslint-disable-next-line no-console
+  console.log(`${highlightFn(code)}\n`);
+}
+
+exports.printDebugWithCode = printDebugWithCode;
+
+/**
+ * checks whether the `type` is in the `list`
+ */
+function typeMatch(type, list, Types) {
+  if (Array.isArray(list)) {
+    return list.some((t) => type === Types[t]);
+  }
+
+  return !!list;
+}
+
+exports.typeMatch = typeMatch;
+
+const privateObjectProps = new Set([
+  '__defineGetter__',
+  '__defineSetter__',
+  '__lookupGetter__',
+  '__lookupSetter__',
+  '__proto__',
+]);
+
+exports.privateObjectProps = privateObjectProps;
+
+const fieldEscape = (field, isEval = true) => {
+  if (privateObjectProps.has(field)) {
+    throw new Error(
+      `The field name (${field}) can't be the same as an object's private property.`
+    );
+  }
+
+  return isEval ? srcEscape(field) : field;
+};
+exports.fieldEscape = fieldEscape;

package/dist/esm/package/mysql2/lib/packet_parser.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const Packet = require('./packets/packet.js');
+
+const MAX_PACKET_LENGTH = 16777215;
+
+function readPacketLength(b, off) {
+  const b0 = b[off];
+  const b1 = b[off + 1];
+  const b2 = b[off + 2];
+  if (b1 + b2 === 0) {
+    return b0;
+  }
+  return b0 + (b1 << 8) + (b2 << 16);
+}
+
+class PacketParser {
+  constructor(onPacket, packetHeaderLength) {
+    // 4 for normal packets, 7 for comprssed protocol packets
+    if (typeof packetHeaderLength === 'undefined') {
+      packetHeaderLength = 4;
+    }
+    // array of last payload chunks
+    // only used when current payload is not complete
+    this.buffer = [];
+    // total length of chunks on buffer
+    this.bufferLength = 0;
+    this.packetHeaderLength = packetHeaderLength;
+    // incomplete header state: number of header bytes received
+    this.headerLen = 0;
+    // expected payload length
+    this.length = 0;
+    this.largePacketParts = [];
+    this.firstPacketSequenceId = 0;
+    this.onPacket = onPacket;
+    this.execute = PacketParser.prototype.executeStart;
+    this._flushLargePacket =
+      packetHeaderLength === 7
+        ? this._flushLargePacket7
+        : this._flushLargePacket4;
+  }
+
+  _flushLargePacket4() {
+    const numPackets = this.largePacketParts.length;
+    this.largePacketParts.unshift(Buffer.from([0, 0, 0, 0])); // insert header
+    const body = Buffer.concat(this.largePacketParts);
+    const packet = new Packet(this.firstPacketSequenceId, body, 0, body.length);
+    this.largePacketParts.length = 0;
+    packet.numPackets = numPackets;
+    this.onPacket(packet);
+  }
+
+  _flushLargePacket7() {
+    const numPackets = this.largePacketParts.length;
+    this.largePacketParts.unshift(Buffer.from([0, 0, 0, 0, 0, 0, 0])); // insert header
+    const body = Buffer.concat(this.largePacketParts);
+    this.largePacketParts.length = 0;
+    const packet = new Packet(this.firstPacketSequenceId, body, 0, body.length);
+    packet.numPackets = numPackets;
+    this.onPacket(packet);
+  }
+
+  executeStart(chunk) {
+    let start = 0;
+    const end = chunk.length;
+    while (end - start >= 3) {
+      this.length = readPacketLength(chunk, start);
+      if (end - start >= this.length + this.packetHeaderLength) {
+        // at least one full packet
+        const sequenceId = chunk[start + 3];
+        if (
+          this.length < MAX_PACKET_LENGTH &&
+          this.largePacketParts.length === 0
+        ) {
+          this.onPacket(
+            new Packet(
+              sequenceId,
+              chunk,
+              start,
+              start + this.packetHeaderLength + this.length
+            )
+          );
+        } else {
+          // first large packet - remember it's id
+          if (this.largePacketParts.length === 0) {
+            this.firstPacketSequenceId = sequenceId;
+          }
+          this.largePacketParts.push(
+            chunk.slice(
+              start + this.packetHeaderLength,
+              start + this.packetHeaderLength + this.length
+            )
+          );
+          if (this.length < MAX_PACKET_LENGTH) {
+            this._flushLargePacket();
+          }
+        }
+        start += this.packetHeaderLength + this.length;
+      } else {
+        // payload is incomplete
+        this.buffer = [chunk.slice(start + 3, end)];
+        this.bufferLength = end - start - 3;
+        this.execute = PacketParser.prototype.executePayload;
+        return;
+      }
+    }
+    if (end - start > 0) {
+      // there is start of length header, but it's not full 3 bytes
+      this.headerLen = end - start; // 1 or 2 bytes
+      this.length = chunk[start];
+      if (this.headerLen === 2) {
+        this.length = chunk[start] + (chunk[start + 1] << 8);
+        this.execute = PacketParser.prototype.executeHeader3;
+      } else {
+        this.execute = PacketParser.prototype.executeHeader2;
+      }
+    }
+  }
+
+  executePayload(chunk) {
+    let start = 0;
+    const end = chunk.length;
+    const remainingPayload =
+      this.length - this.bufferLength + this.packetHeaderLength - 3;
+    if (end - start >= remainingPayload) {
+      // last chunk for payload
+      const payload = Buffer.allocUnsafe(this.length + this.packetHeaderLength);
+      let offset = 3;
+      for (let i = 0; i < this.buffer.length; ++i) {
+        this.buffer[i].copy(payload, offset);
+        offset += this.buffer[i].length;
+      }
+      chunk.copy(payload, offset, start, start + remainingPayload);
+      const sequenceId = payload[3];
+      if (
+        this.length < MAX_PACKET_LENGTH &&
+        this.largePacketParts.length === 0
+      ) {
+        this.onPacket(
+          new Packet(
+            sequenceId,
+            payload,
+            0,
+            this.length + this.packetHeaderLength
+          )
+        );
+      } else {
+        // first large packet - remember it's id
+        if (this.largePacketParts.length === 0) {
+          this.firstPacketSequenceId = sequenceId;
+        }
+        this.largePacketParts.push(
+          payload.slice(
+            this.packetHeaderLength,
+            this.packetHeaderLength + this.length
+          )
+        );
+        if (this.length < MAX_PACKET_LENGTH) {
+          this._flushLargePacket();
+        }
+      }
+      this.buffer = [];
+      this.bufferLength = 0;
+      this.execute = PacketParser.prototype.executeStart;
+      start += remainingPayload;
+      if (end - start > 0) {
+        return this.execute(chunk.slice(start, end));
+      }
+    } else {
+      this.buffer.push(chunk);
+      this.bufferLength += chunk.length;
+    }
+    return null;
+  }
+
+  executeHeader2(chunk) {
+    this.length += chunk[0] << 8;
+    if (chunk.length > 1) {
+      this.length += chunk[1] << 16;
+      this.execute = PacketParser.prototype.executePayload;
+      return this.executePayload(chunk.slice(2));
+    }
+    this.execute = PacketParser.prototype.executeHeader3;
+
+    return null;
+  }
+
+  executeHeader3(chunk) {
+    this.length += chunk[0] << 16;
+    this.execute = PacketParser.prototype.executePayload;
+    return this.executePayload(chunk.slice(1));
+  }
+}
+
+module.exports = PacketParser;

package/dist/esm/package/mysql2/lib/packets/auth_next_factor.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2021, Oracle and/or its affiliates.
+
+'use strict';
+
+const Packet = require('../packets/packet');
+
+class AuthNextFactor {
+  constructor(opts) {
+    this.pluginName = opts.pluginName;
+    this.pluginData = opts.pluginData;
+  }
+
+  toPacket(encoding) {
+    const length = 6 + this.pluginName.length + this.pluginData.length;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeInt8(0x02);
+    packet.writeNullTerminatedString(this.pluginName, encoding);
+    packet.writeBuffer(this.pluginData);
+    return packet;
+  }
+
+  static fromPacket(packet, encoding) {
+    packet.readInt8(); // marker
+    const name = packet.readNullTerminatedString(encoding);
+    const data = packet.readBuffer();
+    return new AuthNextFactor({
+      pluginName: name,
+      pluginData: data,
+    });
+  }
+}
+
+module.exports = AuthNextFactor;

package/dist/esm/package/mysql2/lib/packets/auth_switch_request.js

@@ -0,0 +1,38 @@
+'use strict';
+
+// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::AuthSwitchRequest
+
+const Packet = require('../packets/packet');
+
+class AuthSwitchRequest {
+  constructor(opts) {
+    this.pluginName = opts.pluginName;
+    this.pluginData = opts.pluginData;
+  }
+
+  toPacket() {
+    const length = 6 + this.pluginName.length + this.pluginData.length;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeInt8(0xfe);
+    // TODO: use server encoding
+    packet.writeNullTerminatedString(this.pluginName, 'cesu8');
+    packet.writeBuffer(this.pluginData);
+    return packet;
+  }
+
+  static fromPacket(packet) {
+    packet.readInt8(); // marker
+    // assert marker == 0xfe?
+    // TODO: use server encoding
+    const name = packet.readNullTerminatedString('cesu8');
+    const data = packet.readBuffer();
+    return new AuthSwitchRequest({
+      pluginName: name,
+      pluginData: data,
+    });
+  }
+}
+
+module.exports = AuthSwitchRequest;

package/dist/esm/package/mysql2/lib/packets/auth_switch_request_more_data.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::AuthSwitchRequest
+
+const Packet = require('../packets/packet');
+
+class AuthSwitchRequestMoreData {
+  constructor(data) {
+    this.data = data;
+  }
+
+  toPacket() {
+    const length = 5 + this.data.length;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeInt8(0x01);
+    packet.writeBuffer(this.data);
+    return packet;
+  }
+
+  static fromPacket(packet) {
+    packet.readInt8(); // marker
+    const data = packet.readBuffer();
+    return new AuthSwitchRequestMoreData(data);
+  }
+
+  static verifyMarker(packet) {
+    return packet.peekByte() === 0x01;
+  }
+}
+
+module.exports = AuthSwitchRequestMoreData;

package/dist/esm/package/mysql2/lib/packets/auth_switch_response.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::AuthSwitchRequest
+
+const Packet = require('../packets/packet');
+
+class AuthSwitchResponse {
+  constructor(data) {
+    if (!Buffer.isBuffer(data)) {
+      data = Buffer.from(data);
+    }
+    this.data = data;
+  }
+
+  toPacket() {
+    const length = 4 + this.data.length;
+    const buffer = Buffer.allocUnsafe(length);
+    const packet = new Packet(0, buffer, 0, length);
+    packet.offset = 4;
+    packet.writeBuffer(this.data);
+    return packet;
+  }
+
+  static fromPacket(packet) {
+    const data = packet.readBuffer();
+    return new AuthSwitchResponse(data);
+  }
+}
+
+module.exports = AuthSwitchResponse;