@tachybase/module-multi-app 1.6.0 → 1.6.2

package/dist/node_modules/mariadb/lib/cmd/change-user.js

@@ -1,3 +1,8 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+// noinspection JSBitwiseOperatorUsage
+
 'use strict';
 
 const Iconv = require('iconv-lite');
@@ -5,26 +10,26 @@ const Capabilities = require('../const/capabilities');
 const Ed25519PasswordAuth = require('./handshake/auth/ed25519-password-auth');
 const NativePasswordAuth = require('./handshake/auth/native-password-auth');
 const Collations = require('../const/collations');
-const Handshake = require('./handshake/handshake');
+const Authentication = require('./handshake/authentication');
 
 /**
  * send a COM_CHANGE_USER: resets the connection and re-authenticates with the given credentials
  * see https://mariadb.com/kb/en/library/com_change_user/
  */
-class ChangeUser extends Handshake {
-  constructor(options, resolve, reject, addCommand) {
-    super(resolve, reject, () => {}, addCommand);
-    this.opts = options;
+class ChangeUser extends Authentication {
+  constructor(cmdParam, connOpts, resolve, reject, getSocket) {
+    super(cmdParam, resolve, reject, () => {}, getSocket);
+    this.configAssign(connOpts, cmdParam.opts);
   }
 
   start(out, opts, info) {
-    this.configAssign(opts, this.opts);
+    if (opts.logger.query) opts.logger.query(`CHANGE USER to '${this.opts.user || ''}'`);
     let authToken;
     const pwd = Array.isArray(this.opts.password) ? this.opts.password[0] : this.opts.password;
     switch (info.defaultPluginName) {
       case 'mysql_native_password':
       case '':
-        authToken = NativePasswordAuth.encryptPassword(pwd, info.seed, 'sha1');
+        authToken = NativePasswordAuth.encryptSha1Password(pwd, info.seed);
         break;
       case 'client_ed25519':
         authToken = Ed25519PasswordAuth.encryptPassword(pwd, info.seed);
@@ -52,8 +57,20 @@ class ChangeUser extends Handshake {
       out.writeInt8(0);
       info.database = this.opts.database;
     }
-
-    out.writeInt16(this.opts.collation.index);
+    // handle default collation.
+    if (this.opts.collation) {
+      // collation has been set using charset.
+      // If server use same charset, use server collation.
+      if (!this.opts.charset || info.collation.charset !== this.opts.collation.charset) {
+        info.collation = this.opts.collation;
+      }
+    } else {
+      // if not utf8mb4 and no configuration, force to use UTF8MB4_UNICODE_CI
+      if (info.collation.charset !== 'utf8' || info.collation.maxLength === 3) {
+        info.collation = Collations.fromIndex(224);
+      }
+    }
+    out.writeInt16(info.collation.index);
 
     if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
       out.writeString(info.defaultPluginName);
@@ -65,23 +82,23 @@ class ChangeUser extends Handshake {
       let initPos = out.pos; //save position, assuming connection attributes length will be less than 2 bytes length
       out.writeInt16(0);
 
-      const encoding = this.opts.collation.charset;
+      const encoding = info.collation.charset;
 
-      writeParam(out, '_client_name', encoding);
-      writeParam(out, 'MariaDB connector/Node', encoding);
+      writeAttribute(out, '_client_name', encoding);
+      writeAttribute(out, 'MariaDB connector/Node', encoding);
 
       let packageJson = require('../../package.json');
-      writeParam(out, '_client_version', encoding);
-      writeParam(out, packageJson.version, encoding);
+      writeAttribute(out, '_client_version', encoding);
+      writeAttribute(out, packageJson.version, encoding);
 
-      writeParam(out, '_node_version', encoding);
-      writeParam(out, process.versions.node, encoding);
+      writeAttribute(out, '_node_version', encoding);
+      writeAttribute(out, process.versions.node, encoding);
 
       if (opts.connectAttributes !== true) {
         let attrNames = Object.keys(this.opts.connectAttributes);
         for (let k = 0; k < attrNames.length; ++k) {
-          writeParam(out, attrNames[k], encoding);
-          writeParam(out, this.opts.connectAttributes[attrNames[k]], encoding);
+          writeAttribute(out, attrNames[k], encoding);
+          writeAttribute(out, this.opts.connectAttributes[attrNames[k]], encoding);
         }
       }
 
@@ -89,8 +106,8 @@ class ChangeUser extends Handshake {
       out.writeInt16AtPos(initPos);
     }
 
-    out.flushBuffer(true);
-    this.onPacketReceive = this.handshakeResult;
+    out.flush();
+    this.plugin.onPacketReceive = this.handshakeResult.bind(this);
   }
 
   /**
@@ -98,50 +115,43 @@ class ChangeUser extends Handshake {
    * a little faster than Object.assign() since doest copy all information
    *
    * @param connOpts  connection global configuration
-   * @param opt       current options
+   * @param cmdOpts   current options
    */
-  configAssign(connOpts, opt) {
-    if (!opt) {
+  configAssign(connOpts, cmdOpts) {
+    if (!cmdOpts) {
       this.opts = connOpts;
       return;
     }
-    this.opts.database = opt.database ? opt.database : connOpts.database;
-    this.opts.connectAttributes = opt.connectAttributes
-      ? opt.connectAttributes
-      : connOpts.connectAttributes;
+    this.opts = cmdOpts ? Object.assign({}, connOpts, cmdOpts) : connOpts;
 
-    if (opt.charset && typeof opt.charset === 'string') {
-      this.opts.collation = Collations.fromCharset(opt.charset.toLowerCase());
+    if (cmdOpts.charset && typeof cmdOpts.charset === 'string') {
+      this.opts.collation = Collations.fromCharset(cmdOpts.charset.toLowerCase());
       if (this.opts.collation === undefined) {
-        this.opts.collation = Collations.fromName(opt.charset.toUpperCase());
+        this.opts.collation = Collations.fromName(cmdOpts.charset.toUpperCase());
         if (this.opts.collation !== undefined) {
-          console.log(
+          this.opts.logger.warning(
             "warning: please use option 'collation' " +
               "in replacement of 'charset' when using a collation name ('" +
-              opt.charset +
+              cmdOpts.charset +
               "')\n" +
               "(collation looks like 'UTF8MB4_UNICODE_CI', charset like 'utf8')."
           );
         }
       }
-      if (this.opts.collation === undefined)
-        throw new RangeError("Unknown charset '" + opt.charset + "'");
-    } else if (opt.collation && typeof opt.collation === 'string') {
-      const initial = opt.collation;
+      if (this.opts.collation === undefined) throw new RangeError("Unknown charset '" + cmdOpts.charset + "'");
+    } else if (cmdOpts.collation && typeof cmdOpts.collation === 'string') {
+      const initial = cmdOpts.collation;
       this.opts.collation = Collations.fromName(initial.toUpperCase());
-      if (this.opts.collation === undefined)
-        throw new RangeError("Unknown collation '" + initial + "'");
+      if (this.opts.collation === undefined) throw new RangeError("Unknown collation '" + initial + "'");
     } else {
-      this.opts.collation = Collations.fromIndex(opt.charsetNumber) || connOpts.collation;
+      this.opts.collation = Collations.fromIndex(cmdOpts.charsetNumber) || connOpts.collation;
     }
-    connOpts.password = opt.password;
+    connOpts.password = cmdOpts.password;
   }
 }
 
-function writeParam(out, val, encoding) {
-  let param = Buffer.isEncoding(encoding)
-    ? Buffer.from(val, encoding)
-    : Iconv.encode(val, encoding);
+function writeAttribute(out, val, encoding) {
+  let param = Buffer.isEncoding(encoding) ? Buffer.from(val, encoding) : Iconv.encode(val, encoding);
   out.writeLengthCoded(param.length);
   out.writeBuffer(param, 0, param.length);
 }

package/dist/node_modules/mariadb/lib/cmd/class/ok-packet.js

@@ -1,6 +1,7 @@
-'use strict';
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
 
-const Command = require('../command');
+'use strict';
 
 /**
  * Ok_Packet

package/dist/node_modules/mariadb/lib/cmd/class/prepare-cache-wrapper.js

@@ -0,0 +1,46 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const PrepareWrapper = require('./prepare-wrapper');
+
+/**
+ * Prepare cache wrapper
+ * see https://mariadb.com/kb/en/com_stmt_prepare/#com_stmt_prepare_ok
+ */
+class PrepareCacheWrapper {
+  #use = 0;
+  #cached;
+  #prepare;
+
+  constructor(prepare) {
+    this.#prepare = prepare;
+    this.#cached = true;
+  }
+
+  incrementUse() {
+    this.#use += 1;
+    return new PrepareWrapper(this, this.#prepare);
+  }
+
+  unCache() {
+    this.#cached = false;
+    if (this.#use === 0) {
+      this.#prepare.close();
+    }
+  }
+
+  decrementUse() {
+    this.#use -= 1;
+    if (this.#use === 0 && !this.#cached) {
+      this.#prepare.close();
+    }
+  }
+
+  toString() {
+    return 'Prepare{use:' + this.#use + ',cached:' + this.#cached + '}';
+  }
+}
+
+module.exports = PrepareCacheWrapper;

package/dist/node_modules/mariadb/lib/cmd/class/prepare-result-packet.js

@@ -0,0 +1,141 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+const Errors = require('../../misc/errors');
+const ExecuteStream = require('../execute-stream');
+const Parser = require('../parser');
+
+/**
+ * Prepare result
+ * see https://mariadb.com/kb/en/com_stmt_prepare/#com_stmt_prepare_ok
+ */
+class PrepareResultPacket {
+  #conn;
+  constructor(statementId, parameterCount, columns, database, sql, placeHolderIndex, conn) {
+    this.id = statementId;
+    this.parameterCount = parameterCount;
+    this.columns = columns;
+    this.database = database;
+    this.query = sql;
+    this.closed = false;
+    this._placeHolderIndex = placeHolderIndex;
+    this.#conn = conn;
+  }
+
+  get conn() {
+    return this.#conn;
+  }
+
+  execute(values, opts, cb, stack) {
+    let _opts = opts,
+      _cb = cb;
+
+    if (typeof _opts === 'function') {
+      _cb = _opts;
+      _opts = undefined;
+    }
+
+    if (this.isClose()) {
+      let sql = this.query;
+      if (this.conn.opts.logParam) {
+        if (this.query.length > this.conn.opts.debugLen) {
+          sql = this.query.substring(0, this.conn.opts.debugLen) + '...';
+        } else {
+          let sqlMsg = this.query + ' - parameters:';
+          sql = Parser.logParameters(this.conn.opts, sqlMsg, values);
+        }
+      }
+
+      const error = Errors.createError(
+        `Execute fails, prepare command as already been closed`,
+        Errors.ER_PREPARE_CLOSED,
+        null,
+        '22000',
+        sql
+      );
+
+      if (!_cb) {
+        return Promise.reject(error);
+      } else {
+        _cb(error);
+        return;
+      }
+    }
+
+    const cmdParam = {
+      sql: this.query,
+      values: values,
+      opts: _opts,
+      callback: _cb
+    };
+    if (stack) cmdParam.stack = stack;
+    const conn = this.conn;
+    const promise = new Promise((resolve, reject) => conn.executePromise.call(conn, cmdParam, this, resolve, reject));
+    if (!_cb) {
+      return promise;
+    } else {
+      promise
+        .then((res) => {
+          if (_cb) _cb(null, res, null);
+        })
+        .catch(_cb || function (err) {});
+    }
+  }
+
+  executeStream(values, opts, cb, stack) {
+    let _opts = opts,
+      _cb = cb;
+
+    if (typeof _opts === 'function') {
+      _cb = _opts;
+      _opts = undefined;
+    }
+
+    if (this.isClose()) {
+      const error = Errors.createError(
+        `Execute fails, prepare command as already been closed`,
+        Errors.ER_PREPARE_CLOSED,
+        null,
+        '22000',
+        this.query
+      );
+
+      if (!_cb) {
+        throw error;
+      } else {
+        _cb(error);
+        return;
+      }
+    }
+
+    const cmdParam = {
+      sql: this.query,
+      values: values,
+      opts: _opts,
+      callback: _cb
+    };
+    if (stack) cmdParam.stack = stack;
+
+    const cmd = new ExecuteStream(cmdParam, this.conn.opts, this, this.conn.socket);
+    if (this.conn.opts.logger.error) cmd.on('error', this.conn.opts.logger.error);
+    this.conn.addCommand(cmd, true);
+    return cmd.inStream;
+  }
+
+  isClose() {
+    return this.closed;
+  }
+
+  close() {
+    if (!this.closed) {
+      this.closed = true;
+      this.#conn.emit('close_prepare', this);
+    }
+  }
+  toString() {
+    return 'Prepare{closed:' + this.closed + '}';
+  }
+}
+
+module.exports = PrepareResultPacket;

package/dist/node_modules/mariadb/lib/cmd/class/prepare-wrapper.js

@@ -0,0 +1,70 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+/**
+ * Prepare result wrapper
+ * This permit to ensure that cache can be close only one time cache.
+ */
+class PrepareWrapper {
+  #closed = false;
+  #cacheWrapper;
+  #prepare;
+  #conn;
+
+  constructor(cacheWrapper, prepare) {
+    this.#cacheWrapper = cacheWrapper;
+    this.#prepare = prepare;
+    this.#conn = prepare.conn;
+    this.execute = this.#prepare.execute;
+    this.executeStream = this.#prepare.executeStream;
+  }
+  get conn() {
+    return this.#conn;
+  }
+
+  get id() {
+    return this.#prepare.id;
+  }
+
+  get parameterCount() {
+    return this.#prepare.parameterCount;
+  }
+
+  get _placeHolderIndex() {
+    return this.#prepare._placeHolderIndex;
+  }
+
+  get columns() {
+    return this.#prepare.columns;
+  }
+
+  set columns(columns) {
+    this.#prepare.columns = columns;
+  }
+  get database() {
+    return this.#prepare.database;
+  }
+
+  get query() {
+    return this.#prepare.query;
+  }
+
+  isClose() {
+    return this.#closed;
+  }
+
+  close() {
+    if (!this.#closed) {
+      this.#closed = true;
+      this.#cacheWrapper.decrementUse();
+    }
+  }
+
+  toString() {
+    return 'PrepareWrapper{closed:' + this.#closed + ',cache:' + this.#cacheWrapper + '}';
+  }
+}
+
+module.exports = PrepareWrapper;

package/dist/node_modules/mariadb/lib/cmd/close-prepare.js

@@ -0,0 +1,38 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const Command = require('./command');
+
+/**
+ * Close prepared statement
+ * see https://mariadb.com/kb/en/3-binary-protocol-prepared-statements-com_stmt_close/
+ */
+class ClosePrepare extends Command {
+  constructor(cmdParam, resolve, reject, prepare) {
+    super(cmdParam, resolve, reject);
+    this.prepare = prepare;
+  }
+
+  start(out, opts, info) {
+    if (opts.logger.query) opts.logger.query(`CLOSE PREPARE: (${this.prepare.id}) ${this.prepare.query}`);
+    const closeCmd = new Uint8Array([
+      5,
+      0,
+      0,
+      0,
+      0x19,
+      this.prepare.id,
+      this.prepare.id >> 8,
+      this.prepare.id >> 16,
+      this.prepare.id >> 24
+    ]);
+    out.fastFlush(this, closeCmd);
+    this.onPacketReceive = null;
+    this.emit('send_end');
+    this.emit('end');
+  }
+}
+
+module.exports = ClosePrepare;