@e-mc/db 0.0.1

package/postgres/index.js

@@ -0,0 +1,272 @@
+"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.AUTH */;
+        let client;
+        if (postgresPool) {
+            pools.push(client = await postgresPool.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 {
+                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.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.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.COMMIT */ | 128 /* TRANSACTION.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.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

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