@tachybase/module-multi-app 0.23.8

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

@@ -0,0 +1,202 @@
+'use strict';
+
+const PoolBase = require('./pool-base');
+const ConnectionCallback = require('./connection-callback');
+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);
+          }
+        }
+      });
+    });
+  };
+
+  PoolBase.call(this, options, processTaskCallback, createConnectionPoolCallback, pingPromise);
+
+  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) => {};
+
+  //*****************************************************************
+  // internal equivalent with callback of promised functions
+  //*****************************************************************
+
+  const _getConnectionCallback = (callback) => {
+    getConnectionPromise()
+      .then((conn) => {
+        if (callback) callback(null, conn);
+      })
+      .catch(callback || emptyError);
+  };
+
+  const _endCallback = (callback) => {
+    endPromise()
+      .then(() => {
+        if (callback) callback(null);
+      })
+      .catch(callback || emptyError);
+  };
+
+  /**
+   * Execute query using text 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
+   * @returns {Query} query
+   */
+  const _queryCallback = function (sql, values, cb) {
+    let _cb = cb,
+      _values = values;
+
+    if (typeof values === 'function') {
+      _cb = values;
+      _values = undefined;
+    }
+
+    queryPromise(sql, _values)
+      .then((rows) => {
+        if (_cb) _cb(null, rows, rows.meta);
+      })
+      .catch(_cb || emptyError);
+  };
+
+  const _batchCallback = function (sql, values, cb) {
+    let _values = values,
+      _cb = cb;
+
+    if (typeof values === 'function') {
+      _cb = values;
+      _values = undefined;
+    }
+
+    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;
+}
+
+util.inherits(PoolCallback, PoolBase);
+
+module.exports = PoolCallback;

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

@@ -0,0 +1,66 @@
+'use strict';
+
+const PoolCluster = require('./pool-cluster');
+const util = require('util');
+
+/**
+ * Create a new Cluster.
+ * Cluster handle pools with patterns and handle failover / distributed load
+ * according to selectors (round robin / random / ordered )
+ *
+ * @param args      cluster argurments. see pool-cluster-options.
+ * @constructor
+ */
+function PoolClusterCallback(args) {
+  PoolCluster.call(this, args);
+  this.setCallback();
+
+  const initialGetConnection = this.getConnection.bind(this);
+  const initialEnd = this.end.bind(this);
+
+  /**
+   * End cluster (and underlying pools).
+   *
+   * @param callback - not mandatory
+   */
+  this.end = (callback) => {
+    if (callback && typeof callback !== 'function') {
+      throw new Error('callback parameter must be a function');
+    }
+    const endingFct = callback ? callback : () => {};
+
+    initialEnd()
+      .then(() => {
+        endingFct();
+      })
+      .catch(endingFct);
+  };
+
+  /**
+   * Get connection from 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
+   */
+  this.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 : (conn) => {};
+
+    initialGetConnection(pat, sel, endingFct);
+  };
+}
+
+util.inherits(PoolClusterCallback, PoolCluster);
+
+module.exports = PoolClusterCallback;

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

@@ -0,0 +1,407 @@
+'use strict';
+
+const PoolClusterOptions = require('./config/pool-cluster-options');
+const PoolOptions = require('./config/pool-options');
+const Pool = require('./pool-promise');
+const PoolCallback = require('./pool-callback');
+const FilteredPoolCluster = require('./filtered-pool-cluster');
+const EventEmitter = require('events');
+const util = require('util');
+
+/**
+ * Create a new Cluster.
+ * Cluster handle pools with patterns and handle failover / distributed load
+ * according to selectors (round robin / random / ordered )
+ *
+ * @param args      cluster argurments. see pool-cluster-options.
+ * @constructor
+ */
+function PoolCluster(args) {
+  const opts = new PoolClusterOptions(args);
+  const nodes = {};
+  let cachedPatterns = {};
+  let nodeCounter = 0;
+  EventEmitter.call(this);
+
+  /**
+   * Add a new pool node to cluster.
+   *
+   * @param id      identifier
+   * @param config  pool configuration
+   */
+  this.add = (id, config) => {
+    let identifier;
+    if (typeof id === 'string' || id instanceof String) {
+      identifier = id;
+      if (nodes[identifier])
+        throw new Error("Node identifier '" + identifier + "' already exist !");
+    } else {
+      identifier = 'PoolNode-' + nodeCounter++;
+      config = id;
+    }
+    const options = new PoolOptions(config);
+    const pool = _createPool(options);
+    pool.initialize();
+    nodes[identifier] = pool;
+  };
+
+  /**
+   * End cluster (and underlying pools).
+   *
+   * @return {Promise<any[]>}
+   */
+  this.end = () => {
+    cachedPatterns = {};
+    const poolEndPromise = [];
+    Object.keys(nodes).forEach((pool) => {
+      poolEndPromise.push(nodes[pool].end());
+      delete nodes[pool];
+    });
+
+    return Promise.all(poolEndPromise);
+  };
+
+  this.of = (pattern, selector) => {
+    return new FilteredPoolCluster(this, pattern, selector);
+  };
+
+  /**
+   * Remove nodes according to pattern.
+   *
+   * @param pattern  pattern
+   */
+  this.remove = (pattern) => {
+    if (!pattern) throw new Error('pattern parameter in Cluster.remove(pattern)  is mandatory');
+
+    const regex = RegExp(pattern);
+    Object.keys(nodes).forEach((key) => {
+      if (regex.test(key)) {
+        nodes[key].end();
+        delete nodes[key];
+        cachedPatterns = {};
+      }
+    });
+  };
+
+  /**
+   * Get connection from available pools matching pattern, according to selector
+   *
+   * @param pattern       pattern filter (not mandatory)
+   * @param selector      node selector ('RR','RANDOM' or 'ORDER')
+   * @return {Promise}
+   */
+  this.getConnection = (pattern, selector) => {
+    return _getConnection(this, pattern, selector);
+  };
+
+  /**
+   * Force using callback methods.
+   */
+  this.setCallback = () => {
+    this.getConnection = _getConnectionCallback.bind(this, this);
+    _createPool = _createPoolCallback;
+  };
+
+  /**
+   * Get connection from 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
+   * @return {Promise}
+   * @private
+   */
+  const _getConnection = (cluster, pattern, selector, avoidNodeKey, lastError) => {
+    const matchingNodeList = _matchingNodes(pattern || /^/);
+
+    if (matchingNodeList.length === 0) {
+      if (Object.keys(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));
+    }
+
+    const retry = _getConnection.bind(this, this, pattern, selector);
+    try {
+      const nodeKey = _selectPool(matchingNodeList, selector, avoidNodeKey);
+      return _handleConnectionError(cluster, matchingNodeList, nodeKey, retry);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  let _createPool = (options) => {
+    return new Pool(options, false);
+  };
+
+  const _createPoolCallback = (options) => {
+    return new PoolCallback(options, false);
+  };
+
+  /**
+   * Get connection from 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 avoidNodeKey  failing node
+   * @param lastError     last error
+   * @private
+   */
+  const _getConnectionCallback = (
+    cluster,
+    pattern,
+    selector,
+    callback,
+    avoidNodeKey,
+    lastError
+  ) => {
+    const matchingNodeList = _matchingNodes(pattern || /^/);
+
+    if (matchingNodeList.length === 0) {
+      if (Object.keys(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;
+    }
+
+    const retry = _getConnectionCallback.bind(this, this, pattern, selector, callback);
+    try {
+      const nodeKey = _selectPool(matchingNodeList, selector, avoidNodeKey);
+      _handleConnectionCallbackError(this, matchingNodeList, nodeKey, retry, callback);
+    } catch (e) {
+      callback(e);
+    }
+  };
+
+  /**
+   * Selecting nodes according to pattern.
+   *
+   * @param pattern pattern
+   * @return {*}
+   * @private
+   */
+  const _matchingNodes = (pattern) => {
+    if (cachedPatterns[pattern]) return cachedPatterns[pattern];
+
+    const regex = RegExp(pattern);
+    const matchingNodeList = [];
+    Object.keys(nodes).forEach((key) => {
+      if (regex.test(key)) {
+        matchingNodeList.push(key);
+      }
+    });
+
+    cachedPatterns[pattern] = matchingNodeList;
+    return matchingNodeList;
+  };
+
+  /**
+   * Select next node to be chosen in 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
+   */
+  const _selectPool = (nodeList, selectorParam, avoidNodeKey) => {
+    const selector = selectorParam || opts.defaultSelector;
+    let retry = 0;
+    let selectorFct;
+    let nodeKey;
+    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'"
+        );
+    }
+
+    nodeKey = selectorFct(nodeList, retry);
+    while (
+      (avoidNodeKey === nodeKey || nodes[nodeKey].blacklistedUntil > Date.now()) &&
+      retry < nodeList.length - 1
+    ) {
+      retry++;
+      nodeKey = selectorFct(nodeList, retry);
+    }
+    return nodeKey;
+  };
+
+  /**
+   * 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 nodeList  node list
+   * @return {String}
+   */
+  const randomSelector = (nodeList) => {
+    let 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];
+  };
+
+  /**
+   * Connect, or if fail handle retry / set timeout error
+   *
+   * @param cluster     current cluster
+   * @param nodeList    current node list
+   * @param nodeKey     node name to connect
+   * @param retryFct    retry function
+   * @return {Promise}
+   * @private
+   */
+  const _handleConnectionError = (cluster, nodeList, nodeKey, retryFct) => {
+    const node = nodes[nodeKey];
+    return node
+      .getConnection()
+      .then((conn) => {
+        node.errorCount = 0;
+        return Promise.resolve(conn);
+      })
+      .catch((err) => {
+        node.errorCount = node.errorCount ? node.errorCount + 1 : 1;
+        node.blacklistedUntil = Date.now() + opts.restoreNodeTimeout;
+        if (
+          opts.removeNodeErrorCount &&
+          node.errorCount >= opts.removeNodeErrorCount &&
+          nodes[nodeKey]
+        ) {
+          delete nodes[nodeKey];
+          cachedPatterns = {};
+          delete nodeList.lastRrIdx;
+          process.nextTick(() => cluster.emit('remove', nodeKey));
+          //remove node from configuration if not already removed
+          node.end().catch((err) => {
+            // dismiss error
+          });
+        }
+
+        if (nodeList.length !== 0 && opts.canRetry) {
+          return retryFct(nodeKey, err);
+        }
+        return Promise.reject(err);
+      });
+  };
+
+  /**
+   * Connect, or if fail handle retry / set timeout error
+   *
+   * @param cluster     current cluster
+   * @param nodeList    current node list
+   * @param nodeKey     node name to connect
+   * @param retryFct    retry function
+   * @param callback    callback function
+   * @private
+   */
+  const _handleConnectionCallbackError = (cluster, nodeList, nodeKey, retryFct, callback) => {
+    const node = nodes[nodeKey];
+    node.getConnection((err, conn) => {
+      if (err) {
+        node.errorCount = node.errorCount ? node.errorCount + 1 : 1;
+        node.blacklistedUntil = Date.now() + opts.restoreNodeTimeout;
+        if (
+          opts.removeNodeErrorCount &&
+          node.errorCount >= opts.removeNodeErrorCount &&
+          nodes[nodeKey]
+        ) {
+          delete nodes[nodeKey];
+          cachedPatterns = {};
+          delete nodeList.lastRrIdx;
+          process.nextTick(() => cluster.emit('remove', nodeKey));
+          //remove node from configuration if not already removed
+          node.end(() => {
+            //dismiss error
+          });
+          if (nodeList.length === 0) return Promise.reject(err);
+        }
+
+        if (opts.canRetry) return retryFct(nodeKey, err);
+        callback(err);
+      } else {
+        node.errorCount = 0;
+        callback(null, conn);
+      }
+    });
+  };
+
+  //*****************************************************************
+  // internal public testing methods
+  //*****************************************************************
+
+  function TestMethods() {}
+  TestMethods.prototype.getNodes = () => {
+    return nodes;
+  };
+
+  this.__tests = new TestMethods();
+}
+
+util.inherits(PoolCluster, EventEmitter);
+
+module.exports = PoolCluster;