@e-mc/db 0.0.1

package/mssql/index.js

@@ -0,0 +1,505 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = void 0;
+const types_1 = require("../../types");
+const util_1 = require("../util");
+const index_1 = require("../index");
+const pool_1 = require("../pool");
+class MSSQLPool extends pool_1.default {
+    getConnection() {
+        return new Promise((resolve, reject) => {
+            this.client.acquire((err, connection) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(connection);
+                }
+            });
+        });
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.client.drain();
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    isEmpty() {
+        return this.closed || (0, util_1.checkEmpty)(this.client.connections) && (0, util_1.checkEmpty)(this.client.waiting);
+    }
+    get closed() {
+        return !!this.client.drained;
+    }
+}
+const POOL_STATE = {};
+function convertParameters(sql, params, output) {
+    if ((0, types_1.isPlainObject)(params)) {
+        const items = [];
+        for (const name in params) {
+            items.push({ ...params[name], name });
+        }
+        params = items;
+    }
+    if (Array.isArray(params)) {
+        for (const param of params) {
+            const { name, value, options = {} } = param;
+            if (name) {
+                const type = convertType(sql, param.type, value, options);
+                if (type.name === 'TVP') {
+                    if (output || !(0, types_1.isPlainObject)(value)) {
+                        continue;
+                    }
+                    const columns = value.columns;
+                    if ((0, types_1.isArray)(columns)) {
+                        columns.forEach(col => col.type = convertType(sql, col.type, col.value, col.options || (col.options = {})));
+                    }
+                }
+                this[output ? 'addOutputParameter' : 'addParameter'](name, type, value, options);
+            }
+        }
+    }
+}
+function convertType(sql, type, value, options) {
+    let result;
+    if (typeof type === 'string') {
+        result = sql[type];
+    }
+    else if ((0, types_1.isObject)(type) && type.name) {
+        result = sql[type.name];
+    }
+    if (result) {
+        return result;
+    }
+    switch (typeof value) {
+        case 'boolean':
+            return sql.Bit;
+        case 'bigint':
+            return sql.BigInt;
+        case 'number':
+            if (value !== Math.floor(value)) {
+                return sql.Decimal;
+            }
+            if (value >= 0 && value <= 255) {
+                return sql.TinyInt;
+            }
+            if (value >= -32768 && value <= 32767) {
+                return sql.SmallInt;
+            }
+            if (value >= -2147483648 && value <= 2147483647) {
+                return sql.Int;
+            }
+            return sql.BigInt;
+        case 'string':
+            return sql.VarChar;
+        case 'object':
+            if (value instanceof Date) {
+                return sql.DateTime2;
+            }
+            if (Buffer.isBuffer(value)) {
+                options.length = Infinity;
+                return sql.VarBinary;
+            }
+        default:
+            return sql.Null;
+    }
+}
+function getPoolKey(credential) {
+    const tls = credential.options?.cryptoCredentialsDetails;
+    if (tls) {
+        if (!(0, types_1.isObject)(tls)) {
+            delete credential.options.cryptoCredentialsDetails;
+        }
+        else if (tls.ca || tls.cert || tls.key) {
+            credential = { ...credential };
+            credential.options = { ...credential.options };
+            delete credential.options.cryptoCredentialsDetails;
+            return JSON.stringify(credential) + '_tls';
+        }
+    }
+    return JSON.stringify(credential);
+}
+function isOutputParameters(params) {
+    return (0, types_1.isPlainObject)(params) && Object.keys(params).length === 2 && 'input' in params && 'output' in params;
+}
+function setCredential(item) {
+    let credential = this.getCredential(item), hostname, username, password, port, database;
+    if (credential) {
+        ({ username, password, hostname, port, database } = (0, util_1.parseServerAuth)(credential, true));
+    }
+    else {
+        credential = {};
+        if (item.uri) {
+            const connection = (0, util_1.parseConnectionString)(item.uri);
+            if (connection) {
+                ({ username, password, hostname, port, database } = connection);
+            }
+        }
+        item.credential = credential;
+    }
+    const errors = [];
+    if (hostname) {
+        credential.server || (credential.server = hostname);
+    }
+    if (!credential.server) {
+        errors.push('server');
+    }
+    const auth = credential.authentication || (credential.authentication = { options: {} });
+    const authOptions = auth.options || (auth.options = {});
+    auth.type || (auth.type = 'default');
+    if (database || port) {
+        const options = credential.options || (credential.options = {});
+        options.database || (options.database = database);
+        if (port) {
+            options.port || (options.port = +port);
+        }
+    }
+    if (username || password) {
+        authOptions.userName || (authOptions.userName = username);
+        authOptions.password || (authOptions.password = password);
+    }
+    if (!authOptions.userName) {
+        errors.push('authentication.options.userName');
+    }
+    if (!authOptions.password) {
+        errors.push('authentication.options.password');
+    }
+    if (errors.length) {
+        throw (0, types_1.errorMessage)("mssql" /* STRINGS.MODULE_NAME */, 'Not defined - ' + errors.join(' | '));
+    }
+    const options = credential.options;
+    if (options) {
+        if (options.cryptoCredentialsDetails) {
+            this.readTLSConfig(options.cryptoCredentialsDetails);
+        }
+        if ('rowCollectionOnDone' in options) {
+            delete options.rowCollectionOnDone;
+        }
+        if ('rowCollectionOnRequestCompletion' in options) {
+            delete options.rowCollectionOnRequestCompletion;
+        }
+        if ('useColumnNames' in options) {
+            delete options.useColumnNames;
+        }
+    }
+    const usePool = item.usePool;
+    if (usePool) {
+        let pool;
+        password = undefined;
+        if (typeof usePool === 'string' && (username = authOptions.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 Pool = require("tedious-connection-pool2" /* STRINGS.PACKAGE_POOL */);
+            const config = this.getPoolConfig("mssql" /* STRINGS.MODULE_NAME */, password);
+            const poolConfig = (0, types_1.isPlainObject)(item.usePool) ? item.usePool : {};
+            if (config) {
+                const { min, max, idle, queue_idle } = config;
+                if (min >= 0) {
+                    poolConfig.min ?? (poolConfig.min = min);
+                }
+                if (max > 0) {
+                    poolConfig.max ?? (poolConfig.max = max);
+                }
+                if (idle >= 0) {
+                    poolConfig.idleTimeout ?? (poolConfig.idleTimeout = idle);
+                }
+                if (queue_idle >= 0) {
+                    poolConfig.acquireTimeout ?? (poolConfig.acquireTimeout = queue_idle);
+                }
+            }
+            new MSSQLPool(new Pool(poolConfig, 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("tedious" /* 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("mssql" /* STRINGS.MODULE_NAME */, sessionKey);
+    const tasks = new Array(length);
+    const clients = [];
+    const pools = [];
+    let mssqlPool, mssqlClient, mssqlCredential, onceCredential = connectOnce ? batch[0].credential : undefined;
+    const getConnection = async (item, credential) => {
+        item.transactionState = 64 /* TRANSACTION.AUTH */;
+        let client;
+        if (mssqlPool) {
+            pools.push(client = await mssqlPool.getConnection());
+            item.transactionState &= ~64 /* TRANSACTION.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 {
+                client = await pool.getConnection();
+                if (connectOnce) {
+                    mssqlPool = pool;
+                }
+                pool.connected = true;
+            }
+            catch (err) {
+                let close;
+                switch (err instanceof Error && err.code) {
+                    case 'ELOGIN':
+                    case 'EDRIVER':
+                    case 'EINSTLOOKUP':
+                        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 new Promise((resolve, reject) => {
+                const sql = new db.Connection(mssqlCredential || credential);
+                sql.connect(err => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(sql);
+                    }
+                });
+            }));
+        }
+        if (connectOnce) {
+            if (!parallel) {
+                mssqlClient = client;
+            }
+            mssqlCredential = credential;
+        }
+        item.transactionState &= ~64 /* TRANSACTION.AUTH */;
+        return client;
+    };
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { source, query, ignoreCache } = item;
+        let credential = mssqlCredential || onceCredential, error;
+        if (!credential && !(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.ACTIVE */;
+        const streamRow = typeof item.streamRow === 'string' ? this.hasCoerce("mssql" /* STRINGS.MODULE_NAME */, 'options', null, credential) && (0, types_1.asFunction)(item.streamRow) : item.streamRow;
+        const renewCache = ignoreCache === 0;
+        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
+        let params = item.params, queryString = '';
+        if ((caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) && !streamRow) {
+            queryString = index_1.default.asString(query, true) + '_' + index_1.default.asString(params, true);
+            if (ignoreCache !== 1) {
+                const result = this.getQueryResult(source, credential, queryString, cacheValue);
+                if (result) {
+                    if (parallel) {
+                        tasks[i] = Promise.resolve(result);
+                    }
+                    else {
+                        outResult[i] = result;
+                    }
+                    this.add(item, 4 /* TRANSACTION.COMMIT */ | 128 /* TRANSACTION.CACHE */);
+                    continue;
+                }
+                if (!ignoreCache && outCacheMiss) {
+                    outCacheMiss.push(source);
+                }
+            }
+        }
+        if (onceCredential && parallel) {
+            try {
+                mssqlClient = await getConnection(item, onceCredential);
+            }
+            catch {
+                connectOnce = false;
+                parallel = false;
+            }
+            onceCredential = undefined;
+        }
+        tasks[i] = new Promise(async (resolve, reject) => {
+            let commandType;
+            try {
+                const client = mssqlClient || await getConnection(item, credential);
+                if (mssqlClient && parallel) {
+                    mssqlClient = undefined;
+                }
+                commandType = this.commandType.SELECT;
+                const processRow = typeof streamRow === 'function' && streamRow;
+                const rows = [];
+                let recordset = 1, resume, output;
+                const request = new db.Request(query, () => {
+                    if (error && this.handleFail(error, item, { errorQuery, commandType })) {
+                        reject(error);
+                    }
+                    else {
+                        this.add(item, 4 /* TRANSACTION.COMMIT */);
+                        if (output) {
+                            output['__recordset__'] = 0;
+                            output['__returnvalue__'] = true;
+                            rows.push([output]);
+                        }
+                        resolve(!error ? this.setQueryResult(source, credential, queryString, rows, cacheValue) : rows);
+                    }
+                });
+                if (params) {
+                    let paramsOutput;
+                    if (isOutputParameters(params)) {
+                        ({ input: params, output: paramsOutput } = params);
+                    }
+                    convertParameters.call(request, db.TYPES, params, false);
+                    if (paramsOutput) {
+                        convertParameters.call(request, db.TYPES, paramsOutput, true);
+                    }
+                }
+                request
+                    .on('row', columns => {
+                    resume = true;
+                    const result = { '__recordset__': recordset };
+                    for (let j = 0, q = columns.length; j < q; ++j) {
+                        const data = columns[j];
+                        const name = data.metadata.colName;
+                        if (name === 'JSON_F52E2B61-18A1-11d1-B105-00805F49916B') {
+                            try {
+                                const items = JSON.parse(data.value);
+                                if ((0, types_1.isArray)(items)) {
+                                    items.forEach((col) => col['__recordset__'] = recordset);
+                                    rows.push(...items);
+                                }
+                            }
+                            catch {
+                            }
+                            return;
+                        }
+                        result[name] = data.value;
+                    }
+                    if (processRow) {
+                        const err = processRow(result);
+                        if (err === false) {
+                            return;
+                        }
+                        if (err instanceof Error) {
+                            error = err;
+                            return;
+                        }
+                    }
+                    rows.push(result);
+                })
+                    .on('returnValue', (name, value) => (output || (output = {}))[name] = value)
+                    .on('done', rowCount => {
+                    if (resume && rowCount >= 0) {
+                        ++recordset;
+                    }
+                    resume = false;
+                })
+                    .on('doneProc', rowCount => {
+                    if (resume && rowCount >= 0) {
+                        ++recordset;
+                    }
+                    resume = false;
+                })
+                    .on('doneInProc', rowCount => {
+                    if (resume && rowCount >= 0) {
+                        ++recordset;
+                    }
+                    resume = false;
+                })
+                    .on('error', err => error || (error = err));
+                if (item.storedProc) {
+                    client.callProcedure(request);
+                }
+                else {
+                    client.execSql(request);
+                }
+            }
+            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.close());
+            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/mysql/index.d.ts

@@ -0,0 +1,10 @@
+import type { IDb } from '../../types/lib';
+import type { MySQLCredential, MySQLDataSource } from '../../types/lib/db';
+
+import type { IDbSourceClient } from '../types';
+
+declare const MySQL: IDbSourceClient<MySQLDataSource> & {
+    setAuthentication: (this: IDb, credential: MySQLCredential) => void;
+};
+
+export = MySQL;