elyse-help 1.1.9

package/backend/node_modules/mysql/lib/protocol/sequences/Sequence.js

@@ -0,0 +1,125 @@
+var Util           = require('util');
+var EventEmitter   = require('events').EventEmitter;
+var Packets        = require('../packets');
+var ErrorConstants = require('../constants/errors');
+var Timer          = require('../Timer');
+
+// istanbul ignore next: Node.js < 0.10 not covered
+var listenerCount = EventEmitter.listenerCount
+  || function(emitter, type){ return emitter.listeners(type).length; };
+
+var LONG_STACK_DELIMITER = '\n    --------------------\n';
+
+module.exports = Sequence;
+Util.inherits(Sequence, EventEmitter);
+function Sequence(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  EventEmitter.call(this);
+
+  options = options || {};
+
+  this._callback = callback;
+  this._callSite = null;
+  this._ended    = false;
+  this._timeout  = options.timeout;
+  this._timer    = new Timer(this);
+}
+
+Sequence.determinePacket = function(byte) {
+  switch (byte) {
+    case 0x00: return Packets.OkPacket;
+    case 0xfe: return Packets.EofPacket;
+    case 0xff: return Packets.ErrorPacket;
+    default:   return undefined;
+  }
+};
+
+Sequence.prototype.hasErrorHandler = function() {
+  return Boolean(this._callback) || listenerCount(this, 'error') > 1;
+};
+
+Sequence.prototype._packetToError = function(packet) {
+  var code = ErrorConstants[packet.errno] || 'UNKNOWN_CODE_PLEASE_REPORT';
+  var err  = new Error(code + ': ' + packet.message);
+  err.code = code;
+  err.errno = packet.errno;
+
+  err.sqlMessage = packet.message;
+  err.sqlState   = packet.sqlState;
+
+  return err;
+};
+
+Sequence.prototype.end = function(err) {
+  if (this._ended) {
+    return;
+  }
+
+  this._ended = true;
+
+  if (err) {
+    this._addLongStackTrace(err);
+  }
+
+  // Without this we are leaking memory. This problem was introduced in
+  // 8189925374e7ce3819bbe88b64c7b15abac96b16. I suspect that the error object
+  // causes a cyclic reference that the GC does not detect properly, but I was
+  // unable to produce a standalone version of this leak. This would be a great
+  // challenge for somebody interested in difficult problems : )!
+  this._callSite = null;
+
+  // try...finally for exception safety
+  try {
+    if (err) {
+      this.emit('error', err);
+    }
+  } finally {
+    try {
+      if (this._callback) {
+        this._callback.apply(this, arguments);
+      }
+    } finally {
+      this.emit('end');
+    }
+  }
+};
+
+Sequence.prototype['OkPacket'] = function(packet) {
+  this.end(null, packet);
+};
+
+Sequence.prototype['ErrorPacket'] = function(packet) {
+  this.end(this._packetToError(packet));
+};
+
+// Implemented by child classes
+Sequence.prototype.start = function() {};
+
+Sequence.prototype._addLongStackTrace = function _addLongStackTrace(err) {
+  var callSiteStack = this._callSite && this._callSite.stack;
+
+  if (!callSiteStack || typeof callSiteStack !== 'string') {
+    // No recorded call site
+    return;
+  }
+
+  if (err.stack.indexOf(LONG_STACK_DELIMITER) !== -1) {
+    // Error stack already looks long
+    return;
+  }
+
+  var index = callSiteStack.indexOf('\n');
+
+  if (index !== -1) {
+    // Append recorded call site
+    err.stack += LONG_STACK_DELIMITER + callSiteStack.substr(index + 1);
+  }
+};
+
+Sequence.prototype._onTimeout = function _onTimeout() {
+  this.emit('timeout');
+};

package/backend/node_modules/mysql/lib/protocol/sequences/Statistics.js

@@ -0,0 +1,30 @@
+var Sequence = require('./Sequence');
+var Util     = require('util');
+var Packets  = require('../packets');
+
+module.exports = Statistics;
+Util.inherits(Statistics, Sequence);
+function Statistics(options, callback) {
+  if (!callback && typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  Sequence.call(this, options, callback);
+}
+
+Statistics.prototype.start = function() {
+  this.emit('packet', new Packets.ComStatisticsPacket());
+};
+
+Statistics.prototype['StatisticsPacket'] = function (packet) {
+  this.end(null, packet);
+};
+
+Statistics.prototype.determinePacket = function determinePacket(firstByte) {
+  if (firstByte === 0x55) {
+    return Packets.StatisticsPacket;
+  }
+
+  return undefined;
+};

package/backend/node_modules/mysql/lib/protocol/sequences/index.js

@@ -0,0 +1,7 @@
+exports.ChangeUser = require('./ChangeUser');
+exports.Handshake = require('./Handshake');
+exports.Ping = require('./Ping');
+exports.Query = require('./Query');
+exports.Quit = require('./Quit');
+exports.Sequence = require('./Sequence');
+exports.Statistics = require('./Statistics');

package/backend/node_modules/mysql/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "mysql",
+  "description": "A node.js driver for mysql. It is written in JavaScript, does not require compiling, and is 100% MIT licensed.",
+  "version": "2.18.1",
+  "license": "MIT",
+  "author": "Felix Geisendörfer <felix@debuggable.com> (http://debuggable.com/)",
+  "contributors": [
+    "Andrey Sidorov <sidorares@yandex.ru>",
+    "Bradley Grainger <bgrainger@gmail.com>",
+    "Douglas Christopher Wilson <doug@somethingdoug.com>",
+    "Diogo Resende <dresende@thinkdigital.pt>",
+    "Nathan Woltman <nwoltman@outlook.com>"
+  ],
+  "repository": "mysqljs/mysql",
+  "dependencies": {
+    "bignumber.js": "9.0.0",
+    "readable-stream": "2.3.7",
+    "safe-buffer": "5.1.2",
+    "sqlstring": "2.3.1"
+  },
+  "devDependencies": {
+    "after": "0.8.2",
+    "eslint": "5.16.0",
+    "seedrandom": "3.0.5",
+    "timezone-mock": "0.0.7",
+    "urun": "0.0.8",
+    "utest": "0.0.8"
+  },
+  "files": [
+    "lib/",
+    "Changes.md",
+    "License",
+    "Readme.md",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "scripts": {
+    "lint": "eslint . && node tool/lint-readme.js",
+    "test": "node test/run.js",
+    "test-ci": "node tool/install-nyc.js --nyc-optional --reporter=text -- npm test",
+    "test-cov": "node tool/install-nyc.js --reporter=html --reporter=text -- npm test",
+    "version": "node tool/version-changes.js && git add Changes.md"
+  }
+}

package/backend/node_modules/mysql2/License

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Andrey Sidorov (sidorares@yandex.ru) and contributors
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

package/backend/node_modules/mysql2/README.md

@@ -0,0 +1,114 @@
+[npm-image]: https://img.shields.io/npm/v/mysql2.svg
+[npm-url]: https://npmjs.com/package/mysql2
+[node-version-image]: https://img.shields.io/node/v/mysql2.svg
+[node-version-url]: https://nodejs.org/en/download
+[downloads-image]: https://img.shields.io/npm/dm/mysql2.svg
+[downloads-url]: https://npmjs.com/package/mysql2
+[license-url]: https://github.com/sidorares/node-mysql2/blob/master/License
+[license-image]: https://img.shields.io/npm/l/mysql2.svg?maxAge=2592000
+[node-mysql]: https://github.com/mysqljs/mysql
+[mysqljs]: https://github.com/mysqljs
+[mysql-native]: https://github.com/sidorares/nodejs-mysql-native
+[sidorares]: https://github.com/sidorares
+[TooTallNate]: https://gist.github.com/TooTallNate
+[starttls.js]: https://gist.github.com/TooTallNate/848444
+[node-mariasql]: https://github.com/mscdex/node-mariasql
+[contributors]: https://github.com/sidorares/node-mysql2/graphs/contributors
+[contributing]: https://github.com/sidorares/node-mysql2/blob/master/Contributing.md
+[docs-base]: https://sidorares.github.io/node-mysql2/docs
+[docs-base-zh-CN]: https://sidorares.github.io/node-mysql2/zh-CN/docs
+[docs-base-pt-BR]: https://sidorares.github.io/node-mysql2/pt-BR/docs
+[docs-prepared-statements]: https://sidorares.github.io/node-mysql2/docs/documentation/prepared-statements
+[docs-mysql-server]: https://sidorares.github.io/node-mysql2/docs/documentation/mysql-server
+[docs-promise-wrapper]: https://sidorares.github.io/node-mysql2/docs/documentation/promise-wrapper
+[docs-authentication-switch]: https://sidorares.github.io/node-mysql2/docs/documentation/authentication-switch
+[docs-streams]: https://sidorares.github.io/node-mysql2/docs/documentation/extras
+[docs-typescript-docs]: https://sidorares.github.io/node-mysql2/docs/documentation/typescript-examples
+[docs-qs-pooling]: https://sidorares.github.io/node-mysql2/docs#using-connection-pools
+[docs-qs-first-query]: https://sidorares.github.io/node-mysql2/docs#first-query
+[docs-qs-using-prepared-statements]: https://sidorares.github.io/node-mysql2/docs#using-prepared-statements
+[docs-examples]: https://sidorares.github.io/node-mysql2/docs/examples
+[docs-faq]: https://sidorares.github.io/node-mysql2/docs/faq
+[docs-documentation]: https://sidorares.github.io/node-mysql2/docs/documentation
+[docs-contributing]: https://sidorares.github.io/node-mysql2/docs/contributing/website
+[coverage]: https://img.shields.io/codecov/c/github/sidorares/node-mysql2
+[coverage-url]: https://app.codecov.io/github/sidorares/node-mysql2
+[ci-url]: https://github.com/sidorares/node-mysql2/actions/workflows/ci-coverage.yml?query=branch%3Amaster
+[ci-image]: https://img.shields.io/github/actions/workflow/status/sidorares/node-mysql2/ci-coverage.yml?event=push&style=flat&label=CI&branch=master
+
+# MySQL2
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![GitHub Workflow Status (with event)][ci-image]][ci-url]
+[![Codecov][coverage]][coverage-url]
+[![License][license-image]][license-url]
+
+[English][docs-base] | [简体中文][docs-base-zh-CN] | [Português (BR)][docs-base-pt-BR]
+
+> MySQL client for Node.js with focus on performance. Supports prepared statements, non-utf8 encodings, binary log protocol, compression, ssl [much more][docs-documentation].
+
+**Table of Contents**
+
+- [History and Why MySQL2](#history-and-why-mysql2)
+- [Installation](#installation)
+- [Documentation](#documentation)
+- [Acknowledgements](#acknowledgements)
+- [Contributing](#contributing)
+
+## History and Why MySQL2
+
+MySQL2 project is a continuation of [MySQL-Native][mysql-native]. Protocol parser code was rewritten from scratch and api changed to match popular [Node MySQL][node-mysql]. MySQL2 team is working together with [Node MySQL][node-mysql] team to factor out shared code and move it under [mysqljs][mysqljs] organization.
+
+MySQL2 is mostly API compatible with [Node MySQL][node-mysql] and supports majority of features. MySQL2 also offers these additional features:
+
+- Faster / Better Performance
+- [Prepared Statements][docs-prepared-statements]
+- MySQL Binary Log Protocol
+- [MySQL Server][docs-mysql-server]
+- Extended support for Encoding and Collation
+- [Promise Wrapper][docs-promise-wrapper]
+- Compression
+- SSL and [Authentication Switch][docs-authentication-switch]
+- [Custom Streams][docs-streams]
+- [Pooling][docs-qs-pooling]
+
+## Installation
+
+MySQL2 is free from native bindings and can be installed on Linux, Mac OS or Windows without any issues.
+
+```bash
+npm install --save mysql2
+```
+
+If you are using TypeScript, you will need to install `@types/node`.
+
+```bash
+npm install --save-dev @types/node
+```
+
+> For TypeScript documentation and examples, see [here][docs-typescript-docs].
+
+## Documentation
+
+- [Quickstart][docs-base]
+  - [First Query][docs-qs-first-query], [Using Prepared Statements][docs-qs-using-prepared-statements], [Using Connection Pools][docs-qs-pooling] and more.
+- [Documentation][docs-documentation]
+- [Examples][docs-examples]
+- [FAQ][docs-faq]
+
+## Acknowledgements
+
+- Internal protocol is written by [@sidorares][sidorares] [MySQL-Native][mysql-native].
+- Constants, SQL parameters interpolation, Pooling, `ConnectionConfig` class taken from [Node MySQL][node-mysql].
+- SSL upgrade code based on [@TooTallNate][TooTallNate] [code][starttls.js].
+- Secure connection / compressed connection api flags compatible to [MariaSQL][node-mariasql] client.
+- [Contributors][contributors].
+
+## Contributing
+
+Want to improve something in **MySQL2**?
+Please check [Contributing.md][contributing] for detailed instruction on how to get started.
+
+To contribute in **MySQL2 Documentation**, please visit the [Website Contributing Guidelines][docs-contributing] for detailed instruction on how to get started.

package/backend/node_modules/mysql2/index.d.ts

@@ -0,0 +1 @@
+export * from './typings/mysql/index.js';

package/backend/node_modules/mysql2/index.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const SqlString = require('sql-escaper');
+
+const ConnectionConfig = require('./lib/connection_config.js');
+const parserCache = require('./lib/parsers/parser_cache.js');
+
+const Connection = require('./lib/connection.js');
+
+exports.createConnection = require('./lib/create_connection.js');
+exports.connect = exports.createConnection;
+exports.Connection = Connection;
+exports.ConnectionConfig = ConnectionConfig;
+
+const Pool = require('./lib/pool.js');
+const PoolCluster = require('./lib/pool_cluster.js');
+const createPool = require('./lib/create_pool.js');
+const createPoolCluster = require('./lib/create_pool_cluster.js');
+
+exports.createPool = createPool;
+
+exports.createPoolCluster = createPoolCluster;
+
+exports.createQuery = Connection.createQuery;
+
+exports.Pool = Pool;
+
+exports.PoolCluster = PoolCluster;
+
+exports.createServer = function (handler) {
+  const Server = require('./lib/server.js');
+  const s = new Server();
+  if (handler) {
+    s.on('connection', handler);
+  }
+  return s;
+};
+
+exports.PoolConnection = require('./lib/pool_connection.js');
+exports.authPlugins = require('./lib/auth_plugins');
+exports.escape = SqlString.escape;
+exports.escapeId = SqlString.escapeId;
+exports.format = SqlString.format;
+exports.raw = SqlString.raw;
+
+exports.__defineGetter__(
+  'createConnectionPromise',
+  () => require('./promise.js').createConnection
+);
+
+exports.__defineGetter__(
+  'createPoolPromise',
+  () => require('./promise.js').createPool
+);
+
+exports.__defineGetter__(
+  'createPoolClusterPromise',
+  () => require('./promise.js').createPoolCluster
+);
+
+exports.__defineGetter__('Types', () => require('./lib/constants/types.js'));
+
+exports.__defineGetter__('Charsets', () =>
+  require('./lib/constants/charsets.js')
+);
+
+exports.__defineGetter__('CharsetToEncoding', () =>
+  require('./lib/constants/charset_encodings.js')
+);
+
+exports.setMaxParserCache = function (max) {
+  parserCache.setMaxCache(max);
+};
+
+exports.clearParserCache = function () {
+  parserCache.clearCache();
+};

package/backend/node_modules/mysql2/lib/auth_41.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/*
+4.1 authentication: (http://bazaar.launchpad.net/~mysql/mysql-server/5.5/view/head:/sql/password.c)
+
+  SERVER:  public_seed=create_random_string()
+           send(public_seed)
+
+  CLIENT:  recv(public_seed)
+           hash_stage1=sha1("password")
+           hash_stage2=sha1(hash_stage1)
+           reply=xor(hash_stage1, sha1(public_seed,hash_stage2)
+
+           // this three steps are done in scramble()
+
+           send(reply)
+
+
+  SERVER:  recv(reply)
+           hash_stage1=xor(reply, sha1(public_seed,hash_stage2))
+           candidate_hash2=sha1(hash_stage1)
+           check(candidate_hash2==hash_stage2)
+
+server stores sha1(sha1(password)) ( hash_stag2)
+*/
+
+const crypto = require('crypto');
+
+function sha1(msg, msg1, msg2) {
+  const hash = crypto.createHash('sha1');
+  hash.update(msg);
+  if (msg1) {
+    hash.update(msg1);
+  }
+
+  if (msg2) {
+    hash.update(msg2);
+  }
+
+  return hash.digest();
+}
+
+function xor(a, b) {
+  const result = Buffer.allocUnsafe(a.length);
+  for (let i = 0; i < a.length; i++) {
+    result[i] = a[i] ^ b[i];
+  }
+  return result;
+}
+
+exports.xor = xor;
+
+function token(password, scramble1, scramble2) {
+  if (!password) {
+    return Buffer.alloc(0);
+  }
+  const stage1 = sha1(password);
+  return exports.calculateTokenFromPasswordSha(stage1, scramble1, scramble2);
+}
+
+exports.calculateTokenFromPasswordSha = function (
+  passwordSha,
+  scramble1,
+  scramble2
+) {
+  // we use AUTH 41 here, and we need only the bytes we just need.
+  const authPluginData1 = scramble1.slice(0, 8);
+  const authPluginData2 = scramble2.slice(0, 12);
+  const stage2 = sha1(passwordSha);
+  const stage3 = sha1(authPluginData1, authPluginData2, stage2);
+  return xor(stage3, passwordSha);
+};
+
+exports.calculateToken = token;
+
+exports.verifyToken = function (publicSeed1, publicSeed2, token, doubleSha) {
+  const hashStage1 = xor(token, sha1(publicSeed1, publicSeed2, doubleSha));
+  const candidateHash2 = sha1(hashStage1);
+  return candidateHash2.compare(doubleSha) === 0;
+};
+
+exports.doubleSha1 = function (password) {
+  return sha1(sha1(password));
+};
+
+function xorRotating(a, seed) {
+  const result = Buffer.allocUnsafe(a.length);
+  const seedLen = seed.length;
+
+  for (let i = 0; i < a.length; i++) {
+    result[i] = a[i] ^ seed[i % seedLen];
+  }
+  return result;
+}
+exports.xorRotating = xorRotating;

package/backend/node_modules/mysql2/lib/auth_plugins/caching_sha2_password.js

@@ -0,0 +1,108 @@
+'use strict';
+
+// https://mysqlserverteam.com/mysql-8-0-4-new-default-authentication-plugin-caching_sha2_password/
+
+const PLUGIN_NAME = 'caching_sha2_password';
+const crypto = require('crypto');
+const { xor, xorRotating } = require('../auth_41');
+
+const REQUEST_SERVER_KEY_PACKET = Buffer.from([2]);
+const FAST_AUTH_SUCCESS_PACKET = Buffer.from([3]);
+const PERFORM_FULL_AUTHENTICATION_PACKET = Buffer.from([4]);
+
+const STATE_INITIAL = 0;
+const STATE_TOKEN_SENT = 1;
+const STATE_WAIT_SERVER_KEY = 2;
+const STATE_FINAL = -1;
+
+function sha256(msg) {
+  const hash = crypto.createHash('sha256');
+  hash.update(msg);
+  return hash.digest();
+}
+
+function calculateToken(password, scramble) {
+  if (!password) {
+    return Buffer.alloc(0);
+  }
+  const stage1 = sha256(Buffer.from(password));
+  const stage2 = sha256(stage1);
+  const stage3 = sha256(Buffer.concat([stage2, scramble]));
+  return xor(stage1, stage3);
+}
+
+function encrypt(password, scramble, key) {
+  const stage1 = xorRotating(Buffer.from(`${password}\0`, 'utf8'), scramble);
+  return crypto.publicEncrypt(
+    {
+      key,
+      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+    },
+    stage1
+  );
+}
+
+module.exports =
+  (pluginOptions = {}) =>
+  ({ connection }) => {
+    let state = 0;
+    let scramble = null;
+
+    const password = connection.config.password;
+
+    const authWithKey = (serverKey) => {
+      const _password = encrypt(password, scramble, serverKey);
+      state = STATE_FINAL;
+      return _password;
+    };
+
+    return (data) => {
+      switch (state) {
+        case STATE_INITIAL:
+          scramble = data.slice(0, 20);
+          state = STATE_TOKEN_SENT;
+          return calculateToken(password, scramble);
+
+        case STATE_TOKEN_SENT:
+          if (FAST_AUTH_SUCCESS_PACKET.equals(data)) {
+            state = STATE_FINAL;
+            return null;
+          }
+
+          if (PERFORM_FULL_AUTHENTICATION_PACKET.equals(data)) {
+            const isSecureConnection =
+              typeof pluginOptions.overrideIsSecure === 'undefined'
+                ? connection.config.ssl || connection.config.socketPath
+                : pluginOptions.overrideIsSecure;
+            if (isSecureConnection) {
+              state = STATE_FINAL;
+              return Buffer.from(`${password}\0`, 'utf8');
+            }
+
+            // if client provides key we can save one extra roundrip on first connection
+            if (pluginOptions.serverPublicKey) {
+              return authWithKey(pluginOptions.serverPublicKey);
+            }
+
+            state = STATE_WAIT_SERVER_KEY;
+            return REQUEST_SERVER_KEY_PACKET;
+          }
+          throw new Error(
+            `Invalid AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_TOKEN_SENT state.`
+          );
+        case STATE_WAIT_SERVER_KEY:
+          if (pluginOptions.onServerPublicKey) {
+            pluginOptions.onServerPublicKey(data);
+          }
+          return authWithKey(data);
+        case STATE_FINAL:
+          throw new Error(
+            `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_FINAL state.`
+          );
+      }
+
+      throw new Error(
+        `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in state ${state}`
+      );
+    };
+  };

package/backend/node_modules/mysql2/lib/auth_plugins/caching_sha2_password.md

@@ -0,0 +1,18 @@
+##
+
+https://dev.mysql.com/doc/refman/8.0/en/caching-sha2-pluggable-authentication.html
+
+```js
+const mysql = require('mysql');
+mysql.createConnection({
+  authPlugins: {
+    caching_sha2_password: mysql.authPlugins.caching_sha2_password({
+      onServerPublikKey: function (key) {
+        console.log(key);
+      },
+      serverPublicKey: 'xxxyyy',
+      overrideIsSecure: true, //
+    }),
+  },
+});
+```

package/backend/node_modules/mysql2/lib/auth_plugins/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  caching_sha2_password: require('./caching_sha2_password'),
+  mysql_clear_password: require('./mysql_clear_password'),
+  mysql_native_password: require('./mysql_native_password'),
+  sha256_password: require('./sha256_password'),
+};

package/backend/node_modules/mysql2/lib/auth_plugins/mysql_clear_password.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function bufferFromStr(str) {
+  return Buffer.from(`${str}\0`);
+}
+
+const create_mysql_clear_password_plugin = (pluginOptions) =>
+  function mysql_clear_password_plugin({ connection, command }) {
+    const password =
+      command.password || pluginOptions.password || connection.config.password;
+
+    return function (/* pluginData */) {
+      return bufferFromStr(password);
+    };
+  };
+
+module.exports = create_mysql_clear_password_plugin;