oracledb 6.0.3 → 6.2.0

package/README.md

@@ -1,10 +1,10 @@
-# node-oracledb version 6.0.3
+# node-oracledb version 6.2.0
 
 The node-oracledb add-on for Node.js powers high performance Oracle Database
 applications.  Applications can be written in TypeScript, or directly in
 JavaScript.
 
-Use node-oracledb 6.0.3 to connect Node.js 14.6, or later, to Oracle
+Use node-oracledb 6.2.0 to connect Node.js 14.6, or later, to Oracle
 Database.  Older versions of node-oracledb may work with older versions of
 Node.js.
 

package/build/Release/oracledb-6.2.0-darwin-x64.node-buildinfo.txt

@@ -0,0 +1 @@
+oracledb-6.2.0-darwin-x64.node v16.20.2 fe16239d5a7ceb588ae0e0766e74da2d20fb7af9 20785f251426f274f4216369b9259908a103384d Wed, 27 Sep 2023 05:56:04 GMT

package/build/Release/oracledb-6.2.0-js-buildinfo.txt

@@ -0,0 +1 @@
+fe16239d5a7ceb588ae0e0766e74da2d20fb7af9

package/build/Release/oracledb-6.2.0-linux-arm64.node-buildinfo.txt

@@ -0,0 +1 @@
+oracledb-6.2.0-linux-arm64.node v18.15.0 fe16239d5a7ceb588ae0e0766e74da2d20fb7af9 20785f251426f274f4216369b9259908a103384d Wed, 27 Sep 2023 06:02:23 GMT

package/build/Release/oracledb-6.2.0-linux-x64.node-buildinfo.txt

@@ -0,0 +1 @@
+oracledb-6.2.0-linux-x64.node v16.19.1 fe16239d5a7ceb588ae0e0766e74da2d20fb7af9 20785f251426f274f4216369b9259908a103384d Thu, 28 Sep 2023 16:23:40 GMT

package/build/Release/oracledb-6.2.0-win32-x64.node-buildinfo.txt

@@ -0,0 +1 @@
+oracledb-6.2.0-win32-x64.node v16.19.0 fe16239d5a7ceb588ae0e0766e74da2d20fb7af9 20785f251426f274f4216369b9259908a103384d Wed, 27 Sep 2023 10:36:18 GMT

package/examples/dbconfig.js

@@ -30,7 +30,7 @@
  *   to the database.  Production applications should consider using
  *   External Authentication to avoid hard coded credentials.
  *
- *   To create a database user see
+ *   To create a database user, see
  *   https://blogs.oracle.com/sql/post/how-to-create-users-grant-them-privileges-and-remove-them-in-oracle-database
  *
  *   Applications can set the connectString value to an Easy Connect
@@ -46,8 +46,8 @@
  *   Commonly just the host_name and service_name are needed
  *   e.g. "localhost/orclpdb1" or "example.com/XEPDB1"
  *
- *   The Easy Connect syntax was enhanced in Oracle Database 19c to
- *   allow more options, refer to the documentation:
+ *   The Easy Connect syntax supports lots of options. To know more, please
+ *   refer to the latest Oracle documentation on Easy Connect syntax:
  *   https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-B0437826-43C1-49EC-A94D-B650B6A4A6EE
  *
  *   If using a tnsnames.ora file, the file can be in a default
@@ -66,17 +66,10 @@
  *   creating a pool should not be set when externalAuth is true.
  *
  * TROUBLESHOOTING
- *   Errors like:
- *     ORA-12541: TNS:no listener
- *   or
- *     ORA-12154: TNS:could not resolve the connect identifier specified
- *   indicate connectString is invalid.
- *
- *   The error:
- *     ORA-12514: TNS:listener does not currently know of requested in connect descriptor
- *   indicates connectString is invalid.  You are reaching a computer
- *   with Oracle installed but the service name isn't known.
- *   Use 'lsnrctl services' on the database server to find available services
+ *   Refer to the Error Handling section in node-oracledb documentation
+ *   to understand the different types of errors in both the Thin and Thick
+ *   modes of node-oracledb:
+ *   https://node-oracledb.readthedocs.io/en/latest/user_guide/exception_handling.html#errors-in-thin-and-thick-modes
  *
  *****************************************************************************/
 

package/examples/example.js

@@ -127,7 +127,6 @@ async function run() {
     // For a complete list of options see the documentation.
     options = {
       outFormat: oracledb.OUT_FORMAT_OBJECT,   // query result format
-      // extendedMetaData: true,               // get extra metadata
       // fetchArraySize:   100                 // internal buffer allocation size for tuning
     };
 

package/lib/aqQueue.js

@@ -27,13 +27,14 @@
 'use strict';
 
 const { Buffer } = require('buffer');
-const constants = require('./constants.js');
 const errors = require('./errors.js');
 const nodbUtil = require('./util.js');
 const AqDeqOptions = require('./aqDeqOptions.js');
 const AqEnqOptions = require('./aqEnqOptions.js');
 const AqMessage = require('./aqMessage.js');
 const BaseDbObject = require('./dbObject.js');
+const transformer = require('./transformer.js');
+const types = require('./types.js');
 
 class AqQueue {
 
@@ -47,6 +48,19 @@ class AqQueue {
         value instanceof BaseDbObject);
   }
 
+  //---------------------------------------------------------------------------
+  // _makeMessage()
+  //
+  // For enqOne()/deqOne()/enqMany()/deqMany(), wrap the return value with JS
+  // layer object.
+  //---------------------------------------------------------------------------
+  _makeMessage(msgImpl) {
+    const msg = new AqMessage();
+    msg._impl = msgImpl;
+    msg._payloadTypeClass = this._payloadTypeClass;
+    return msg;
+  }
+
   //---------------------------------------------------------------------------
   // _verifyMessage()
   //
@@ -64,7 +78,7 @@ class AqQueue {
       message = {};
     } else {
       message = {...message};
-      if (this._isPayload(message.payload)) {
+      if (this._isJson || this._isPayload(message.payload)) {
         payload = message.payload;
       } else if (this._payloadTypeClass) {
         payload = new this._payloadTypeClass(message.payload);
@@ -74,7 +88,9 @@ class AqQueue {
     }
 
     // validate payload
-    if (typeof payload === 'string') {
+    if (this._isJson) {
+      message.payload = transformer.transformJsonValue(payload);
+    } else if (typeof payload === 'string') {
       message.payload = Buffer.from(payload);
     } else if (Buffer.isBuffer(payload)) {
       message.payload = payload;
@@ -116,8 +132,17 @@ class AqQueue {
   // Creates the queue and populates some internal attributes.
   //---------------------------------------------------------------------------
   async create(conn, name, options) {
-    if (options.payloadType) {
-      if (typeof options.payloadType == 'string') {
+    if (options.payloadType === types.DB_TYPE_JSON) {
+      this._isJson = true;
+      this._payloadType = types.DB_TYPE_JSON;
+      this._payloadTypeName = "JSON";
+    } else if (options.payloadType === undefined ||
+               options.payloadType === types.DB_TYPE_RAW) {
+      this._payloadType = types.DB_TYPE_RAW;
+      this._payloadTypeName = "RAW";
+    } else {
+      if (typeof options.payloadType === 'string') {
+        // DB Object type
         const cls = await conn._getDbObjectClassForName(options.payloadType);
         this._payloadTypeClass = cls;
         options.payloadType = cls;
@@ -126,14 +151,12 @@ class AqQueue {
           options.payloadType.prototype instanceof BaseDbObject, 2, "payloadType");
         this._payloadTypeClass = options.payloadType;
       }
-      this._payloadType = constants.DB_TYPE_OBJECT;
+      this._payloadType = types.DB_TYPE_OBJECT;
       this._payloadTypeName = this._payloadTypeClass.prototype.name;
-    } else {
-      this._payloadType = constants.DB_TYPE_RAW;
-      this._payloadTypeName = "RAW";
     }
     this._name = name;
-    this._impl = await conn._impl.getQueue(name, options);
+    this._impl = await conn._impl.getQueue(name, this._payloadTypeClass,
+      this._payloadType);
   }
 
   //---------------------------------------------------------------------------
@@ -147,14 +170,7 @@ class AqQueue {
     errors.assertParamValue(Number.isInteger(maxMessages) && maxMessages > 0,
       1);
     const msgImpls = await this._impl.deqMany(maxMessages);
-    const messages = new Array(msgImpls.length);
-    for (let i = 0; i < msgImpls.length; i++) {
-      const msg = new AqMessage();
-      msg._impl = msgImpls[i];
-      msg._payloadTypeClass = this._payloadTypeClass;
-      messages[i] = msg;
-    }
-    return messages;
+    return  msgImpls.map(i => this._makeMessage(i));
   }
 
   //---------------------------------------------------------------------------
@@ -165,12 +181,8 @@ class AqQueue {
   async deqOne() {
     errors.assertArgCount(arguments, 0, 0);
     const msgImpl = await this._impl.deqOne();
-    if (msgImpl) {
-      const msg = new AqMessage();
-      msg._impl = msgImpl;
-      msg._payloadTypeClass = this._payloadTypeClass;
-      return msg;
-    }
+    if (msgImpl)
+      return this._makeMessage(msgImpl);
   }
 
   //---------------------------------------------------------------------------
@@ -200,7 +212,8 @@ class AqQueue {
     for (let i = 0; i < messages.length; i++) {
       verifiedMessages[i] = this._verifyMessage(messages[i]);
     }
-    return await this._impl.enqMany(verifiedMessages);
+    const msgImpls = await this._impl.enqMany(verifiedMessages);
+    return msgImpls.map(i => this._makeMessage(i));
   }
 
   //---------------------------------------------------------------------------
@@ -211,7 +224,8 @@ class AqQueue {
   async enqOne(message) {
     errors.assertArgCount(arguments, 1, 1);
     message = this._verifyMessage(message);
-    return await this._impl.enqOne(message);
+    const msgImpl = await this._impl.enqOne(message);
+    return this._makeMessage(msgImpl);
   }
 
   //---------------------------------------------------------------------------

package/lib/connection.js

@@ -1039,6 +1039,19 @@ class Connection extends EventEmitter {
     return info;
   }
 
+  //---------------------------------------------------------------------------
+  // instanceName
+  //
+  // Returns the Oracle Database instance name associated with the connection.
+  // This is the equivalent of the SQL expression:
+  // sys_context('userenv', 'instance_name')
+  //---------------------------------------------------------------------------
+  get instanceName() {
+    if (this._impl)
+      return this._impl.getInstanceName();
+    return undefined;
+  }
+
   //---------------------------------------------------------------------------
   // internalName
   //
@@ -1061,7 +1074,7 @@ class Connection extends EventEmitter {
   //
   // Returns the health status of the connection. If this function returns
   // false, the caller should close the connection.
-  // ---------------------------------------------------------------------------
+  //---------------------------------------------------------------------------
   isHealthy() {
     return (this._impl !== undefined && !this._closing &&
       this._impl.isHealthy());
@@ -1227,7 +1240,7 @@ class Connection extends EventEmitter {
     errors.assertArgCount(arguments, 2, 2);
     errors.assertParamValue(typeof name === 'string', 1);
     errors.assertParamValue(nodbUtil.isObject(options), 2);
-    options = {...options};
+    options = {name: name, ...options};
     errors.assertParamPropUnsignedInt(options, 2, "namespace");
     if (options.namespace === undefined)
       options.namespace = constants.SUBSCR_NAMESPACE_DBCHANGE;
@@ -1253,14 +1266,13 @@ class Connection extends EventEmitter {
     errors.assert(this._impl, errors.ERR_INVALID_CONNECTION);
 
     const inSubscr = _subscriptions.get(name);
-    let outValue = await this._impl.subscribe(inSubscr, options);
+    const outValue = await this._impl.subscribe(inSubscr, options);
     let subscription;
     if (options.namespace === constants.SUBSCR_NAMESPACE_DBCHANGE) {
       subscription = outValue.subscription;
       delete outValue.subscription;
     } else {
       subscription = outValue;
-      outValue = undefined;
     }
     _subscriptions.set(name, subscription);
     return outValue;

package/lib/dbObject.js

@@ -319,6 +319,15 @@ class BaseDbObject {
     return this._objType.schema;
   }
 
+  //---------------------------------------------------------------------------
+  // packageName
+  //
+  // Property for the packageName of the database object type.
+  //---------------------------------------------------------------------------
+  get packageName() {
+    return this._objType.packageName;
+  }
+
   //---------------------------------------------------------------------------
   // setElement()
   //

package/lib/errors.js

@@ -116,7 +116,6 @@ const ERR_UNEXPECTED_DATA = 113;
 const ERR_OSON_FIELD_NAME_LIMITATION = 114;
 const ERR_ORACLE_NUMBER_NO_REPR = 115;
 const ERR_UNSUPPORTED_VERIFIER_TYPE = 116;
-const ERR_INVALID_PRIVATE_KEY = 117;
 const ERR_THIN_CONNECTION_ALREADY_CREATED = 118;
 const ERR_UNSUPPORTED_CONVERSION = 119;
 const ERR_FETCH_TYPE_HANDLER_RETURN_VALUE = 120;
@@ -178,7 +177,6 @@ adjustErrorXref.set("OCI-22165", [ERR_INVALID_COLL_INDEX_SET, /index \[([0-9]+)\
 adjustErrorXref.set("ORA-00028", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-00600", ERR_CONNECTION_CLOSED);
 adjustErrorXref.set("ORA-24338", ERR_INVALID_REF_CURSOR);
-adjustErrorXref.set("ORA-24422", ERR_POOL_HAS_BUSY_CONNECTIONS);
 adjustErrorXref.set("ORA-25708", ERR_TOKEN_HAS_EXPIRED);
 
 // define mapping for error messages
@@ -355,8 +353,6 @@ messages.set(ERR_ORACLE_NUMBER_NO_REPR,                 // NJS-115
   'value cannot be represented as an Oracle Database number');
 messages.set(ERR_UNSUPPORTED_VERIFIER_TYPE,             // NJS-116
   'password verifier type 0x%s is not supported by node-oracledb in Thin mode');
-messages.set(ERR_INVALID_PRIVATE_KEY,                   // NJS-117
-  'invalid private key. Headers and footers are not allowed');
 messages.set(ERR_THIN_CONNECTION_ALREADY_CREATED,       // NJS-118
   'node-oracledb Thick mode cannot be enabled because a Thin mode connection has already been created');
 messages.set(ERR_UNSUPPORTED_CONVERSION,                // NJS-119
@@ -470,7 +466,7 @@ function assertArgCount(args, minArgCount, maxArgCount) {
 //-----------------------------------------------------------------------------
 // assertParamPropBool()
 //
-// Asserts that the property value of a parmeter is a boolean value (or
+// Asserts that the property value of a parameter is a boolean value (or
 // undefined).
 //-----------------------------------------------------------------------------
 function assertParamPropBool(obj, parameterNum, propName) {
@@ -483,7 +479,7 @@ function assertParamPropBool(obj, parameterNum, propName) {
 //-----------------------------------------------------------------------------
 // assertParamPropFunction()
 //
-// Asserts that the property value of a parmeter is a function (or undefined).
+// Asserts that the property value of a parameter is a function (or undefined).
 //-----------------------------------------------------------------------------
 function assertParamPropFunction(obj, parameterNum, propName) {
   if (obj[propName] !== undefined) {
@@ -495,7 +491,7 @@ function assertParamPropFunction(obj, parameterNum, propName) {
 //-----------------------------------------------------------------------------
 // assertParamPropInt()
 //
-// Asserts that the property value of a parmeter is an integer value (or
+// Asserts that the property value of a parameter is an integer value (or
 // undefined).
 //-----------------------------------------------------------------------------
 function assertParamPropInt(obj, parameterNum, propName) {
@@ -508,7 +504,7 @@ function assertParamPropInt(obj, parameterNum, propName) {
 //-----------------------------------------------------------------------------
 // assertParamPropUnsignedInt()
 //
-// Asserts that the property value of a parmeter is a positive integer value
+// Asserts that the property value of a parameter is a positive integer value
 // (or undefined).
 //-----------------------------------------------------------------------------
 function assertParamPropUnsignedInt(obj, parameterNum, propName) {
@@ -521,7 +517,7 @@ function assertParamPropUnsignedInt(obj, parameterNum, propName) {
 //-----------------------------------------------------------------------------
 // assertParamPropString()
 //
-// Asserts that the property value of a parmeter is a function (or undefined).
+// Asserts that the property value of a parameter is a string value (or undefined).
 //-----------------------------------------------------------------------------
 function assertParamPropString(obj, parameterNum, propName) {
   if (obj[propName] !== undefined) {
@@ -533,7 +529,7 @@ function assertParamPropString(obj, parameterNum, propName) {
 //-----------------------------------------------------------------------------
 // assertParamPropValue()
 //
-// Asserts that the property value of a parmeter passes the specified
+// Asserts that the property value of a parameter passes the specified
 // condition.
 //-----------------------------------------------------------------------------
 function assertParamPropValue(condition, parameterNum, propName) {
@@ -544,7 +540,7 @@ function assertParamPropValue(condition, parameterNum, propName) {
 //-----------------------------------------------------------------------------
 // assertParamValue()
 //
-// Asserts that the parmeter value passes the specified condition.
+// Asserts that the parameter value passes the specified condition.
 //-----------------------------------------------------------------------------
 function assertParamValue(condition, parameterNum) {
   assert(condition, ERR_INVALID_PARAMETER_VALUE, parameterNum);
@@ -612,10 +608,19 @@ function transformErr(err, fnOpt) {
     const pos = err.message.indexOf(":");
     if (pos > 0) {
       err.code = err.message.substr(0, pos);
+      /* add Oracle Database Error Help Portal URL for database error
+         messages, but only in thin mode since this is done
+         automatically in thick mode with Oracle Client 23c and higher
+      */
+      const settings = require('./settings.js');
+      if (err.errorNum && settings.thin) {
+        err.message += '\n' + 'Help: https://docs.oracle.com/error-help/db/ora-' +
+          `${err.errorNum.toString().padStart(5, '0')}/`;
+      }
       if (adjustErrorXref.has(err.code)) {
         let args = [];
         let driverErrorNum;
-        let driverErrorInfo = adjustErrorXref.get(err.code);
+        const driverErrorInfo = adjustErrorXref.get(err.code);
         if (typeof driverErrorInfo === 'number') {
           driverErrorNum = driverErrorInfo;
         } else {
@@ -748,7 +753,6 @@ module.exports = {
   ERR_UNEXPECTED_DATA,
   ERR_OSON_FIELD_NAME_LIMITATION,
   ERR_OSON_VERSION_NOT_SUPPORTED,
-  ERR_INVALID_PRIVATE_KEY,
   ERR_THIN_CONNECTION_ALREADY_CREATED,
   ERR_UNSUPPORTED_CONVERSION,
   ERR_FETCH_TYPE_HANDLER_RETURN_VALUE,

package/lib/impl/connection.js

@@ -226,6 +226,15 @@ class ConnectionImpl {
     errors.throwNotImplemented("getting the external name");
   }
 
+  //---------------------------------------------------------------------------
+  // getInstanceName()
+  //
+  // Returns the Oracle Database instance name associated with the connection.
+  //---------------------------------------------------------------------------
+  getInstanceName() {
+    errors.throwNotImplemented("getting the Oracle Database instance name.");
+  }
+
   //---------------------------------------------------------------------------
   // getInternalName()
   //

package/lib/impl/resultset.js

@@ -111,14 +111,17 @@ class ResultSetImpl {
       if (metadata.dbType === types.DB_TYPE_NUMBER &&
           metadata.fetchType === types.DB_TYPE_NUMBER) {
         converter = (v) => (v === null) ? null : parseFloat(v);
-      } else if (metadata.fetchType === types.DB_TYPE_VARCHAR &&
-          (metadata.dbType === types.DB_TYPE_BINARY_DOUBLE ||
+      } else if (metadata.fetchType === types.DB_TYPE_VARCHAR) {
+        if (metadata.dbType === types.DB_TYPE_BINARY_DOUBLE ||
            metadata.dbType === types.DB_TYPE_BINARY_FLOAT ||
            metadata.dbType === types.DB_TYPE_DATE ||
            metadata.dbType === types.DB_TYPE_TIMESTAMP ||
            metadata.dbType === types.DB_TYPE_TIMESTAMP_LTZ ||
-           metadata.dbType === types.DB_TYPE_TIMESTAMP_TZ)) {
-        converter = (v) => (v === null) ? null : v.toString();
+           metadata.dbType === types.DB_TYPE_TIMESTAMP_TZ) {
+          converter = (v) => (v === null) ? null : v.toString();
+        } else if (metadata.dbType === types.DB_TYPE_RAW) {
+          converter = (v) => (v === null) ? null : v.toString('hex').toUpperCase();
+        }
       }
       if (userConverter && converter) {
         const internalConverter = converter;

package/lib/oracledb.js

@@ -67,25 +67,28 @@ const defaultPoolAlias = 'default';
 
 // save arguments for call to initOracleClient()
 let _initOracleClientArgs;
-let _thinDriverInitialized = false;
 
 // Load the Oracledb binary
-function _initCLib() {
+function _initCLib(options) {
   /*global __non_webpack_require__*/  // quieten eslint
   const requireBinary = (typeof __non_webpack_require__ === 'function') ? __non_webpack_require__ : require; // See Issue 1156
-
   const binaryLocations = [
     '../' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BINARY_FILE,  // pre-built binary
-    '../' + nodbUtil.RELEASE_DIR + '/' + 'oracledb.node',       // binary built from source
-    '../build/Debug/oracledb.node',                             // debug binary
+    '../' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BUILD_FILE,   // binary built from source
+    '../build/Debug/' + nodbUtil.BUILD_FILE,                    // debug binary
     // Paths for Webpack.
     // Note: to use node-oracledb Thick mode, you will need a Webpack copy plugin to
     // copy 'node_modules/oracledb/build/' to the output directory,
     // see https://github.com/oracle/node-oracledb/issues/1156
     // If you want to use only node-oracledb Thin mode, a copy plugin is not needed.
     './node_modules/oracledb/' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BINARY_FILE,
-    './node_modules/oracledb/' + nodbUtil.RELEASE_DIR + '/' + 'oracledb.node'
+    './node_modules/oracledb/' + nodbUtil.RELEASE_DIR + '/' + nodbUtil.BUILD_FILE
   ];
+
+  if (options.binaryDir !== undefined) {
+    binaryLocations.splice(0, 0, options.binaryDir + '/' + nodbUtil.BINARY_FILE,
+      options.binaryDir + '/' + nodbUtil.BUILD_FILE);
+  }
   let oracledbCLib;
   for (let i = 0; i < binaryLocations.length; i++) {
     try {
@@ -248,6 +251,12 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.sslServerDNMatch = options.sslServerDNMatch;
   }
 
+  // sslAllowWeakDNMatch must be a boolean
+  if (options.sslAllowWeakDNMatch !== undefined) {
+    errors.assertParamPropValue(typeof options.sslAllowWeakDNMatch === 'boolean',
+      1, "sslAllowWeakDNMatch");
+    outOptions.sslAllowWeakDNMatch = options.sslAllowWeakDNMatch;
+  }
   // httpsProxy must be a string
   if (options.httpsProxy !== undefined) {
     errors.assertParamPropValue(typeof options.httpsProxy === 'string',
@@ -472,8 +481,10 @@ async function _verifyOptions(options, inCreatePool) {
     errors.assert(nodbUtil.isTokenValid(accessToken),
       errors.ERR_TOKEN_HAS_EXPIRED);
     if (accessToken.privateKey !== undefined) {
-      errors.assert(nodbUtil.isPrivateKeyValid(accessToken),
-        errors.ERR_INVALID_PRIVATE_KEY);
+      errors.assert(typeof accessToken.privateKey === 'string', errors.ERR_TOKEN_BASED_AUTH);
+      accessToken.privateKey = accessToken.privateKey.replace(/\n/g, '');
+      accessToken.privateKey = accessToken.privateKey.replace('-----BEGIN PRIVATE KEY-----', '');
+      accessToken.privateKey = accessToken.privateKey.replace('-----END PRIVATE KEY-----', '');
     }
 
     // store token and privatekey
@@ -546,7 +557,7 @@ async function createPool(options) {
   }
 
   // initialize the Oracle client, if necessary
-  if (_initOracleClientArgs === undefined && !_thinDriverInitialized) {
+  if (_initOracleClientArgs === undefined && !settings.thinDriverInitialized) {
     _initializeThinDriver();
   }
 
@@ -579,6 +590,9 @@ async function createPool(options) {
       delete poolCache[pool.poolAlias];
     }
   });
+  if (_initOracleClientArgs === undefined) {
+    settings.thinDriverInitialized = true;
+  }
 
   return pool;
 }
@@ -638,7 +652,6 @@ async function getConnection(a1) {
 // Returns a pool for the given alias.
 //-----------------------------------------------------------------------------
 function getPool(poolAlias) {
-  let pool;
 
   errors.assertArgCount(arguments, 0, 1);
 
@@ -649,7 +662,7 @@ function getPool(poolAlias) {
 
   poolAlias = poolAlias || defaultPoolAlias;
 
-  pool = poolCache[poolAlias];
+  const pool = poolCache[poolAlias];
 
   if (!pool) {
     errors.throwErr(errors.ERR_POOL_WITH_ALIAS_NOT_FOUND, poolAlias);
@@ -673,12 +686,13 @@ function initOracleClient(arg1) {
     errors.assertParamPropString(options, 1, "configDir");
     errors.assertParamPropString(options, 1, "errorUrl");
     errors.assertParamPropString(options, 1, "driverName");
+    errors.assertParamPropString(options, 1, "binaryDir");
   }
   if (settings.thinDriverInitialized) {
     errors.throwErr(errors.ERR_THIN_CONNECTION_ALREADY_CREATED);
   }
   if (_initOracleClientArgs === undefined) {
-    const oracledbCLib = _initCLib();
+    const oracledbCLib = _initCLib(options);
     if (options.driverName === undefined)
       options.driverName = constants.DEFAULT_DRIVER_NAME + " thk";
     if (options.errorUrl === undefined)
@@ -1053,16 +1067,10 @@ module.exports = {
   },
 
   get oracleClientVersion() {
-    if (_initOracleClientArgs === undefined) {
-      errors.throwNotImplemented("getting the Oracle Client version");
-    }
     return settings.oracleClientVersion;
   },
 
   get oracleClientVersionString() {
-    if (_initOracleClientArgs === undefined) {
-      errors.throwNotImplemented("getting the Oracle Client version");
-    }
     return settings.oracleClientVersionString;
   },
 

package/lib/pool.js

@@ -279,8 +279,14 @@ class Pool extends EventEmitter {
       });
     }
 
+    // if any connections are still out and the pool is not being force closed,
+    // throw an exception
+    if (!forceClose && this._connectionsOut > 0) {
+      errors.throwErr(errors.ERR_POOL_HAS_BUSY_CONNECTIONS);
+    }
+
     // close the pool
-    await this._impl.close({forceClose: forceClose});
+    await this._impl.close();
     this._status = constants.POOL_STATUS_CLOSED;
     this.emit('_afterPoolClose');
 

package/lib/sodaCollection.js

@@ -109,7 +109,7 @@ class SodaCollection {
     errors.assertArgCount(arguments, 1, 1);
     errors.assertParamValue(Array.isArray(docs) && docs.length > 0, 1);
 
-    let actualDocs = Array(docs.length);
+    const actualDocs = Array(docs.length);
     for (let i = 0; i < docs.length; i++) {
       actualDocs[i] = nodbUtil.verifySodaDoc(docs[i]);
     }
@@ -188,6 +188,16 @@ class SodaCollection {
     return doc;
   }
 
+  //---------------------------------------------------------------------------
+  // listIndexes()
+  //
+  //   To obtain all indices from the collection
+  //---------------------------------------------------------------------------
+  async listIndexes() {
+    const arr = await this._impl.listIndexes();
+    return arr.map(i => JSON.parse(i));
+  }
+
   //---------------------------------------------------------------------------
   // metaData()
   //
@@ -262,6 +272,7 @@ nodbUtil.wrapFns(SodaCollection.prototype,
   "insertManyAndGet",
   "insertOne",
   "insertOneAndGet",
+  "listIndexes",
   "save",
   "saveAndGet",
   "truncate");

package/lib/sodaOperation.js

@@ -94,6 +94,22 @@ class SodaOperation {
     }
   }
 
+
+  //---------------------------------------------------------------------------
+  // lock()
+  //
+  //  Pessimistic locking - similar to SELECT FOR UPDATE, these documents
+  //  cannot be updated by other threads until an explicit commit/rollback is
+  //  called.  With autoCommit set to true is applicable only for one immediate
+  //  operation and is not recommended in this context
+  //---------------------------------------------------------------------------
+  lock()  {
+    errors.assertArgCount(arguments, 0, 0);
+    this._options.lock = true;
+    return this;
+  }
+
+
   //---------------------------------------------------------------------------
   // replaceOne()
   //