oracledb 6.0.3 → 6.1.0

package/README.md

@@ -1,10 +1,10 @@
-# node-oracledb version 6.0.3
+# node-oracledb version 6.1.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.1.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.1.0-darwin-x64.node-buildinfo.txt

@@ -0,0 +1 @@
+oracledb-6.1.0-darwin-x64.node v18.17.1 98df02823e1fc31b0e57044cd1fb2358dfc620ed 20785f251426f274f4216369b9259908a103384d Mon, 21 Aug 2023 05:58:15 GMT

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

@@ -0,0 +1 @@
+98df02823e1fc31b0e57044cd1fb2358dfc620ed

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

@@ -0,0 +1 @@
+oracledb-6.1.0-linux-arm64.node v18.15.0 98df02823e1fc31b0e57044cd1fb2358dfc620ed 20785f251426f274f4216369b9259908a103384d Mon, 21 Aug 2023 07:05:34 GMT

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

@@ -0,0 +1 @@
+oracledb-6.1.0-linux-x64.node v16.20.0 98df02823e1fc31b0e57044cd1fb2358dfc620ed 20785f251426f274f4216369b9259908a103384d Mon, 21 Aug 2023 05:55:55 GMT

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

@@ -0,0 +1 @@
+oracledb-6.1.0-win32-x64.node v16.19.0 98df02823e1fc31b0e57044cd1fb2358dfc620ed 20785f251426f274f4216369b9259908a103384d Mon, 21 Aug 2023 09:35:54 GMT

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
   //
@@ -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/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
@@ -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,7 +67,6 @@ const defaultPoolAlias = 'default';
 
 // save arguments for call to initOracleClient()
 let _initOracleClientArgs;
-let _thinDriverInitialized = false;
 
 // Load the Oracledb binary
 function _initCLib() {
@@ -248,6 +247,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 +477,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 +553,7 @@ async function createPool(options) {
   }
 
   // initialize the Oracle client, if necessary
-  if (_initOracleClientArgs === undefined && !_thinDriverInitialized) {
+  if (_initOracleClientArgs === undefined && !settings.thinDriverInitialized) {
     _initializeThinDriver();
   }
 
@@ -579,6 +586,9 @@ async function createPool(options) {
       delete poolCache[pool.poolAlias];
     }
   });
+  if (_initOracleClientArgs === undefined) {
+    settings.thinDriverInitialized = true;
+  }
 
   return pool;
 }
@@ -638,7 +648,6 @@ async function getConnection(a1) {
 // Returns a pool for the given alias.
 //-----------------------------------------------------------------------------
 function getPool(poolAlias) {
-  let pool;
 
   errors.assertArgCount(arguments, 0, 1);
 
@@ -649,7 +658,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);
@@ -1053,16 +1062,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]);
     }

package/lib/thin/connection.js

@@ -32,7 +32,7 @@ const ThinResultSetImpl = require('./resultSet.js');
 const ThinLobImpl  = require("./lob.js");
 const Protocol = require("./protocol/protocol.js");
 const { BaseBuffer } = require('./protocol/buffer.js');
-const {NetworkSession:nsi, getConnectionInfo} = require("./sqlnet/networkSession.js");
+const {NetworkSession:nsi} = require("./sqlnet/networkSession.js");
 const { Statement } = require("./statement");
 const thinUtil = require('./util');
 const sqlNetConstants = require('./sqlnet/constants.js');
@@ -49,6 +49,8 @@ const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
 class TDSBuffer extends BaseBuffer {
 }
 
+const connectionCookies = new Map();
+
 class ThinConnectionImpl extends ConnectionImpl {
 
   /**
@@ -443,10 +445,6 @@ class ThinConnectionImpl extends ConnectionImpl {
     await this._protocol.breakMessage();
   }
 
-  _healthStatus() {
-    return this.nscon.recvInbandNotif();
-  }
-
   isHealthy() {
     try {
       if (this.nscon.recvInbandNotif() === 0)
@@ -461,6 +459,26 @@ class ThinConnectionImpl extends ConnectionImpl {
     return (this._pool) ? true : false;
   }
 
+  //---------------------------------------------------------------------------
+  // getConnectionCookieByUUID()
+  //
+  // It fetches from map which keeps keyname as UUID+ServiceName.
+  // UUID identifies the CDB instance and ServiceName identifies the
+  // entity within a PDB which uniquely identifies a pdb instance.
+  //---------------------------------------------------------------------------
+  getConnectionCookieByUUID(uuid) {
+    let cookie;
+    if (uuid) {
+      const key = uuid + ((this.serviceName) ? this.serviceName : this.sid);
+      cookie = connectionCookies.get(key);
+      if (!cookie) {
+        cookie = {};
+        connectionCookies.set(key, cookie);
+      }
+    }
+    return cookie;
+  }
+
   /**
    *
    * @param {object} params  Configuration of the connection
@@ -499,22 +517,32 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._clientInfoModified = false;
     this._module = "";
     this._moduleModified = false;
+    this._drcpEnabled = false;
     this.serviceName = '';
     this.remoteAddress = '';
-    this.privilege = params.privilege;
     this.comboKey = null; // used in changePassword API
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
     await this.nscon.connect(params);
 
-    this._connInfo = (this.isPooled()) ? params._connInfo.map((x) => x) :
-      await getConnectionInfo(params);
-    this._drcpEnabled = String(this._connInfo[0]).toLowerCase() === 'pooled';
-    this.serviceName = this._connInfo[2];
-    this.purity = this._connInfo[3] | constants.PURITY_DEFAULT;
+    let serverType;
+    if (this.isPooled()) {
+      serverType = params._connInfo[0];
+      this.serviceName = params._connInfo[2];
+      this.purity = params._connInfo[3] | constants.PURITY_DEFAULT;
+      this.sid = params._connInfo[4];
+    } else {
+      serverType = this.nscon.getOption(sqlNetConstants.SERVERTYPE);
+      this.serviceName = this.nscon.getOption(sqlNetConstants.SVCNAME);
+      this.sid = this.nscon.getOption(sqlNetConstants.SID);
+      this.purity = this.nscon.getOption(sqlNetConstants.PURITY) | constants.PURITY_DEFAULT;
+    }
+    if (serverType) {
+      this._drcpEnabled = serverType.toLowerCase() === 'pooled';
+    }
     this.remoteAddress = this.nscon.getOption(sqlNetConstants.REMOTEADDR);
-    this.connClass = params.connectionClass;
+    this.connectionClass = params.connectionClass;
 
     /*
      * if drcp is used, use purity = NEW as the default purity for
@@ -538,13 +566,41 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     try {
-      let message = new messages.ProtocolMessage(this);
-      await this._protocol._processMessage(message);
-      message = new messages.DataTypeMessage(this);
-      await this._protocol._processMessage(message);
-      message = new messages.AuthMessage(this, params);
-      await this._protocol._processMessage(message);        // OSESSKEY
-      await this._protocol._processMessage(message);        // OAUTH
+      const cookie = this.getConnectionCookieByUUID(this.nscon.dbUUID);
+      this.nscon.dbUUID = null;
+      const protocolMessage = new messages.ProtocolMessage(this);
+      const dataTypeMessage = new messages.DataTypeMessage(this);
+      const authMessage = new messages.AuthMessage(this, params);
+      let sentCookie = false;
+      if (cookie && cookie.populated) {
+        const cookieMessage = new messages.ConnectionCookieMessage(this);
+        cookieMessage.cookie = cookie;
+        cookieMessage.protocolMessage = protocolMessage;
+        cookieMessage.dataTypeMessage = dataTypeMessage;
+        cookieMessage.authMessage = authMessage;
+        await this._protocol._processMessage(cookieMessage);
+        sentCookie = true;
+      } else {
+        await this._protocol._processMessage(protocolMessage);
+      }
+      if (!sentCookie || !cookie.populated) {
+        await this._protocol._processMessage(dataTypeMessage);
+        // Does OSESSKEY for non-token Authentication else OAUTH
+        await this._protocol._processMessage(authMessage);
+        if (cookie && !cookie.populated) {
+          cookie.protocolVersion = protocolMessage.serverVersion;
+          cookie.serverBanner = protocolMessage.serverBanner;
+          cookie.charsetID = this._protocol.caps.charSetID;
+          cookie.ncharsetID = this._protocol.caps.nCharsetId;
+          cookie.flags = protocolMessage.serverFlags;
+          cookie.compileCaps = Buffer.from(protocolMessage.serverCompileCaps);
+          cookie.runtimeCaps = Buffer.from(protocolMessage.serverRunTimeCaps);
+          cookie.populated = true;
+        }
+      }
+      if (!params.token) { // non-token Authentication
+        await this._protocol._processMessage(authMessage); // OAUTH
+      }
     } catch (err) {
       this.nscon.disconnect();
       throw err;
@@ -614,7 +670,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   // option is true
   //---------------------------------------------------------------------------
   _prepare(sql, options) {
-    let statement = this._getStatement(sql, options.keepInStmtCache);
+    const statement = this._getStatement(sql, options.keepInStmtCache);
     statement.bufferRowIndex = 0;
     statement.bufferRowCount = 0;
     statement.lastRowIndex = 0;
@@ -626,8 +682,8 @@ class ThinConnectionImpl extends ConnectionImpl {
   // Binds the values by user to the statement object
   //---------------------------------------------------------------------------
   async _bind(stmt, variable, pos = 0) {
-    let bindInfoDict = stmt.bindInfoDict;
-    let bindInfoList = stmt.bindInfoList;
+    const bindInfoDict = stmt.bindInfoDict;
+    const bindInfoList = stmt.bindInfoList;
 
     /*
      * For PL/SQL blocks, if the size of a string or bytes object exceeds
@@ -650,8 +706,8 @@ class ThinConnectionImpl extends ConnectionImpl {
         if (val === null) {
           return null;
         }
-        let data = await val.getData();
-        let len = val._length;
+        const data = await val.getData();
+        const len = val._length;
         if (data && len > maxSize) {
           errors.throwErr(errors.ERR_INSUFFICIENT_BUFFER_FOR_BINDS);
         }
@@ -662,7 +718,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     if (variable.type === types.DB_TYPE_CLOB ||
         variable.type === types.DB_TYPE_NCLOB ||
         variable.type === types.DB_TYPE_BLOB) {
-      for (let [index, val] of variable.values.entries()) {
+      for (const [index, val] of variable.values.entries()) {
         if (!(val instanceof ThinLobImpl)) {
           if (val && val.length > 0) {
             const lobImpl = new ThinLobImpl();
@@ -693,7 +749,7 @@ class ThinConnectionImpl extends ConnectionImpl {
         stmt._setVariable(bindInfo, variable);
       });
     } else {
-      let bindInfo = bindInfoList[pos - 1];
+      const bindInfo = bindInfoList[pos - 1];
       stmt._setVariable(bindInfo, variable);
     }
   }
@@ -739,7 +795,7 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   // Clears the statement cache for the connection
   //---------------------------------------------------------------------------
-  resetStatmentCache() {
+  resetStatementCache() {
     this.statementCache.clear();
     this._cursorsToClose.clear();
   }
@@ -761,9 +817,9 @@ class ThinConnectionImpl extends ConnectionImpl {
   // information for a statment.
   //---------------------------------------------------------------------------
   async getStatementInfo(sql) {
-    let options = {};
-    let result = {};
-    let statement = await this._prepareAndBind(sql, null, options, true);
+    const options = {};
+    const result = {};
+    const statement = await this._prepareAndBind(sql, null, options, true);
     options.connection = this;
     // parse the statement (but not for DDL which doesn't support it)
     if (!statement.isDdl) {
@@ -1038,6 +1094,12 @@ class ThinConnectionImpl extends ConnectionImpl {
     return '';
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database instance name associated with the connection.
+  //---------------------------------------------------------------------------
+  getInstanceName() {
+    return this.instanceName;
+  }
 }
 
 module.exports = ThinConnectionImpl;