@nocobase/plugin-multi-app-manager 2.1.0-alpha.1 → 2.1.0-alpha.11

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

@@ -1,202 +0,0 @@
-'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

@@ -1,66 +0,0 @@
-'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

@@ -1,407 +0,0 @@
-'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;