@tachybase/module-multi-app 0.23.8

package/dist/node_modules/mariadb/lib/cmd/common-text-cmd.js

@@ -0,0 +1,427 @@
+'use strict';
+
+const ResultSet = require('./resultset');
+const FieldDetail = require('../const/field-detail');
+const FieldType = require('../const/field-type');
+const Long = require('long');
+const moment = require('moment-timezone');
+const QUOTE = 0x27;
+
+class CommonText extends ResultSet {
+  constructor(resolve, reject, cmdOpts, connOpts, sql, values) {
+    super(resolve, reject);
+    this.configAssign(connOpts, cmdOpts);
+    this.sql = sql;
+    this.initialValues = values;
+    this.getDateQuote = this.opts.tz
+      ? this.opts.tz === 'Etc/UTC'
+        ? CommonText.getUtcDate
+        : CommonText.getTimezoneDate
+      : CommonText.getLocalDate;
+  }
+
+  /**
+   * Write (and escape) current parameter value to output writer
+   *
+   * @param out     output writer
+   * @param value   current parameter
+   * @param opts    connection options
+   * @param info    connection information
+   */
+  writeParam(out, value, opts, info) {
+    switch (typeof value) {
+      case 'boolean':
+        out.writeStringAscii(value ? 'true' : 'false');
+        break;
+      case 'bigint':
+      case 'number':
+        out.writeStringAscii('' + value);
+        break;
+      case 'object':
+        if (value === null) {
+          out.writeStringAscii('NULL');
+        } else if (Object.prototype.toString.call(value) === '[object Date]') {
+          out.writeStringAscii(this.getDateQuote(value, opts));
+        } else if (Buffer.isBuffer(value)) {
+          out.writeStringAscii("_BINARY '");
+          out.writeBufferEscape(value);
+          out.writeInt8(QUOTE);
+        } else if (typeof value.toSqlString === 'function') {
+          out.writeStringEscapeQuote(String(value.toSqlString()));
+        } else if (Long.isLong(value)) {
+          out.writeStringAscii(value.toString());
+        } else if (Array.isArray(value)) {
+          if (opts.arrayParenthesis) {
+            out.writeStringAscii('(');
+          }
+          for (let i = 0; i < value.length; i++) {
+            if (i !== 0) out.writeStringAscii(',');
+            this.writeParam(out, value[i], opts, info);
+          }
+          if (opts.arrayParenthesis) {
+            out.writeStringAscii(')');
+          }
+        } else {
+          if (
+            value.type != null &&
+            [
+              'Point',
+              'LineString',
+              'Polygon',
+              'MultiPoint',
+              'MultiLineString',
+              'MultiPolygon',
+              'GeometryCollection'
+            ].includes(value.type)
+          ) {
+            //GeoJSON format.
+            let prefix =
+              (info.isMariaDB() && info.hasMinVersion(10, 1, 4)) ||
+              (!info.isMariaDB() && info.hasMinVersion(5, 7, 6))
+                ? 'ST_'
+                : '';
+            switch (value.type) {
+              case 'Point':
+                out.writeStringAscii(
+                  prefix +
+                    "PointFromText('POINT(" +
+                    CommonText.geoPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'LineString':
+                out.writeStringAscii(
+                  prefix +
+                    "LineFromText('LINESTRING(" +
+                    CommonText.geoArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'Polygon':
+                out.writeStringAscii(
+                  prefix +
+                    "PolygonFromText('POLYGON(" +
+                    CommonText.geoMultiArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'MultiPoint':
+                out.writeStringAscii(
+                  prefix +
+                    "MULTIPOINTFROMTEXT('MULTIPOINT(" +
+                    CommonText.geoArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'MultiLineString':
+                out.writeStringAscii(
+                  prefix +
+                    "MLineFromText('MULTILINESTRING(" +
+                    CommonText.geoMultiArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'MultiPolygon':
+                out.writeStringAscii(
+                  prefix +
+                    "MPolyFromText('MULTIPOLYGON(" +
+                    CommonText.geoMultiPolygonToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'GeometryCollection':
+                out.writeStringAscii(
+                  prefix +
+                    "GeomCollFromText('GEOMETRYCOLLECTION(" +
+                    CommonText.geometricCollectionToString(value.geometries) +
+                    ")')"
+                );
+                break;
+            }
+          } else {
+            if (opts.permitSetMultiParamEntries) {
+              let first = true;
+              for (let key in value) {
+                const val = value[key];
+                if (typeof val === 'function') continue;
+                if (first) {
+                  first = false;
+                } else {
+                  out.writeStringAscii(',');
+                }
+                out.writeString('`' + key + '`');
+                out.writeStringAscii('=');
+                this.writeParam(out, val, opts, info);
+              }
+              if (first) out.writeStringEscapeQuote(JSON.stringify(value));
+            } else {
+              out.writeStringEscapeQuote(JSON.stringify(value));
+            }
+          }
+        }
+        break;
+      default:
+        out.writeStringEscapeQuote(value);
+    }
+  }
+
+  static geometricCollectionToString(geo) {
+    if (!geo) return '';
+    let st = '';
+    for (let i = 0; i < geo.length; i++) {
+      //GeoJSON format.
+      st += i !== 0 ? ',' : '';
+      switch (geo[i].type) {
+        case 'Point':
+          st += 'POINT(' + CommonText.geoPointToString(geo[i].coordinates) + ')';
+          break;
+
+        case 'LineString':
+          st += 'LINESTRING(' + CommonText.geoArrayPointToString(geo[i].coordinates) + ')';
+          break;
+
+        case 'Polygon':
+          st += 'POLYGON(' + CommonText.geoMultiArrayPointToString(geo[i].coordinates) + ')';
+          break;
+
+        case 'MultiPoint':
+          st += 'MULTIPOINT(' + CommonText.geoArrayPointToString(geo[i].coordinates) + ')';
+          break;
+
+        case 'MultiLineString':
+          st +=
+            'MULTILINESTRING(' + CommonText.geoMultiArrayPointToString(geo[i].coordinates) + ')';
+          break;
+
+        case 'MultiPolygon':
+          st += 'MULTIPOLYGON(' + CommonText.geoMultiPolygonToString(geo[i].coordinates) + ')';
+          break;
+      }
+    }
+    return st;
+  }
+
+  static geoMultiPolygonToString(coords) {
+    if (!coords) return '';
+    let st = '';
+    for (let i = 0; i < coords.length; i++) {
+      st += (i !== 0 ? ',(' : '(') + CommonText.geoMultiArrayPointToString(coords[i]) + ')';
+    }
+    return st;
+  }
+
+  static geoMultiArrayPointToString(coords) {
+    if (!coords) return '';
+    let st = '';
+    for (let i = 0; i < coords.length; i++) {
+      st += (i !== 0 ? ',(' : '(') + CommonText.geoArrayPointToString(coords[i]) + ')';
+    }
+    return st;
+  }
+
+  static geoArrayPointToString(coords) {
+    if (!coords) return '';
+    let st = '';
+    for (let i = 0; i < coords.length; i++) {
+      st += (i !== 0 ? ',' : '') + CommonText.geoPointToString(coords[i]);
+    }
+    return st;
+  }
+
+  static geoPointToString(coords) {
+    if (!coords) return '';
+    return (isNaN(coords[0]) ? '' : coords[0]) + ' ' + (isNaN(coords[1]) ? '' : coords[1]);
+  }
+
+  parseRowAsArray(columns, packet, connOpts) {
+    const row = new Array(this._columnCount);
+    for (let i = 0; i < this._columnCount; i++) {
+      row[i] = this._getValue(i, columns[i], this.opts, connOpts, packet);
+    }
+    return row;
+  }
+
+  parseRowNested(columns, packet, connOpts) {
+    const row = {};
+    for (let i = 0; i < this._columnCount; i++) {
+      if (!row[this.tableHeader[i][0]]) row[this.tableHeader[i][0]] = {};
+      row[this.tableHeader[i][0]][this.tableHeader[i][1]] = this._getValue(
+        i,
+        columns[i],
+        this.opts,
+        connOpts,
+        packet
+      );
+    }
+    return row;
+  }
+
+  parseRowStd(columns, packet, connOpts) {
+    const row = {};
+    for (let i = 0; i < this._columnCount; i++) {
+      row[this.tableHeader[i]] = this._getValue(i, columns[i], this.opts, connOpts, packet);
+    }
+    return row;
+  }
+
+  castTextWrapper(column, opts, connOpts, packet) {
+    column.string = () => packet.readStringLength();
+    column.buffer = () => packet.readBufferLengthEncoded();
+    column.float = () => packet.readFloatLengthCoded();
+    column.int = () => packet.readIntLengthEncoded();
+    column.long = () =>
+      packet.readLongLengthEncoded(
+        opts.supportBigInt,
+        opts.supportBigNumbers,
+        opts.bigNumberStrings,
+        (column.flags & FieldDetail.UNSIGNED) > 0
+      );
+    column.decimal = () => packet.readDecimalLengthEncoded(opts.bigNumberStrings);
+    column.date = () => packet.readDateTime(opts);
+    column.geometry = () => {
+      return column.readGeometry();
+    };
+  }
+
+  readCastValue(index, column, opts, connOpts, packet) {
+    this.castTextWrapper(column, opts, connOpts, packet);
+    return opts.typeCast(
+      column,
+      this.readRowData.bind(this, index, column, opts, connOpts, packet)
+    );
+  }
+
+  /**
+   * Read row data.
+   *
+   * @param index     current data index in row
+   * @param column    associate metadata
+   * @param opts   query options
+   * @param connOpts  connection options
+   * @param packet    row packet
+   * @returns {*}     data
+   */
+  readRowData(index, column, opts, connOpts, packet) {
+    switch (column.columnType) {
+      case FieldType.TINY:
+      case FieldType.SHORT:
+      case FieldType.LONG:
+      case FieldType.INT24:
+      case FieldType.YEAR:
+        return packet.readIntLengthEncoded();
+      case FieldType.FLOAT:
+      case FieldType.DOUBLE:
+        return packet.readFloatLengthCoded();
+      case FieldType.LONGLONG:
+        return packet.readLongLengthEncoded(
+          opts.supportBigInt,
+          opts.supportBigNumbers,
+          opts.bigNumberStrings,
+          (column.flags & FieldDetail.UNSIGNED) > 0
+        );
+      case FieldType.DECIMAL:
+      case FieldType.NEWDECIMAL:
+        return packet.readDecimalLengthEncoded(opts.bigNumberStrings);
+      case FieldType.DATE:
+        if (opts.dateStrings) {
+          return packet.readAsciiStringLengthEncoded();
+        }
+        return packet.readDate();
+      case FieldType.DATETIME:
+      case FieldType.TIMESTAMP:
+        if (opts.dateStrings) {
+          return packet.readAsciiStringLengthEncoded();
+        }
+        return packet.readDateTime(opts);
+      case FieldType.TIME:
+        return packet.readAsciiStringLengthEncoded();
+      case FieldType.GEOMETRY:
+        return packet.readGeometry(column.dataTypeName);
+      case FieldType.JSON:
+        //for mysql only => parse string as JSON object
+        return JSON.parse(packet.readStringLengthEncoded('utf8'));
+
+      default:
+        if (column.dataTypeFormat && column.dataTypeFormat === 'json' && opts.autoJsonMap) {
+          return JSON.parse(packet.readStringLengthEncoded('utf8'));
+        }
+
+        if (column.collation.index === 63) {
+          return packet.readBufferLengthEncoded();
+        }
+        const string = packet.readStringLength();
+        if (column.flags & 2048) {
+          //SET
+          return string == null ? null : string === '' ? [] : string.split(',');
+        }
+        return string;
+    }
+  }
+}
+
+function getDatePartQuote(year, mon, day, hour, min, sec, ms) {
+  //return 'YYYY-MM-DD HH:MM:SS' datetime format
+  //see https://mariadb.com/kb/en/library/datetime/
+  return (
+    "'" +
+    (year > 999 ? year : year > 99 ? '0' + year : year > 9 ? '00' + year : '000' + year) +
+    '-' +
+    (mon < 10 ? '0' : '') +
+    mon +
+    '-' +
+    (day < 10 ? '0' : '') +
+    day +
+    ' ' +
+    (hour < 10 ? '0' : '') +
+    hour +
+    ':' +
+    (min < 10 ? '0' : '') +
+    min +
+    ':' +
+    (sec < 10 ? '0' : '') +
+    sec +
+    '.' +
+    (ms > 99 ? ms : ms > 9 ? '0' + ms : '00' + ms) +
+    "'"
+  );
+}
+
+function getLocalDate(date, opts) {
+  const year = date.getFullYear();
+  const mon = date.getMonth() + 1;
+  const day = date.getDate();
+  const hour = date.getHours();
+  const min = date.getMinutes();
+  const sec = date.getSeconds();
+  const ms = date.getMilliseconds();
+  return getDatePartQuote(year, mon, day, hour, min, sec, ms);
+}
+
+function getUtcDate(date, opts) {
+  const year = date.getUTCFullYear();
+  const mon = date.getUTCMonth() + 1;
+  const day = date.getUTCDate();
+  const hour = date.getUTCHours();
+  const min = date.getUTCMinutes();
+  const sec = date.getUTCSeconds();
+  const ms = date.getUTCMilliseconds();
+  return getDatePartQuote(year, mon, day, hour, min, sec, ms);
+}
+
+function getTimezoneDate(date, opts) {
+  if (date.getMilliseconds() != 0) {
+    return moment.tz(date, opts.tz).format("'YYYY-MM-DD HH:mm:ss.SSS'");
+  }
+  return moment.tz(date, opts.tz).format("'YYYY-MM-DD HH:mm:ss'");
+}
+
+module.exports = CommonText;
+module.exports.getTimezoneDate = getTimezoneDate;
+module.exports.getUtcDate = getUtcDate;
+module.exports.getLocalDate = getLocalDate;

package/dist/node_modules/mariadb/lib/cmd/handshake/auth/caching-sha2-password-auth.js

@@ -0,0 +1,168 @@
+const PluginAuth = require('./plugin-auth');
+const fs = require('fs');
+const crypto = require('crypto');
+const Errors = require('../../../misc/errors');
+const NativePasswordAuth = require('./native-password-auth');
+const Sha256PasswordAuth = require('./sha256-password-auth');
+
+const State = {
+  INIT: 'INIT',
+  FAST_AUTH_RESULT: 'FAST_AUTH_RESULT',
+  REQUEST_SERVER_KEY: 'REQUEST_SERVER_KEY',
+  SEND_AUTH: 'SEND_AUTH'
+};
+
+/**
+ * Use caching Sha2 password authentication
+ */
+class CachingSha2PasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.pluginData = pluginData;
+    this.sequenceNo = packSeq;
+    this.counter = 0;
+    this.state = State.INIT;
+  }
+
+  start(out, opts, info) {
+    this.exchange(this.pluginData, out, opts, info);
+    this.onPacketReceive = this.response;
+  }
+
+  exchange(buffer, out, opts, info) {
+    switch (this.state) {
+      case State.INIT:
+        const truncatedSeed = this.pluginData.slice(0, this.pluginData.length - 1);
+        const encPwd = NativePasswordAuth.encryptPassword(opts.password, truncatedSeed, 'sha256');
+        out.startPacket(this);
+        if (encPwd.length > 0) {
+          out.writeBuffer(encPwd, 0, encPwd.length);
+          out.flushBuffer(true);
+        } else {
+          out.writeEmptyPacket(true);
+        }
+        this.state = State.FAST_AUTH_RESULT;
+        return;
+
+      case State.FAST_AUTH_RESULT:
+        // length encoded numeric : 0x01 0x03/0x04
+        const fastAuthResult = buffer[1];
+        switch (fastAuthResult) {
+          case 0x03:
+            // success authentication
+            this.emit('send_end');
+            return this.successSend(packet, out, opts, info);
+
+          case 0x04:
+            if (opts.ssl) {
+              // using SSL, so sending password in clear
+              out.startPacket(this);
+              out.writeString(opts.password);
+              out.writeInt8(0);
+              out.flushBuffer(true);
+              return;
+            }
+
+            // retrieve public key from configuration or from server
+            if (opts.cachingRsaPublicKey) {
+              try {
+                let key = opts.cachingRsaPublicKey;
+                if (!key.includes('-----BEGIN')) {
+                  // rsaPublicKey contain path
+                  key = fs.readFileSync(key, 'utf8');
+                }
+                this.publicKey = Sha256PasswordAuth.retreivePublicKey(key);
+              } catch (err) {
+                return this.throwError(err, info);
+              }
+              // send Sha256Password Packet
+              Sha256PasswordAuth.sendSha256PwdPacket(
+                this,
+                this.pluginData,
+                this.publicKey,
+                opts.password,
+                out
+              );
+            } else {
+              if (!opts.allowPublicKeyRetrieval) {
+                return this.throwError(
+                  Errors.createError(
+                    'RSA public key is not available client side. Either set option `cachingRsaPublicKey` to indicate' +
+                      ' public key path, or allow public key retrieval with option `allowPublicKeyRetrieval`',
+                    null,
+                    true,
+                    info,
+                    '08S01',
+                    Errors.ER_CANNOT_RETRIEVE_RSA_KEY
+                  ),
+                  info
+                );
+              }
+              this.state = State.REQUEST_SERVER_KEY;
+              // ask caching public Key Retrieval
+              out.startPacket(this);
+              out.writeInt8(0x02);
+              out.flushBuffer(true);
+            }
+            return;
+        }
+
+      case State.REQUEST_SERVER_KEY:
+        this.publicKey = Sha256PasswordAuth.retreivePublicKey(buffer.toString('utf8', 1));
+        this.state = State.SEND_AUTH;
+        Sha256PasswordAuth.sendSha256PwdPacket(
+          this,
+          this.pluginData,
+          this.publicKey,
+          opts.password,
+          out
+        );
+    }
+  }
+
+  static retreivePublicKey(key) {
+    return key.replace('(-+BEGIN PUBLIC KEY-+\\r?\\n|\\n?-+END PUBLIC KEY-+\\r?\\n?)', '');
+  }
+
+  static sendSha256PwdPacket(cmd, pluginData, publicKey, password, out) {
+    const truncatedSeed = pluginData.slice(0, pluginData.length - 1);
+    out.startPacket(cmd);
+    const enc = Sha256PasswordAuth.encrypt(truncatedSeed, password, publicKey);
+    out.writeBuffer(enc, 0, enc.length);
+    out.flushBuffer(cmd);
+  }
+
+  // encrypt password with public key
+  static encrypt(seed, password, publicKey) {
+    const nullFinishedPwd = Buffer.from(password + '\0');
+    const xorBytes = Buffer.allocUnsafe(nullFinishedPwd.length);
+    const seedLength = seed.length;
+    for (let i = 0; i < xorBytes.length; i++) {
+      xorBytes[i] = nullFinishedPwd[i] ^ seed[i % seedLength];
+    }
+    return crypto.publicEncrypt(
+      { key: publicKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
+      xorBytes
+    );
+  }
+
+  response(packet, out, opts, info) {
+    const marker = packet.peek();
+    switch (marker) {
+      //*********************************************************************************************************
+      //* OK_Packet and Err_Packet ending packet
+      //*********************************************************************************************************
+      case 0x00:
+      case 0xff:
+        this.emit('send_end');
+        return this.successSend(packet, out, opts, info);
+
+      default:
+        let promptData = packet.readBufferRemaining();
+        this.exchange(promptData, out, opts, info);
+        this.onPacketReceive = this.response;
+    }
+  }
+}
+
+module.exports = CachingSha2PasswordAuth;

package/dist/node_modules/mariadb/lib/cmd/handshake/auth/clear-password-auth.js

@@ -0,0 +1,23 @@
+const PluginAuth = require('./plugin-auth');
+
+/**
+ * Send password in clear.
+ * (used only when SSL is active)
+ */
+class ClearPasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.sequenceNo = packSeq;
+  }
+
+  start(out, opts, info) {
+    out.startPacket(this);
+    if (opts.password) out.writeString(opts.password);
+    out.writeInt8(0);
+    out.flushBuffer(true);
+    this.emit('send_end');
+    this.onPacketReceive = this.successSend;
+  }
+}
+
+module.exports = ClearPasswordAuth;