@tachybase/module-multi-app 1.5.1 → 1.6.1

package/dist/node_modules/mariadb/lib/config/cluster-options.js

@@ -0,0 +1,23 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
+'use strict';
+
+class ClusterOptions {
+  constructor(opts) {
+    if (opts) {
+      this.canRetry = opts.canRetry === undefined ? true : Boolean(opts.canRetry);
+      this.removeNodeErrorCount =
+        opts.removeNodeErrorCount === undefined ? Number.POSITIVE_INFINITY : Number(opts.removeNodeErrorCount);
+      this.restoreNodeTimeout = opts.restoreNodeTimeout === undefined ? 1000 : Number(opts.restoreNodeTimeout);
+      this.defaultSelector = opts.defaultSelector || 'RR';
+    } else {
+      this.canRetry = true;
+      this.removeNodeErrorCount = Number.POSITIVE_INFINITY;
+      this.restoreNodeTimeout = 1000;
+      this.defaultSelector = 'RR';
+    }
+  }
+}
+
+module.exports = ClusterOptions;

package/dist/node_modules/mariadb/lib/config/connection-options.js

@@ -1,9 +1,10 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2025 MariaDB Corporation Ab
+
 'use strict';
 
 const Collations = require('../const/collations.js');
 const urlFormat = /mariadb:\/\/(([^/@:]+)?(:([^/]+))?@)?(([^/:]+)(:([0-9]+))?)\/([^?]+)(\?(.*))?$/;
-const moment = require('moment-timezone');
-const Errors = require('../misc/errors');
 
 /**
  * Default option similar to mysql driver.
@@ -24,199 +25,264 @@ class ConnectionOptions {
 
     if (!opts) opts = {};
     this.host = opts.host || 'localhost';
-    this.port = opts.port || 3306;
+    this.port = opts.port ? Number(opts.port) : 3306;
+    this.keepEof = Boolean(opts.keepEof) || false;
     this.user = opts.user || process.env.USERNAME;
     this.password = opts.password;
     this.database = opts.database;
+    this.stream = opts.stream;
+    this.fullResult = opts.fullResult;
+
+    // log
+    this.debug = Boolean(opts.debug) || false;
+    this.debugCompress = Boolean(opts.debugCompress) || false;
+    this.debugLen = opts.debugLen ? Number(opts.debugLen) : 256;
+    this.logParam = opts.logParam === undefined ? true : Boolean(opts.logParam);
+    if (opts.logger) {
+      if (typeof opts.logger === 'function') {
+        this.logger = {
+          network: opts.logger,
+          query: opts.logger,
+          error: opts.logger,
+          warning: opts.logger
+        };
+      } else {
+        this.logger = {
+          network: opts.logger.network,
+          query: opts.logger.query,
+          error: opts.logger.error,
+          warning: opts.logger.warning || console.log
+        };
+        if (opts.logger.logParam !== undefined) this.logParam = Boolean(opts.logger.logParam);
+      }
+    } else {
+      this.logger = {
+        network: this.debug || this.debugCompress ? console.log : null,
+        query: null,
+        error: null,
+        warning: console.log
+      };
+    }
+    this.debug = !!this.logger.network;
+
     if (opts.charset && typeof opts.charset === 'string') {
       this.collation = Collations.fromCharset(opts.charset.toLowerCase());
       if (this.collation === undefined) {
         this.collation = Collations.fromName(opts.charset.toUpperCase());
         if (this.collation !== undefined) {
-          console.log(
+          this.logger.warning(
             "warning: please use option 'collation' " +
               "in replacement of 'charset' when using a collation name ('" +
               opts.charset +
               "')\n" +
               "(collation looks like 'UTF8MB4_UNICODE_CI', charset like 'utf8')."
           );
+        } else {
+          this.charset = opts.charset;
         }
       }
-      if (this.collation === undefined)
-        throw new RangeError("Unknown charset '" + opts.charset + "'");
     } else if (opts.collation && typeof opts.collation === 'string') {
       this.collation = Collations.fromName(opts.collation.toUpperCase());
-      if (this.collation === undefined)
-        throw new RangeError("Unknown collation '" + opts.collation + "'");
+      if (this.collation === undefined) throw new RangeError("Unknown collation '" + opts.collation + "'");
     } else {
-      this.collation = Collations.fromIndex(opts.charsetNumber) || Collations.fromIndex(224); //UTF8MB4_UNICODE_CI;
+      this.collation = opts.charsetNumber ? Collations.fromIndex(Number(opts.charsetNumber)) : undefined;
     }
 
     // connection options
     this.initSql = opts.initSql;
-    this.connectTimeout = opts.connectTimeout === undefined ? 1000 : opts.connectTimeout;
+    this.connectTimeout = opts.connectTimeout === undefined ? 1000 : Number(opts.connectTimeout);
     this.connectAttributes = opts.connectAttributes || false;
-    this.compress = opts.compress || false;
+    this.compress = Boolean(opts.compress) || false;
     this.rsaPublicKey = opts.rsaPublicKey;
     this.cachingRsaPublicKey = opts.cachingRsaPublicKey;
-    this.allowPublicKeyRetrieval = opts.allowPublicKeyRetrieval || false;
-    this.forceVersionCheck = opts.forceVersionCheck || false;
-    this.maxAllowedPacket = opts.maxAllowedPacket;
-    this.permitConnectionWhenExpired = opts.permitConnectionWhenExpired || false;
+    this.allowPublicKeyRetrieval = Boolean(opts.allowPublicKeyRetrieval) || false;
+    this.forceVersionCheck = Boolean(opts.forceVersionCheck) || false;
+    this.maxAllowedPacket = opts.maxAllowedPacket ? Number(opts.maxAllowedPacket) : undefined;
+    this.permitConnectionWhenExpired = Boolean(opts.permitConnectionWhenExpired) || false;
     this.pipelining = opts.pipelining;
     this.timezone = opts.timezone || 'local';
     this.socketPath = opts.socketPath;
     this.sessionVariables = opts.sessionVariables;
+    this.infileStreamFactory = opts.infileStreamFactory;
     this.ssl = opts.ssl;
     if (opts.ssl) {
       if (typeof opts.ssl !== 'boolean' && typeof opts.ssl !== 'string') {
         this.ssl.rejectUnauthorized = opts.ssl.rejectUnauthorized !== false;
       }
     }
+    this.permitRedirect =
+      opts.permitRedirect === undefined
+        ? !!this.ssl && this.ssl.rejectUnauthorized !== false
+        : Boolean(opts.permitRedirect);
 
     // socket
-    this.queryTimeout = opts.queryTimeout === undefined ? 0 : opts.queryTimeout;
-    this.socketTimeout = opts.socketTimeout === undefined ? 0 : opts.socketTimeout;
-    this.keepAliveDelay = opts.keepAliveDelay === undefined ? 0 : opts.keepAliveDelay;
-
-    // log
-    this.debug = opts.debug || false;
-    this.debugCompress = opts.debugCompress || false;
-    this.debugLen = opts.debugLen || 256;
-    this.logPackets = opts.logPackets || false;
-    this.trace = opts.trace || false;
+    this.queryTimeout = isNaN(opts.queryTimeout) || Number(opts.queryTimeout) < 0 ? 0 : Number(opts.queryTimeout);
+    this.socketTimeout = isNaN(opts.socketTimeout) || Number(opts.socketTimeout) < 0 ? 0 : Number(opts.socketTimeout);
+    this.keepAliveDelay = opts.keepAliveDelay === undefined ? 0 : Number(opts.keepAliveDelay);
+    if (!opts.keepAliveDelay) {
+      // for mysql2 compatibility, check keepAliveInitialDelay/enableKeepAlive options.
+      if (opts.enableKeepAlive === true && opts.keepAliveInitialDelay !== undefined) {
+        this.keepAliveDelay = Number(opts.keepAliveInitialDelay);
+      }
+    }
+    this.trace = Boolean(opts.trace) || false;
 
     // result-set
-    this.checkDuplicate = opts.checkDuplicate === undefined ? true : opts.checkDuplicate;
-    this.dateStrings = opts.dateStrings || false;
-    this.foundRows = opts.foundRows === undefined || opts.foundRows;
-    this.metaAsArray = opts.metaAsArray || false;
-    this.multipleStatements = opts.multipleStatements || false;
-    this.namedPlaceholders = opts.namedPlaceholders || false;
+    this.checkDuplicate = opts.checkDuplicate === undefined ? true : Boolean(opts.checkDuplicate);
+    this.dateStrings = Boolean(opts.dateStrings) || false;
+    this.foundRows = opts.foundRows === undefined || Boolean(opts.foundRows);
+    this.metaAsArray = Boolean(opts.metaAsArray) || false;
+    this.metaEnumerable = Boolean(opts.metaEnumerable) || false;
+    this.multipleStatements = Boolean(opts.multipleStatements) || false;
+    this.namedPlaceholders = Boolean(opts.namedPlaceholders) || false;
     this.nestTables = opts.nestTables;
-    this.autoJsonMap = opts.autoJsonMap === undefined ? true : opts.autoJsonMap;
-    this.arrayParenthesis = opts.arrayParenthesis || false;
-    this.permitSetMultiParamEntries = opts.permitSetMultiParamEntries || false;
-    this.rowsAsArray = opts.rowsAsArray || false;
-    this.supportBigNumbers = opts.supportBigNumbers || false;
-    this.supportBigInt = opts.supportBigInt || false;
-    this.skipSetTimezone = opts.skipSetTimezone || false;
+    this.autoJsonMap = opts.autoJsonMap === undefined ? true : Boolean(opts.autoJsonMap);
+    this.jsonStrings = Boolean(opts.jsonStrings) || false;
+    if (opts.jsonStrings !== undefined) {
+      this.autoJsonMap = !this.jsonStrings;
+    }
+    this.bitOneIsBoolean = opts.bitOneIsBoolean === undefined ? true : Boolean(opts.bitOneIsBoolean);
+    this.arrayParenthesis = Boolean(opts.arrayParenthesis) || false;
+    this.permitSetMultiParamEntries = Boolean(opts.permitSetMultiParamEntries) || false;
+    this.rowsAsArray = Boolean(opts.rowsAsArray) || false;
     this.typeCast = opts.typeCast;
     if (this.typeCast !== undefined && typeof this.typeCast !== 'function') {
       this.typeCast = undefined;
     }
-    this.bigNumberStrings = opts.bigNumberStrings || false;
-    this.bulk = opts.bulk === undefined || opts.bulk;
+    this.bulk = opts.bulk === undefined || Boolean(opts.bulk);
+    this.checkNumberRange = Boolean(opts.checkNumberRange) || false;
 
     // coherence check
     if (opts.pipelining === undefined) {
-      this.permitLocalInfile = opts.permitLocalInfile || false;
+      this.permitLocalInfile = Boolean(opts.permitLocalInfile) || false;
       this.pipelining = !this.permitLocalInfile;
     } else {
-      this.pipelining = opts.pipelining;
+      this.pipelining = Boolean(opts.pipelining);
       if (opts.permitLocalInfile === true && this.pipelining) {
         throw new Error(
           'enabling options `permitLocalInfile` and `pipelining` is not possible, options are incompatible.'
         );
       }
-      this.permitLocalInfile = this.pipelining ? false : opts.permitLocalInfile || false;
-    }
-    if (this.maxAllowedPacket && !Number.isInteger(this.maxAllowedPacket)) {
-      throw new RangeError(
-        "maxAllowedPacket must be an integer. was '" + this.maxAllowedPacket + "'"
-      );
+      this.permitLocalInfile = this.pipelining ? false : Boolean(opts.permitLocalInfile) || false;
     }
-    if (this.timezone && this.timezone !== 'local' && this.timezone !== 'auto') {
-      let tzName = this.timezone;
-      if (this.timezone === 'Z') {
-        tzName = 'Etc/UTC';
-      } else {
-        const matched = this.timezone.match(/([+\-\s])(\d\d):?(\d\d)?/);
-        if (matched) {
-          const hour = (matched[1] === '-' ? 1 : -1) * Number.parseInt(matched[2], 10);
-          const minutes = matched.length > 2 && matched[3] ? Number.parseInt(matched[3], 10) : 0;
-          if (minutes > 0) {
-            throw new RangeError(
-              "timezone format incompatible with IANA standard timezone format was '" +
-                this.timezone +
-                "'"
-            );
-          }
-          if (hour == 0) {
-            tzName = 'Etc/UTC';
-          } else {
-            tzName = 'Etc/GMT' + (matched[1] === '-' ? '+' : '') + hour;
-          }
-        }
-      }
-      this._localTz = moment.tz.guess();
-      if (tzName === this._localTz) {
-        this.tz = null;
-      } else {
-        this.tz = tzName;
-        if (!moment.tz.zone(tzName)) {
-          throw Errors.createError(
-            "Unknown IANA timezone '" + tzName + "'.",
-            null,
-            true,
-            null,
-            '08S01',
-            Errors.ER_WRONG_IANA_TIMEZONE
-          );
-        }
+    this.prepareCacheLength = opts.prepareCacheLength === undefined ? 256 : Number(opts.prepareCacheLength);
+    this.restrictedAuth = opts.restrictedAuth;
+    if (this.restrictedAuth != null) {
+      if (!Array.isArray(this.restrictedAuth)) {
+        this.restrictedAuth = this.restrictedAuth.split(',');
       }
     }
+
+    // for compatibility with 2.x version and mysql/mysql2
+    this.bigIntAsNumber = Boolean(opts.bigIntAsNumber) || false;
+    this.insertIdAsNumber = Boolean(opts.insertIdAsNumber) || false;
+    this.decimalAsNumber = Boolean(opts.decimalAsNumber) || false;
+    this.supportBigNumbers = Boolean(opts.supportBigNumbers) || false;
+    this.bigNumberStrings = Boolean(opts.bigNumberStrings) || false;
+
+    if (opts.maxAllowedPacket && isNaN(this.maxAllowedPacket)) {
+      throw new RangeError(`maxAllowedPacket must be an integer. was '${opts.maxAllowedPacket}'`);
+    }
   }
 
   /**
    * When parsing from String, correcting type.
    *
-   * @param opts options
-   * @return {opts}
+   * @param {object} opts - options
+   * @return {object} options with corrected data types
    */
   static parseOptionDataType(opts) {
-    if (opts.bigNumberStrings) opts.bigNumberStrings = opts.bigNumberStrings == 'true';
-    if (opts.bulk) opts.bulk = opts.bulk == 'true';
-    if (opts.rsaPublicKey) opts.rsaPublicKey = opts.rsaPublicKey;
-    if (opts.cachingRsaPublicKey) opts.cachingRsaPublicKey = opts.cachingRsaPublicKey;
-    if (opts.logPackets) opts.logPackets = opts.logPackets == 'true';
-    if (opts.allowPublicKeyRetrieval)
-      opts.allowPublicKeyRetrieval = opts.allowPublicKeyRetrieval == 'true';
+    // Convert boolean strings to boolean values
+    const booleanOptions = [
+      'bulk',
+      'allowPublicKeyRetrieval',
+      'insertIdAsNumber',
+      'decimalAsNumber',
+      'bigIntAsNumber',
+      'permitRedirect',
+      'logParam',
+      'compress',
+      'dateStrings',
+      'debug',
+      'autoJsonMap',
+      'arrayParenthesis',
+      'checkDuplicate',
+      'debugCompress',
+      'foundRows',
+      'metaAsArray',
+      'metaEnumerable',
+      'multipleStatements',
+      'namedPlaceholders',
+      'nestTables',
+      'permitSetMultiParamEntries',
+      'pipelining',
+      'forceVersionCheck',
+      'rowsAsArray',
+      'trace',
+      'bitOneIsBoolean',
+      'jsonStrings',
+      'enableKeepAlive',
+      'supportBigNumbers',
+      'bigNumberStrings',
+      'keepEof',
+      'permitLocalInfile',
+      'permitConnectionWhenExpired'
+    ];
+
+    booleanOptions.forEach((option) => {
+      if (opts[option] !== undefined && typeof opts[option] === 'string') {
+        opts[option] = opts[option] === 'true';
+      }
+    });
+
+    // Convert numeric strings to numbers
+    const numericOptions = [
+      'charsetNumber',
+      'connectTimeout',
+      'keepAliveDelay',
+      'socketTimeout',
+      'debugLen',
+      'prepareCacheLength',
+      'queryTimeout',
+      'maxAllowedPacket',
+      'keepAliveInitialDelay',
+      'port'
+    ];
+
+    numericOptions.forEach((option) => {
+      if (opts[option] !== undefined && typeof opts[option] === 'string') {
+        const parsedValue = parseInt(opts[option], 10);
+        if (!isNaN(parsedValue)) {
+          opts[option] = parsedValue;
+        }
+      }
+    });
 
-    if (opts.charsetNumber && !isNaN(Number.parseInt(opts.charsetNumber))) {
-      opts.charsetNumber = Number.parseInt(opts.charsetNumber);
+    // Handle special case for SSL
+    if (opts.ssl !== undefined && typeof opts.ssl === 'string') {
+      opts.ssl = opts.ssl === 'true';
+    }
+
+    // Handle special case for connectAttributes (JSON parsing)
+    if (opts.connectAttributes !== undefined && typeof opts.connectAttributes === 'string') {
+      try {
+        opts.connectAttributes = JSON.parse(opts.connectAttributes);
+      } catch (e) {
+        throw new Error(`Failed to parse connectAttributes as JSON: ${e.message}`);
+      }
+    }
+
+    // Handle special case for sessionVariables (JSON parsing if it's a string and looks like JSON)
+    if (opts.sessionVariables !== undefined && typeof opts.sessionVariables === 'string') {
+      if (opts.sessionVariables.trim().startsWith('{')) {
+        try {
+          opts.sessionVariables = JSON.parse(opts.sessionVariables);
+        } catch (e) {
+          // If it fails to parse, keep it as a string
+        }
+      }
     }
-    if (opts.compress) opts.compress = opts.compress == 'true';
-    if (opts.connectAttributes) opts.connectAttributes = JSON.parse(opts.connectAttributes);
-    if (opts.connectTimeout) opts.connectTimeout = parseInt(opts.connectTimeout);
-    if (opts.keepAliveDelay) opts.keepAliveDelay = parseInt(opts.keepAliveDelay);
-    if (opts.socketTimeout) opts.socketTimeout = parseInt(opts.socketTimeout);
-    if (opts.dateStrings) opts.dateStrings = opts.dateStrings == 'true';
-    if (opts.debug) opts.debug = opts.debug == 'true';
-    if (opts.autoJsonMap) opts.autoJsonMap = opts.autoJsonMap == 'true';
-    if (opts.arrayParenthesis) opts.arrayParenthesis = opts.arrayParenthesis == 'true';
-    if (opts.skipSetTimezone) opts.skipSetTimezone = opts.skipSetTimezone == 'true';
 
-    if (opts.checkDuplicate) opts.checkDuplicate = opts.checkDuplicate == 'true';
-    if (opts.debugCompress) opts.debugCompress = opts.debugCompress == 'true';
-    if (opts.debugLen) opts.debugLen = parseInt(opts.debugLen);
-    if (opts.queryTimeout) opts.queryTimeout = parseInt(opts.queryTimeout);
-    if (opts.foundRows) opts.foundRows = opts.foundRows == 'true';
-    if (opts.maxAllowedPacket && !isNaN(Number.parseInt(opts.maxAllowedPacket)))
-      opts.maxAllowedPacket = parseInt(opts.maxAllowedPacket);
-    if (opts.metaAsArray) opts.metaAsArray = opts.metaAsArray == 'true';
-    if (opts.multipleStatements) opts.multipleStatements = opts.multipleStatements == 'true';
-    if (opts.namedPlaceholders) opts.namedPlaceholders = opts.namedPlaceholders == 'true';
-    if (opts.nestTables) opts.nestTables = opts.nestTables == 'true';
-    if (opts.permitSetMultiParamEntries)
-      opts.permitSetMultiParamEntries = opts.permitSetMultiParamEntries == 'true';
-    if (opts.pipelining) opts.pipelining = opts.pipelining == 'true';
-    if (opts.forceVersionCheck) opts.forceVersionCheck = opts.forceVersionCheck == 'true';
-    if (opts.rowsAsArray) opts.rowsAsArray = opts.rowsAsArray == 'true';
-    if (opts.supportBigNumbers) opts.supportBigNumbers = opts.supportBigNumbers == 'true';
-    if (opts.supportBigInt) opts.supportBigInt = opts.supportBigInt == 'true';
-    if (opts.trace) opts.trace = opts.trace == 'true';
-    if (opts.ssl && (opts.ssl == 'true' || opts.ssl == 'false')) opts.ssl = opts.ssl == 'true';
     return opts;
   }
 
@@ -225,9 +291,7 @@ class ConnectionOptions {
 
     if (!matchResults) {
       throw new Error(
-        "error parsing connection string '" +
-          opts +
-          "'. format must be 'mariadb://[<user>[:<password>]@]<host>[:<port>]/[<db>[?<opt1>=<value1>[&<opt2>=<value2>]]]'"
+        `error parsing connection string '${opts}'. format must be 'mariadb://[<user>[:<password>]@]<host>[:<port>]/[<db>[?<opt1>=<value1>[&<opt2>=<value2>]]]'`
       );
     }
     const options = {
@@ -240,8 +304,8 @@ class ConnectionOptions {
 
     const variousOptsString = matchResults[11];
     if (variousOptsString) {
-      const keyVals = variousOptsString.split('&');
-      keyVals.forEach(function (keyVal) {
+      const keyValues = variousOptsString.split('&');
+      keyValues.forEach(function (keyVal) {
         const equalIdx = keyVal.indexOf('=');
         if (equalIdx !== 1) {
           let val = keyVal.substring(equalIdx + 1);

package/dist/node_modules/mariadb/lib/config/pool-options.js

@@ -1,3 +1,6 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
 
 let ConnOptions = require('./connection-options');
@@ -7,37 +10,42 @@ class PoolOptions {
     if (typeof opts === 'string') {
       opts = ConnOptions.parse(opts);
 
-      //set data type
+      // Set data type
+      // These conversions will be replaced with explicit type casting in the main assignment below
       if (opts.acquireTimeout) opts.acquireTimeout = parseInt(opts.acquireTimeout);
       if (opts.connectionLimit) opts.connectionLimit = parseInt(opts.connectionLimit);
       if (opts.idleTimeout) opts.idleTimeout = parseInt(opts.idleTimeout);
-      if (opts.leakDetectionTimeout)
-        opts.leakDetectionTimeout = parseInt(opts.leakDetectionTimeout);
-      if (opts.initializationTimeout)
-        opts.initializationTimeout = parseInt(opts.initializationTimeout);
+      if (opts.leakDetectionTimeout) opts.leakDetectionTimeout = parseInt(opts.leakDetectionTimeout);
+      if (opts.initializationTimeout) opts.initializationTimeout = parseInt(opts.initializationTimeout);
       if (opts.minDelayValidation) opts.minDelayValidation = parseInt(opts.minDelayValidation);
       if (opts.minimumIdle) opts.minimumIdle = parseInt(opts.minimumIdle);
-      if (opts.noControlAfterUse) opts.noControlAfterUse = opts.noControlAfterUse == 'true';
-      if (opts.resetAfterUse) opts.resetAfterUse = opts.resetAfterUse == 'true';
+      if (opts.noControlAfterUse) opts.noControlAfterUse = opts.noControlAfterUse === 'true';
+      if (opts.resetAfterUse) opts.resetAfterUse = opts.resetAfterUse === 'true';
       if (opts.pingTimeout) opts.pingTimeout = parseInt(opts.pingTimeout);
     }
 
-    this.acquireTimeout = opts.acquireTimeout === undefined ? 10000 : opts.acquireTimeout;
-    this.connectionLimit = opts.connectionLimit === undefined ? 10 : opts.connectionLimit;
-    this.idleTimeout = opts.idleTimeout || 1800;
-    this.leakDetectionTimeout = opts.leakDetectionTimeout || 0;
+    // Apply explicit type conversion for all numeric options
+    this.acquireTimeout = opts.acquireTimeout === undefined ? 10000 : Number(opts.acquireTimeout);
+    this.connectionLimit = opts.connectionLimit === undefined ? 10 : Number(opts.connectionLimit);
+    this.idleTimeout = opts.idleTimeout === undefined ? 1800 : Number(opts.idleTimeout);
+    this.leakDetectionTimeout = Number(opts.leakDetectionTimeout) || 0;
     this.initializationTimeout =
-      opts.initializationTimeout === undefined ? 30000 : opts.initializationTimeout;
-    this.minDelayValidation = opts.minDelayValidation === undefined ? 500 : opts.minDelayValidation;
+      opts.initializationTimeout === undefined
+        ? Math.max(100, this.acquireTimeout - 100)
+        : Number(opts.initializationTimeout);
+    this.minDelayValidation = opts.minDelayValidation === undefined ? 500 : Number(opts.minDelayValidation);
     this.minimumIdle =
-      opts.minimumIdle === undefined
-        ? this.connectionLimit
-        : Math.min(opts.minimumIdle, this.connectionLimit);
-    this.noControlAfterUse = opts.noControlAfterUse || false;
-    this.resetAfterUse = opts.resetAfterUse === undefined ? true : opts.resetAfterUse;
-    this.pingTimeout = opts.pingTimeout || 250;
+      opts.minimumIdle === undefined ? this.connectionLimit : Math.min(Number(opts.minimumIdle), this.connectionLimit);
+
+    // Apply explicit type conversion for boolean options
+    this.noControlAfterUse = Boolean(opts.noControlAfterUse) || false;
+    this.resetAfterUse = Boolean(opts.resetAfterUse) || false;
+    this.pingTimeout = Number(opts.pingTimeout) || 250;
+
+    // Create connection options
     this.connOptions = new ConnOptions(opts);
 
+    // Adjust connectTimeout if acquireTimeout is smaller
     if (this.acquireTimeout > 0 && this.connOptions.connectTimeout > this.acquireTimeout) {
       this.connOptions.connectTimeout = this.acquireTimeout;
     }