@e-mc/db 0.0.1

package/oracle/index.js

@@ -0,0 +1,358 @@
+"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.AUTH */;
+        let client;
+        if (oraclePool) {
+            clients.push(client = await oraclePool.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) {
+                    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.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.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.COMMIT */ | 128 /* TRANSACTION.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.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.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/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@e-mc/db",
+  "version": "0.0.1",
+  "description": "DB modules for e-mc.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/e-mc.git",
+    "directory": "src/db"
+  },
+  "keywords": [
+    "squared",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "BSD 3-Clause",
+  "homepage": "https://github.com/anpham6/e-mc#readme",
+  "dependencies": {
+    "@e-mc/core": "0.0.1",
+    "@e-mc/request": "0.0.1"
+  }
+}

package/pool.d.ts

@@ -0,0 +1,5 @@
+import type { DbPoolConstructor } from '../types/lib/db';
+
+declare const DbPool: DbPoolConstructor;
+
+export = DbPool;

package/pool.js

@@ -0,0 +1,144 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const util_1 = require("./util");
+const kItems = Symbol('items');
+const kParent = Symbol('parent');
+const kIdlePrevious = Symbol('idlePrevious');
+class DbPool {
+    static findKey(pools, uuidKey, poolKey, ...items) {
+        if (uuidKey) {
+            let pool;
+            if (typeof uuidKey === 'string') {
+                for (const key in pools) {
+                    const result = pools[key];
+                    if (result.uuidKey === uuidKey) {
+                        pool = result;
+                        break;
+                    }
+                }
+            }
+            if (pool || poolKey && (pool = pools[poolKey])) {
+                if (!pool.closed) {
+                    return items.length && !items.some(item => pool.has(item)) ? null : pool;
+                }
+                pool.remove();
+            }
+        }
+        return null;
+    }
+    static validateKey(pools, username, uuidKey) {
+        if ((0, types_1.validateUUID)(uuidKey)) {
+            if ((0, types_1.isString)(username)) {
+                for (const key in pools) {
+                    const pool = pools[key];
+                    const auth = pool.uuidKey;
+                    if (auth?.username === username && auth.password === uuidKey) {
+                        if (!pool.closed) {
+                            return [uuidKey, pool];
+                        }
+                        delete pools[key];
+                        break;
+                    }
+                }
+            }
+            return [uuidKey, null];
+        }
+        return ['', null];
+    }
+    static async checkTimeout(pools, value, limit = 0) {
+        let result = 0;
+        for (const key in pools) {
+            const pool = pools[key];
+            if (pool.isIdle(value)) {
+                await pool.detach(true);
+                if (++result === limit) {
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    constructor(client, poolKey, uuidKey = null) {
+        this.client = client;
+        this.poolKey = poolKey;
+        this.uuidKey = uuidKey;
+        this.success = 0;
+        this.failed = 0;
+        this.lastAccessed = 0;
+        this[_a] = new WeakSet();
+        this[_b] = null;
+        this[_c] = { success: -1, failed: -1, count: 0, error: 0 };
+    }
+    add(item, uuidKey) {
+        this[kItems].add(item);
+        if (uuidKey || (uuidKey = this.uuidKey?.password)) {
+            (0, util_1.setUUIDKey)(item, uuidKey);
+        }
+        this.lastAccessed = Date.now();
+        return this;
+    }
+    has(item) {
+        return this[kItems].has(item);
+    }
+    remove() {
+        const parent = this[kParent];
+        if (parent) {
+            delete parent[this.poolKey];
+        }
+    }
+    detach(force) {
+        this.remove();
+        return this.closed ? Promise.resolve() : force ? this.close().catch(() => { }) : this.close();
+    }
+    isIdle(timeout) {
+        if (this.closed) {
+            return true;
+        }
+        const { success, failed } = this;
+        const previous = this[kIdlePrevious];
+        let count = 0, error = 0;
+        if (success === previous.success && failed >= previous.failed) {
+            count = ++previous.count;
+            if (failed > previous.failed) {
+                error = ++previous.error;
+            }
+        }
+        else {
+            previous.count = 0;
+            if (failed === previous.failed) {
+                previous.error = 0;
+            }
+        }
+        previous.success = success;
+        previous.failed = failed;
+        return Date.now() - timeout >= this.lastAccessed && (this.closeable || count >= (this.uuidKey ? 10 /* IDLE_THRESHOLD.UUID */ : 5 /* IDLE_THRESHOLD.CONFIG */)) || error >= (this.uuidKey ? 3 /* IDLE_THRESHOLD.UUID_ERROR */ : 2 /* IDLE_THRESHOLD.CONFIG_ERROR */);
+    }
+    get persist() {
+        return this.uuidKey ? this.success > this.failed : false;
+    }
+    get closeable() {
+        return this.success === 0 && this.failed > 0 || !this.persist && this.isEmpty();
+    }
+    set connected(value) {
+        if (value) {
+            ++this.success;
+            this.lastAccessed = Date.now();
+        }
+        else {
+            ++this.failed;
+        }
+    }
+    set parent(value) {
+        value[this.poolKey] = this;
+        this[kParent] = value;
+    }
+}
+_a = kItems, _b = kParent, _c = kIdlePrevious;
+exports.default = DbPool;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/postgres/index.d.ts

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