@pi-r/oracle 0.7.2 → 0.8.0

package/client/index.d.ts

@@ -8,6 +8,7 @@ import type { InitialiseOptions } from 'oracledb';
 
 declare const Oracle: IDbSourceClient<OracleDataSource> & {
     initOracleClient(this: IModule, credential: InitialiseOptions, type?: LogType): void;
+    getConfigObject(value: Undef<string>): string;
 };
 
 export = Oracle;

package/client/index.js

@@ -1,70 +1,19 @@
 "use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = exports.initOracleClient = void 0;
+exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
+exports.getConfigObject = getConfigObject;
+exports.initOracleClient = initOracleClient;
+exports.setCredential = setCredential;
+exports.executeQuery = executeQuery;
+exports.executeBatchQuery = executeBatchQuery;
+exports.checkTimeout = checkTimeout;
 const oracledb = require("oracledb");
+const Db = require("@e-mc/db");
 const util_1 = require("@e-mc/db/util");
 const types_1 = require("@e-mc/types");
-const Db = require("@e-mc/db");
-const DbPool = require('@e-mc/db/pool');
-class OraclePool extends DbPool {
-    async getConnection() {
-        return this.client.getConnection();
-    }
-    async close() {
-        return this.client.close();
-    }
-    isEmpty() {
-        if (this.closed) {
-            return true;
-        }
-        try {
-            const data = this.client.getStatistics();
-            if (data) {
-                const { connectionsInUse, currentQueueLength } = data;
-                return connectionsInUse === 0 && currentQueueLength === 0;
-            }
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    get closeable() {
-        return super.closeable || this.client.status === 6001;
-    }
-    get closed() {
-        return this.client.status === 6002;
-    }
-}
-const DRIVER_MODE = process.env.NODE_ORACLEDB_DRIVER_MODE;
+const DbPool = require("@pi-r/oracle/client/pool");
 const POOL_STATE = {};
-const POOL_UNUSED = ['connectTimeout', 'transportConnectTimeout', 'expireTime', 'poolMax', 'poolMin', 'poolIncrement', 'poolTimeout', 'poolPingInterval', 'poolMaxPerShard', 'queueMax', 'queueRequests', 'queueTimeout', 'enableStatistics', 'sodaMetaDataCache', 'stmtCacheSize'];
-const POOL_ACTIVE = new WeakSet();
-function removePoolProperties(credential) {
-    if (!credential.uuidKey && POOL_ACTIVE.has(credential)) {
-        let result;
-        for (let i = 0, length = POOL_UNUSED.length; i < length; ++i) {
-            const attr = POOL_UNUSED[i];
-            if (attr in credential) {
-                result ||= { ...credential };
-                delete result[attr];
-            }
-        }
-        if (result) {
-            return result;
-        }
-    }
-    return credential;
-}
-function getPoolKey(credential) {
-    if (credential.connectString && (credential.user && credential.password || credential.externalAuth) || credential.poolAlias) {
-        if ('uuidKey' in credential) {
-            credential = { ...credential };
-            delete credential.uuidKey;
-        }
-        return JSON.stringify(credential);
-    }
-}
-const useLibDir = () => process.platform === 'win32' || process.platform === 'darwin' && process.arch === 'x64';
+const DRIVER_MODE = process.env.NODE_ORACLEDB_DRIVER_MODE;
+const useLibDir = () => Db.PLATFORM_WIN32 || process.platform === 'darwin' && process.arch === 'x64';
 if (DRIVER_MODE === 'thick' && oracledb.thin) {
     let libDir;
     if (!useLibDir() || (0, types_1.isString)(libDir = process.env.NODE_ORACLEDB_CLIENT_LIB_DIR || process.env.ORACLE_HOME)) {
@@ -76,6 +25,9 @@ if (DRIVER_MODE === 'thick' && oracledb.thin) {
         }
     }
 }
+function getConfigObject(value) {
+    return (0, types_1.isString)(value) && /^config-(?:ociobject|azure):\/\//i.test(value) ? value : '';
+}
 function initOracleClient(credential, type) {
     if (credential.libDir && oracledb.thin) {
         if (DRIVER_MODE === 'thick') {
@@ -101,7 +53,6 @@ function initOracleClient(credential, type) {
         delete credential.libDir;
     }
 }
-exports.initOracleClient = initOracleClient;
 async function setCredential(item) {
     let credential = this.getCredential(item), hostname, port, username, database;
     if (credential) {
@@ -129,13 +80,19 @@ async function setCredential(item) {
     if (hostname) {
         credential.connectString ||= hostname + (port ? ':' + port : '') + (database ? '/' + database : '');
     }
-    if (credential.externalAuth) {
+    const configObject = getConfigObject(credential.connectString);
+    if (credential.externalAuth || configObject) {
         delete credential.user;
         delete credential.password;
     }
-    if (!credential.poolAlias) {
+    if (!credential.poolAlias && !configObject) {
         const errors = [];
+        const env = Db.enabled("process.env.apply");
         if (!credential.externalAuth) {
+            if (env && !credential.user && !credential.password) {
+                credential.user = process.env.NODE_ORACLEDB_USER;
+                credential.password = process.env.NODE_ORACLEDB_PASSWORD;
+            }
             if (!credential.user) {
                 errors.push('user');
             }
@@ -143,10 +100,10 @@ async function setCredential(item) {
                 errors.push('password');
             }
         }
-        if (!credential.connectString) {
+        if (!credential.connectString && (!env || !(credential.connectString = process.env.NODE_ORACLEDB_CONNECTIONSTRING))) {
             errors.push('connectString');
         }
-        if (errors.length) {
+        if (errors.length > 0) {
             throw (0, types_1.errorMessage)("oracle", 'Not defined - ' + errors.join(' | '));
         }
     }
@@ -158,7 +115,7 @@ async function setCredential(item) {
     const poolAlias = credential.poolAlias;
     let password, pool;
     if ((0, types_1.isString)(usePool)) {
-        if (username = credential.user || poolAlias) {
+        if (username = credential.user || poolAlias || configObject) {
             [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
             if (pool) {
                 pool.add(item, password);
@@ -205,18 +162,19 @@ async function setCredential(item) {
             credential.connectTimeout ??= idle / 1000;
         }
     }
-    const poolKey = getPoolKey(credential);
+    const poolKey = DbPool.asString(credential);
     if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
         pool.add(item);
         return;
     }
-    new OraclePool(await oracledb.createPool(credential), poolKey, username && password ? { username, password } : undefined).add(item).parent = POOL_STATE;
+    const client = await oracledb.createPool(credential);
+    new DbPool(client, poolKey, username && password ? { username, password } : configObject ? { username: configObject, password: configObject } : undefined)
+        .add(item)
+        .parent = POOL_STATE;
 }
-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) {
@@ -250,20 +208,18 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState = 64;
         let client;
         if (oraclePool) {
-            clients.push(client = await oraclePool.getConnection());
+            clients.push(client = await oraclePool.getConnection(credential));
             item.transactionState &= ~64;
-            POOL_ACTIVE.add(credential);
             return client;
         }
-        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, getPoolKey(credential), ...connectOnce ? [item, batch[0]] : [item]);
+        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential), ...connectOnce ? [item, batch[0]] : [item]);
         if (pool) {
             try {
-                client = await pool.getConnection();
+                client = await pool.getConnection(credential);
                 if (connectOnce) {
                     oraclePool = pool;
                 }
                 pool.connected = true;
-                POOL_ACTIVE.add(credential);
             }
             catch (err) {
                 let close;
@@ -324,7 +280,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         if (caching && ignoreCache !== true && !streamRow) {
             queryString = Db.asString(query, true) + '_' + Db.asString(params, true) + Db.asString(clientOptions, true);
             if (ignoreCache !== 1) {
-                const result = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue);
+                const result = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue);
                 if (result) {
                     if (parallel) {
                         tasks[i] = Promise.resolve(result);
@@ -361,7 +317,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 commandType = this.commandType.SELECT;
                 if (streamRow) {
                     const rows = [];
-                    const processRow = typeof streamRow === 'function' && streamRow;
+                    const processRow = typeof streamRow === 'function' ? streamRow : null;
                     const stream = client.queryStream(query, params || [], executeOptions);
                     stream
                         .on('data', row => {
@@ -384,7 +340,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                         else {
                             this.add(item, 4);
-                            resolve(!error ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : rows);
+                            resolve(!error ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : rows);
                         }
                     })
                         .on('end', () => stream.destroy());
@@ -392,7 +348,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 else {
                     const { rows } = await client.execute(query, params || [], executeOptions);
                     this.add(item, 4);
-                    resolve(rows ? this.setQueryResult(source, removePoolProperties(credential), queryString, rows, cacheValue) : null);
+                    resolve(rows ? this.setQueryResult(source, DbPool.sanitize(credential), queryString, rows, cacheValue) : null);
                 }
             }
             catch (err) {
@@ -415,20 +371,20 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
-        disconnect: () => clients.forEach(item => {
-            item.close(err => {
-                if (err) {
-                    this.writeFail(["Unable to close connnection", "oracle"], err, { type: 65536, fatal: false });
-                }
-            });
-        }),
-        parallel
+        parallel,
+        disconnect: () => {
+            for (const item of clients) {
+                item.close(err => {
+                    if (err) {
+                        this.writeFail(["Unable to close connnection", "oracle"], err, { type: 65536, fatal: false });
+                    }
+                });
+            }
+        }
     }, outResult);
 }
-exports.executeBatchQuery = executeBatchQuery;
 async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
-exports.checkTimeout = checkTimeout;
 exports.DB_SOURCE_CLIENT = true;
 exports.DB_SOURCE_TYPE = types_1.DB_TYPE.SQL;

package/client/pool.d.ts

@@ -0,0 +1,9 @@
+import type { DbPoolConstructor } from '@e-mc/types/lib/db';
+
+import type { DbPoolCredential, OracleDataSource } from '../types';
+
+import type { Pool } from 'oracledb';
+
+declare const OraclePool: DbPoolConstructor<OracleDataSource, Pool, unknown, DbPoolCredential>;
+
+export = OraclePool;

package/client/pool.js

@@ -0,0 +1,50 @@
+"use strict";
+const DbPool = require('@e-mc/db/pool');
+const POOL_ACTIVE = new WeakSet();
+class OraclePool extends DbPool {
+    static CACHE_UNUSED = ['connectTimeout', 'transportConnectTimeout', 'expireTime', 'poolMax', 'poolMin', 'poolIncrement', 'poolTimeout', 'poolPingInterval', 'poolMaxPerShard', 'queueMax', 'queueRequests', 'queueTimeout', 'enableStatistics', 'sodaMetaDataCache', 'stmtCacheSize'];
+    static asString(credential) {
+        if (credential.connectString && (credential.user && credential.password || credential.externalAuth) || credential.poolAlias) {
+            return JSON.stringify(this.removeUUIDKey(credential));
+        }
+        return super.asString(credential);
+    }
+    static sanitize(credential) {
+        if (!POOL_ACTIVE.has(credential) || credential.uuidKey) {
+            return credential;
+        }
+        return super.sanitize(credential);
+    }
+    get closeable() {
+        return super.closeable || this.client.status === 6001;
+    }
+    async getConnection(credential) {
+        if (credential) {
+            POOL_ACTIVE.add(credential);
+        }
+        return this.client.getConnection();
+    }
+    async close() {
+        return this.client.close();
+    }
+    isEmpty() {
+        if (this.closed) {
+            return true;
+        }
+        try {
+            const data = this.client.getStatistics();
+            if (data) {
+                const { connectionsInUse, currentQueueLength } = data;
+                return connectionsInUse === 0 && currentQueueLength === 0;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    get closed() {
+        return this.client.status === 6002;
+    }
+}
+module.exports = OraclePool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/oracle",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Oracle client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.9.4",
-    "@e-mc/types": "^0.9.4",
-    "oracledb": "^6.5.1"
+    "@e-mc/db": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
+    "oracledb": "^6.6.0"
   }
 }

package/types/index.d.ts

@@ -1,12 +1,21 @@
 import type { DbDataSource } from '@e-mc/types/lib/squared';
 
+import type { IdentifierAction } from '@e-mc/types/lib/core';
 import type { ExecuteAction, ServerAuth } from '@e-mc/types/lib/db';
 
 // @ts-ignore
 import type { BindParameters, ConnectionAttributes, ExecuteOptions, InitialiseOptions, PoolAttributes } from 'oracledb';
 
+export const enum POOL_STATUS {
+    CLOSED = 6002,
+    DRAINING = 6001,
+    OPEN = 6000,
+    RECONFIGURING = 6003
+}
+
 export interface OracleDataSource extends DbDataSource<string, ExecuteOptions, unknown, OracleCredential, string>, ExecuteAction<BindParameters> {
     source: "oracle";
 }
 
-export interface OracleCredential extends ServerAuth, ConnectionAttributes, PoolAttributes, InitialiseOptions {}
+export type OracleCredential = ConnectionAttributes & PoolAttributes & InitialiseOptions & ServerAuth;
+export type DbPoolCredential = PoolAttributes & IdentifierAction;