oracledb 6.7.2 → 6.9.0

package/lib/thin/connection.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -85,6 +85,9 @@ class ThinConnectionImpl extends ConnectionImpl {
       // immediate close of open socket on failure
       // exception won't be thrown to user
       this.nscon.disconnect(sqlNetConstants.NSFIMM);
+      // If connection is associated with a pool, we release it
+      if (this._pool)
+        await this._pool.release(this);
     }
   }
 
@@ -299,13 +302,20 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     // process the type code.
+    let tempPrecision, tempScale;
     switch (attrType) {
       case constants.TNS_OBJ_TDS_TYPE_NUMBER:
-        metaData.precision = buf.readInt8();
-        metaData.scale = buf.readInt8();
+        tempPrecision = buf.readInt8();
+        tempScale = buf.readInt8();
+        if (tempPrecision || tempScale) {
+          metaData.precision = tempPrecision;
+          metaData.scale = tempScale;
+        }
         return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_FLOAT:
-        metaData.precision = buf.readInt8();
+        tempPrecision = buf.readInt8();
+        if (tempPrecision)
+          metaData.precision = tempPrecision;
         return types.DB_TYPE_NUMBER;
       case constants.TNS_OBJ_TDS_TYPE_VARCHAR:
       case constants.TNS_OBJ_TDS_TYPE_CHAR:
@@ -433,11 +443,24 @@ class ThinConnectionImpl extends ConnectionImpl {
         case
           when data_type in
             ('CHAR', 'NCHAR', 'VARCHAR2', 'NVARCHAR2', 'RAW')
-          then data_length
+            then data_length
           else 0
         end,
-        nvl(data_precision, 0),
-        nvl(data_scale, 0)
+        case
+          when data_precision is null and data_scale is null
+            then 0
+          when data_precision is null
+            then 38
+          else data_precision
+        end,
+        case
+          when data_precision is null and data_scale is null
+              and data_type = 'NUMBER'
+            then -127
+          when data_scale is null
+            then 0
+          else data_scale
+        end
       from all_tab_cols
       where owner = :owner
         and table_name = :name
@@ -670,10 +693,36 @@ class ThinConnectionImpl extends ConnectionImpl {
         this._partialDbObjectTypes.push(attr.typeClass);
       }
     } else {
-      attr.type = types.getTypeByColumnTypeName(attrInfo.dataType);
-      attr.maxSize = attrInfo.maxSize;
-      attr.precision = attrInfo.dataPrecision;
-      attr.scale = attrInfo.dataScale;
+      if (attrInfo.dataType === 'INTEGER' || attrInfo.dataType === 'SMALLINT') {
+        attr.type = types.DB_TYPE_NUMBER;
+        attr.precision = 38;
+        attr.scale = 0;
+      } else if (attrInfo.dataType === 'REAL') {
+        attr.type = types.DB_TYPE_NUMBER;
+        attr.precision = 63;
+        attr.scale = -127;
+      } else if (attrInfo.dataType === 'DOUBLE PRECISION' || attrInfo.dataType === 'FLOAT') {
+        attr.type = types.DB_TYPE_NUMBER;
+        // the database sends type name "FLOAT" instead of type name "REAL"
+        // when looking at table metadata but not when examining database
+        // object attribute metadata so account for that here
+        if (attrInfo.dataPrecision != null || attrInfo.dataPrecision != undefined)
+          attr.precision = Number(attrInfo.dataPrecision);
+        else
+          attr.precision = 126;
+        attr.scale = -127;
+      } else {
+        attr.type = types.getTypeByColumnTypeName(attrInfo.dataType);
+        if (attrInfo.maxSize != null || attrInfo.maxSize != undefined) {
+          const tempMaxSize = Number(attrInfo.maxSize);
+          if (tempMaxSize)
+            attr.maxSize = tempMaxSize;
+        }
+        if (attr.type === types.DB_TYPE_NUMBER) {
+          attr.precision = Number(attrInfo.dataPrecision);
+          attr.scale = Number(attrInfo.dataScale);
+        }
+      }
     }
     attributes.push(attr);
   }
@@ -715,6 +764,9 @@ class ThinConnectionImpl extends ConnectionImpl {
     await this._protocol.breakMessage();
   }
 
+  isCompressionEnabled() {
+    return this.nscon.compressionEnabled;
+  }
   isHealthy() {
     try {
       if (this.nscon.recvInbandNotif() === 0)
@@ -769,6 +821,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     this.remoteAddress = '';
     this.comboKey = null; // used in changePassword API
     this.tpcContext = null;
+    this._sessionlessData = null;
 
     this.nscon = new nsi();
     finalizationRegistry.register(this, this.nscon);
@@ -839,7 +892,7 @@ class ThinConnectionImpl extends ConnectionImpl {
         this.nscon.endOfRequestSupport = endOfRequestSupport;
         await this._protocol._processMessage(authMessage);
       }
-      if (!params.token) { // non-token Authentication
+      if (!params.externalAuth) { // non-token Authentication
         await this._protocol._processMessage(authMessage); // OAUTH
       }
     } catch (err) {
@@ -1230,6 +1283,55 @@ class ThinConnectionImpl extends ConnectionImpl {
       errors.throwErr(errors.ERR_UNKNOWN_TRANSACTION_STATE, message.state);
     }
   }
+  //---------------------------------------------------------------------------
+  // Ensure no sessionless transaction was started through server procedure
+  //---------------------------------------------------------------------------
+  _validateSessionlessState() {
+    if (this._sessionlessData?.startedOnServer) {
+      errors.throwErr(errors.ERR_SESSIONLESS_DIFFERING_METHODS);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // Begin/Resume a sessionless transaction with provided transactionId
+  //---------------------------------------------------------------------------
+  async startSessionlessTransaction(transactionId, timeout, flags,
+    deferRoundTrip) {
+    this._validateSessionlessState();
+    if (this._sessionlessData)
+      errors.throwErr(errors.ERR_SESSIONLESS_ALREADY_ACTIVE);
+    const message = new messages.TransactionSwitchMessage(this);
+    message.xid = {
+      globalTransactionId: transactionId,
+      branchQualifier: "",
+      formatId: constants.TNS_TPC_TRANS_SESSIONLESS_FORMAT
+    };
+    message.timeout = timeout;
+    message.operation = constants.TNS_TPC_TXN_START;
+    message.flags = constants.TNS_TPC_TRANS_SESSIONLESS | flags;
+    if (deferRoundTrip) {
+      message.messageType = constants.TNS_MSG_TYPE_PIGGYBACK;
+      this._sessionlessData = {
+        piggyback: message,
+        pending: true
+      };
+    } else {
+      await this._protocol._processMessage(message);
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // Suspend the active sessionless transaction
+  //---------------------------------------------------------------------------
+  async suspendSessionlessTransaction() {
+    this._validateSessionlessState();
+    if (!this._sessionlessData)
+      errors.throwErr(errors.ERR_SESSIONLESS_INACTIVE);
+    const message = new messages.TransactionSwitchMessage(this);
+    message.operation = constants.TNS_TPC_TXN_DETACH;
+    message.flags = constants.TNS_TPC_TRANS_SESSIONLESS;
+    await this._protocol._processMessage(message);
+  }
 
 
   //---------------------------------------------------------------------------
@@ -1270,6 +1372,14 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.internalName;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the Logical Transaction ID (ltxid) associated with the connection.
+  // Used with Oracle Database Transaction Guard feature.
+  //---------------------------------------------------------------------------
+  getLTXID() {
+    return this._ltxid;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database domain name associated with the connection.
   //---------------------------------------------------------------------------
@@ -1312,6 +1422,14 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.maxOpenCursors;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the maximum length of identifiers supported by the database to
+  // which this connection has been established.
+  //---------------------------------------------------------------------------
+  getMaxIdentifierLength() {
+    return this.maxIdentifierLength;
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database service name associated with the connection.
   //---------------------------------------------------------------------------

package/lib/thin/dbObject.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -55,10 +55,10 @@ class DbObjectPickleBuffer extends GrowableBuffer {
   // Reads the next byte and checks to see if the value is atomically null. If
   // not, the byte is returned to the buffer for further processing.
   //---------------------------------------------------------------------------
-  getIsAtomicNull() {
+  getIsAtomicNull(isCollection) {
     const value = this.readUInt8();
     if (value === constants.TNS_OBJ_ATOMIC_NULL ||
-        value === constants.TNS_NULL_LENGTH_INDICATOR) {
+      (isCollection && value === constants.TNS_NULL_LENGTH_INDICATOR)) {
       return true;
     }
     this.pos -= 1;
@@ -365,13 +365,10 @@ class ThinDbObjectImpl extends DbObjectImpl {
   // Unpacks a single value and returns it.
   //---------------------------------------------------------------------------
   _unpackValue(buf, type, typeClass) {
-    let isNull, obj, value;
+    let isNull, obj, value, isCollection;
     switch (type) {
       case types.DB_TYPE_NUMBER:
-        value = buf.readOracleNumber();
-        if (value !== null)
-          value = parseFloat(value);
-        return value;
+        return buf.readOracleNumber();
       case types.DB_TYPE_BINARY_INTEGER:
         return buf.readBinaryInteger();
       case types.DB_TYPE_VARCHAR:
@@ -399,14 +396,16 @@ class ThinDbObjectImpl extends DbObjectImpl {
         return buf.readBool();
       case types.DB_TYPE_OBJECT:
       case types.DB_TYPE_XMLTYPE:
-        isNull = buf.getIsAtomicNull();
+        obj = new ThinDbObjectImpl(typeClass);
+        isCollection = obj._objType.isCollection ||
+          this._objType.isCollection;
+        isNull = buf.getIsAtomicNull(isCollection);
         if (isNull)
           return null;
-        obj = new ThinDbObjectImpl(typeClass);
         if (obj._objType.isXmlType) {
           return readXML(obj._objType._connection, buf.readBytesWithLength());
         }
-        if (obj._objType.isCollection || this._objType.isCollection) {
+        if (isCollection) {
           obj.packedData = Buffer.from(buf.readBytesWithLength());
         } else {
           obj._unpackDataFromBuf(buf);
@@ -429,7 +428,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
       if (objType.maxNumElements > 0 &&
           this.unpackedArray.length >= objType.maxNumElements) {
         errors.throwErr(errors.ERR_INVALID_COLL_INDEX_SET,
-          this.unpackedArray.length, 0, objType.maxNumElements);
+          this.unpackedArray.length, 0, objType.maxNumElements - 1);
       }
       this.unpackedArray.push(value);
     } else {
@@ -446,6 +445,26 @@ class ThinDbObjectImpl extends DbObjectImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // copy
+  //
+  // Creates and returns a copy of the ThinDBObjectImpl object. The copy is
+  // independent of the original object that was copied.
+  //---------------------------------------------------------------------------
+  copy() {
+    // We send in marshalled data of the original object to the constructor
+    // when we create the object copy
+    const newObjImpl = new ThinDbObjectImpl(this._objType, this._getPackedData());
+
+    // Set other properties
+    newObjImpl.toid = this.toid;
+    newObjImpl.flags = this.flags;
+    newObjImpl.imageFlags = this.imageFlags;
+    newObjImpl.imageVersion = this.imageVersion;
+
+    return newObjImpl;
+  }
+
   //---------------------------------------------------------------------------
   // deleteElement()
   //
@@ -459,7 +478,7 @@ class ThinDbObjectImpl extends DbObjectImpl {
       }
       this.unpackedArray.splice(index, 1);
     } else {
-      this._unpackedAssocKeys = undefined;
+      this.unpackedAssocKeys = undefined;
       this.unpackedAssocArray.delete(index);
     }
   }
@@ -610,6 +629,20 @@ class ThinDbObjectImpl extends DbObjectImpl {
     return result;
   }
 
+  //---------------------------------------------------------------------------
+  // getLength
+  //
+  // Gets the size of the database object if it is a collection. Else returns
+  // undefined.
+  //---------------------------------------------------------------------------
+  getLength() {
+    this._ensureUnpacked();
+    if (this.unpackedArray)
+      return this.unpackedArray.length;
+    if (this.unpackedAssocArray)
+      return this.unpackedAssocArray.size;
+  }
+
   //---------------------------------------------------------------------------
   // hasElement()
   //

package/lib/thin/lob.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -220,10 +220,9 @@ class ThinLobImpl extends LobImpl {
     const options = {
       operation: constants.TNS_LOB_OP_CREATE_TEMP,
       sourceLobImpl: this,
-      amount: constants.TNS_DURATION_SESSION,
       destOffset: dbType._oraTypeNum,
       sourceOffset: dbType._csfrm,
-      sendAmount: true
+      destLength: constants.TNS_DURATION_SESSION
     };
     await this._sendMessage(options);
     await this._getChunkSizeAsync();

package/lib/thin/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -35,7 +35,6 @@ const util = require('../util.js');
 const thinUtil = require('./util.js');
 const {getConnectionInfo} = require('./sqlnet/networkSession.js');
 const crypto = require('crypto');
-const EventEmitter = require('events');
 const Timers = require('timers');
 
 class ThinPoolImpl extends PoolImpl {
@@ -57,6 +56,7 @@ class ThinPoolImpl extends PoolImpl {
     this._poolTimeout = params.poolTimeout;
     this._poolPingInterval = params.poolPingInterval;
     this._poolPingTimeout = params.poolPingTimeout;
+    this._maxLifetimeSession = params.maxLifetimeSession || 0;
     this._stmtCacheSize = params.stmtCacheSize;
 
     // The user Config filterd from common layer is cached except
@@ -77,6 +77,9 @@ class ThinPoolImpl extends PoolImpl {
     this._schedulerJob = null;
     this._poolCloseWaiter = null;
     this._pendingRequests = [];
+    this._connsToDrop = [];
+    this._bgCleaner = null;
+    this._poolCloseCleaner = null;
 
     // password obfuscation
     if (this._password !== undefined) {
@@ -117,11 +120,6 @@ class ThinPoolImpl extends PoolImpl {
     this._accessTokenConfig = params.accessTokenConfig;
     this._isDRCPEnabled = false;
     this._implicitPool = null;
-    this.eventEmitter = new EventEmitter();
-    // listener to remove dead or idle connections
-    this.eventEmitter.on('_removePoolConnection', async (connImpl) => {
-      await this._destroy(connImpl);
-    });
   }
 
   //---------------------------------------------------------------------------
@@ -142,6 +140,9 @@ class ThinPoolImpl extends PoolImpl {
     // create a background task. It will create minimum connections in the pool
     // and expand the pool as required.
     this.bgThreadFunc();
+    // create a background task to remove connections that are to in
+    // _connsToDrop, reason for dropping may be poolTimeout or poolMax decrease
+    this._bgConnCleaner();
   }
 
   //---------------------------------------------------------------------------
@@ -197,7 +198,11 @@ class ThinPoolImpl extends PoolImpl {
         protocolUtil.getDeobfuscatedValue(this._token, this._obfuscatedToken);
       if (util.isTokenExpired(clonedAttrs.token)) {
         if (typeof this._accessTokenFn === 'function') {
-          accessToken = await this._accessTokenFn(true, this._accessTokenConfig);
+          try {
+            accessToken = await this._accessTokenFn(true, this._accessTokenConfig);
+          } catch (error) {
+            errors.throwWrapErr(error, errors.ERR_ACCESS_TOKEN);
+          }
           if (typeof accessToken === 'string') {
             clonedAttrs.token = accessToken;
             if (util.isTokenExpired(clonedAttrs.token)) {
@@ -211,7 +216,7 @@ class ThinPoolImpl extends PoolImpl {
             }
           } else if (typeof accessToken === 'object') {
             clonedAttrs.token = accessToken.token;
-            clonedAttrs.privateKey = accessToken.privateKey;
+            clonedAttrs.privateKey = util.denormalizePrivateKey(accessToken.privateKey);
             if (util.isTokenExpired(clonedAttrs.token)) {
               // IAM token is expired
               errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
@@ -250,9 +255,13 @@ class ThinPoolImpl extends PoolImpl {
   // destroy connection when pool close operation is called
   //---------------------------------------------------------------------------
   async _destroy(connection) {
-    if (connection.nscon.ntAdapter.connected) {
-      connection._dropSess = true;
-      await connection.close();
+    try {
+      if (connection.nscon.ntAdapter.connected) {
+        connection._dropSess = true;
+        await connection.close();
+      }
+    } catch (err) {
+      return;
     }
   }
 
@@ -286,7 +295,12 @@ class ThinPoolImpl extends PoolImpl {
       await this._destroy(conn);
     }
 
-    this.eventEmitter.removeAllListeners();
+    // Let the bgCleaner destroy all connsToDrop and stop
+    await new Promise((resolve) => {
+      this._poolCloseCleaner = resolve;
+      if (this._bgCleaner)
+        this._bgCleaner();
+    });
   }
 
   //---------------------------------------------------------------------------
@@ -352,6 +366,13 @@ class ThinPoolImpl extends PoolImpl {
     return this._poolTimeout;
   }
 
+  //---------------------------------------------------------------------------
+  // returns the pool max lifetime for a session  (seconds)
+  //---------------------------------------------------------------------------
+  getMaxLifetimeSession() {
+    return this._maxLifetimeSession;
+  }
+
   //---------------------------------------------------------------------------
   // returns whether the SODA metadata cache is enabled or not
   //---------------------------------------------------------------------------
@@ -395,10 +416,13 @@ class ThinPoolImpl extends PoolImpl {
         break;
       }
 
-      this.eventEmitter.emit('_removePoolConnection', conn);
+      this._connsToDrop.push(conn);
       this._freeConnectionList.shift();
     }
 
+    // call cleaner for destroying connections added to _connsToDrop
+    if (this._bgCleaner)
+      this._bgCleaner();
     this._schedulerJob = null;
     this._setScheduler();
   }
@@ -434,15 +458,6 @@ class ThinPoolImpl extends PoolImpl {
 
     // continue until a close request is received
     while (!this._poolCloseWaiter) {
-      // eliminate connections that exceed the poolMax (this should only happen
-      // after a reconfiguration has taken place where the maximum number of
-      // connections is reduced)
-      let numToDestroy = this._poolMax - this.getConnectionsOpen();
-      while (numToDestroy > 0 && this._freeConnectionList.length > 0) {
-        const connToBeRemoved = this._freeConnectionList.shift();
-        this.eventEmitter.emit('_removePoolConnection', connToBeRemoved);
-        numToDestroy--;
-      }
 
       const numToCreate = this._getNumConnsToCreate();
       // connection creation is going on serially and not concurrently
@@ -455,6 +470,7 @@ class ThinPoolImpl extends PoolImpl {
           await conn.connect(config);
           conn._newSession = true;
           conn._dropSess = false;
+          conn._creationTime = Date.now();
           conn._lastTimeUsed = Date.now();
           this._freeConnectionList.push(conn);
         } catch (err) {
@@ -487,7 +503,8 @@ class ThinPoolImpl extends PoolImpl {
       }
 
       // if no pending requests, wait for pending requests to appear!
-      if (this._pendingRequests.length == 0 || this._bgErr) {
+      if ((this._pendingRequests.length == 0 || this._bgErr) &&
+        this.getConnectionsOpen() >= this._poolMin) {
         await new Promise((resolve) => {
           this.bgWaiter = resolve;
         });
@@ -499,6 +516,27 @@ class ThinPoolImpl extends PoolImpl {
     this._poolCloseWaiter();
   }
 
+  //---------------------------------------------------------------------------
+  // _bgConnCleaner()
+  // Method which stays in the stack and performs cleanup whenever a connection
+  // gets added for cleanup to _connsToDrop
+  // acquire a connection from connection pool
+  //---------------------------------------------------------------------------
+  async _bgConnCleaner() {
+    // run until a pool.close() is issued
+    while (!this._poolCloseCleaner) {
+
+      // wait for _bgCleaner to be called for cleanup
+      if (this._connsToDrop.length == 0)
+        await new Promise(resolve => this._bgCleaner = resolve);
+
+      // destroy connections in _connsToDrop
+      while (this._connsToDrop.length)
+        await this._destroy(this._connsToDrop.pop());
+    }
+    this._poolCloseCleaner();
+  }
+
   //---------------------------------------------------------------------------
   // acquire()
   //
@@ -510,9 +548,10 @@ class ThinPoolImpl extends PoolImpl {
     while (this._freeConnectionList.length > 0) {
       const conn = this._freeConnectionList.pop();
 
-      // if connection is unhealthy, drop it from the pool
-      if (!conn.isHealthy()) {
-        this.eventEmitter.emit('_removePoolConnection', conn);
+      // drop from the pool if the connection is unhealthy, or if the
+      // connection's lifetime exceeds maxLifetimeSession
+      if (!this._shouldRetainInPool(conn)) {
+        this._invokeBgCleaner(conn);
         continue;
       }
 
@@ -591,11 +630,11 @@ class ThinPoolImpl extends PoolImpl {
     if (conn.nscon.connected) {
       conn._lastTimeUsed = Date.now();
       conn._newSession = false;
-      if ((this._freeConnectionList.length + this._usedConnectionList.size)
-        < this._poolMax) {
+      if ((this.getConnectionsOpen() < this._poolMax) &&
+          this._shouldRetainInPool(conn)) {
         this._freeConnectionList.push(conn);
       } else {
-        this.eventEmitter.emit('_removePoolConnection', conn);
+        this._invokeBgCleaner(conn);
       }
     }
 
@@ -648,9 +687,51 @@ class ThinPoolImpl extends PoolImpl {
       this._poolMin = params.poolMin;
     }
 
-    if (this.bgWaiter) {
+    if (params.maxLifetimeSession !== undefined) {
+      this._maxLifetimeSession = params.maxLifetimeSession;
+    }
+
+    let numToDestroy = this.getConnectionsOpen() - this._poolMax;
+    while (this._freeConnectionList.length && numToDestroy > 0) {
+      const conn = this._freeConnectionList.pop();
+      this._connsToDrop.push(conn);
+      numToDestroy--;
+    }
+
+    // call cleanup for destroying connections in _connsToDrop
+    if (this._bgCleaner)
+      this._bgCleaner();
+  }
+
+  //---------------------------------------------------------------------------
+  // _invokeBgCleaner()
+  //
+  // drop conn and invoke the bgCleaner while also ensuring min connections
+  //---------------------------------------------------------------------------
+  _invokeBgCleaner(conn) {
+    this._connsToDrop.push(conn);
+    if (this._bgCleaner)
+      this._bgCleaner();
+
+    // ensure min connections are maintained in pool
+    if ((this.getConnectionsOpen() < this._poolMin) && this.bgWaiter)
       this.bgWaiter();
+  }
+
+  //---------------------------------------------------------------------------
+  // _shouldRetainInPool()
+  //
+  // returns true if the connection should be retained in pool
+  //---------------------------------------------------------------------------
+  _shouldRetainInPool(conn) {
+    if (!conn.isHealthy())
+      return false;
+    // check if maxLifetimeSession of conn has expired
+    if (this._maxLifetimeSession !== 0) {
+      if ((Date.now() - conn._creationTime) > (this._maxLifetimeSession * 1000))
+        return false;
     }
+    return true;
   }
 }
 

package/lib/thin/protocol/capabilities.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -104,11 +104,14 @@ class Capabilities {
       constants.TNS_CCAP_LOB2_QUASI | constants.TNS_CCAP_LOB2_2GB_PREFETCH;
     this.compileCaps[constants.TNS_CCAP_TTC3] =
       constants.TNS_CCAP_IMPLICIT_RESULTS | constants.TNS_CCAP_BIG_CHUNK_CLR |
-      constants.TNS_CCAP_KEEP_OUT_ORDER;
+      constants.TNS_CCAP_KEEP_OUT_ORDER | constants.TNS_CCAP_LTXID;
+    this.compileCaps[constants.TNS_CCAP_OCI3] = constants.TNS_CCAP_OCI3_OCSSYNC;
     this.compileCaps[constants.TNS_CCAP_TTC2] = constants.TNS_CCAP_ZLNP;
     this.compileCaps[constants.TNS_CCAP_OCI2] = constants.TNS_CCAP_DRCP;
     this.compileCaps[constants.TNS_CCAP_CLIENT_FN] =
       constants.TNS_CCAP_CLIENT_FN_MAX;
+    this.compileCaps[constants.TNS_CCAP_SESS_SIGNATURE_VERSION] =
+      constants.TNS_CCAP_FIELD_VERSION_12_2;
     this.compileCaps[constants.TNS_CCAP_TTC4] =
       constants.TNS_CCAP_INBAND_NOTIFICATION;
     if (nscon.endOfRequestSupport) {
@@ -117,9 +120,10 @@ class Capabilities {
     this.compileCaps[constants.TNS_CCAP_CTB_FEATURE_BACKPORT] =
       constants.TNS_CCAP_CTB_IMPLICIT_POOL;
     this.compileCaps[constants.TNS_CCAP_TTC5] =
-      constants.TNS_CCAP_VECTOR_SUPPORT;
+      constants.TNS_CCAP_VECTOR_SUPPORT |
+      constants.TNS_CCAP_TTC5_SESSIONLESS_TXNS;
     this.compileCaps[constants.TNS_CCAP_VECTOR_FEATURES] =
-      constants.TNS_CCAP_VECTOR_FEATURE_BINARY;
+      constants.TNS_CCAP_VECTOR_FEATURE_BINARY | constants.TNS_CCAP_VECTOR_FEATURE_SPARSE;
   }
 
   initRuntimeCaps() {