@pi-r/mariadb 0.7.2 → 0.8.0

package/client/index.js

@@ -1,65 +1,20 @@
 "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 mariadb = require("mariadb");
+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 MariaDBPool extends DbPool {
-    async getConnection() {
-        return this.client.getConnection();
-    }
-    async close() {
-        return this.client.end();
-    }
-    isEmpty() {
-        const client = this.client;
-        return this.closed || client.activeConnections() === 0 && client.taskQueueSize() === 0;
-    }
-    get closed() {
-        return this.client.closed;
-    }
-}
+const DbPool = require("@pi-r/mariadb/client/pool");
 const POOL_STATE = {};
-const POOL_UNUSED = ['ssl', 'connectTimeout', 'socketTimeout', 'compress', 'keepAliveDelay', 'acquireTimeout', 'connectionLimit', 'idleTimeout', 'initializationTimeout', 'minDelayValidation', 'minimumIdle', 'resetAfterUse', 'noControlAfterUse', 'leakDetectionTimeout'];
-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 isOkPacket(value) {
     const result = Array.isArray(value) ? value[0] : value;
     return !!result && !Array.isArray(result) && result.constructor.name === 'OkPacket';
 }
-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;
@@ -68,17 +23,15 @@ function setAuthentication(credential) {
         this.readTLSConfig(credential.ssl);
     }
 }
-exports.setAuthentication = setAuthentication;
 function setCredential(item) {
     let credential = this.getCredential(item);
     if (credential) {
         setAuthentication.call(this, credential);
     }
     else {
-        const uri = item.uri;
         credential = {};
-        if (uri) {
-            const connection = (0, util_1.parseConnectionString)(uri);
+        if (item.uri) {
+            const connection = (0, util_1.parseConnectionString)(item.uri);
             if (connection) {
                 const { username, password, hostname, port, database } = connection;
                 credential.host = hostname;
@@ -99,9 +52,20 @@ function setCredential(item) {
     if (!credential.user) {
         errors.push('user');
     }
-    if (errors.length) {
+    if (errors.length > 0) {
         throw (0, types_1.errorMessage)("mariadb", 'Not defined - ' + errors.join(' | '));
     }
+    if (credential.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;
@@ -142,18 +106,19 @@ function setCredential(item) {
             credential.socketTimeout ??= socket_timeout;
         }
     }
-    const poolKey = getPoolKey(credential);
+    const poolKey = DbPool.asString(credential);
     if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
         pool.add(item);
         return;
     }
-    new MariaDBPool(mariadb.createPool(removeUUIDKey(credential)), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
+    const client = mariadb.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) {
@@ -188,20 +153,18 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState = 64;
         let client;
         if (mariaDBPool) {
-            pools.push(client = await mariaDBPool.getConnection());
+            pools.push(client = await mariaDBPool.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) {
                     mariaDBPool = pool;
                 }
                 pool.connected = true;
-                POOL_ACTIVE.add(credential);
             }
             catch (err) {
                 let close;
@@ -226,7 +189,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
             }
         }
         if (!client) {
-            clients.push(client = await mariadb.createConnection(removeUUIDKey(mariaDBCredential || credential)));
+            clients.push(client = await mariadb.createConnection(DbPool.removeUUIDKey(mariaDBCredential || credential)));
         }
         if (connectOnce) {
             if (!parallel) {
@@ -267,7 +230,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);
@@ -296,14 +259,14 @@ async function executeBatchQuery(batch, options = '', outResult) {
         tasks[i] = new Promise(async (resolve, reject) => {
             let commandType;
             try {
-                const client = mariaDBClient || await getConnection(item, removeUUIDKey(credential));
+                const client = mariaDBClient || await getConnection(item, DbPool.removeUUIDKey(credential));
                 if (mariaDBClient && parallel) {
                     mariaDBClient = undefined;
                 }
                 commandType = this.commandType.SELECT;
                 if (streamRow) {
                     const rows = [];
-                    const processRow = typeof streamRow === 'function' && streamRow;
+                    const processRow = typeof streamRow === 'function' ? streamRow : null;
                     try {
                         for await (const row of client.queryStream(query, params)) {
                             if (processRow) {
@@ -327,7 +290,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);
                     }
                 }
                 else {
@@ -339,7 +302,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             resolve(row1);
                         }
                         else {
-                            resolve(!isOkPacket(row1) ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
+                            resolve(!isOkPacket(row1) ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : null);
                         }
                     }
                     else {
@@ -367,21 +330,19 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
-        disconnect: () => {
-            clients.forEach(item => {
-                item.end();
-            });
-            pools.forEach(item => {
-                item.release();
-            });
-        },
-        parallel
+        parallel,
+        disconnect() {
+            for (const item of clients) {
+                void item.end();
+            }
+            for (const item of pools) {
+                void item.release();
+            }
+        }
     }, 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, MariaDBDataSource } from '../types';
+
+import type { Pool, PoolConnection } from 'mariadb';
+
+declare const MariaDBPool: DbPoolConstructor<MariaDBDataSource, Pool, PoolConnection, DbPoolCredential>;
+
+export = MariaDBPool;

package/client/pool.js

@@ -0,0 +1,56 @@
+"use strict";
+const types_1 = require("@e-mc/types");
+const DbPool = require('@e-mc/db/pool');
+const POOL_ACTIVE = new WeakSet();
+class MariaDBPool extends DbPool {
+    static CACHE_UNUSED = ['connectTimeout', 'socketTimeout', 'compress', 'keepAliveDelay', 'acquireTimeout', 'connectionLimit', 'idleTimeout', 'initializationTimeout', 'minDelayValidation', 'minimumIdle', 'resetAfterUse', 'noControlAfterUse', 'leakDetectionTimeout'];
+    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: cert.toString('utf-8') };
+            }
+            else if ((0, types_1.isArray)(cert)) {
+                result.ssl = { cert: cert.reduce((a, b) => a + (Buffer.isBuffer(b) ? b.toString('utf-8') : b), '') };
+            }
+            else {
+                result.ssl = { cert: "Unknown" };
+            }
+        }
+        return result;
+    }
+    async getConnection(credential) {
+        if (credential) {
+            POOL_ACTIVE.add(credential);
+        }
+        return this.client.getConnection();
+    }
+    async close() {
+        return this.client.end();
+    }
+    isEmpty() {
+        const client = this.client;
+        return this.closed || client.activeConnections() === 0 && client.taskQueueSize() === 0;
+    }
+    get closed() {
+        return this.client.closed;
+    }
+}
+module.exports = MariaDBPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/mariadb",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "MariaDB 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",
+    "@e-mc/db": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
     "mariadb": "^3.3.1"
   }
 }

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 { PoolConfig, QueryConfig } from 'mariadb';
 
 export interface MariaDBDataSource<T = unknown> extends DbDataSource<string | QueryConfig, unknown, unknown, MariaDBCredential, string>, ExecuteAction<T> {
     source: "mariadb";
 }
 
-export interface MariaDBCredential extends ServerAuth, Omit<PoolConfig, "ssl"> {
-    ssl?: boolean | string | SecureContextOptions & { rejectUnauthorized?: boolean };
-}
+export type MariaDBCredential = PoolConfig & ServerAuth;
+export type DbPoolCredential = PoolConfig & IdentifierAction;