@tachybase/module-multi-app 1.6.0 → 1.6.2

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

@@ -1,17 +1,23 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
 
-const CommonText = require('./common-text-cmd');
+const Parser = require('./parser');
 const Errors = require('../misc/errors');
 const Parse = require('../misc/parse');
+const TextEncoder = require('./encoder/text-encoder');
+const { Readable } = require('stream');
 const QUOTE = 0x27;
 
 /**
  * Protocol COM_QUERY
  * see : https://mariadb.com/kb/en/library/com_query/
  */
-class Query extends CommonText {
-  constructor(resolve, reject, options, connOpts, sql, values) {
-    super(resolve, reject, options, connOpts, sql, values);
+class Query extends Parser {
+  constructor(resolve, reject, connOpts, cmdParam) {
+    super(resolve, reject, connOpts, cmdParam);
+    this.binary = false;
   }
 
   /**
@@ -22,33 +28,37 @@ class Query extends CommonText {
    * @param info  connection information
    */
   start(out, opts, info) {
+    if (opts.logger.query) opts.logger.query(`QUERY: ${opts.logParam ? this.displaySql() : this.sql}`);
+    this.onPacketReceive = this.readResponsePacket;
     if (this.initialValues === undefined) {
       //shortcut if no parameters
       out.startPacket(this);
       out.writeInt8(0x03);
       if (!this.handleTimeout(out, info)) return;
       out.writeString(this.sql);
-      out.flushBuffer(true);
+      out.flush();
       this.emit('send_end');
-      return (this.onPacketReceive = this.readResponsePacket);
+      return;
     }
 
+    this.encodedSql = out.encodeString(this.sql);
+
     if (this.opts.namedPlaceholders) {
       try {
         const parsed = Parse.splitQueryPlaceholder(
-          this.sql,
+          this.encodedSql,
           info,
           this.initialValues,
-          this.displaySql.bind(this)
+          this.opts.logParam ? this.displaySql.bind(this) : () => this.sql
         );
-        this.queryParts = parsed.parts;
+        this.paramPositions = parsed.paramPositions;
         this.values = parsed.values;
       } catch (err) {
         this.emit('send_end');
         return this.throwError(err, info);
       }
     } else {
-      this.queryParts = Parse.splitQuery(this.sql);
+      this.paramPositions = Parse.splitQuery(this.encodedSql);
       this.values = Array.isArray(this.initialValues) ? this.initialValues : [this.initialValues];
       if (!this.validateParameters(info)) return;
     }
@@ -56,54 +66,185 @@ class Query extends CommonText {
     out.startPacket(this);
     out.writeInt8(0x03);
     if (!this.handleTimeout(out, info)) return;
-    out.writeString(this.queryParts[0]);
-    this.onPacketReceive = this.readResponsePacket;
+
+    this.paramPos = 0;
+    this.sqlPos = 0;
 
     //********************************************
     // send params
     //********************************************
-    const len = this.queryParts.length;
-    for (let i = 1; i < len; i++) {
-      const value = this.values[i - 1];
-
-      if (
-        value !== null &&
-        typeof value === 'object' &&
-        typeof value.pipe === 'function' &&
-        typeof value.read === 'function'
-      ) {
-        this.sending = true;
-        //********************************************
-        // param is stream,
-        // now all params will be written by event
-        //********************************************
-        this.registerStreamSendEvent(out, info);
-        this.currentParam = i;
-        out.writeInt8(QUOTE); //'
-
-        value.on('data', function (chunk) {
-          out.writeBufferEscape(chunk);
-        });
+    const len = this.paramPositions.length / 2;
+    for (this.valueIdx = 0; this.valueIdx < len; ) {
+      out.writeBuffer(this.encodedSql, this.sqlPos, this.paramPositions[this.paramPos++] - this.sqlPos);
+      this.sqlPos = this.paramPositions[this.paramPos++];
 
-        value.on(
-          'end',
-          function () {
+      const value = this.values[this.valueIdx++];
+      if (value == null) {
+        out.writeStringAscii('NULL');
+        continue;
+      }
+      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 (typeof value.pipe === 'function' && typeof value.read === 'function') {
+            this.sending = true;
+            //********************************************
+            // param is stream,
+            // now all params will be written by event
+            //********************************************
+            this.paramWritten = this._paramWritten.bind(this, out, info);
             out.writeInt8(QUOTE); //'
-            out.writeString(this.queryParts[this.currentParam++]);
-            this.paramWritten();
-          }.bind(this)
-        );
+            value.on('data', out.writeBufferEscape.bind(out));
 
-        return;
-      } else {
-        //********************************************
-        // param isn't stream. directly write in buffer
-        //********************************************
-        this.writeParam(out, value, this.opts, info);
-        out.writeString(this.queryParts[i]);
+            value.on(
+              'end',
+              function () {
+                out.writeInt8(QUOTE); //'
+                this.paramWritten();
+              }.bind(this)
+            );
+            return;
+          }
+
+          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 &&
+              [
+                '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(" + 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 (let 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;
       }
     }
-    out.flushBuffer(true);
+    out.writeBuffer(this.encodedSql, this.sqlPos, this.encodedSql.length - this.sqlPos);
+    out.flush();
     this.emit('send_end');
   }
 
@@ -117,35 +258,24 @@ class Query extends CommonText {
     if (this.opts.timeout) {
       if (info.isMariaDB()) {
         if (info.hasMinVersion(10, 1, 2)) {
-          out.writeString('SET STATEMENT max_statement_time=' + this.opts.timeout / 1000 + ' FOR ');
+          out.writeString(`SET STATEMENT max_statement_time=${this.opts.timeout / 1000} FOR `);
           return true;
         } else {
-          const err = Errors.createError(
-            'Cannot use timeout for MariaDB server before 10.1.2. timeout value: ' +
-              this.opts.timeout,
-            this.sql,
-            false,
-            info,
-            'HY000',
-            Errors.ER_TIMEOUT_NOT_SUPPORTED
+          this.sendCancelled(
+            `Cannot use timeout for xpand/MariaDB server before 10.1.2. timeout value: ${this.opts.timeout}`,
+            Errors.ER_TIMEOUT_NOT_SUPPORTED,
+            info
           );
-          this.emit('send_end');
-          this.throwError(err, info);
           return false;
         }
       } else {
         //not available for MySQL
         // max_execution time exist, but only for select, and as hint
-        const err = Errors.createError(
-          'Cannot use timeout for MySQL server. timeout value: ' + this.opts.timeout,
-          this.sql,
-          false,
-          info,
-          'HY000',
-          Errors.ER_TIMEOUT_NOT_SUPPORTED
+        this.sendCancelled(
+          `Cannot use timeout for MySQL server. timeout value: ${this.opts.timeout}`,
+          Errors.ER_TIMEOUT_NOT_SUPPORTED,
+          info
         );
-        this.emit('send_end');
-        this.throwError(err, info);
         return false;
       }
     }
@@ -160,95 +290,102 @@ class Query extends CommonText {
    */
   validateParameters(info) {
     //validate parameter size.
-    if (this.queryParts.length - 1 > this.values.length) {
-      this.emit('send_end');
-      this.throwNewError(
-        'Parameter at position ' + (this.values.length + 1) + ' is not set',
-        false,
-        info,
-        'HY000',
-        Errors.ER_MISSING_PARAMETER
+    if (this.paramPositions.length / 2 > this.values.length) {
+      this.sendCancelled(
+        `Parameter at position ${this.values.length + 1} is not set`,
+        Errors.ER_MISSING_PARAMETER,
+        info
       );
       return false;
     }
+    return true;
+  }
 
-    //validate parameter is defined.
-    for (let i = 0; i < this.queryParts.length - 1; i++) {
-      if (this.values[i] === undefined) {
+  _paramWritten(out, info) {
+    while (true) {
+      if (this.valueIdx === this.paramPositions.length / 2) {
+        //********************************************
+        // all parameters are written.
+        // flush packet
+        //********************************************
+        out.writeBuffer(this.encodedSql, this.sqlPos, this.encodedSql.length - this.sqlPos);
+        out.flush();
+        this.sending = false;
         this.emit('send_end');
-        this.throwNewError(
-          'Parameter at position ' + (i + 1) + ' is undefined\n' + this.displaySql(),
-          false,
-          info,
-          'HY000',
-          Errors.ER_PARAMETER_UNDEFINED
-        );
-        return false;
-      }
-    }
+        return;
+      } else {
+        const value = this.values[this.valueIdx++];
+        out.writeBuffer(this.encodedSql, this.sqlPos, this.paramPositions[this.paramPos++] - this.sqlPos);
+        this.sqlPos = this.paramPositions[this.paramPos++];
 
-    return true;
-  }
+        if (value == null) {
+          out.writeStringAscii('NULL');
+          continue;
+        }
 
-  /**
-   * 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 never get near v8 max call stack size
-    //since event launched for stream parameter only
-    this.paramWritten = function () {
-      while (true) {
-        if (this.currentParam === this.queryParts.length) {
+        if (typeof value === 'object' && typeof value.pipe === 'function' && typeof value.read === 'function') {
           //********************************************
-          // all parameters are written.
-          // flush packet
+          // param is stream,
           //********************************************
-          out.flushBuffer(true);
-          this.sending = false;
-          this.emit('send_end');
+          out.writeInt8(QUOTE);
+          value.once(
+            'end',
+            function () {
+              out.writeInt8(QUOTE);
+              this._paramWritten(out, info);
+            }.bind(this)
+          );
+          value.on('data', out.writeBufferEscape.bind(out));
           return;
-        } else {
-          const value = this.values[this.currentParam - 1];
+        }
 
-          if (value === null) {
-            out.writeStringAscii('NULL');
-            out.writeString(this.queryParts[this.currentParam++]);
-            continue;
-          }
+        //********************************************
+        // param isn't stream. directly write in buffer
+        //********************************************
+        TextEncoder.writeParam(out, value, this.opts, info);
+      }
+    }
+  }
 
-          if (
-            typeof value === 'object' &&
-            typeof value.pipe === 'function' &&
-            typeof value.read === 'function'
-          ) {
-            //********************************************
-            // param is stream,
-            //********************************************
-            out.writeInt8(QUOTE);
-            value.once(
-              'end',
-              function () {
-                out.writeInt8(QUOTE);
-                out.writeString(this.queryParts[this.currentParam++]);
-                this.paramWritten();
-              }.bind(this)
-            );
-            value.on('data', function (chunk) {
-              out.writeBufferEscape(chunk);
-            });
-            return;
-          }
+  _stream(socket, options) {
+    this.socket = socket;
+    options = options || {};
+    options.objectMode = true;
+    options.read = () => {
+      this.socket.resume();
+    };
+    this.inStream = new Readable(options);
 
-          //********************************************
-          // param isn't stream. directly write in buffer
-          //********************************************
-          this.writeParam(out, value, this.opts, info);
-          out.writeString(this.queryParts[this.currentParam++]);
-        }
-      }
+    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);
+
+    this.handleNewRows = function (row) {
+      if (!this.inStream.push(row)) {
+        this.socket.pause();
+      }
+    };
+
+    return this.inStream;
   }
 }
 

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

@@ -1,23 +1,26 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
 
 const Command = require('./command');
+const QUIT_COMMAND = new Uint8Array([1, 0, 0, 0, 0x01]);
 
 /**
  * Quit (close connection)
  * see https://mariadb.com/kb/en/library/com_quit/
  */
 class Quit extends Command {
-  constructor(resolve, reject) {
-    super(resolve, reject);
+  constructor(cmdParam, resolve, reject) {
+    super(cmdParam, resolve, reject);
   }
 
   start(out, opts, info) {
-    out.startPacket(this);
-    out.writeInt8(0x01);
-    out.flushBuffer(true);
+    if (opts.logger.query) opts.logger.query('QUIT');
+    this.onPacketReceive = this.skipResults;
+    out.fastFlush(this, QUIT_COMMAND);
     this.emit('send_end');
     this.successEnd();
-    this.onPacketReceive = this.skipResults;
   }
 
   skipResults(packet, out, opts, info) {

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

@@ -1,23 +1,25 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
 
 const Command = require('./command');
-const Errors = require('../misc/errors');
-
+const ServerStatus = require('../const/server-status');
+const RESET_COMMAND = new Uint8Array([1, 0, 0, 0, 0x1f]);
 /**
  * send a COM_RESET_CONNECTION: permits to reset a connection without re-authentication.
  * see https://mariadb.com/kb/en/library/com_reset_connection/
  */
 class Reset extends Command {
-  constructor(resolve, reject) {
-    super(resolve, reject);
+  constructor(cmdParam, resolve, reject) {
+    super(cmdParam, resolve, reject);
   }
 
   start(out, opts, info) {
-    out.startPacket(this);
-    out.writeInt8(0x1f);
-    out.flushBuffer(true);
-    this.emit('send_end');
+    if (opts.logger.query) opts.logger.query('RESET');
     this.onPacketReceive = this.readResetResponsePacket;
+    out.fastFlush(this, RESET_COMMAND);
+    this.emit('send_end');
   }
 
   /**
@@ -32,22 +34,16 @@ class Reset extends Command {
    * @param info    connection info
    */
   readResetResponsePacket(packet, out, opts, info) {
-    if (packet.peek() !== 0x00) {
-      return this.throwNewError(
-        'unexpected packet',
-        false,
-        info,
-        '42000',
-        Errors.ER_RESET_BAD_PACKET
-      );
-    }
-
     packet.skip(1); //skip header
     packet.skipLengthCodedNumber(); //affected rows
     packet.skipLengthCodedNumber(); //insert ids
 
     info.status = packet.readUInt16();
-    this.successEnd(null);
+    if (info.redirectRequest && (info.status & ServerStatus.STATUS_IN_TRANS) === 0) {
+      info.redirect(info.redirectRequest, this.successEnd.bind(this));
+    } else {
+      this.successEnd();
+    }
   }
 }
 

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

@@ -1,3 +1,6 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
 
 const Query = require('./query');
@@ -8,19 +11,19 @@ const { Readable } = require('stream');
  * see : https://mariadb.com/kb/en/library/com_query/
  */
 class Stream extends Query {
-  constructor(cmdOpts, connOpts, sql, values, socket) {
+  constructor(cmdParam, connOpts, socket) {
     super(
       () => {},
       () => {},
-      cmdOpts,
       connOpts,
-      sql,
-      values
+      cmdParam
     );
     this.socket = socket;
     this.inStream = new Readable({
       objectMode: true,
-      read: () => {}
+      read: () => {
+        this.socket.resume();
+      }
     });
 
     this.on('fields', function (meta) {
@@ -31,14 +34,26 @@ class Stream extends Query {
       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) {
-    this.inStream.push(row);
+    if (!this.inStream.push(row)) {
+      this.socket.pause();
+    }
   }
 }