@tachybase/module-multi-app 1.5.1 → 1.6.1

package/dist/node_modules/mariadb/lib/misc/utils.js

@@ -1,9 +1,11 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
-const Long = require('long');
 const hexArray = '0123456789ABCDEF'.split('');
 const Errors = require('../misc/errors');
-const CommonText = require('../cmd/common-text-cmd');
 const Iconv = require('iconv-lite');
+const TextEncoder = require('../cmd/encoder/text-encoder');
 
 /**
  * Write bytes/hexadecimal value of a byte array to a string.
@@ -40,8 +42,7 @@ module.exports.log = function (opts, buf, off, end, header) {
       if (posHexa === 0) out.push('| ');
       byteValue = header[pos++] & 0xff;
       out.push(hexArray[byteValue >>> 4], hexArray[byteValue & 0x0f], ' ');
-      asciiValue[posHexa++] =
-        byteValue > 31 && byteValue < 127 ? String.fromCharCode(byteValue) : '.';
+      asciiValue[posHexa++] = byteValue > 31 && byteValue < 127 ? String.fromCharCode(byteValue) : '.';
       if (posHexa === 8) out.push(' ');
     }
   }
@@ -53,8 +54,7 @@ module.exports.log = function (opts, buf, off, end, header) {
 
     out.push(hexArray[byteValue >>> 4], hexArray[byteValue & 0x0f], ' ');
 
-    asciiValue[posHexa++] =
-      byteValue > 31 && byteValue < 127 ? String.fromCharCode(byteValue) : '.';
+    asciiValue[posHexa++] = byteValue > 31 && byteValue < 127 ? String.fromCharCode(byteValue) : '.';
 
     if (posHexa === 8) out.push(' ');
     if (posHexa === 16) {
@@ -87,65 +87,52 @@ module.exports.log = function (opts, buf, off, end, header) {
   return out.join('');
 };
 
+module.exports.toHexString = (bytes) => {
+  return Array.from(bytes, (byte) => {
+    return ('0' + (byte & 0xff).toString(16)).slice(-2);
+  }).join('');
+};
+
 module.exports.escapeId = (opts, info, value) => {
   if (!value || value === '') {
-    throw Errors.createError(
-      'Cannot escape empty ID value',
-      null,
-      false,
-      info,
-      '0A000',
-      Errors.ER_NULL_ESCAPEID
-    );
+    throw Errors.createError('Cannot escape empty ID value', Errors.ER_NULL_ESCAPEID, info, '0A000');
   }
   if (value.includes('\u0000')) {
     throw Errors.createError(
       'Cannot escape ID with null character (u0000)',
-      null,
-      false,
+      Errors.ER_NULL_CHAR_ESCAPEID,
       info,
-      '0A000',
-      Errors.ER_NULL_CHAR_ESCAPEID
+      '0A000'
     );
   }
 
-  // always return escaped value, event when there is no special characters
+  // always return escaped value, even when there is no special characters
   // to permit working with reserved words
-  if (value.match(/^`.+`$/g)) {
-    // already escaped
-    return value;
-  }
   return '`' + value.replace(/`/g, '``') + '`';
 };
 
 const escapeParameters = (opts, info, value) => {
-  if (value === undefined || value === null) return 'NULL';
+  if (value == null) return 'NULL';
 
   switch (typeof value) {
     case 'boolean':
       return value ? 'true' : 'false';
     case 'bigint':
     case 'number':
-      return '' + value;
+      return `${value}`;
     case 'object':
       if (Object.prototype.toString.call(value) === '[object Date]') {
-        return opts.tz
-          ? opts.tz === 'Etc/UTC'
-            ? CommonText.getUtcDate(value, opts)
-            : CommonText.getTimezoneDate(value, opts)
-          : CommonText.getLocalDate(value, opts);
+        return TextEncoder.getFixedFormatDate(value);
       } else if (Buffer.isBuffer(value)) {
         let stValue;
-        if (Buffer.isEncoding(opts.collation.charset)) {
-          stValue = value.toString(opts.collation.charset, 0, value.length);
+        if (Buffer.isEncoding(info.collation.charset)) {
+          stValue = value.toString(info.collation.charset, 0, value.length);
         } else {
-          stValue = Iconv.decode(value, opts.collation.charset);
+          stValue = Iconv.decode(value, info.collation.charset);
         }
         return "_binary'" + escapeString(stValue) + "'";
       } else if (typeof value.toSqlString === 'function') {
         return "'" + escapeString(String(value.toSqlString())) + "'";
-      } else if (Long.isLong(value)) {
-        return value.toString();
       } else if (Array.isArray(value)) {
         let out = opts.arrayParenthesis ? '(' : '';
         for (let i = 0; i < value.length; i++) {
@@ -170,40 +157,28 @@ const escapeParameters = (opts, info, value) => {
           //GeoJSON format.
           let prefix =
             info &&
-            ((info.isMariaDB() && info.hasMinVersion(10, 1, 4)) ||
-              (!info.isMariaDB() && info.hasMinVersion(5, 7, 6)))
+            ((info.isMariaDB() && info.hasMinVersion(10, 1, 4)) || (!info.isMariaDB() && info.hasMinVersion(5, 7, 6)))
               ? 'ST_'
               : '';
           switch (value.type) {
             case 'Point':
-              return (
-                prefix +
-                "PointFromText('POINT(" +
-                CommonText.geoPointToString(value.coordinates) +
-                ")')"
-              );
+              return prefix + "PointFromText('POINT(" + TextEncoder.geoPointToString(value.coordinates) + ")')";
 
             case 'LineString':
               return (
-                prefix +
-                "LineFromText('LINESTRING(" +
-                CommonText.geoArrayPointToString(value.coordinates) +
-                ")')"
+                prefix + "LineFromText('LINESTRING(" + TextEncoder.geoArrayPointToString(value.coordinates) + ")')"
               );
 
             case 'Polygon':
               return (
-                prefix +
-                "PolygonFromText('POLYGON(" +
-                CommonText.geoMultiArrayPointToString(value.coordinates) +
-                ")')"
+                prefix + "PolygonFromText('POLYGON(" + TextEncoder.geoMultiArrayPointToString(value.coordinates) + ")')"
               );
 
             case 'MultiPoint':
               return (
                 prefix +
                 "MULTIPOINTFROMTEXT('MULTIPOINT(" +
-                CommonText.geoArrayPointToString(value.coordinates) +
+                TextEncoder.geoArrayPointToString(value.coordinates) +
                 ")')"
               );
 
@@ -211,23 +186,20 @@ const escapeParameters = (opts, info, value) => {
               return (
                 prefix +
                 "MLineFromText('MULTILINESTRING(" +
-                CommonText.geoMultiArrayPointToString(value.coordinates) +
+                TextEncoder.geoMultiArrayPointToString(value.coordinates) +
                 ")')"
               );
 
             case 'MultiPolygon':
               return (
-                prefix +
-                "MPolyFromText('MULTIPOLYGON(" +
-                CommonText.geoMultiPolygonToString(value.coordinates) +
-                ")')"
+                prefix + "MPolyFromText('MULTIPOLYGON(" + TextEncoder.geoMultiPolygonToString(value.coordinates) + ")')"
               );
 
             case 'GeometryCollection':
               return (
                 prefix +
                 "GeomCollFromText('GEOMETRYCOLLECTION(" +
-                CommonText.geometricCollectionToString(value.geometries) +
+                TextEncoder.geometricCollectionToString(value.geometries) +
                 ")')"
               );
           }
@@ -271,17 +243,17 @@ const LITTERAL_ESCAPE = {
   '\\': '\\\\'
 };
 
-const escapeString = (val) => {
-  const pattern = /[\u0000'"\b\n\r\t\u001A\\]/g;
+const CHARS_GLOBAL_REGEXP = /[\000\032"'\\\b\n\r\t]/g;
 
+const escapeString = (val) => {
   let offset = 0;
   let escaped = '';
   let match;
 
-  while ((match = pattern.exec(val))) {
+  while ((match = CHARS_GLOBAL_REGEXP.exec(val))) {
     escaped += val.substring(offset, match.index);
     escaped += LITTERAL_ESCAPE[match[0]];
-    offset = pattern.lastIndex;
+    offset = CHARS_GLOBAL_REGEXP.lastIndex;
   }
 
   if (offset === 0) {

package/dist/node_modules/mariadb/lib/pool-callback.js

@@ -1,149 +1,110 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2025 MariaDB Corporation Ab
+
 'use strict';
 
-const PoolBase = require('./pool-base');
-const ConnectionCallback = require('./connection-callback');
+const { EventEmitter } = require('events');
+
+const Pool = require('./pool');
 const Errors = require('./misc/errors');
-const util = require('util');
-
-function PoolCallback(options) {
-  const processTaskCallback = function (conn, sql, values, isBatch) {
-    if (sql) {
-      return new Promise((resolve, reject) => {
-        const fct = isBatch ? conn.batch : conn.query;
-        fct(sql, values, (err, rows, fields) => {
-          conn.releaseWithoutError();
-          if (err) {
-            reject(err);
-            return;
-          }
-          return resolve(rows);
-        });
-      });
-    } else {
-      return Promise.resolve(conn);
-    }
-  };
-
-  const pingPromise = function (conn) {
-    return new Promise((resolve, reject) => {
-      conn.ping(options.pingTimeout, (err) => {
-        if (err) {
-          reject(err);
-        } else resolve();
-      });
-    });
-  };
-
-  const createConnectionPoolCallback = function (pool) {
-    const conn = new ConnectionCallback(options.connOptions);
-    return new Promise(function (resolve, reject) {
-      conn.connect((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          if (pool.closed) {
-            //discard connection
-            conn.end((err) => {});
-            reject(
-              Errors.createError(
-                'Cannot create new connection to pool, pool closed',
-                null,
-                true,
-                null,
-                '08S01',
-                Errors.ER_ADD_CONNECTION_CLOSED_POOL,
-                null
-              )
-            );
-          } else {
-            const initialEnd = conn.end;
-            conn.forceEnd = () => {
-              return new Promise(function (res, rej) {
-                initialEnd((err) => {
-                  if (err) {
-                    rej(err);
-                  } else {
-                    res();
-                  }
-                });
-              });
-            };
-
-            conn.release = function (cb) {
-              if (pool.closed) {
-                pool._discardConnection(conn);
-                if (cb) cb();
-                return;
-              }
-              if (options.noControlAfterUse) {
-                pool._releaseConnection(conn);
-                if (cb) cb();
-                return;
-              }
-
-              //if server permit it, reset the connection, or rollback only if not
-              // COM_RESET_CONNECTION exist since mysql 5.7.3 and mariadb 10.2.4
-              // but not possible to use it with mysql waiting for https://bugs.mysql.com/bug.php?id=97633 correction.
-              // and mariadb only since https://jira.mariadb.org/browse/MDEV-18281
-              let revertFunction = conn.rollback;
-              if (
-                options.resetAfterUse &&
-                conn.info.isMariaDB() &&
-                ((conn.info.serverVersion.minor === 2 && conn.info.hasMinVersion(10, 2, 22)) ||
-                  conn.info.hasMinVersion(10, 3, 13))
-              ) {
-                revertFunction = conn.reset;
-              }
-              revertFunction((errCall) => {
-                if (errCall) {
-                  //uncertain connection state.
-                  pool._discardConnection(conn);
-                  if (cb) cb();
-                  return;
-                } else {
-                  pool._releaseConnection(conn);
-                }
-                if (cb) cb();
-              });
-            };
-            conn.end = conn.release;
-            conn.releaseWithoutError = () => {
-              conn.end((err) => {});
-            };
-            resolve(conn);
-          }
-        }
-      });
-    });
-  };
+const ConnectionCallback = require('./connection-callback');
 
-  PoolBase.call(this, options, processTaskCallback, createConnectionPoolCallback, pingPromise);
+class PoolCallback extends EventEmitter {
+  #pool;
+  constructor(options) {
+    super();
+    this.#pool = new Pool(options);
+    this.#pool.on('acquire', this.emit.bind(this, 'acquire'));
+    this.#pool.on('connection', this.emit.bind(this, 'connection'));
+    this.#pool.on('enqueue', this.emit.bind(this, 'enqueue'));
+    this.#pool.on('release', this.emit.bind(this, 'release'));
+    this.#pool.on('error', this.emit.bind(this, 'error'));
+  }
 
-  const getConnectionPromise = this.getConnection.bind(this);
-  const endPromise = this.end.bind(this);
-  const queryPromise = this.query.bind(this);
-  const batchPromise = this.batch.bind(this);
-  const emptyError = (err) => {};
+  #noop = () => {};
 
-  //*****************************************************************
-  // internal equivalent with callback of promised functions
-  //*****************************************************************
+  get closed() {
+    return this.#pool.closed;
+  }
 
-  const _getConnectionCallback = (callback) => {
-    getConnectionPromise()
-      .then((conn) => {
-        if (callback) callback(null, conn);
-      })
-      .catch(callback || emptyError);
-  };
+  /**
+   * Get current total connection number.
+   * @return {number}
+   */
+  totalConnections() {
+    return this.#pool.totalConnections();
+  }
+
+  /**
+   * Get current active connections.
+   * @return {number}
+   */
+  activeConnections() {
+    return this.#pool.activeConnections();
+  }
+
+  /**
+   * Get current idle connection number.
+   * @return {number}
+   */
+  idleConnections() {
+    return this.#pool.idleConnections();
+  }
+
+  /**
+   * Get current stacked connection request.
+   * @return {number}
+   */
+  taskQueueSize() {
+    return this.#pool.taskQueueSize();
+  }
+
+  escape(value) {
+    return this.#pool.escape(value);
+  }
 
-  const _endCallback = (callback) => {
-    endPromise()
+  escapeId(value) {
+    return this.#pool.escapeId(value);
+  }
+
+  /**
+   * Ends pool
+   *
+   * @param callback
+   */
+  end(callback) {
+    this.#pool
+      .end()
       .then(() => {
         if (callback) callback(null);
       })
-      .catch(callback || emptyError);
-  };
+      .catch(callback || this.#noop);
+  }
+
+  /**
+   * Retrieve a connection from the pool.
+   * Create a new one if the limit is not reached.
+   * wait until acquireTimeout.
+   *
+   * @param cb callback
+   */
+  getConnection(cb) {
+    if (!cb) {
+      throw new Errors.createError('missing mandatory callback parameter', Errors.ER_MISSING_PARAMETER);
+    }
+    const cmdParam = {};
+    if (this.#pool.opts.connOptions.trace) Error.captureStackTrace(cmdParam);
+    this.#pool.getConnection(cmdParam, (err, baseConn) => {
+      if (err) {
+        cb(err);
+      } else {
+        const cc = new ConnectionCallback(baseConn);
+        cc.end = (cb) => cc.release(cb);
+        cc.close = (cb) => cc.release(cb);
+        cb(null, cc);
+      }
+    });
+  }
 
   /**
    * Execute query using text protocol with callback emit columns/data/end/error
@@ -153,50 +114,128 @@ function PoolCallback(options) {
    *                Object must then have sql property.
    * @param values  object / array of placeholder values (not mandatory)
    * @param cb      callback
-   * @returns {Query} query
    */
-  const _queryCallback = function (sql, values, cb) {
-    let _cb = cb,
-      _values = values;
-
-    if (typeof values === 'function') {
-      _cb = values;
-      _values = undefined;
-    }
+  query(sql, values, cb) {
+    const cmdParam = ConnectionCallback._PARAM(this.#pool.opts.connOptions, sql, values, cb);
+    this.#pool.getConnection(cmdParam, (err, baseConn) => {
+      if (err) {
+        if (cmdParam.callback) cmdParam.callback(err);
+      } else {
+        const _cb = cmdParam.callback;
+        cmdParam.callback = (err, rows, meta) => {
+          this.#pool.release(baseConn);
+          if (_cb) _cb(err, rows, meta);
+        };
+        ConnectionCallback._QUERY_CMD(baseConn, cmdParam);
+      }
+    });
+  }
 
-    queryPromise(sql, _values)
-      .then((rows) => {
-        if (_cb) _cb(null, rows, rows.meta);
-      })
-      .catch(_cb || emptyError);
-  };
+  /**
+   * Execute query using binary protocol with callback emit columns/data/end/error
+   * events to permit streaming big result-set
+   *
+   * @param sql     sql parameter Object can be used to supersede default option.
+   *                Object must then have sql property.
+   * @param values  object / array of placeholder values (not mandatory)
+   * @param cb      callback
+   */
+  execute(sql, values, cb) {
+    const cmdParam = ConnectionCallback._PARAM(this.#pool.opts.connOptions, sql, values, cb);
+
+    this.#pool.getConnection(cmdParam, (err, baseConn) => {
+      if (err) {
+        if (cmdParam.callback) cmdParam.callback(err);
+      } else {
+        const _cb = cmdParam.callback;
+        baseConn.prepareExecute(
+          cmdParam,
+          (res) => {
+            this.#pool.release(baseConn);
+            if (_cb) _cb(null, res, res.meta);
+          },
+          (err) => {
+            this.#pool.release(baseConn);
+            if (_cb) _cb(err);
+          }
+        );
+      }
+    });
+  }
 
-  const _batchCallback = function (sql, values, cb) {
-    let _values = values,
-      _cb = cb;
+  /**
+   * execute a batch
+   *
+   * @param sql     sql parameter Object can be used to supersede default option.
+   *                Object must then have sql property.
+   * @param values  array of placeholder values
+   * @param cb      callback
+   */
+  batch(sql, values, cb) {
+    const cmdParam = ConnectionCallback._PARAM(this.#pool.opts.connOptions, sql, values, cb);
+    this.#pool.getConnection(cmdParam, (err, baseConn) => {
+      if (err) {
+        if (cmdParam.callback) cmdParam.callback(err);
+      } else {
+        const _cb = cmdParam.callback;
+        baseConn.batch(
+          cmdParam,
+          (res) => {
+            this.#pool.release(baseConn);
+            if (_cb) _cb(null, res);
+          },
+          (err) => {
+            this.#pool.release(baseConn);
+            if (_cb) _cb(err);
+          }
+        );
+      }
+    });
+  }
 
-    if (typeof values === 'function') {
-      _cb = values;
-      _values = undefined;
+  /**
+   * Import sql file.
+   *
+   * @param opts JSON array with 2 possible fields: file and database
+   * @param cb callback
+   */
+  importFile(opts, cb) {
+    if (!opts) {
+      if (cb)
+        cb(
+          Errors.createError(
+            'SQL file parameter is mandatory',
+            Errors.ER_MISSING_SQL_PARAMETER,
+            null,
+            'HY000',
+            null,
+            false,
+            null
+          )
+        );
+      return;
     }
-
-    batchPromise(sql, _values)
-      .then((rows) => {
-        if (_cb) _cb(null, rows, rows.meta);
-      })
-      .catch(_cb || emptyError);
-  };
-
-  //*****************************************************************
-  // replacing public promise function with callback equivalent
-  //*****************************************************************
-
-  this.end = _endCallback;
-  this.query = _queryCallback;
-  this.batch = _batchCallback;
-  this.getConnection = _getConnectionCallback;
+    this.#pool.getConnection({}, (err, baseConn) => {
+      if (err) {
+        if (cb) cb(err);
+      } else {
+        baseConn.importFile(
+          { file: opts.file, database: opts.database },
+          (res) => {
+            this.#pool.release(baseConn);
+            if (cb) cb(null, res);
+          },
+          (err) => {
+            this.#pool.release(baseConn);
+            if (cb) cb(err);
+          }
+        );
+      }
+    });
+  }
+  toString() {
+    return 'poolCallback(' + this.#pool.toString() + ')';
+  }
 }
 
-util.inherits(PoolCallback, PoolBase);
-
 module.exports = PoolCallback;