@tachybase/module-multi-app 1.6.0 → 1.6.2

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

@@ -0,0 +1,311 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const QUOTE = 0x27;
+
+// Cache common GeoJSON types
+const GEO_TYPES = new Set([
+  'Point',
+  'LineString',
+  'Polygon',
+  'MultiPoint',
+  'MultiLineString',
+  'MultiPolygon',
+  'GeometryCollection'
+]);
+
+// Optimized function to pad numbers with leading zeros
+const formatDigit = function (val, significantDigit) {
+  const str = `${val}`;
+  return str.length < significantDigit ? '0'.repeat(significantDigit - str.length) + str : str;
+};
+
+class TextEncoder {
+  /**
+   * Write (and escape) current parameter value to output writer
+   *
+   * @param out     output writer
+   * @param value   current parameter. Expected to be non-null
+   * @param opts    connection options
+   * @param info    connection information
+   */
+  static 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 'string':
+        out.writeStringEscapeQuote(value);
+        break;
+      case 'object':
+        if (Object.prototype.toString.call(value) === '[object Date]') {
+          out.writeStringAscii(TextEncoder.getLocalDate(value));
+        } 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 (Array.isArray(value)) {
+          if (opts.arrayParenthesis) {
+            out.writeStringAscii('(');
+          }
+          for (let i = 0; i < value.length; i++) {
+            if (i !== 0) out.writeStringAscii(',');
+            if (value[i] == null) {
+              out.writeStringAscii('NULL');
+            } else TextEncoder.writeParam(out, value[i], opts, info);
+          }
+
+          if (opts.arrayParenthesis) {
+            out.writeStringAscii(')');
+          }
+        } else {
+          if (value.type != null && GEO_TYPES.has(value.type)) {
+            //GeoJSON format.
+            const isMariaDb = info.isMariaDB();
+            const prefix =
+              (isMariaDb && info.hasMinVersion(10, 1, 4)) || (!isMariaDb && info.hasMinVersion(5, 7, 6)) ? 'ST_' : '';
+
+            switch (value.type) {
+              case 'Point':
+                out.writeStringAscii(
+                  prefix + "PointFromText('POINT(" + TextEncoder.geoPointToString(value.coordinates) + ")')"
+                );
+                break;
+
+              case 'LineString':
+                out.writeStringAscii(
+                  prefix + "LineFromText('LINESTRING(" + TextEncoder.geoArrayPointToString(value.coordinates) + ")')"
+                );
+                break;
+
+              case 'Polygon':
+                out.writeStringAscii(
+                  prefix +
+                    "PolygonFromText('POLYGON(" +
+                    TextEncoder.geoMultiArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'MultiPoint':
+                out.writeStringAscii(
+                  prefix +
+                    "MULTIPOINTFROMTEXT('MULTIPOINT(" +
+                    TextEncoder.geoArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'MultiLineString':
+                out.writeStringAscii(
+                  prefix +
+                    "MLineFromText('MULTILINESTRING(" +
+                    TextEncoder.geoMultiArrayPointToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'MultiPolygon':
+                out.writeStringAscii(
+                  prefix +
+                    "MPolyFromText('MULTIPOLYGON(" +
+                    TextEncoder.geoMultiPolygonToString(value.coordinates) +
+                    ")')"
+                );
+                break;
+
+              case 'GeometryCollection':
+                out.writeStringAscii(
+                  prefix +
+                    "GeomCollFromText('GEOMETRYCOLLECTION(" +
+                    TextEncoder.geometricCollectionToString(value.geometries) +
+                    ")')"
+                );
+                break;
+            }
+          } else if (String === value.constructor) {
+            out.writeStringEscapeQuote(value);
+            break;
+          } else {
+            if (opts.permitSetMultiParamEntries) {
+              let first = true;
+              for (const key in value) {
+                const val = value[key];
+                if (typeof val === 'function') continue;
+
+                if (first) {
+                  first = false;
+                } else {
+                  out.writeStringAscii(',');
+                }
+
+                out.writeString('`' + key + '`');
+
+                if (val == null) {
+                  out.writeStringAscii('=NULL');
+                } else {
+                  out.writeStringAscii('=');
+                  TextEncoder.writeParam(out, val, opts, info);
+                }
+              }
+              if (first) out.writeStringEscapeQuote(JSON.stringify(value));
+            } else {
+              out.writeStringEscapeQuote(JSON.stringify(value));
+            }
+          }
+        }
+        break;
+    }
+  }
+
+  static geometricCollectionToString(geo) {
+    if (!geo) return '';
+
+    const len = geo.length;
+    let st = '';
+
+    for (let i = 0; i < len; i++) {
+      const item = geo[i];
+      //GeoJSON format.
+      if (i !== 0) st += ',';
+
+      switch (item.type) {
+        case 'Point':
+          st += `POINT(${TextEncoder.geoPointToString(item.coordinates)})`;
+          break;
+
+        case 'LineString':
+          st += `LINESTRING(${TextEncoder.geoArrayPointToString(item.coordinates)})`;
+          break;
+
+        case 'Polygon':
+          st += `POLYGON(${TextEncoder.geoMultiArrayPointToString(item.coordinates)})`;
+          break;
+
+        case 'MultiPoint':
+          st += `MULTIPOINT(${TextEncoder.geoArrayPointToString(item.coordinates)})`;
+          break;
+
+        case 'MultiLineString':
+          st += `MULTILINESTRING(${TextEncoder.geoMultiArrayPointToString(item.coordinates)})`;
+          break;
+
+        case 'MultiPolygon':
+          st += `MULTIPOLYGON(${TextEncoder.geoMultiPolygonToString(item.coordinates)})`;
+          break;
+      }
+    }
+    return st;
+  }
+
+  static geoMultiPolygonToString(coords) {
+    if (!coords) return '';
+
+    const len = coords.length;
+    if (len === 0) return '';
+
+    let st = '(';
+
+    for (let i = 0; i < len; i++) {
+      if (i !== 0) st += ',(';
+      st += TextEncoder.geoMultiArrayPointToString(coords[i]) + ')';
+    }
+
+    return st;
+  }
+
+  static geoMultiArrayPointToString(coords) {
+    if (!coords) return '';
+
+    const len = coords.length;
+    if (len === 0) return '';
+
+    let st = '(';
+
+    for (let i = 0; i < len; i++) {
+      if (i !== 0) st += ',(';
+      st += TextEncoder.geoArrayPointToString(coords[i]) + ')';
+    }
+
+    return st;
+  }
+
+  static geoArrayPointToString(coords) {
+    if (!coords) return '';
+
+    const len = coords.length;
+    if (len === 0) return '';
+
+    let st = '';
+
+    for (let i = 0; i < len; i++) {
+      if (i !== 0) st += ',';
+      st += TextEncoder.geoPointToString(coords[i]);
+    }
+
+    return st;
+  }
+
+  static geoPointToString(coords) {
+    if (!coords) return '';
+    const x = isNaN(coords[0]) ? '' : coords[0];
+    const y = isNaN(coords[1]) ? '' : coords[1];
+    return x + ' ' + y;
+  }
+
+  static getLocalDate(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    const ms = date.getMilliseconds();
+
+    const d = "'" + year + '-' + month + '-' + day + ' ' + hours + ':' + minutes + ':' + seconds;
+
+    if (ms === 0) return d + "'";
+
+    return d + '.' + (ms < 10 ? '00' : ms < 100 ? '0' : '') + ms + "'";
+  }
+
+  static getFixedFormatDate(date) {
+    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();
+
+    let result =
+      "'" +
+      formatDigit(year, 4) +
+      '-' +
+      formatDigit(mon, 2) +
+      '-' +
+      formatDigit(day, 2) +
+      ' ' +
+      formatDigit(hour, 2) +
+      ':' +
+      formatDigit(min, 2) +
+      ':' +
+      formatDigit(sec, 2);
+
+    if (ms > 0) {
+      result += '.' + formatDigit(ms, 3);
+    }
+
+    return result + "'";
+  }
+}
+
+module.exports = TextEncoder;

package/dist/node_modules/mariadb/lib/cmd/execute-stream.js

@@ -0,0 +1,61 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const Execute = require('./execute');
+const { Readable } = require('stream');
+
+/**
+ * Protocol COM_STMT_EXECUTE with streaming events.
+ * see : https://mariadb.com/kb/en/com_stmt_execute/
+ */
+class ExecuteStream extends Execute {
+  constructor(cmdParam, connOpts, prepare, socket) {
+    super(
+      () => {},
+      () => {},
+      connOpts,
+      cmdParam,
+      prepare
+    );
+    this.socket = socket;
+    this.inStream = new Readable({
+      objectMode: true,
+      read: () => {
+        this.socket.resume();
+      }
+    });
+
+    this.on('fields', function (meta) {
+      this.inStream.emit('fields', meta);
+    });
+
+    this.on('error', function (err) {
+      this.inStream.emit('error', err);
+    });
+
+    this.on('close', function (err) {
+      this.inStream.emit('error', err);
+    });
+
+    this.on('end', function (err) {
+      if (err) this.inStream.emit('error', err);
+      this.socket.resume();
+      this.inStream.push(null);
+    });
+
+    this.inStream.close = function () {
+      this.handleNewRows = () => {};
+      this.socket.resume();
+    }.bind(this);
+  }
+
+  handleNewRows(row) {
+    if (!this.inStream.push(row)) {
+      this.socket.pause();
+    }
+  }
+}
+
+module.exports = ExecuteStream;

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

@@ -0,0 +1,338 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const Parser = require('./parser');
+const Errors = require('../misc/errors');
+const BinaryEncoder = require('./encoder/binary-encoder');
+const FieldType = require('../const/field-type');
+const Parse = require('../misc/parse');
+
+/**
+ * Protocol COM_STMT_EXECUTE
+ * see : https://mariadb.com/kb/en/com_stmt_execute/
+ */
+class Execute extends Parser {
+  constructor(resolve, reject, connOpts, cmdParam, prepare) {
+    super(resolve, reject, connOpts, cmdParam);
+    this.binary = true;
+    this.prepare = prepare;
+    this.canSkipMeta = true;
+  }
+
+  /**
+   * Send COM_QUERY
+   *
+   * @param out   output writer
+   * @param opts  connection options
+   * @param info  connection information
+   */
+  start(out, opts, info) {
+    this.onPacketReceive = this.readResponsePacket;
+    this.values = [];
+
+    if (this.opts.namedPlaceholders) {
+      if (this.prepare) {
+        // using named placeholders, so change values accordingly
+        this.values = new Array(this.prepare.parameterCount);
+        this.placeHolderIndex = this.prepare._placeHolderIndex;
+      } else {
+        const res = Parse.searchPlaceholder(this.sql);
+        this.placeHolderIndex = res.placeHolderIndex;
+        this.values = new Array(this.placeHolderIndex.length);
+      }
+      if (this.initialValues) {
+        for (let i = 0; i < this.placeHolderIndex.length; i++) {
+          this.values[i] = this.initialValues[this.placeHolderIndex[i]];
+        }
+      }
+    } else {
+      if (this.initialValues)
+        this.values = Array.isArray(this.initialValues) ? this.initialValues : [this.initialValues];
+    }
+    this.parameterCount = this.prepare ? this.prepare.parameterCount : this.values.length;
+
+    if (!this.validateParameters(info)) return;
+
+    // fill parameter data type
+    this.parametersType = new Array(this.parameterCount);
+    let hasLongData = false; // send long data
+    let val;
+    for (let i = 0; i < this.parameterCount; i++) {
+      val = this.values[i];
+      // special check for GEOJSON that can be null even if object is not
+      if (
+        val &&
+        val.type != null &&
+        [
+          'Point',
+          'LineString',
+          'Polygon',
+          'MultiPoint',
+          'MultiLineString',
+          'MultiPolygon',
+          'GeometryCollection'
+        ].includes(val.type)
+      ) {
+        const geoBuff = BinaryEncoder.getBufferFromGeometryValue(val);
+        if (geoBuff == null) {
+          this.values[i] = null;
+          val = null;
+        } else {
+          this.values[i] = Buffer.concat([
+            Buffer.from([0, 0, 0, 0]), // SRID
+            geoBuff // WKB
+          ]);
+          val = this.values[i];
+        }
+      }
+      if (val == null) {
+        this.parametersType[i] = NULL_PARAM_TYPE;
+      } else {
+        switch (typeof val) {
+          case 'boolean':
+            this.parametersType[i] = BOOLEAN_TYPE;
+            break;
+          case 'bigint':
+            if (val >= 2n ** 63n) {
+              this.parametersType[i] = BIG_BIGINT_TYPE;
+            } else {
+              this.parametersType[i] = BIGINT_TYPE;
+            }
+            break;
+          case 'number':
+            // additional verification, to permit query without type,
+            // like 'SELECT ?' returning same type of value
+            if (Number.isInteger(val) && val >= -2147483648 && val < 2147483647) {
+              this.parametersType[i] = INT_TYPE;
+              break;
+            }
+            this.parametersType[i] = DOUBLE_TYPE;
+            break;
+          case 'string':
+            this.parametersType[i] = STRING_TYPE;
+            break;
+          case 'object':
+            if (Object.prototype.toString.call(val) === '[object Date]') {
+              this.parametersType[i] = DATE_TYPE;
+            } else if (Buffer.isBuffer(val)) {
+              if (val.length < 16384 || !this.prepare) {
+                this.parametersType[i] = BLOB_TYPE;
+              } else {
+                this.parametersType[i] = LONGBLOB_TYPE;
+                hasLongData = true;
+              }
+            } else if (typeof val.toSqlString === 'function') {
+              this.parametersType[i] = STRING_FCT_TYPE;
+            } else if (typeof val.pipe === 'function' && typeof val.read === 'function') {
+              hasLongData = true;
+              this.parametersType[i] = STREAM_TYPE;
+            } else if (String === val.constructor) {
+              this.parametersType[i] = STRING_TOSTR_TYPE;
+            } else {
+              this.parametersType[i] = STRINGIFY_TYPE;
+            }
+            break;
+        }
+      }
+    }
+
+    // send long data using COM_STMT_SEND_LONG_DATA
+    this.longDataStep = false; // send long data
+    if (hasLongData) {
+      for (let i = 0; i < this.parameterCount; i++) {
+        if (this.parametersType[i].isLongData()) {
+          if (opts.logger.query)
+            opts.logger.query(
+              `EXECUTE: (${this.prepare ? this.prepare.id : -1}) sql: ${opts.logParam ? this.displaySql() : this.sql}`
+            );
+          if (!this.longDataStep) {
+            this.longDataStep = true;
+            this.registerStreamSendEvent(out, info);
+            this.currentParam = i;
+          }
+          this.sendComStmtLongData(out, info, this.values[i]);
+          return;
+        }
+      }
+    }
+
+    if (!this.longDataStep) {
+      // no stream parameter, so can send directly
+      if (opts.logger.query)
+        opts.logger.query(
+          `EXECUTE: (${this.prepare ? this.prepare.id : -1}) sql: ${opts.logParam ? this.displaySql() : this.sql}`
+        );
+      this.sendComStmtExecute(out, info);
+    }
+  }
+
+  /**
+   * Validate that parameters exists and are defined.
+   *
+   * @param info        connection info
+   * @returns {boolean} return false if any error occur.
+   */
+  validateParameters(info) {
+    //validate parameter size.
+    if (this.parameterCount > this.values.length) {
+      this.sendCancelled(
+        `Parameter at position ${this.values.length} is not set\\nsql: ${
+          this.opts.logParam ? this.displaySql() : this.sql
+        }`,
+        Errors.ER_MISSING_PARAMETER,
+        info
+      );
+      return false;
+    }
+
+    // validate placeholder
+    if (this.opts.namedPlaceholders && this.placeHolderIndex) {
+      for (let i = 0; i < this.parameterCount; i++) {
+        if (this.values[i] === undefined) {
+          let errMsg = `Parameter named ${this.placeHolderIndex[i]} is not set`;
+          if (this.placeHolderIndex.length < this.parameterCount) {
+            errMsg = `Command expect ${this.parameterCount} parameters, but found only ${this.placeHolderIndex.length} named parameters. You probably use question mark in place of named parameters`;
+          }
+          this.sendCancelled(errMsg, Errors.ER_PARAMETER_UNDEFINED, info);
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  sendComStmtLongData(out, info, value) {
+    out.startPacket(this);
+    out.writeInt8(0x18);
+    out.writeInt32(this.prepare.id);
+    out.writeInt16(this.currentParam);
+
+    if (Buffer.isBuffer(value)) {
+      out.writeBuffer(value, 0, value.length);
+      out.flush();
+      this.currentParam++;
+      return this.paramWritten();
+    }
+    this.sending = true;
+
+    // streaming
+    value.on('data', function (chunk) {
+      out.writeBuffer(chunk, 0, chunk.length);
+    });
+
+    value.on(
+      'end',
+      function () {
+        out.flush();
+        this.currentParam++;
+        this.paramWritten();
+      }.bind(this)
+    );
+  }
+
+  /**
+   * Send a COM_STMT_EXECUTE
+   * @param out
+   * @param info
+   */
+  sendComStmtExecute(out, info) {
+    let nullCount = ~~((this.parameterCount + 7) / 8);
+    const nullBitsBuffer = Buffer.alloc(nullCount);
+    for (let i = 0; i < this.parameterCount; i++) {
+      if (this.values[i] == null) {
+        nullBitsBuffer[~~(i / 8)] |= 1 << i % 8;
+      }
+    }
+
+    out.startPacket(this);
+    out.writeInt8(0x17); // COM_STMT_EXECUTE
+    out.writeInt32(this.prepare ? this.prepare.id : -1); // Statement id
+    out.writeInt8(0); // no cursor flag
+    out.writeInt32(1); // 1 command
+    out.writeBuffer(nullBitsBuffer, 0, nullCount); // null buffer
+    out.writeInt8(1); // always send type to server
+
+    // send types
+    for (let i = 0; i < this.parameterCount; i++) {
+      out.writeInt8(this.parametersType[i].type);
+      out.writeInt8(0);
+    }
+
+    //********************************************
+    // send not null / not streaming values
+    //********************************************
+    for (let i = 0; i < this.parameterCount; i++) {
+      const parameterType = this.parametersType[i];
+      if (parameterType.encoder) parameterType.encoder(out, this.values[i]);
+    }
+    out.flush();
+    this.sending = false;
+    this.emit('send_end');
+  }
+
+  /**
+   * Define params events.
+   * Each parameter indicate that he is written to socket,
+   * emitting event so next stream parameter can be written.
+   */
+  registerStreamSendEvent(out, info) {
+    // note : Implementation use recursive calls, but stack won't get near v8 max call stack size
+    //since event launched for stream parameter only
+    this.paramWritten = function () {
+      if (this.longDataStep) {
+        for (; this.currentParam < this.parameterCount; this.currentParam++) {
+          if (this.parametersType[this.currentParam].isLongData()) {
+            const value = this.values[this.currentParam];
+            this.sendComStmtLongData(out, info, value);
+            return;
+          }
+        }
+        this.longDataStep = false; // all streams have been send
+      }
+
+      if (!this.longDataStep) {
+        this.sendComStmtExecute(out, info);
+      }
+    }.bind(this);
+  }
+}
+
+class ParameterType {
+  constructor(type, encoder, pipe = false, isNull = false) {
+    this.pipe = pipe;
+    this.type = type;
+    this.encoder = encoder;
+    this.isNull = isNull;
+  }
+
+  isLongData() {
+    return this.encoder === null && !this.isNull;
+  }
+}
+
+const NULL_PARAM_TYPE = new ParameterType(FieldType.VAR_STRING, null, false, true);
+const BOOLEAN_TYPE = new ParameterType(FieldType.TINY, (out, value) => out.writeInt8(value ? 0x01 : 0x00));
+const BIG_BIGINT_TYPE = new ParameterType(FieldType.NEWDECIMAL, (out, value) =>
+  out.writeLengthEncodedString(value.toString())
+);
+const BIGINT_TYPE = new ParameterType(FieldType.BIGINT, (out, value) => out.writeBigInt(value));
+const INT_TYPE = new ParameterType(FieldType.INT, (out, value) => out.writeInt32(value));
+const DOUBLE_TYPE = new ParameterType(FieldType.DOUBLE, (out, value) => out.writeDouble(value));
+const STRING_TYPE = new ParameterType(FieldType.VAR_STRING, (out, value) => out.writeLengthEncodedString(value));
+const STRING_TOSTR_TYPE = new ParameterType(FieldType.VAR_STRING, (out, value) =>
+  out.writeLengthEncodedString(value.toString())
+);
+const DATE_TYPE = new ParameterType(FieldType.DATETIME, (out, value) => out.writeBinaryDate(value));
+const BLOB_TYPE = new ParameterType(FieldType.BLOB, (out, value) => out.writeLengthEncodedBuffer(value));
+const LONGBLOB_TYPE = new ParameterType(FieldType.BLOB, null);
+const STRING_FCT_TYPE = new ParameterType(FieldType.VAR_STRING, (out, value) =>
+  out.writeLengthEncodedString(String(value.toSqlString()))
+);
+const STREAM_TYPE = new ParameterType(FieldType.BLOB, null, true);
+const STRINGIFY_TYPE = new ParameterType(FieldType.VAR_STRING, (out, value) =>
+  out.writeLengthEncodedString(JSON.stringify(value))
+);
+
+module.exports = Execute;