@e-mc/db 0.0.2 → 0.0.4

package/oracle/index.js

@@ -1,358 +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 = void 0;
-const util_1 = require("../util");
-const types_1 = require("../../types");
-const index_1 = require("../index");
-const pool_1 = require("../pool");
-class OraclePool extends pool_1.default {
-    getConnection() {
-        return this.client.getConnection();
-    }
-    close() {
-        return this.client.close();
-    }
-    isEmpty() {
-        const { connectionsInUse, currentQueueLength } = this.client.getStatistics();
-        return this.closed || connectionsInUse === 0 && currentQueueLength === 0;
-    }
-    get closeable() {
-        return super.closeable || this.client.status === 6001 /* POOL_STATUS.DRAINING */;
-    }
-    get closed() {
-        return this.client.status === 6002 /* POOL_STATUS.CLOSED */;
-    }
-}
-const POOL_STATE = {};
-function removePoolProperties(options) {
-    if (!options.uuidKey && ('poolMax' in options || 'poolMin' in options || 'poolIncrement' in options || 'poolTimeout' in options || 'poolPingInterval' in options || 'poolMaxPerShard' in options || 'queueMax' in options || 'queueRequests' in options || 'queueTimeout' in options)) {
-        return { ...options, poolMax: undefined, poolMin: undefined, poolIncrement: undefined, poolTimeout: undefined, poolPingInterval: undefined, poolMaxPerShard: undefined, queueMax: undefined, queueRequests: undefined, queueTimeout: undefined };
-    }
-    return options;
-}
-function getPoolKey(credential) {
-    if (credential.connectString && (credential.user && credential.password || credential.externalAuth)) {
-        return credential.connectString + '_' + (credential.externalAuth ? 'external' : credential.user + '_' + credential.password) + '_' + (credential.edition || '') + '_' + (credential.tag ? credential.tag + '#' + (credential.matchAny ? '1' : '0') : '') + '_' + (credential.privilege ?? '') + '_' + index_1.default.asString(credential.shardingKey) + '_' + index_1.default.asString(credential.superShardingKey);
-    }
-}
-async function setCredential(item) {
-    let credential = this.getCredential(item), hostname, port, username, database;
-    if (credential) {
-        ({ hostname, port, username } = (0, util_1.parseServerAuth)(credential));
-        credential.user || (credential.user = username);
-        if ('database' in credential) {
-            database = credential.database;
-            delete credential.database;
-        }
-        if ('connectionString' in credential) {
-            credential.connectString || (credential.connectString = credential.connectionString);
-            delete credential.connectionString;
-        }
-    }
-    else {
-        const uri = item.uri;
-        credential = {};
-        if (uri) {
-            const connection = (0, util_1.parseConnectionString)(uri);
-            if (connection) {
-                ({ hostname, port, username: credential.user, password: credential.password, database } = connection);
-            }
-            else {
-                credential.poolAlias = uri;
-            }
-        }
-        item.credential = credential;
-    }
-    if (hostname) {
-        credential.connectString || (credential.connectString = hostname + (port ? ':' + port : '') + (database ? '/' + database : ''));
-    }
-    if (credential.externalAuth) {
-        delete credential.user;
-        delete credential.password;
-    }
-    if (!credential.poolAlias) {
-        const errors = [];
-        if (!credential.externalAuth) {
-            if (!credential.user) {
-                errors.push('user');
-            }
-            if (!credential.password) {
-                errors.push('password');
-            }
-        }
-        if (!credential.connectString) {
-            errors.push('connectString');
-        }
-        if (errors.length) {
-            throw (0, types_1.errorMessage)("oracle" /* STRINGS.MODULE_NAME */, 'Not defined - ' + errors.join(' | '));
-        }
-    }
-    const usePool = item.usePool;
-    if (usePool) {
-        const poolAlias = credential.poolAlias;
-        let password, pool;
-        if (typeof usePool === 'string' && (username = credential.user || poolAlias)) {
-            [password, pool] = pool_1.default.validateKey(POOL_STATE, username, usePool);
-            if (pool) {
-                pool.add(item, password);
-                return;
-            }
-        }
-        if (poolAlias) {
-            for (const poolKey in POOL_STATE) {
-                const current = POOL_STATE[poolKey];
-                if (current.client.poolAlias === poolAlias) {
-                    if (!current.closed) {
-                        current.add(item);
-                        return;
-                    }
-                    current.remove();
-                    break;
-                }
-            }
-        }
-        const poolKey = getPoolKey(credential);
-        if (poolKey) {
-            if (!(pool = POOL_STATE[poolKey]) || pool.closed) {
-                const { createPool } = require("oracledb" /* STRINGS.PACKAGE_NAME */);
-                const config = this.getPoolConfig("oracle" /* STRINGS.MODULE_NAME */, password);
-                if (config) {
-                    const { min, max, idle, queue_max, queue_idle } = config;
-                    if (min >= 0) {
-                        credential.poolMin ?? (credential.poolMin = min);
-                    }
-                    if (max > 0) {
-                        credential.poolMax ?? (credential.poolMax = max);
-                    }
-                    if (idle >= 0) {
-                        credential.poolTimeout ?? (credential.poolTimeout = idle / 1000);
-                    }
-                    if (queue_max >= 0) {
-                        credential.queueMax ?? (credential.queueMax = queue_max);
-                    }
-                    if (queue_idle >= 0) {
-                        credential.queueTimeout ?? (credential.queueTimeout = queue_idle);
-                    }
-                }
-                new OraclePool(await createPool(credential), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
-            }
-            else {
-                pool.add(item);
-            }
-        }
-        else {
-            item.usePool = false;
-        }
-    }
-}
-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("oracledb" /* STRINGS.PACKAGE_NAME */);
-    let parallel, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if ((0, types_1.isPlainObject)(options)) {
-        ({ parallel, connectOnce, errorQuery, sessionKey } = 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("oracle" /* STRINGS.MODULE_NAME */, sessionKey);
-    const tasks = new Array(length);
-    const clients = [];
-    let oraclePool, oracleClient, oracleCredential, onceCredential = connectOnce ? batch[0].credential : undefined;
-    const getConnection = async (item, credential) => {
-        item.transactionState = 64 /* TRANSACTION_DB.AUTH */;
-        let client;
-        if (oraclePool) {
-            clients.push(client = await oraclePool.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 {
-                client = await pool.getConnection();
-                if (connectOnce) {
-                    oraclePool = pool;
-                }
-                pool.connected = true;
-            }
-            catch (err) {
-                let close;
-                switch (err instanceof Error && err.code) {
-                    case 'ORA-01017':
-                        close = 1;
-                        break;
-                    default:
-                        close = pool.closeable;
-                        break;
-                }
-                if (close) {
-                    await pool.detach(true);
-                    if (close === 1) {
-                        throw err;
-                    }
-                }
-                pool.connected = false;
-            }
-        }
-        clients.push(client || (client = await db.getConnection((oracleCredential || credential))));
-        if (connectOnce) {
-            if (!parallel) {
-                oracleClient = client;
-            }
-            oracleCredential = credential;
-        }
-        item.transactionState &= ~64 /* TRANSACTION_DB.AUTH */;
-        return client;
-    };
-    for (let i = 0; i < length; ++i) {
-        const item = batch[i];
-        const { source, query, params, ignoreCache, options: clientOptions } = item;
-        let credential = oracleCredential || 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_DB.ACTIVE */;
-        const streamRow = typeof item.streamRow === 'string' ? this.hasCoerce("oracle" /* 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 queryString = '';
-        if ((caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) && !streamRow) {
-            queryString = index_1.default.asString(query, true) + '_' + index_1.default.asString(params, true) + index_1.default.asString(clientOptions, true);
-            if (ignoreCache !== 1) {
-                const result = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue);
-                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) {
-            try {
-                oracleClient = await getConnection(item, onceCredential);
-            }
-            catch {
-                connectOnce = false;
-                parallel = false;
-            }
-            onceCredential = undefined;
-        }
-        tasks[i] = new Promise(async (resolve, reject) => {
-            let commandType;
-            try {
-                const client = oracleClient || await getConnection(item, credential);
-                if (oracleClient && parallel) {
-                    oracleClient = undefined;
-                }
-                const executeOptions = { outFormat: db.OUT_FORMAT_OBJECT, ...clientOptions, resultSet: false, autoCommit: true };
-                commandType = this.commandType.SELECT;
-                if (streamRow) {
-                    const rows = [];
-                    const processRow = typeof streamRow === 'function' && streamRow;
-                    const stream = client.queryStream(query, params || [], executeOptions);
-                    stream
-                        .on('data', row => {
-                        if (processRow) {
-                            const err = processRow(row);
-                            if (err === false) {
-                                return;
-                            }
-                            if (err instanceof Error) {
-                                error = err;
-                                return;
-                            }
-                        }
-                        rows.push(row);
-                    })
-                        .on('error', err => error || (error = err))
-                        .on('close', () => {
-                        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);
-                        }
-                    })
-                        .on('end', () => stream.destroy());
-                }
-                else {
-                    const { rows } = await client.execute(query, params || [], executeOptions);
-                    this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                    resolve(rows ? 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.close(err => err && this.writeFail(["Unable to close connnection" /* ERR_DB.CONNECTION_CLOSE */, "oracle" /* STRINGS.MODULE_NAME */], err, { type: 65536 /* LOG_TYPE.DB */, fatal: false }))),
-        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/postgres/index.d.ts

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

package/postgres/index.js

@@ -1,272 +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 = void 0;
-const util_1 = require("../util");
-const mysql_1 = require("../mysql");
-const types_1 = require("../../types");
-const index_1 = require("../index");
-const pool_1 = require("../pool");
-class PostgresPool extends pool_1.default {
-    getConnection() {
-        return this.client.connect();
-    }
-    close() {
-        return this.client.end();
-    }
-    isEmpty() {
-        return this.closed || this.client.totalCount === 0 && this.client.waitingCount === 0;
-    }
-    get closed() {
-        return this.client.ended;
-    }
-}
-const POOL_STATE = {};
-function removePoolProperties(options) {
-    if (!options.uuidKey && ('ssl' in options || 'max' in options || 'min' in options || 'idleTimeoutMillis' in options || 'log' in options || 'allowExitOnIdle' in options || 'maxUses' in options)) {
-        return { ...options, ssl: (0, types_1.isObject)(options.ssl) ? true : undefined, max: undefined, min: undefined, idleTimeoutMillis: undefined, log: undefined, allowExitOnIdle: undefined, maxUses: undefined };
-    }
-    return options;
-}
-const getPoolKey = (credential) => (credential.host || '') + '_' + (credential.port || '5432') + (credential.user || '') + '_' + (credential.password || '') + '_' + (credential.database || '') + '_' + (credential.connectionString || '');
-function setCredential(item) {
-    let credential = this.getCredential(item);
-    if (credential) {
-        mysql_1.setAuthentication.call(this, credential);
-    }
-    else {
-        credential = { connectionString: item.uri };
-        item.credential = credential;
-    }
-    if (!credential.connectionString) {
-        const errors = [];
-        if (!credential.host) {
-            errors.push('host');
-        }
-        if (!credential.user) {
-            errors.push('user');
-        }
-        if (errors.length) {
-            throw (0, types_1.errorMessage)("postgres" /* STRINGS.MODULE_NAME */, 'Not defined - ' + errors.join(' | '));
-        }
-    }
-    const usePool = item.usePool;
-    if (item.usePool && typeof credential.password !== 'function') {
-        let username, password, pool;
-        if (typeof usePool === 'string' && (username = credential.user || credential.connectionString && (0, util_1.parseConnectionString)(credential.connectionString)?.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("pg" /* STRINGS.PACKAGE_NAME */);
-            const config = this.getPoolConfig("postgres" /* STRINGS.MODULE_NAME */, password);
-            if (config) {
-                const { min, max, idle } = config;
-                if (min >= 0) {
-                    credential.min ?? (credential.min = min);
-                }
-                if (max > 0) {
-                    credential.max ?? (credential.max = max);
-                }
-                if (idle > 0) {
-                    credential.idleTimeoutMillis ?? (credential.idleTimeoutMillis = idle);
-                }
-            }
-            new PostgresPool(new Pool(credential), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
-        }
-        else {
-            pool.add(item);
-        }
-    }
-    else if ('usePool' in item) {
-        item.usePool = false;
-    }
-}
-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("pg" /* 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("postgres" /* STRINGS.MODULE_NAME */, sessionKey);
-    const tasks = new Array(length);
-    const clients = [];
-    const pools = [];
-    let postgresPool, postgresClient, postgresCredential, onceCredential = connectOnce ? batch[0].credential : undefined;
-    const getConnection = async (item, credential) => {
-        item.transactionState = 64 /* TRANSACTION_DB.AUTH */;
-        let client;
-        if (postgresPool) {
-            pools.push(client = await postgresPool.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) {
-                    postgresPool = pool;
-                }
-                pool.connected = true;
-            }
-            catch (err) {
-                let close;
-                switch (err instanceof Error && err.code) {
-                    case '28000':
-                    case '28P01':
-                        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 = new db.Client((postgresCredential || credential)));
-            await client.connect();
-        }
-        if (connectOnce) {
-            if (!parallel) {
-                postgresClient = client;
-            }
-            postgresCredential = credential;
-        }
-        item.transactionState &= ~64 /* TRANSACTION_DB.AUTH */;
-        return client;
-    };
-    for (let i = 0; i < length; ++i) {
-        const item = batch[i];
-        const { source, query, params, ignoreCache } = item;
-        let credential = postgresCredential || 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_DB.ACTIVE */;
-        const renewCache = ignoreCache === 0;
-        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
-        let queryString = '';
-        if (caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) {
-            queryString = index_1.default.asString(query, true) + '_' + index_1.default.asString(params, true);
-            if (ignoreCache !== 1) {
-                const result = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue);
-                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) {
-            try {
-                postgresClient = await getConnection(item, onceCredential);
-            }
-            catch {
-                connectOnce = false;
-                parallel = false;
-            }
-            onceCredential = undefined;
-        }
-        tasks[i] = new Promise(async (resolve, reject) => {
-            let commandType;
-            try {
-                const client = postgresClient || await getConnection(item, credential);
-                if (postgresClient && parallel) {
-                    postgresClient = undefined;
-                }
-                commandType = this.commandType.SELECT;
-                const { rows, command } = await client.query(query, params);
-                this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                resolve(rows.length || command === 'SELECT' ? 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 */, "postgres" /* 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/redis/index.d.ts

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