@tachybase/module-multi-app 1.6.0 → 1.6.2

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

@@ -1,108 +1,242 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2025 MariaDB Corporation Ab
+
 'use strict';
 
-const Connection = require('./connection');
-const PoolBase = require('./pool-base');
+const { EventEmitter } = require('events');
+
+const Pool = require('./pool');
+const ConnectionPromise = require('./connection-promise');
 const Errors = require('./misc/errors');
-const util = require('util');
-
-function PoolPromise(options) {
-  const processTaskPromise = function (conn, sql, values, isBatch) {
-    if (sql) {
-      const fct = isBatch ? conn.batch : conn.query;
-      return fct(sql, values)
-        .then((res) => {
-          conn.releaseWithoutError();
-          return Promise.resolve(res);
-        })
-        .catch((err) => {
-          conn.releaseWithoutError();
-          return Promise.reject(err);
-        });
-    }
-    return Promise.resolve(conn);
-  };
+
+class PoolPromise 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'));
+  }
+
+  get closed() {
+    return this.#pool.closed;
+  }
+
+  /**
+   * 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);
+  }
+
+  escapeId(value) {
+    return this.#pool.escapeId(value);
+  }
+
+  /**
+   * Ends pool
+   *
+   * @return Promise
+   **/
+  end() {
+    return this.#pool.end();
+  }
+
+  /**
+   * Retrieve a connection from pool.
+   * Create a new one, if limit is not reached.
+   * wait until acquireTimeout.
+   *
+   */
+  async getConnection() {
+    const cmdParam = {};
+    if (this.#pool.opts.connOptions.trace) Error.captureStackTrace(cmdParam);
+    return new Promise((resolve, reject) => {
+      this.#pool.getConnection(cmdParam, (err, baseConn) => {
+        if (err) {
+          reject(err);
+        } else {
+          const conn = new ConnectionPromise(baseConn);
+          conn.release = () => new Promise(baseConn.release);
+          conn.end = conn.release;
+          conn.close = conn.release;
+          resolve(conn);
+        }
+      });
+    });
+  }
 
   /**
-   * Add connection to pool.
+   * 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)
    */
-  const createConnectionPoolPromise = function (pool) {
-    const conn = new Connection(options.connOptions);
-    return conn
-      .connect()
-      .then(() => {
-        if (pool.closed) {
-          conn
-            .end()
-            .then(() => {})
-            .catch(() => {});
-          return Promise.reject(
-            Errors.createError(
-              'Cannot create new connection to pool, pool closed',
-              null,
-              true,
-              null,
-              '08S01',
-              Errors.ER_ADD_CONNECTION_CLOSED_POOL,
-              null
-            )
+  query(sql, values) {
+    const cmdParam = ConnectionPromise.paramSetter(sql, values);
+    if (this.#pool.opts.connOptions.trace) Error.captureStackTrace(cmdParam);
+    return new Promise((resolve, reject) => {
+      return this.#pool.getConnection(cmdParam, (err, baseConn) => {
+        if (err) {
+          reject(err);
+        } else {
+          baseConn.query(
+            cmdParam,
+            (res) => {
+              this.#pool.release(baseConn);
+              resolve(res);
+            },
+            (err) => {
+              this.#pool.release(baseConn);
+              reject(err);
+            }
           );
         }
+      });
+    });
+  }
 
-        conn.releaseWithoutError = () => {
-          conn.release().catch(() => {});
-        };
-
-        conn.forceEnd = conn.end;
-
-        conn.release = () => {
-          if (pool.closed) {
-            pool._discardConnection(conn);
-            return Promise.resolve();
-          }
-          if (options.noControlAfterUse) {
-            pool._releaseConnection(conn);
-            return Promise.resolve();
-          }
-
-          //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;
-          }
-
-          return revertFunction()
-            .then(() => {
-              pool._releaseConnection(conn);
-              return Promise.resolve();
-            })
-            .catch((err) => {
-              //uncertain connection state.
-              // discard it
-              pool._discardConnection(conn);
-              return Promise.resolve();
-            });
-        };
-        conn.end = conn.release;
-        return Promise.resolve(conn);
-      })
-      .catch((err) => {
-        return Promise.reject(err);
+  /**
+   * 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)
+   */
+  execute(sql, values) {
+    const cmdParam = ConnectionPromise.paramSetter(sql, values);
+    if (this.#pool.opts.connOptions.trace) Error.captureStackTrace(cmdParam);
+    return new Promise((resolve, reject) => {
+      return this.#pool.getConnection(cmdParam, (err, baseConn) => {
+        if (err) {
+          reject(err);
+        } else {
+          baseConn.prepareExecute(
+            cmdParam,
+            (res) => {
+              this.#pool.release(baseConn);
+              resolve(res);
+            },
+            (err) => {
+              this.#pool.release(baseConn);
+              reject(err);
+            }
+          );
+        }
       });
-  };
+    });
+  }
 
-  PoolBase.call(this, options, processTaskPromise, createConnectionPoolPromise, (conn) =>
-    conn.ping(options.pingTimeout)
-  );
-}
+  /**
+   * 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
+   */
+  batch(sql, values) {
+    const cmdParam = ConnectionPromise.paramSetter(sql, values);
+    if (this.#pool.opts.connOptions.trace) Error.captureStackTrace(cmdParam);
+    return new Promise((resolve, reject) => {
+      return this.#pool.getConnection(cmdParam, (err, baseConn) => {
+        if (err) {
+          reject(err);
+        } else {
+          baseConn.batch(
+            cmdParam,
+            (res) => {
+              this.#pool.release(baseConn);
+              resolve(res);
+            },
+            (err) => {
+              this.#pool.release(baseConn);
+              reject(err);
+            }
+          );
+        }
+      });
+    });
+  }
+
+  /**
+   * Import sql file.
+   *
+   * @param opts JSON array with 2 possible fields: file and database
+   */
+  importFile(opts) {
+    if (!opts) {
+      return Promise.reject(
+        Errors.createError(
+          'SQL file parameter is mandatory',
+          Errors.ER_MISSING_SQL_PARAMETER,
+          null,
+          'HY000',
+          null,
+          false,
+          null
+        )
+      );
+    }
 
-util.inherits(PoolPromise, PoolBase);
+    return new Promise((resolve, reject) => {
+      return this.#pool.getConnection({}, (err, baseConn) => {
+        if (err) {
+          reject(err);
+        } else {
+          baseConn.importFile(
+            { file: opts.file, database: opts.database },
+            (res) => {
+              this.#pool.release(baseConn);
+              resolve(res);
+            },
+            (err) => {
+              this.#pool.release(baseConn);
+              reject(err);
+            }
+          );
+        }
+      });
+    });
+  }
+
+  toString() {
+    return 'poolPromise(' + this.#pool.toString() + ')';
+  }
+}
 
 module.exports = PoolPromise;