@tachybase/module-multi-app 1.6.0 → 1.6.1

package/dist/externalVersion.js

@@ -1,14 +1,14 @@
 module.exports = {
   "react-i18next": "16.2.1",
-  "@tachybase/client": "1.6.0",
-  "@tego/server": "1.3.52",
+  "@tachybase/client": "1.6.1",
+  "@tego/server": "1.6.0-alpha.9",
   "lodash": "4.17.21",
   "mysql2": "3.14.3",
   "pg": "8.16.3",
   "react": "18.3.1",
-  "@tachybase/schema": "1.3.52",
+  "@tachybase/schema": "1.6.0-alpha.9",
   "antd": "5.22.5",
   "react-router-dom": "6.28.1",
-  "@tego/client": "1.3.52",
-  "@ant-design/icons": "5.6.1"
+  "@tego/client": "1.6.0-alpha.9",
+  "@ant-design/icons": "6.1.0"
 };

package/dist/node_modules/mariadb/callback.js

@@ -1,14 +1,18 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
-const pkg = require('./package.json');
-require('please-upgrade-node')(pkg);
+
+require('./check-node');
 
 const ConnectionCallback = require('./lib/connection-callback');
-const PoolClusterCallback = require('./lib/pool-cluster-callback');
+const ClusterCallback = require('./lib/cluster-callback');
 const PoolCallback = require('./lib/pool-callback');
 
 const ConnOptions = require('./lib/config/connection-options');
 const PoolOptions = require('./lib/config/pool-options');
-const PoolClusterOptions = require('./lib/config/pool-cluster-options');
+const ClusterOptions = require('./lib/config/cluster-options');
+const Connection = require('./lib/connection');
 
 module.exports.version = require('./package.json').version;
 module.exports.SqlError = require('./lib/misc/errors').SqlError;
@@ -25,17 +29,48 @@ module.exports.defaultOptions = function defaultOptions(opts) {
 };
 
 module.exports.createConnection = function createConnection(opts) {
-  return new ConnectionCallback(new ConnOptions(opts));
+  const conn = new Connection(new ConnOptions(opts));
+  const connCallback = new ConnectionCallback(conn);
+  conn
+    .connect()
+    .then(
+      function () {
+        conn.emit('connect');
+      }.bind(conn)
+    )
+    .catch(conn.emit.bind(conn, 'connect'));
+  return connCallback;
 };
 
 exports.createPool = function createPool(opts) {
   const options = new PoolOptions(opts);
   const pool = new PoolCallback(options);
-  pool.initialize();
+  // adding a default error handler to avoid exiting application on connection error.
+  pool.on('error', (err) => {});
   return pool;
 };
 
 exports.createPoolCluster = function createPoolCluster(opts) {
-  const options = new PoolClusterOptions(opts);
-  return new PoolClusterCallback(options);
+  const options = new ClusterOptions(opts);
+  return new ClusterCallback(options);
+};
+
+module.exports.importFile = function importFile(opts, callback) {
+  const cb = callback ? callback : () => {};
+  try {
+    const options = new ConnOptions(opts);
+    const conn = new Connection(options);
+    conn
+      .connect()
+      .then(() => {
+        return new Promise(conn.importFile.bind(conn, Object.assign({ skipDbCheck: true }, opts)));
+      })
+      .then(() => cb())
+      .catch((err) => cb(err))
+      .finally(() => {
+        new Promise(conn.end.bind(conn, {})).catch(console.log);
+      });
+  } catch (err) {
+    cb(err);
+  }
 };

package/dist/node_modules/mariadb/check-node.js

@@ -0,0 +1,30 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const hasMinVersion = function (nodeVersionStr, connectorRequirement) {
+  const versNode = nodeVersionStr.split('.');
+  const versReq = connectorRequirement.split('.');
+
+  const majorNode = Number(versNode[0]);
+  const majorReq = Number(versReq[0]);
+  if (majorNode > majorReq) return true;
+  if (majorNode < majorReq) return false;
+
+  if (versReq.length === 1) return true;
+
+  const minorNode = Number(versNode[1]);
+  const minorReq = Number(versReq[1]);
+  return minorNode >= minorReq;
+};
+
+module.exports.hasMinVersion = hasMinVersion;
+
+const requirement = require('./package.json').engines.node;
+const connectorRequirement = requirement.replace('>=', '').trim();
+const currentNodeVersion = process.version.replace('v', '');
+if (!hasMinVersion(currentNodeVersion, connectorRequirement)) {
+  console.error(`please upgrade node: mariadb requires at least version ${connectorRequirement}`);
+  process.exit(1);
+}

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

@@ -0,0 +1,84 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+const Cluster = require('./cluster');
+
+/**
+ * Create a new Cluster.
+ * Cluster handle pools with patterns and handle failover / distributed load
+ * according to selectors (round-robin / random / ordered )
+ *
+ * @param args      cluster arguments. see pool-cluster-options.
+ * @constructor
+ */
+class ClusterCallback {
+  #cluster;
+  constructor(args) {
+    this.#cluster = new Cluster(args);
+    this.#cluster._setCallback();
+    this.on = this.#cluster.on.bind(this.#cluster);
+    this.once = this.#cluster.once.bind(this.#cluster);
+  }
+
+  /**
+   * End cluster (and underlying pools).
+   *
+   * @param callback - not mandatory
+   */
+  end(callback) {
+    if (callback && typeof callback !== 'function') {
+      throw new Error('callback parameter must be a function');
+    }
+    const endingFct = callback ? callback : () => {};
+
+    this.#cluster
+      .end()
+      .then(() => {
+        endingFct();
+      })
+      .catch(endingFct);
+  }
+
+  /**
+   * Get connection from an available pools matching pattern, according to selector
+   *
+   * @param pattern       pattern filter (not mandatory)
+   * @param selector      node selector ('RR','RANDOM' or 'ORDER')
+   * @param callback      callback function
+   */
+  getConnection(pattern, selector, callback) {
+    let pat = pattern,
+      sel = selector,
+      cal = callback;
+    if (typeof pattern === 'function') {
+      pat = null;
+      sel = null;
+      cal = pattern;
+    } else if (typeof selector === 'function') {
+      sel = null;
+      cal = selector;
+    }
+    const endingFct = cal ? cal : (err, conn) => {};
+    this.#cluster.getConnection(pat, sel, endingFct);
+  }
+
+  add(id, config) {
+    this.#cluster.add(id, config);
+  }
+
+  of(pattern, selector) {
+    return this.#cluster.of(pattern, selector);
+  }
+
+  remove(pattern) {
+    this.#cluster.remove(pattern);
+  }
+
+  get __tests() {
+    return this.#cluster.__tests;
+  }
+}
+
+module.exports = ClusterCallback;

package/dist/node_modules/mariadb/lib/cluster.js

@@ -0,0 +1,446 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2025 MariaDB Corporation Ab
+
+'use strict';
+
+const ClusterOptions = require('./config/cluster-options');
+const PoolOptions = require('./config/pool-options');
+const PoolCallback = require('./pool-callback');
+const PoolPromise = require('./pool-promise');
+const FilteredCluster = require('./filtered-cluster');
+const FilteredClusterCallback = require('./filtered-cluster-callback');
+const EventEmitter = require('events');
+
+/**
+ * Create a new Cluster.
+ * Cluster handle pools with patterns and handle failover / distributed load
+ * according to selectors (round-robin / random / ordered )
+ *
+ * @param args      cluster arguments. see pool-cluster-options.
+ * @constructor
+ */
+class Cluster extends EventEmitter {
+  #opts;
+  #nodes = {};
+  #cachedPatterns = {};
+  #nodeCounter = 0;
+
+  constructor(args) {
+    super();
+    this.#opts = new ClusterOptions(args);
+  }
+
+  /**
+   * Add a new pool node to the cluster.
+   *
+   * @param id      identifier
+   * @param config  pool configuration
+   */
+  add(id, config) {
+    let identifier;
+    if (typeof id === 'string' || id instanceof String) {
+      identifier = id;
+      if (this.#nodes[identifier]) throw new Error(`Node identifier '${identifier}' already exist !`);
+    } else {
+      identifier = 'PoolNode-' + this.#nodeCounter++;
+      config = id;
+    }
+    const options = new PoolOptions(config);
+    this.#nodes[identifier] = this._createPool(options);
+  }
+
+  /**
+   * End cluster (and underlying pools).
+   *
+   * @return {Promise<any[]>}
+   */
+  end() {
+    const cluster = this;
+    this.#cachedPatterns = {};
+    const poolEndPromise = [];
+    Object.keys(this.#nodes).forEach((pool) => {
+      const res = cluster.#nodes[pool].end();
+      if (res) poolEndPromise.push(res);
+    });
+    this.#nodes = null;
+    return Promise.all(poolEndPromise);
+  }
+
+  of(pattern, selector) {
+    return new FilteredCluster(this, pattern, selector);
+  }
+
+  _ofCallback(pattern, selector) {
+    return new FilteredClusterCallback(this, pattern, selector);
+  }
+
+  /**
+   * Remove nodes according to pattern.
+   *
+   * @param pattern  pattern
+   */
+  remove(pattern) {
+    if (!pattern) throw new Error('pattern parameter in Cluster.remove(pattern)  is mandatory');
+
+    const regex = RegExp(pattern);
+    Object.keys(this.#nodes).forEach(
+      function (key) {
+        if (regex.test(key)) {
+          this.#nodes[key].end();
+          delete this.#nodes[key];
+          this.#cachedPatterns = {};
+        }
+      }.bind(this)
+    );
+  }
+
+  /**
+   * Get connection from an available pools matching pattern, according to selector
+   *
+   * @param pattern       pattern filter (not mandatory)
+   * @param selector      node selector ('RR','RANDOM' or 'ORDER')
+   * @return {Promise}
+   */
+  getConnection(pattern, selector) {
+    return this._getConnection(pattern, selector, undefined, undefined, undefined);
+  }
+
+  /**
+   * Force using callback methods.
+   */
+  _setCallback() {
+    this.getConnection = this._getConnectionCallback;
+    this._createPool = this._createPoolCallback;
+    this.of = this._ofCallback;
+  }
+
+  /**
+   * Get connection from an available pools matching pattern, according to selector
+   * with additional parameter to avoid reusing failing node
+   *
+   * @param pattern       pattern filter (not mandatory)
+   * @param selector      node selector ('RR','RANDOM' or 'ORDER')
+   * @param avoidNodeKey  failing node
+   * @param lastError     last error
+   * @param remainingRetry remaining possible retry
+   * @return {Promise}
+   * @private
+   */
+  _getConnection(pattern, selector, remainingRetry, avoidNodeKey, lastError) {
+    const matchingNodeList = this._matchingNodes(pattern || /^/);
+
+    if (matchingNodeList.length === 0) {
+      if (Object.keys(this.#nodes).length === 0 && !lastError) {
+        return Promise.reject(
+          new Error('No node have been added to cluster or nodes have been removed due to too much connection error')
+        );
+      }
+      if (avoidNodeKey === undefined) return Promise.reject(new Error(`No node found for pattern '${pattern}'`));
+      const errMsg = `No Connection available for '${pattern}'${
+        lastError ? '. Last connection error was: ' + lastError.message : ''
+      }`;
+      return Promise.reject(new Error(errMsg));
+    }
+
+    if (remainingRetry === undefined) remainingRetry = matchingNodeList.length;
+    const retry = --remainingRetry >= 0 ? this._getConnection.bind(this, pattern, selector, remainingRetry) : null;
+
+    try {
+      const nodeKey = this._selectPool(matchingNodeList, selector, avoidNodeKey);
+      return this._handleConnectionError(matchingNodeList, nodeKey, retry);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  _createPool(options) {
+    const pool = new PoolPromise(options);
+    pool.on('error', (err) => {});
+    return pool;
+  }
+
+  _createPoolCallback(options) {
+    const pool = new PoolCallback(options);
+    pool.on('error', (err) => {});
+    return pool;
+  }
+
+  /**
+   * Get connection from an available pools matching pattern, according to selector
+   * with additional parameter to avoid reusing failing node
+   *
+   * @param pattern       pattern filter (not mandatory)
+   * @param selector      node selector ('RR','RANDOM' or 'ORDER')
+   * @param callback      callback function
+   * @param remainingRetry remaining retry
+   * @param avoidNodeKey  failing node
+   * @param lastError     last error
+   * @private
+   */
+  _getConnectionCallback(pattern, selector, callback, remainingRetry, avoidNodeKey, lastError) {
+    const matchingNodeList = this._matchingNodes(pattern || /^/);
+
+    if (matchingNodeList.length === 0) {
+      if (Object.keys(this.#nodes).length === 0 && !lastError) {
+        callback(
+          new Error('No node have been added to cluster or nodes have been removed due to too much connection error')
+        );
+        return;
+      }
+
+      if (avoidNodeKey === undefined) callback(new Error(`No node found for pattern '${pattern}'`));
+      const errMsg = `No Connection available for '${pattern}'${
+        lastError ? '. Last connection error was: ' + lastError.message : ''
+      }`;
+      callback(new Error(errMsg));
+      return;
+    }
+    if (remainingRetry === undefined) remainingRetry = matchingNodeList.length;
+    const retry =
+      --remainingRetry >= 0
+        ? this._getConnectionCallback.bind(this, pattern, selector, callback, remainingRetry)
+        : null;
+    try {
+      const nodeKey = this._selectPool(matchingNodeList, selector, avoidNodeKey);
+      this._handleConnectionCallbackError(matchingNodeList, nodeKey, retry, callback);
+    } catch (e) {
+      callback(e);
+    }
+  }
+
+  /**
+   * Selecting nodes according to pattern.
+   *
+   * @param pattern pattern
+   * @return {*}
+   * @private
+   */
+  _matchingNodes(pattern) {
+    if (this.#cachedPatterns[pattern]) return this.#cachedPatterns[pattern];
+
+    const regex = RegExp(pattern);
+    const matchingNodeList = [];
+    Object.keys(this.#nodes).forEach((key) => {
+      if (regex.test(key)) {
+        matchingNodeList.push(key);
+      }
+    });
+
+    this.#cachedPatterns[pattern] = matchingNodeList;
+    return matchingNodeList;
+  }
+
+  /**
+   * Select the next node to be chosen in the nodeList according to selector and failed nodes.
+   *
+   * @param nodeList        current node list
+   * @param selectorParam   selector
+   * @param avoidNodeKey    last failing node to avoid selecting this one.
+   * @return {Promise}
+   * @private
+   */
+  _selectPool(nodeList, selectorParam, avoidNodeKey) {
+    const selector = selectorParam || this.#opts.defaultSelector;
+
+    let selectorFct;
+    switch (selector) {
+      case 'RR':
+        selectorFct = roundRobinSelector;
+        break;
+
+      case 'RANDOM':
+        selectorFct = randomSelector;
+        break;
+
+      case 'ORDER':
+        selectorFct = orderedSelector;
+        break;
+
+      default:
+        throw new Error(`Wrong selector value '${selector}'. Possible values are 'RR','RANDOM' or 'ORDER'`);
+    }
+
+    let nodeIdx = 0;
+    let nodeKey = selectorFct(nodeList, nodeIdx);
+    // first loop : search for node not blacklisted AND not the avoided key
+    while (
+      (avoidNodeKey === nodeKey ||
+        (this.#nodes[nodeKey].blacklistedUntil && this.#nodes[nodeKey].blacklistedUntil > Date.now())) &&
+      nodeIdx < nodeList.length - 1
+    ) {
+      nodeIdx++;
+      nodeKey = selectorFct(nodeList, nodeIdx);
+    }
+
+    if (avoidNodeKey === nodeKey) {
+      // second loop, search even in blacklisted node in order to choose a different node than to be avoided
+      nodeIdx = 0;
+      while (avoidNodeKey === nodeKey && nodeIdx < nodeList.length - 1) {
+        nodeIdx++;
+        nodeKey = selectorFct(nodeList, nodeIdx);
+      }
+    }
+
+    return nodeKey;
+  }
+
+  /**
+   * Handle node blacklisting and potential removal after a connection error
+   *
+   * @param {string} nodeKey - The key of the node that failed
+   * @param {Array<string>} nodeList - List of available nodes
+   * @returns {void}
+   * @private
+   */
+  _handleNodeFailure(nodeKey, nodeList) {
+    const node = this.#nodes[nodeKey];
+    if (!node) return;
+
+    const cluster = this;
+
+    // Increment error count and blacklist node temporarily
+    node.errorCount = node.errorCount ? node.errorCount + 1 : 1;
+    node.blacklistedUntil = Date.now() + cluster.#opts.restoreNodeTimeout;
+
+    // Check if node should be removed due to excessive errors
+    if (
+      cluster.#opts.removeNodeErrorCount &&
+      node.errorCount >= cluster.#opts.removeNodeErrorCount &&
+      cluster.#nodes[nodeKey]
+    ) {
+      delete cluster.#nodes[nodeKey];
+      cluster.#cachedPatterns = {};
+      delete nodeList.lastRrIdx;
+      setImmediate(cluster.emit.bind(cluster, 'remove', nodeKey));
+
+      if (node instanceof PoolCallback) {
+        node.end(() => {
+          // Intentionally ignore error during cleanup
+        });
+      } else {
+        node.end().catch((err) => {
+          // Intentionally ignore error during cleanup
+        });
+      }
+    }
+  }
+
+  /**
+   * Connect, or if fail handle retry / set timeout error
+   *
+   * @param nodeList    current node list
+   * @param nodeKey     node name to connect
+   * @param retryFct    retry function
+   * @return {Promise}
+   * @private
+   */
+  _handleConnectionError(nodeList, nodeKey, retryFct) {
+    const cluster = this;
+    const node = this.#nodes[nodeKey];
+
+    return node
+      .getConnection()
+      .then((conn) => {
+        // Connection successful, reset error state
+        node.blacklistedUntil = null;
+        node.errorCount = 0;
+        return conn;
+      })
+      .catch((err) => {
+        this._handleNodeFailure(nodeKey, nodeList);
+
+        if (nodeList.length !== 0 && cluster.#opts.canRetry && retryFct) {
+          return retryFct(nodeKey, err);
+        }
+        return Promise.reject(err);
+      });
+  }
+
+  /**
+   * Connect, or if fail handle retry / set timeout error
+   *
+   * @param nodeList    current node list
+   * @param nodeKey     node name to connect
+   * @param retryFct    retry function
+   * @param callback    callback function
+   * @private
+   */
+  _handleConnectionCallbackError(nodeList, nodeKey, retryFct, callback) {
+    const cluster = this;
+    const node = this.#nodes[nodeKey];
+
+    node.getConnection((err, conn) => {
+      if (err) {
+        this._handleNodeFailure(nodeKey, nodeList);
+
+        if (nodeList.length !== 0 && cluster.#opts.canRetry && retryFct) {
+          return retryFct(nodeKey, err);
+        }
+
+        callback(err);
+      } else {
+        // Connection successful, reset error state
+        node.blacklistedUntil = null;
+        node.errorCount = 0;
+        callback(null, conn);
+      }
+    });
+  }
+
+  //*****************************************************************
+  // internal public testing methods
+  //*****************************************************************
+
+  get __tests() {
+    return new TestMethods(this.#nodes);
+  }
+}
+
+class TestMethods {
+  #nodes;
+
+  constructor(nodes) {
+    this.#nodes = nodes;
+  }
+  getNodes() {
+    return this.#nodes;
+  }
+}
+
+/**
+ * Round robin selector: using nodes one after the other.
+ *
+ * @param nodeList  node list
+ * @return {String}
+ */
+const roundRobinSelector = (nodeList) => {
+  let lastRoundRobin = nodeList.lastRrIdx;
+  if (lastRoundRobin === undefined) lastRoundRobin = -1;
+  if (++lastRoundRobin >= nodeList.length) lastRoundRobin = 0;
+  nodeList.lastRrIdx = lastRoundRobin;
+  return nodeList[lastRoundRobin];
+};
+
+/**
+ * Random selector: use a random node.
+ *
+ * @param {Array<string>} nodeList - List of available nodes
+ * @return {String} - Selected node key
+ */
+const randomSelector = (nodeList) => {
+  const randomIdx = Math.floor(Math.random() * nodeList.length);
+  return nodeList[randomIdx];
+};
+
+/**
+ * Ordered selector: always use the nodes in sequence, unless failing.
+ *
+ * @param nodeList  node list
+ * @param retry     sequence number if last node is tagged has failing
+ * @return {String}
+ */
+const orderedSelector = (nodeList, retry) => {
+  return nodeList[retry];
+};
+
+module.exports = Cluster;