@tachybase/module-multi-app 0.23.8

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

@@ -0,0 +1,149 @@
+'use strict';
+
+const Iconv = require('iconv-lite');
+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');
+
+/**
+ * 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;
+  }
+
+  start(out, opts, info) {
+    this.configAssign(opts, this.opts);
+    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');
+        break;
+      case 'client_ed25519':
+        authToken = Ed25519PasswordAuth.encryptPassword(pwd, info.seed);
+        break;
+      default:
+        authToken = Buffer.alloc(0);
+        break;
+    }
+
+    out.startPacket(this);
+    out.writeInt8(0x11);
+    out.writeString(this.opts.user || '');
+    out.writeInt8(0);
+
+    if (info.serverCapabilities & Capabilities.SECURE_CONNECTION) {
+      out.writeInt8(authToken.length);
+      out.writeBuffer(authToken, 0, authToken.length);
+    } else {
+      out.writeBuffer(authToken, 0, authToken.length);
+      out.writeInt8(0);
+    }
+
+    if (info.clientCapabilities & Capabilities.CONNECT_WITH_DB) {
+      out.writeString(this.opts.database);
+      out.writeInt8(0);
+      info.database = this.opts.database;
+    }
+
+    out.writeInt16(this.opts.collation.index);
+
+    if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
+      out.writeString(info.defaultPluginName);
+      out.writeInt8(0);
+    }
+
+    if (info.clientCapabilities & Capabilities.CONNECT_ATTRS) {
+      out.writeInt8(0xfc);
+      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;
+
+      writeParam(out, '_client_name', encoding);
+      writeParam(out, 'MariaDB connector/Node', encoding);
+
+      let packageJson = require('../../package.json');
+      writeParam(out, '_client_version', encoding);
+      writeParam(out, packageJson.version, encoding);
+
+      writeParam(out, '_node_version', encoding);
+      writeParam(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);
+        }
+      }
+
+      //write end size
+      out.writeInt16AtPos(initPos);
+    }
+
+    out.flushBuffer(true);
+    this.onPacketReceive = this.handshakeResult;
+  }
+
+  /**
+   * Assign global configuration option used by result-set to current query option.
+   * a little faster than Object.assign() since doest copy all information
+   *
+   * @param connOpts  connection global configuration
+   * @param opt       current options
+   */
+  configAssign(connOpts, opt) {
+    if (!opt) {
+      this.opts = connOpts;
+      return;
+    }
+    this.opts.database = opt.database ? opt.database : connOpts.database;
+    this.opts.connectAttributes = opt.connectAttributes
+      ? opt.connectAttributes
+      : connOpts.connectAttributes;
+
+    if (opt.charset && typeof opt.charset === 'string') {
+      this.opts.collation = Collations.fromCharset(opt.charset.toLowerCase());
+      if (this.opts.collation === undefined) {
+        this.opts.collation = Collations.fromName(opt.charset.toUpperCase());
+        if (this.opts.collation !== undefined) {
+          console.log(
+            "warning: please use option 'collation' " +
+              "in replacement of 'charset' when using a collation name ('" +
+              opt.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;
+      this.opts.collation = Collations.fromName(initial.toUpperCase());
+      if (this.opts.collation === undefined)
+        throw new RangeError("Unknown collation '" + initial + "'");
+    } else {
+      this.opts.collation = Collations.fromIndex(opt.charsetNumber) || connOpts.collation;
+    }
+    connOpts.password = opt.password;
+  }
+}
+
+function writeParam(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);
+}
+
+module.exports = ChangeUser;

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

@@ -0,0 +1,17 @@
+'use strict';
+
+const Command = require('../command');
+
+/**
+ * Ok_Packet
+ * see https://mariadb.com/kb/en/ok_packet/
+ */
+class OkPacket {
+  constructor(affectedRows, insertId, warningStatus) {
+    this.affectedRows = affectedRows;
+    this.insertId = insertId;
+    this.warningStatus = warningStatus;
+  }
+}
+
+module.exports = OkPacket;

package/dist/node_modules/mariadb/lib/cmd/column-definition.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const Collations = require('../const/collations.js');
+const FieldType = require('../const/field-type');
+const Capabilities = require('../const/capabilities');
+
+/**
+ * Column definition
+ * see https://mariadb.com/kb/en/library/resultset/#column-definition-packet
+ */
+class ColumnDef {
+  constructor(packet, info) {
+    this._parse = new StringParser(packet);
+    if (info.serverCapabilities & Capabilities.MARIADB_CLIENT_EXTENDED_TYPE_INFO) {
+      const subPacket = packet.subPacketLengthEncoded();
+      while (subPacket.remaining()) {
+        switch (subPacket.readUInt8()) {
+          case 0:
+            this.dataTypeName = subPacket.readAsciiStringLengthEncoded();
+            break;
+
+          case 1:
+            this.dataTypeFormat = subPacket.readAsciiStringLengthEncoded();
+            break;
+
+          default:
+            // skip data
+            const len = subPacket.readUnsignedLength();
+            if (len) {
+              subPacket.skip(len);
+            }
+            break;
+        }
+      }
+    }
+
+    packet.skip(1); // length of fixed fields
+    this.collation = Collations.fromIndex(packet.readUInt16());
+    this.columnLength = packet.readUInt32();
+    this.columnType = packet.readUInt8();
+    this.flags = packet.readUInt16();
+    this.scale = packet.readUInt8();
+    this.type = FieldType.TYPES[this.columnType];
+  }
+
+  db() {
+    return this._parse.packet.readString(this._parse.dbOffset, this._parse.dbLength);
+  }
+
+  schema() {
+    return this._parse.packet.readString(this._parse.dbOffset, this._parse.dbLength);
+  }
+
+  table() {
+    return this._parse.packet.readString(this._parse.tableOffset, this._parse.tableLength);
+  }
+
+  orgTable() {
+    return this._parse.packet.readString(this._parse.orgTableOffset, this._parse.orgTableLength);
+  }
+
+  name() {
+    return this._parse.packet.readString(this._parse.nameOffset, this._parse.nameLength);
+  }
+
+  orgName() {
+    return this._parse.packet.readString(this._parse.orgNameOffset, this._parse.orgNameLength);
+  }
+}
+
+/**
+ * String parser.
+ * This object permits to avoid listing all private information to metadata object.
+ */
+class StringParser {
+  constructor(packet) {
+    packet.skip(4); // skip 'def'
+
+    this.dbLength = packet.readUnsignedLength();
+    this.dbOffset = packet.pos;
+    packet.skip(this.dbLength);
+
+    this.tableLength = packet.readUnsignedLength();
+    this.tableOffset = packet.pos;
+    packet.skip(this.tableLength);
+
+    this.orgTableLength = packet.readUnsignedLength();
+    this.orgTableOffset = packet.pos;
+    packet.skip(this.orgTableLength);
+
+    this.nameLength = packet.readUnsignedLength();
+    this.nameOffset = packet.pos;
+    packet.skip(this.nameLength);
+
+    this.orgNameLength = packet.readUnsignedLength();
+    this.orgNameOffset = packet.pos;
+    packet.skip(this.orgNameLength);
+    this.packet = packet;
+  }
+}
+
+module.exports = ColumnDef;

package/dist/node_modules/mariadb/lib/cmd/command.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const EventEmitter = require('events');
+const Errors = require('../misc/errors');
+const ServerStatus = require('../const/server-status');
+const StateChange = require('../const/state-change');
+const Collations = require('../const/collations');
+const OkPacket = require('./class/ok-packet');
+
+/**
+ * Default command interface.
+ */
+class Command extends EventEmitter {
+  constructor(resolve, reject) {
+    super();
+    this.sequenceNo = -1;
+    this.compressSequenceNo = -1;
+    this.resolve = resolve;
+    this.reject = reject;
+    this.sending = false;
+  }
+
+  displaySql() {
+    return null;
+  }
+
+  /**
+   * Throw an an unexpected error.
+   * server exchange will still be read to keep connection in a good state, but promise will be rejected.
+   *
+   * @param msg message
+   * @param fatal is error fatal for connection
+   * @param info current server state information
+   * @param sqlState error sqlState
+   * @param errno error number
+   */
+  throwUnexpectedError(msg, fatal, info, sqlState, errno) {
+    if (this.reject) {
+      process.nextTick(
+        this.reject,
+        Errors.createError(msg, this.displaySql(), fatal, info, sqlState, errno, this.stack, false)
+      );
+      this.resolve = null;
+      this.reject = null;
+    }
+  }
+
+  /**
+   * Create and throw new Error from error information
+   * only first called throwing an error or successfully end will be executed.
+   *
+   * @param msg message
+   * @param fatal is error fatal for connection
+   * @param info current server state information
+   * @param sqlState error sqlState
+   * @param errno error number
+   */
+  throwNewError(msg, fatal, info, sqlState, errno) {
+    this.onPacketReceive = null;
+    if (this.reject) {
+      process.nextTick(
+        this.reject,
+        Errors.createError(msg, this.displaySql(), fatal, info, sqlState, errno, this.stack, false)
+      );
+      this.resolve = null;
+      this.reject = null;
+    }
+    this.emit('end');
+  }
+
+  /**
+   * Throw Error
+   *  only first called throwing an error or successfully end will be executed.
+   *
+   * @param err error to be thrown
+   * @param info current server state information
+   */
+  throwError(err, info) {
+    this.onPacketReceive = null;
+    if (this.reject) {
+      if (this.stack) {
+        err = Errors.createError(
+          err.message,
+          err.sql,
+          err.fatal,
+          info,
+          err.sqlState,
+          err.errno,
+          this.stack,
+          false
+        );
+      }
+      this.resolve = null;
+      process.nextTick(this.reject, err);
+      this.reject = null;
+    }
+    this.emit('end', err);
+  }
+
+  /**
+   * Successfully end command.
+   * only first called throwing an error or successfully end will be executed.
+   *
+   * @param val return value.
+   */
+  successEnd(val) {
+    this.onPacketReceive = null;
+    if (this.resolve) {
+      this.reject = null;
+      process.nextTick(this.resolve, val);
+      this.resolve = null;
+    }
+    this.emit('end');
+  }
+
+  parseOkPacket(packet, out, opts, info) {
+    packet.skip(1); //skip header
+
+    const affectedRows = packet.readUnsignedLength();
+    const insertId = opts.supportBigInt
+      ? packet.readSignedLengthBigInt()
+      : packet.readSignedLength();
+
+    info.status = packet.readUInt16();
+
+    const okPacket = new OkPacket(affectedRows, insertId, packet.readUInt16());
+
+    if (info.status & ServerStatus.SESSION_STATE_CHANGED) {
+      packet.skipLengthCodedNumber();
+      while (packet.remaining()) {
+        const subPacket = packet.subPacketLengthEncoded();
+        while (subPacket.remaining()) {
+          const type = subPacket.readUInt8();
+          switch (type) {
+            case StateChange.SESSION_TRACK_SYSTEM_VARIABLES:
+              const subSubPacket = subPacket.subPacketLengthEncoded();
+              const variable = subSubPacket.readStringLength();
+              const value = subSubPacket.readStringLength();
+
+              switch (variable) {
+                case 'character_set_client':
+                  opts.collation = Collations.fromCharset(value);
+                  if (opts.collation === undefined) {
+                    this.throwError(new Error("unknown charset : '" + value + "'"), info);
+                    return;
+                  }
+                  opts.emit('collation', opts.collation);
+                  break;
+
+                default:
+                //variable not used by driver
+              }
+              break;
+
+            case StateChange.SESSION_TRACK_SCHEMA:
+              const subSubPacket2 = subPacket.subPacketLengthEncoded();
+              info.database = subSubPacket2.readStringLength();
+              break;
+          }
+        }
+      }
+    }
+
+    return okPacket;
+  }
+}
+
+module.exports = Command;