@e-mc/db 0.0.2 → 0.0.4

package/mysql/index.js

@@ -1,332 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = exports.setAuthentication = void 0;
-const util_1 = require("../util");
-const types_1 = require("../../types");
-const index_1 = require("../index");
-const pool_1 = require("../pool");
-class MySQLPool extends pool_1.default {
-    getConnection() {
-        return this.client.getConnection();
-    }
-    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 POOL_STATE = {};
-function removePoolProperties(credential) {
-    if (!credential.uuidKey && ('ssl' in credential || 'connectionLimit' in credential || 'queueLimit' in credential || 'waitForConnections' in credential || 'enableKeepAlive' in credential || 'keepAliveInitialDelay' in credential || 'connectTimeout' in credential)) {
-        return { ...credential, ssl: (0, types_1.isObject)(credential.ssl) ? true : undefined, connectionLimit: undefined, queueLimit: undefined, waitForConnections: undefined, enableKeepAlive: undefined, keepAliveInitialDelay: undefined, connectTimeout: undefined };
-    }
-    return credential;
-}
-function removeUUIDKey(credential) {
-    if ('uuidKey' in credential) {
-        credential = { ...credential };
-        delete credential.uuidKey;
-        return credential;
-    }
-    return credential;
-}
-const getPoolKey = (credential) => (credential.host || '') + '_' + (credential.port || '3306') + (credential.user || '') + '_' + (credential.password || '') + '_' + (credential.database || '') + '_' + (credential.uri || '') + '_' + (credential.rowsAsArray ? '1' : '0');
-function setAuthentication(credential) {
-    const auth = (0, util_1.parseServerAuth)(credential);
-    credential.host || (credential.host = auth.hostname);
-    credential.user || (credential.user = auth.username);
-    if ((0, types_1.isPlainObject)(credential.ssl)) {
-        this.readTLSConfig(credential.ssl);
-    }
-}
-exports.setAuthentication = setAuthentication;
-function setCredential(item) {
-    let credential = this.getCredential(item);
-    if (credential) {
-        setAuthentication.call(this, credential);
-    }
-    else {
-        credential = { uri: item.uri };
-        item.credential = credential;
-    }
-    if (!credential.uri) {
-        const errors = [];
-        if (!credential.host) {
-            errors.push('host');
-        }
-        if (!credential.user) {
-            errors.push('user');
-        }
-        if (errors.length) {
-            throw (0, types_1.errorMessage)("mysql" /* STRINGS.MODULE_NAME */, 'Not defined - ' + errors.join(' | '));
-        }
-    }
-    const usePool = item.usePool;
-    if (usePool) {
-        let username, password, pool;
-        if (typeof usePool === 'string' && (username = credential.user || credential.uri && (0, util_1.parseConnectionString)(credential.uri)?.username)) {
-            [password, pool] = pool_1.default.validateKey(POOL_STATE, username, usePool);
-            if (pool) {
-                pool.add(item, password);
-                return;
-            }
-        }
-        const poolKey = getPoolKey(credential);
-        if (!(pool = POOL_STATE[poolKey]) || pool.closed) {
-            const { createPool } = require("mysql2/promise" /* STRINGS.PACKAGE_NAME */);
-            const config = this.getPoolConfig("mysql" /* STRINGS.MODULE_NAME */, password);
-            if (config) {
-                const { max, queue_max } = config;
-                if (max > 0) {
-                    credential.connectionLimit ?? (credential.connectionLimit = max);
-                }
-                if (queue_max >= 0) {
-                    credential.queueLimit ?? (credential.queueLimit = queue_max);
-                }
-            }
-            new MySQLPool(createPool(removeUUIDKey(credential)), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
-        }
-        else {
-            pool.add(item);
-        }
-    }
-}
-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) {
-        return [];
-    }
-    const db = require("mysql2/promise" /* STRINGS.PACKAGE_NAME */);
-    let parallel, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if ((0, types_1.isPlainObject)(options)) {
-        ({ parallel, connectOnce, errorQuery, sessionKey, outCacheMiss } = options);
-    }
-    else {
-        if (typeof options === 'string') {
-            sessionKey = options;
-        }
-        options = undefined;
-    }
-    if (length === 1) {
-        connectOnce = false;
-        parallel = false;
-    }
-    else if (parallel === undefined) {
-        parallel = !batch.some(item => item.parallel === false);
-    }
-    if (!parallel) {
-        outResult || (outResult = new Array(length));
-    }
-    const caching = this.hasCache("mysql" /* STRINGS.MODULE_NAME */, sessionKey);
-    const tasks = new Array(length);
-    const clients = [];
-    const pools = [];
-    let mysqlPool, mysqlClient, mysqlCredential, onceCredential = connectOnce ? batch[0].credential : undefined;
-    const getConnection = async (item, credential) => {
-        item.transactionState = 64 /* TRANSACTION_DB.AUTH */;
-        let client;
-        if (mysqlPool) {
-            pools.push(client = await mysqlPool.getConnection());
-            item.transactionState &= ~64 /* TRANSACTION_DB.AUTH */;
-            return client;
-        }
-        const pool = item.usePool && pool_1.default.findKey(POOL_STATE, item.usePool, getPoolKey(credential), ...connectOnce ? [item, batch[0]] : [item]);
-        if (pool) {
-            try {
-                pools.push(client = await pool.getConnection());
-                if (connectOnce) {
-                    mysqlPool = pool;
-                }
-                pool.connected = true;
-            }
-            catch (err) {
-                let close;
-                switch (err instanceof Error && err.code) {
-                    case 'ER_ACCESS_DENIED_ERROR':
-                        close = 1;
-                        break;
-                    default:
-                        close = pool.closeable;
-                        break;
-                }
-                if (close) {
-                    await pool.detach(true);
-                    if (close === 1) {
-                        throw err;
-                    }
-                }
-                pool.connected = false;
-            }
-        }
-        if (!client) {
-            clients.push(client = await db.createConnection(removeUUIDKey(mysqlCredential || credential)));
-        }
-        if (connectOnce) {
-            if (!parallel) {
-                mysqlClient = client;
-            }
-            mysqlCredential = credential;
-        }
-        item.transactionState &= ~64 /* TRANSACTION_DB.AUTH */;
-        return client;
-    };
-    for (let i = 0, mysql2Client, mysql2Credential; i < length; ++i) {
-        const item = batch[i];
-        const { source, query, params, ignoreCache } = item;
-        const streamRow = typeof item.streamRow === 'string' ? this.hasCoerce("mysql" /* STRINGS.MODULE_NAME */, 'options', null, mysql2Credential || item.credential) && (0, types_1.asFunction)(item.streamRow) : item.streamRow;
-        let credential, error;
-        if (streamRow) {
-            if (mysql2Credential) {
-                credential = mysql2Credential;
-                error = null;
-            }
-        }
-        else if (credential = mysqlCredential || onceCredential) {
-            error = null;
-        }
-        if (error !== null && !(0, types_1.isPlainObject)(credential = item.credential) && (error = (0, types_1.errorMessage)(source, "Invalid credentials" /* ERR_DB.CREDENTIALS */)) || !query && (error = (0, types_1.errorMessage)(source, "Missing database query" /* ERR_DB.QUERY */))) {
-            if (this.handleFail(error, item, { errorQuery })) {
-                if (!parallel) {
-                    tasks.length = 0;
-                    break;
-                }
-                tasks[i] = Promise.reject(error);
-            }
-            else if (parallel) {
-                tasks[i] = Promise.resolve([]);
-            }
-            else {
-                outResult[i] = [];
-            }
-            continue;
-        }
-        item.transactionState = 1 /* TRANSACTION_DB.ACTIVE */;
-        const renewCache = ignoreCache === 0;
-        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
-        let queryString = '';
-        if ((caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) && !streamRow) {
-            queryString = index_1.default.asString(query, true) + '_' + index_1.default.asString(params, true);
-            const result = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue);
-            if (ignoreCache !== 1) {
-                if (result) {
-                    if (parallel) {
-                        tasks[i] = Promise.resolve(result);
-                    }
-                    else {
-                        outResult[i] = result;
-                    }
-                    this.add(item, 4 /* TRANSACTION_DB.COMMIT */ | 128 /* TRANSACTION_DB.CACHE */);
-                    continue;
-                }
-                if (!ignoreCache && outCacheMiss) {
-                    outCacheMiss.push(source);
-                }
-            }
-        }
-        if (onceCredential && parallel && !streamRow) {
-            try {
-                mysqlClient = await getConnection(item, onceCredential);
-            }
-            catch {
-                connectOnce = false;
-                parallel = false;
-            }
-            onceCredential = undefined;
-        }
-        tasks[i] = new Promise(async (resolve, reject) => {
-            let commandType;
-            try {
-                if (streamRow) {
-                    const rows = [];
-                    const processRow = typeof streamRow === 'function' && streamRow;
-                    const { createConnection } = require("mysql2" /* STRINGS.PACKAGE_STREAM */);
-                    const client = mysql2Client || createConnection((mysql2Credential || credential));
-                    clients.push(client);
-                    if (connectOnce) {
-                        if (!parallel) {
-                            mysql2Client = client;
-                        }
-                        mysql2Credential = credential;
-                    }
-                    commandType = this.commandType.SELECT;
-                    client
-                        .query(query, params)
-                        .on('error', err => error || (error = err))
-                        .on('result', row => {
-                        if (processRow) {
-                            const err = processRow(row);
-                            if (err === false) {
-                                return;
-                            }
-                            if (err instanceof Error) {
-                                error = err;
-                                return;
-                            }
-                        }
-                        rows.push(row);
-                    })
-                        .on('end', () => {
-                        if (error && this.handleFail(error, item, { errorQuery, commandType })) {
-                            reject(error);
-                        }
-                        else {
-                            this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                            resolve(!error ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : rows);
-                        }
-                    });
-                }
-                else {
-                    const client = mysqlClient || await getConnection(item, credential);
-                    if (mysqlClient && parallel) {
-                        mysqlClient = undefined;
-                    }
-                    commandType = this.commandType.SELECT;
-                    const [rows] = await client.query(query, params);
-                    this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                    resolve(Array.isArray(rows) && !rows.some(row => row.constructor.name === 'OkPacket') ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
-                }
-            }
-            catch (err) {
-                if (this.handleFail(err, item, { errorQuery, commandType })) {
-                    reject(err);
-                }
-                else {
-                    resolve([]);
-                }
-            }
-        });
-        if (!parallel) {
-            try {
-                outResult[i] = await tasks[i];
-            }
-            catch {
-                tasks.length = 0;
-                break;
-            }
-        }
-    }
-    return this.processRows(batch, tasks, {
-        disconnect: () => {
-            clients.forEach(item => item.end(err => err && this.writeFail(["Unable to close connnection" /* ERR_DB.CONNECTION_CLOSE */, "mysql" /* STRINGS.MODULE_NAME */], err, { type: 65536 /* LOG_TYPE.DB */, fatal: false })));
-            pools.forEach(item => item.release());
-        },
-        parallel
-    }, outResult);
-}
-exports.executeBatchQuery = executeBatchQuery;
-function checkTimeout(value, limit = 0) {
-    return pool_1.default.checkTimeout(POOL_STATE, value, limit);
-}
-exports.checkTimeout = checkTimeout;
-exports.DB_SOURCE_CLIENT = true;
-exports.DB_SOURCE_TYPE = types_1.DB_TYPE.SQL;

package/oracle/index.d.ts

@@ -1,7 +0,0 @@
-import type { OracleDataSource } from '../../types/lib/db';
-
-import type { IDbSourceClient } from '../types';
-
-declare const Oracle: IDbSourceClient<OracleDataSource>;
-
-export = Oracle;