@pi-r/mysql 0.7.2 → 0.8.0

package/client/index.js

@@ -1,57 +1,17 @@
 "use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = exports.setAuthentication = void 0;
+exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
+exports.setAuthentication = setAuthentication;
+exports.setCredential = setCredential;
+exports.executeQuery = executeQuery;
+exports.executeBatchQuery = executeBatchQuery;
+exports.checkTimeout = checkTimeout;
 const main = require("mysql2");
 const mysql = require("mysql2/promise");
+const Db = require("@e-mc/db");
 const util_1 = require("@e-mc/db/util");
 const types_1 = require("@e-mc/types");
-const Db = require("@e-mc/db");
-const DbPool = require('@e-mc/db/pool');
-class MySQLPool extends DbPool {
-    async getConnection() {
-        return this.client.getConnection();
-    }
-    async close() {
-        return this.client.end();
-    }
-    isEmpty() {
-        const pool = this.client.pool;
-        return this.closed || (0, util_1.checkEmpty)(pool._allConnections) && (0, util_1.checkEmpty)(pool._connectionQueue);
-    }
-    get closed() {
-        return !!this.client.pool._closed;
-    }
-}
+const DbPool = require("@pi-r/mysql/client/pool");
 const POOL_STATE = {};
-const POOL_UNUSED = ['ssl', 'connectTimeout', 'queueLimit', 'waitForConnections', 'connectionLimit', 'maxIdle', 'idleTimeout', 'enableKeepAlive', 'keepAliveInitialDelay', 'Promise'];
-const POOL_ACTIVE = new WeakSet();
-function removePoolProperties(credential) {
-    if (!credential.uuidKey && POOL_ACTIVE.has(credential)) {
-        let result;
-        for (let i = 0, length = POOL_UNUSED.length; i < length; ++i) {
-            const attr = POOL_UNUSED[i];
-            if (attr in credential) {
-                result ||= { ...credential };
-                if (attr !== 'ssl') {
-                    delete result[attr];
-                }
-                else if ((0, types_1.isObject)(result.ssl)) {
-                    result[attr] = true;
-                }
-            }
-        }
-        if (result) {
-            return result;
-        }
-    }
-    return credential;
-}
-function removeUUIDKey(credential) {
-    if ('uuidKey' in credential) {
-        credential = { ...credential };
-        delete credential.uuidKey;
-    }
-    return credential;
-}
 function isResultSetHeader(value) {
     const result = Array.isArray(value) ? value[0] : value;
     if (result && !Array.isArray(result)) {
@@ -63,11 +23,6 @@ function isResultSetHeader(value) {
     }
     return false;
 }
-function getPoolKey(credential) {
-    if ((credential.host || credential.socketPath) && credential.user) {
-        return JSON.stringify(removeUUIDKey(credential));
-    }
-}
 function setAuthentication(credential) {
     const auth = (0, util_1.parseServerAuth)(credential);
     credential.host ||= auth.hostname;
@@ -76,7 +31,6 @@ function setAuthentication(credential) {
         this.readTLSConfig(credential.ssl);
     }
 }
-exports.setAuthentication = setAuthentication;
 function setCredential(item) {
     let credential = this.getCredential(item);
     if (credential) {
@@ -86,18 +40,37 @@ function setCredential(item) {
         credential = { uri: item.uri };
         item.credential = credential;
     }
+    let host;
     if (!credential.uri) {
         const errors = [];
-        if (!credential.host && !credential.socketPath) {
+        if (!(host = credential.host) && !credential.socketPath) {
             errors.push('host');
         }
         if (!credential.user) {
             errors.push('user');
         }
-        if (errors.length) {
+        if (errors.length > 0) {
             throw (0, types_1.errorMessage)("mysql", 'Not defined - ' + errors.join(' | '));
         }
     }
+    else {
+        try {
+            ({ host } = new URL(credential.uri));
+        }
+        catch {
+        }
+    }
+    if (host?.endsWith('.rds.amazonaws.com')) {
+        try {
+            const ssl = credential.ssl ||= {};
+            if ((0, types_1.isPlainObject)(ssl) && !ssl.ca) {
+                const bundle = require('aws-ssl-profiles');
+                ssl.ca = bundle.ca;
+            }
+        }
+        catch {
+        }
+    }
     const usePool = item.usePool;
     if (!usePool) {
         return;
@@ -132,18 +105,19 @@ function setCredential(item) {
             credential.connectTimeout ??= timeout;
         }
     }
-    const poolKey = getPoolKey(credential);
+    const poolKey = DbPool.asString(credential);
     if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
         pool.add(item);
         return;
     }
-    new MySQLPool(mysql.createPool(removeUUIDKey(credential)), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
+    const client = mysql.createPool(DbPool.removeUUIDKey(credential));
+    new DbPool(client, poolKey, username && password ? { username, password } : undefined)
+        .add(item)
+        .parent = POOL_STATE;
 }
-exports.setCredential = setCredential;
 async function executeQuery(item, options) {
     return (await executeBatchQuery.call(this, [item], options))[0] || [];
 }
-exports.executeQuery = executeQuery;
 async function executeBatchQuery(batch, options = '', outResult) {
     const length = batch.length;
     if (length === 0) {
@@ -178,20 +152,18 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState = 64;
         let client;
         if (mysqlPool) {
-            pools.push(client = await mysqlPool.getConnection());
+            pools.push(client = await mysqlPool.getConnection(credential));
             item.transactionState &= ~64;
-            POOL_ACTIVE.add(credential);
             return client;
         }
-        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, getPoolKey(credential), ...connectOnce ? [item, batch[0]] : [item]);
+        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential), ...connectOnce ? [item, batch[0]] : [item]);
         if (pool) {
             try {
-                pools.push(client = await pool.getConnection());
+                pools.push(client = await pool.getConnection(credential));
                 if (connectOnce) {
                     mysqlPool = pool;
                 }
                 pool.connected = true;
-                POOL_ACTIVE.add(credential);
             }
             catch (err) {
                 let close;
@@ -216,7 +188,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
             }
         }
         if (!client) {
-            clients.push(client = await mysql.createConnection(removeUUIDKey(mysqlCredential || credential)));
+            clients.push(client = await mysql.createConnection(DbPool.removeUUIDKey(mysqlCredential || credential)));
         }
         if (connectOnce) {
             if (!parallel) {
@@ -266,7 +238,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         if (caching && ignoreCache !== true && !streamRow) {
             queryString = Db.asString(query, true) + '_' + Db.asString(params, true);
             if (ignoreCache !== 1) {
-                const result = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue);
+                const result = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue);
                 if (result) {
                     if (parallel) {
                         tasks[i] = Promise.resolve(result);
@@ -297,8 +269,8 @@ async function executeBatchQuery(batch, options = '', outResult) {
             try {
                 if (streamRow) {
                     const rows = [];
-                    const processRow = typeof streamRow === 'function' && streamRow;
-                    const client = mysql2Client || main.createConnection(removeUUIDKey(mysql2Credential || credential));
+                    const processRow = typeof streamRow === 'function' ? streamRow : null;
+                    const client = mysql2Client || main.createConnection(DbPool.removeUUIDKey(mysql2Credential || credential));
                     clients.push(client);
                     if (connectOnce) {
                         if (!parallel) {
@@ -329,7 +301,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                         else {
                             this.add(item, 4);
-                            resolve(!error ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : rows.length ? rows : null);
+                            resolve(!error ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : rows.length > 0 ? rows : null);
                         }
                     });
                 }
@@ -347,7 +319,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             resolve(row1);
                         }
                         else {
-                            resolve(!isResultSetHeader(row1) ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
+                            resolve(!isResultSetHeader(row1) ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : null);
                         }
                     }
                     else {
@@ -375,25 +347,23 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
+        parallel,
         disconnect: () => {
-            clients.forEach(item => {
-                item.end(err => {
+            for (const item of clients) {
+                void item.end(err => {
                     if (err) {
                         this.writeFail(["Unable to close connnection", "mysql"], err, { type: 65536, fatal: false });
                     }
                 });
-            });
-            pools.forEach(item => {
+            }
+            for (const item of pools) {
                 item.release();
-            });
-        },
-        parallel
+            }
+        }
     }, outResult);
 }
-exports.executeBatchQuery = executeBatchQuery;
 async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
-exports.checkTimeout = checkTimeout;
 exports.DB_SOURCE_CLIENT = true;
 exports.DB_SOURCE_TYPE = types_1.DB_TYPE.SQL;

package/client/pool.d.ts

@@ -0,0 +1,9 @@
+import type { DbPoolConstructor } from '@e-mc/types/lib/db';
+
+import type { DbPoolCredential, MySQLDataSource } from '../types';
+
+import type { Pool, PoolConnection } from 'mysql2/promise';
+
+declare const MySQLPool: DbPoolConstructor<MySQLDataSource, Pool, PoolConnection, DbPoolCredential>;
+
+export = MySQLPool;

package/client/pool.js

@@ -0,0 +1,57 @@
+"use strict";
+const util_1 = require("@e-mc/db/util");
+const types_1 = require("@e-mc/types");
+const DbPool = require('@e-mc/db/pool');
+const POOL_ACTIVE = new WeakSet();
+class MySQLPool extends DbPool {
+    static CACHE_UNUSED = ['connectTimeout', 'queueLimit', 'waitForConnections', 'connectionLimit', 'maxIdle', 'idleTimeout', 'enableKeepAlive', 'keepAliveInitialDelay', 'Promise'];
+    static asString(credential) {
+        if ((credential.host || credential.socketPath) && credential.user) {
+            return JSON.stringify(this.removeUUIDKey(credential));
+        }
+        return super.asString(credential);
+    }
+    static sanitize(credential) {
+        if (!POOL_ACTIVE.has(credential) || credential.uuidKey) {
+            return credential;
+        }
+        const ssl = credential.ssl;
+        let result = super.sanitize(credential);
+        if ((0, types_1.isObject)(ssl)) {
+            if (result === credential) {
+                result = { ...credential };
+            }
+            const cert = ssl.cert;
+            if ((0, types_1.isString)(cert)) {
+                result.ssl = cert;
+            }
+            else if (Buffer.isBuffer(cert)) {
+                result.ssl = cert.toString('utf-8');
+            }
+            else if ((0, types_1.isArray)(cert)) {
+                result.ssl = cert.reduce((a, b) => a + (Buffer.isBuffer(b) ? b.toString('utf-8') : b), '');
+            }
+            else {
+                result.ssl = "Unknown";
+            }
+        }
+        return result;
+    }
+    async getConnection(credential) {
+        if (credential) {
+            POOL_ACTIVE.add(credential);
+        }
+        return this.client.getConnection();
+    }
+    async close() {
+        return this.client.end();
+    }
+    isEmpty() {
+        const pool = this.client.pool;
+        return this.closed || (0, util_1.checkEmpty)(pool._allConnections) && (0, util_1.checkEmpty)(pool._connectionQueue);
+    }
+    get closed() {
+        return !!this.client.pool._closed;
+    }
+}
+module.exports = MySQLPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/mysql",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "MySQL client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.9.4",
-    "@e-mc/types": "^0.9.4",
-    "mysql2": "^3.10.1"
+    "@e-mc/db": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
+    "mysql2": "^3.11.0"
   }
 }

package/types/index.d.ts

@@ -1,15 +1,13 @@
 import type { DbDataSource } from '@e-mc/types/lib/squared';
 
+import type { IdentifierAction } from '@e-mc/types/lib/core';
 import type { ExecuteAction, ServerAuth } from '@e-mc/types/lib/db';
 
-import type { SecureContextOptions } from 'tls';
-
 import type { PoolOptions, QueryOptions } from 'mysql2/promise';
 
 export interface MySQLDataSource<T = unknown> extends DbDataSource<string | QueryOptions, unknown, unknown, MySQLCredential, string>, ExecuteAction<T> {
     source: "mysql";
 }
 
-export interface MySQLCredential extends ServerAuth, Omit<PoolOptions, "ssl"> {
-    ssl?: boolean | string | SecureContextOptions & { rejectUnauthorized?: boolean };
-}
+export type MySQLCredential = PoolOptions & ServerAuth;
+export type DbPoolCredential = PoolOptions & IdentifierAction;