oracledb 6.7.2 → 6.9.0

package/lib/impl/datahandlers/vector.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2024, Oracle and/or its affiliates.
+// Copyright (c) 2024, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -30,6 +30,7 @@ const { BaseBuffer, GrowableBuffer } = require('./buffer.js');
 const { Buffer } = require('buffer');
 const constants = require("./constants.js");
 const errors = require("../../errors.js");
+const types = require("../../types.js");
 
 /**
  * Class used for decoding
@@ -50,68 +51,83 @@ class VectorDecoder extends BaseBuffer {
       errors.throwErr(errors.ERR_UNEXPECTED_DATA,
         Buffer.from([magicByte]).toString('hex'));
     const version = this.readUInt8();
-    if (version > constants.TNS_VECTOR_VERSION_WITH_BINARY)
+    if (version > constants.TNS_VECTOR_VERSION_WITH_SPARSE)
       errors.throwErr(errors.ERR_VECTOR_VERSION_NOT_SUPPORTED, version);
     const flags = this.readUInt16BE();
     const vectorFormat = this.readUInt8();
     let numElements = this.readUInt32BE();
-    let elementSize, result;
+    let elementSize, value, sparseValue;
+
+    // For binary vector, NORM will never be present but space for NORM is reserved to keep
+    // same header lengh across the different vector formats.
+    if (vectorFormat === constants.VECTOR_FORMAT_BINARY || flags & constants.TNS_VECTOR_FLAG_NORM)
+      this.skipBytes(8);
+
+    let sparseFormat;
+    if (flags & constants.TNS_VECTOR_FLAG_SPARSE) {
+      sparseFormat = true;
+      sparseValue = {};
+      sparseValue.numDimensions = numElements; // vector dimensions.
+      numElements = this.readUInt16BE(); // actual elements.
+      sparseValue.indices = new Uint32Array(numElements);
+      for (let i = 0; i < numElements; i++) {
+        sparseValue.indices[i] = this.readUInt32BE();
+      }
+    }
+
     if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
       elementSize = 4;
-      result = new Float32Array(numElements);
+      value = new Float32Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_FLOAT64) {
       elementSize = 8;
-      result = new Float64Array(numElements);
+      value = new Float64Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_INT8) {
       elementSize = 1;
-      result = new Int8Array(numElements);
+      value = new Int8Array(numElements);
     } else if (vectorFormat === constants.VECTOR_FORMAT_BINARY) {
       elementSize = 1;
       // The number of dimensions are assumed to be multiple of 8.
       numElements = numElements / 8;
-      result = new Uint8Array(numElements);
+      value = new Uint8Array(numElements);
     } else {
       errors.throwErr(errors.ERR_VECTOR_FORMAT_NOT_SUPPORTED, vectorFormat);
     }
 
-    // For binary vector, NORM will never be present but space for NORM is reserved to keep
-    // same header lengh across the different vector formats.
-    if (vectorFormat === constants.VECTOR_FORMAT_BINARY || flags & constants.TNS_VECTOR_FLAG_NORM)
-      this.skipBytes(8);
+    if (sparseFormat) {
+      sparseValue.values = value;
+    }
 
     // parse data
+    let res;
     for (let i = 0; i < numElements; i++) {
       const buf = this.readBytes(elementSize);
       if (vectorFormat === constants.VECTOR_FORMAT_FLOAT32) {
-        result[i] = this.parseBinaryFloat(buf);
+        res = this.parseBinaryFloat(buf);
       } else if (vectorFormat === constants.VECTOR_FORMAT_FLOAT64)  {
-        result[i] = this.parseBinaryDouble(buf);
+        res = this.parseBinaryDouble(buf);
       } else {
-        result[i] = buf[0];
+        res = buf[0];
       }
+      value[i] = res;
     }
 
-    return result;
+    return sparseFormat ? types.SparseVector.create(sparseValue) : value;
   }
 
 }
 
 class VectorEncoder extends GrowableBuffer {
 
-  //---------------------------------------------------------------------------
-  // encode()
-  //
-  // Encodes the value as OSON and returns a buffer containing the OSON bytes.
-  //---------------------------------------------------------------------------
-  encode(value) {
-
-    // determine some basic information about the vector
-    let vectorFormat = constants.VECTOR_FORMAT_FLOAT32;
-    let writeFn = this.writeBinaryFloat.bind(this);
+  // Writes Header from value.
+  // It returns function to serialize the value.
+  // sparseVal is provided for SparseVector.
+  _updateVectorHeader(value, sparseVal) {
+    let flags = constants.TNS_VECTOR_FLAG_NORMSRC
+    | constants.TNS_VECTOR_FLAG_NORM; // NORM is present and reserve space.
     let numElements = value.length;
     let vectorVersion = constants.TNS_VECTOR_VERSION_BASE;
-    let flags = constants.TNS_VECTOR_FLAG_NORMSRC
-      | constants.TNS_VECTOR_FLAG_NORM; // NORM is present and reserve space.
+    let vectorFormat = constants.VECTOR_FORMAT_FLOAT32;
+    let writeFn = this.writeBinaryFloat.bind(this);
 
     if (Array.isArray(value) || value instanceof Float64Array) {
       vectorFormat = constants.VECTOR_FORMAT_FLOAT64;
@@ -127,6 +143,11 @@ class VectorEncoder extends GrowableBuffer {
       flags = constants.TNS_VECTOR_FLAG_NORMSRC; // only space is reserved.
       writeFn = this.writeUInt8.bind(this);
     }
+    if (sparseVal && sparseVal instanceof types.SparseVector) {
+      vectorVersion = constants.TNS_VECTOR_VERSION_WITH_SPARSE;
+      numElements = sparseVal.numDimensions;
+      flags |= constants.TNS_VECTOR_FLAG_SPARSE;
+    }
 
     // write header
     this.writeUInt8(constants.TNS_VECTOR_MAGIC_BYTE);
@@ -135,6 +156,30 @@ class VectorEncoder extends GrowableBuffer {
     this.writeUInt8(vectorFormat);
     this.writeUInt32BE(numElements);
     this.reserveBytes(8);
+    return writeFn;
+  }
+
+  //---------------------------------------------------------------------------
+  // encode()
+  //
+  // Encodes the value as OSON and returns a buffer containing the OSON bytes.
+  //---------------------------------------------------------------------------
+  encode(value) {
+    let writeFn;
+
+    if (value instanceof types.SparseVector) {
+      writeFn = this._updateVectorHeader(value.values, value);
+      const numElements = value.indices.length;
+      this.writeUInt16BE(numElements);
+
+      // Write indices
+      value.indices.forEach((element) => {
+        this.writeUInt32BE(element);
+      });
+      value = value.values;
+    } else {
+      writeFn = this._updateVectorHeader(value);
+    }
 
     // write data
     value.forEach((element) => {

package/lib/impl/pool.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -165,6 +165,15 @@ class PoolImpl {
     errors.throwNotImplemented("getting the pool timeout");
   }
 
+  //---------------------------------------------------------------------------
+  // getMaxLifetimeSession()
+  //
+  // Returns the pool max lifetime for a session.
+  //---------------------------------------------------------------------------
+  getMaxLifetimeSession() {
+    errors.throwNotImplemented("getting the pool max lifetime");
+  }
+
   //---------------------------------------------------------------------------
   // getStmtCacheSize()
   //

package/lib/impl/resultset.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -43,8 +43,9 @@ class ResultSetImpl extends BaseImpl {
   // _determineFetchType()
   //
   // Determine the fetch type to use for the specified metadata.
+  // Param rowsetMetaData includes metadata of all the columns fetched.
   //---------------------------------------------------------------------------
-  _determineFetchType(metadata, options) {
+  _determineFetchType(metadata, options, rowsetMetaData) {
 
     // clear any previous fetch type and converter functions that may have been
     // retained
@@ -54,7 +55,7 @@ class ResultSetImpl extends BaseImpl {
     // if a fetch type handler is specified, call it; if no value (undefined)
     // is returned, the normal processing takes place
     if (options.fetchTypeHandler) {
-      const result = options.fetchTypeHandler(metadata);
+      const result = options.fetchTypeHandler(metadata, rowsetMetaData);
       if (result !== undefined) {
         errors.assert(typeof result === 'object',
           errors.ERR_FETCH_TYPE_HANDLER_RETURN_VALUE);
@@ -232,7 +233,7 @@ class ResultSetImpl extends BaseImpl {
         info.dbTypeClass = cls;
       }
       nodbUtil.addTypeProperties(info, "dbType");
-      this._determineFetchType(info, options);
+      this._determineFetchType(info, options, metaData);
       if (info.fetchType === types.DB_TYPE_CURSOR) {
         this.nestedCursorIndices.push(i);
       } else if (info.fetchType === types.DB_TYPE_CLOB ||

package/lib/lob.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2016, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2016, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -246,6 +246,14 @@ class Lob extends Duplex {
     this._checkIsBfile();
     errors.assertArgCount(arguments, 1, 1);
     errors.assertParamValue(nodbUtil.isObject(a1), 1);
+    errors.assertParamValue(Object.hasOwn(a1, "dirName"), 1);
+    errors.assertParamValue(Object.hasOwn(a1, "fileName"), 1);
+    errors.assertPropValue(
+      a1.dirName != "" && a1.dirName != null, "dirName"
+    );
+    errors.assertPropValue(
+      a1.fileName != "" && a1.fileName != null, "fileName"
+    );
     this._impl.setDirFileName(a1);
   }
 

package/lib/oracledb.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2015, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2015, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -34,15 +34,15 @@ const impl = require('./impl');
 const process = require('process');
 const util = require('util');
 
-// This version of node-oracledb works with Node.js 14.6 or later.
+// This version of node-oracledb works with Node.js 14.17 or later.
 // Note: the checked version is the minimum required for Node-API
 // compatibility.  When new Node.js versions are released, older Node.js
 // versions are dropped from the node-oracledb test plan.
 //
 // Keep this code in sync with package/install.js
 const vs = process.version.substring(1).split(".").map(Number);
-errors.assert(vs[0] > 14 || (vs[0] === 14 && vs[1] >= 6),
-  errors.ERR_NODE_TOO_OLD, nodbUtil.PACKAGE_JSON_VERSION, "14.6");
+errors.assert(vs[0] > 14 || (vs[0] === 14 && vs[1] >= 17),
+  errors.ERR_NODE_TOO_OLD, nodbUtil.PACKAGE_JSON_VERSION, "14.17");
 
 const AqDeqOptions = require('./aqDeqOptions.js');
 const AqEnqOptions = require('./aqEnqOptions.js');
@@ -67,6 +67,8 @@ const SodaOperation = require('./sodaOperation.js');
 const poolCache = {};
 const tempUsedPoolAliases = {};
 const defaultPoolAlias = 'default';
+const registeredHooks = [];
+const registeredConfigProviderHooks = new Map();
 let configProviderCache;
 
 // save arguments for call to initOracleClient()
@@ -188,6 +190,18 @@ async function _verifyOptions(options, inCreatePool) {
       "walletLocation");
     outOptions.walletLocation = options.walletLocation;
   }
+  if (options.networkCompression !== undefined) {
+    errors.assertParamPropValue(typeof options.networkCompression === 'boolean', 1,
+      "networkCompression");
+    outOptions.networkCompression = options.networkCompression;
+    outOptions.networkCompressionLevels = [];
+    outOptions.networkCompressionLevels.push('high');
+  }
+
+  if (options.networkCompressionThreshold !== undefined) {
+    errors.assertParamPropValue(Number.isInteger(options.networkCompressionThreshold), 1, "networkCompressionThreshold");
+    outOptions.networkCompressionThreshold = options.networkCompressionThreshold;
+  }
 
   //wallet content must be a string
   if (options.walletContent !== undefined) {
@@ -362,6 +376,22 @@ async function _verifyOptions(options, inCreatePool) {
     outOptions.terminal = options.terminal;
   }
 
+  // useSNI must be a boolean
+  if (options.useSNI !== undefined) {
+    errors.assertParamPropValue(typeof options.useSNI === 'boolean', 1,
+      "useSNI");
+    outOptions.useSNI = options.useSNI;
+  }
+
+  // appContext must be an array of array values. The element arrays should
+  // have 3 string values (namespace, name and value).
+  if (options.appContext !== undefined) {
+    const value = options.appContext;
+    errors.assertParamPropValue(nodbUtil.isAppContext(value), 1,
+      "appContext");
+    outOptions.appContext = options.appContext;
+  }
+
   // check pool specific options
   if (inCreatePool) {
 
@@ -415,6 +445,13 @@ async function _verifyOptions(options, inCreatePool) {
       outOptions.poolPingTimeout = options.poolPingTimeout;
     }
 
+    // maxLifeTime must be an unsigned integer
+    if (options.maxLifetimeSession !== undefined) {
+      errors.assertParamPropValue(Number.isInteger(options.maxLifetimeSession) &&
+    options.maxLifetimeSession >= 0, 1, "maxLifetimeSession");
+      outOptions.maxLifetimeSession = options.maxLifetimeSession;
+    }
+
     // homogeneous must be a boolean (and defaults to True)
     outOptions.homogeneous = true;
     if (options.homogeneous !== undefined) {
@@ -513,9 +550,13 @@ async function _verifyOptions(options, inCreatePool) {
     if (typeof options.accessToken === 'function') {
       outOptions.accessTokenFn = options.accessToken;
       outOptions.accessTokenConfig = options.accessTokenConfig;
-      accessToken = await options.accessToken(false, options.accessTokenConfig);
-      if (!nodbUtil.isTokenValid(accessToken)) {
-        accessToken = await options.accessToken(true, options.accessTokenConfig);
+      try {
+        accessToken = await options.accessToken(false, outOptions.accessTokenConfig);
+        if (!nodbUtil.isTokenValid(accessToken)) {
+          accessToken = await options.accessToken(true, outOptions.accessTokenConfig);
+        }
+      } catch (error) {
+        errors.throwWrapErr(error, errors.ERR_ACCESS_TOKEN);
       }
     } else {
       accessToken = options.accessToken;
@@ -568,6 +609,18 @@ async function createPool(options) {
   // check arguments
   errors.assertArgCount(arguments, 1, 1);
   errors.assertParamValue(nodbUtil.isObject(options), 1);
+
+  // this will invoke hookFn() written in application side.
+  // for token based auth it will generate access token and save it in options.
+  for (const hookFn of registeredHooks) {
+    // eslint-disable-next-line no-useless-catch
+    try {
+      await hookFn(options);
+    } catch (error) {
+      errors.throwWrapErr(error, errors.ERR_CALLOUT_FN);
+    }
+  }
+
   options = await _verifyOptions(options, true);
   const sessionCallback = options.sessionCallback;
   if (typeof sessionCallback === 'function')
@@ -700,6 +753,17 @@ async function getConnection(a1) {
     return await pool.getConnection(options);
   }
 
+  // this will invoke hookFn() written in application side.
+  // for token based auth it will generate access token and save it in options.
+  for (const hookFn of registeredHooks) {
+    // eslint-disable-next-line no-useless-catch
+    try {
+      await hookFn(options);
+    } catch (error) {
+      errors.throwWrapErr(error, errors.ERR_CALLOUT_FN);
+    }
+  }
+
   // create a standalone connection
   options = await _verifyOptions(options, false);
   settings.addToOptions(options,
@@ -841,6 +905,84 @@ async function shutdown(a1, a2) {
   await conn.close();
 }
 
+async function _setConfigParameters(obj, credential, configProvider) {
+  const configObject = {};
+  const pmSection = 'njs';
+  const params = obj[pmSection];
+  for (const key in params) {
+    const val = params[key];
+    configObject[key] = val;
+  }
+  configObject.connectString = obj.connect_descriptor;
+  if (!configObject.connectString)
+    errors.throwErr(errors.ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG, 'connect_descriptor must be set');
+
+  configObject.user = obj.user;
+  if (obj.password) {
+    configObject.password = await _retrieveParamValueFromVault(obj['password'], credential, configProvider);
+  }
+  if (obj.wallet_location) {
+    // retrieve wallet_location
+    configObject.walletContent = await _retrieveParamValueFromVault(obj['wallet_location'], credential, configProvider);
+    //only Pem file supported
+    if (!nodbUtil.isPemFile(configObject.walletContent))
+      errors.throwErr(errors.ERR_WALLET_TYPE_NOT_SUPPORTED);
+  }
+  return configObject;
+}
+
+async function _retrieveParamValueFromVault(paramObj, credential, configProvider) {
+  const paramMap = new Map();
+  const auth = paramObj.authentication;
+  if (auth) {
+    for (const key in auth) {
+      if (key == 'method')
+        paramMap.set('authentication', auth[key]);
+      const val = auth[key];
+      paramMap.set(key.toLowerCase(), val);
+    }
+  }
+  const args = {};
+  if (paramObj.type == "base64") {
+    console.log("WARNING: Base64 Encoding in a JSON Password should only be used in development environments");
+    return Buffer.from(paramObj.value, "base64").toString("utf-8");
+  } else if (paramObj.type == "text") {
+    if (configProvider == 'azurevault' || configProvider == 'ocivault') {
+      console.log("WARNING: Plain Text in a JSON Password should only be used in development environments");
+      return paramObj.value;
+    } else
+      errors.throwErr(errors.ERR_CONFIG_PROVIDER_PARAM_TYPE, 'password type text is only allowed in ocivault and azurevault');
+  } else if (paramObj.type == "azurevault") {
+    paramMap.set('azuresecreturl', paramObj.value);
+    if (!(configProvider == 'azure' || configProvider == 'azurevault'))
+      credential = null;
+    const hookFn = registeredConfigProviderHooks['azurevault'];
+    if (hookFn == undefined)
+      errors.throwErr(errors.ERR_REGISTER_HOOKFN_CONFIGPROVIDER, 'azurevault');
+    args.credential = credential;
+    args.paramMap = paramMap;
+    const vaultReturn = await hookFn(args);
+    const paramValue = vaultReturn[0];
+    return paramValue;
+
+  } else if (paramObj.type == "ocivault") {
+
+    paramMap.set('ocidvault', paramObj.value);
+    if (!(configProvider == 'ociobject' || configProvider == 'ocivault'))
+      credential = null;
+    const hookFn = registeredConfigProviderHooks['ocivault'];
+    if (hookFn == undefined)
+      errors.throwErr(errors.ERR_REGISTER_HOOKFN_CONFIGPROVIDER, 'ocivault');
+    const args = {};
+    args.credential = credential;
+    args.paramMap = paramMap;
+    const vaultReturn = await hookFn(args);
+    const paramValue = vaultReturn[0];
+    return paramValue;
+  }  else {
+    errors.throwErr(errors.ERR_CONFIG_PROVIDER_PARAM_TYPE, 'password/wallet_location');
+  }
+}
 //-----------------------------------------------------------------------------
 // _checkConfigProvider()
 //
@@ -881,23 +1023,27 @@ async function _checkConfigProvider(options) {
     if (match) {
       const provider = match.groups.provider;
       const provider_arg = match.groups.provider_arg;
-      let configPckg;
-      try {
-        configPckg = require('./configProviders/' + provider);
-      } catch (err) {
-        errors.throwErr(errors.ERR_CONFIG_PROVIDER_NOT_SUPPORTED, provider);
-      }
-      const configProvider = new configPckg(provider_arg, urlExtendedPart);
-      try {
-        configProvider.init();
-      } catch (err) {
-        errors.throwErr(errors.ERR_CONFIG_PROVIDER_LOAD_FAILED, err.message);
-      }
+      const hookFn = registeredConfigProviderHooks[provider];
+      if (hookFn == undefined)
+        errors.throwErr(errors.ERR_REGISTER_HOOKFN_CONFIGPROVIDER, provider);
+      const args = {};
+      args.provider_arg = provider_arg;
+      args.urlExtendedPart = urlExtendedPart;
+
       try {
+      // hookFn returns an array with first element as the config stored in the configProvider
+      // second being the credential to the configProvider
+        const configProviderReturn = await hookFn(args);
+        secondOpts = configProviderReturn[0];
         if (!configProviderCache) {
           configProviderCache = new Map();
         }
-        secondOpts = await configProvider.returnConfig();
+        if (!secondOpts) {
+          errors.throwErr(errors.ERR_CONFIG_PROVIDER_FAILED_TO_RETRIEVE_CONFIG, 'no configuration found in ' + provider);
+        }
+        if (provider != 'azure')
+          secondOpts = await _setConfigParameters(secondOpts, configProviderReturn[1], provider);
+
         // obfuscate password & walletcontent and store config in the cache
         const cacheOpts = { ...secondOpts};
         if (secondOpts.password)
@@ -998,6 +1144,31 @@ async function startup(a1, a2) {
   await conn.close();
 }
 
+//-----------------------------------------------------------------------------
+// registerProcessConfigurationHook()
+//
+// Registers extension modules and registered modules will be called and
+// executed during pool and standalone connection creation.
+//-----------------------------------------------------------------------------
+function registerProcessConfigurationHook(fn) {
+  errors.assertArgCount(arguments, 1, 1);
+  errors.assertParamValue(typeof fn === 'function', 1);
+  registeredHooks.push(fn);
+}
+
+//-----------------------------------------------------------------------------
+// registerConfigurationProviderHook()
+//
+// Registers Configuration Provider plugin modules and registered modules will
+// be called and executed during pool and standalone connection creation.
+//-----------------------------------------------------------------------------
+function registerConfigurationProviderHook(configProvider, fn) {
+  errors.assertArgCount(arguments, 2, 2);
+  errors.assertParamValue(typeof fn === 'function', 1);
+  errors.assertParamValue(typeof configProvider === 'string', 1);
+  registeredConfigProviderHooks[configProvider] = fn;
+}
+
 // module exports
 module.exports = {
 
@@ -1018,6 +1189,9 @@ module.exports = {
   SodaDocCursor,
   SodaDocument,
   SodaOperation,
+  SparseVector: types.SparseVector,
+  IntervalYM: types.IntervalYM,
+  IntervalDS: types.IntervalDS,
 
   // top-level functions
   getConnection: nodbUtil.callbackify(nodbUtil.wrapFn(getConnection)),
@@ -1025,6 +1199,8 @@ module.exports = {
   getNetworkServiceNames: nodbUtil.callbackify(nodbUtil.wrapFn(getNetworkServiceNames)),
   getPool,
   initOracleClient,
+  registerProcessConfigurationHook,
+  registerConfigurationProviderHook,
   shutdown: nodbUtil.callbackify(nodbUtil.wrapFn(shutdown)),
   startup: nodbUtil.callbackify(nodbUtil.wrapFn(startup)),
 
@@ -1269,6 +1445,10 @@ module.exports = {
     return settings.fetchTypeHandler;
   },
 
+  get dbObjectTypeHandler() {
+    return settings.dbObjectTypeHandler;
+  },
+
   get lobPrefetchSize() {
     return settings.lobPrefetchSize;
   },
@@ -1329,6 +1509,7 @@ module.exports = {
     return settings.configProviderCacheTimeout;
   },
 
+
   get thin() {
     return settings.thin;
   },
@@ -1413,6 +1594,13 @@ module.exports = {
     settings.fetchTypeHandler = value;
   },
 
+  set dbObjectTypeHandler(value) {
+    if (value !== undefined) {
+      errors.assertPropValue(typeof value === 'function', "dbObjectTypeHandler");
+    }
+    settings.dbObjectTypeHandler = value;
+  },
+
   set lobPrefetchSize(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "lobPrefetchSize");
@@ -1509,6 +1697,7 @@ module.exports = {
     errors.assertPropValue(typeof value === 'string', "terminal");
     settings.terminal = value;
   },
+
   set configProviderCacheTimeout(value) {
     errors.assertPropValue(Number.isInteger(value) && value >= 0,
       "configProviderCacheTimeout");

package/lib/pool.js

@@ -653,6 +653,15 @@ class Pool extends EventEmitter {
     return this._impl.getPoolTimeout();
   }
 
+  //---------------------------------------------------------------------------
+  // maxLifetimeSession
+  //
+  // Property for the max allowed lifetime of a session in the pool.
+  //---------------------------------------------------------------------------
+  get maxLifetimeSession() {
+    return this._impl.getMaxLifetimeSession();
+  }
+
   //---------------------------------------------------------------------------
   // queueMax
   //
@@ -693,6 +702,7 @@ class Pool extends EventEmitter {
     errors.assertParamPropUnsignedInt(options, 1, "poolIncrement");
     errors.assertParamPropInt(options, 1, "poolPingInterval");
     errors.assertParamPropUnsignedInt(options, 1, "poolTimeout");
+    errors.assertParamPropUnsignedInt(options, 1, "maxLifetimeSession");
     errors.assertParamPropUnsignedInt(options, 1, "stmtCacheSize");
     errors.assertParamPropBool(options, 1, "sodaMetaDataCache");
 
@@ -708,7 +718,8 @@ class Pool extends EventEmitter {
     this._status = constants.POOL_STATUS_RECONFIGURING;
     try {
       // poolMin/poolMax/poolIncrement/poolPingInterval/poolTimeout/
-      // poolMaxPerShard/stmtCacheSize/sodaMetaDataCache parameters
+      // poolMaxPerShard/stmtCacheSize/sodaMetaDataCache/maxLifetimeSession
+      // parameters
       await this._impl.reconfigure(options);
 
       // pool JS parameters: queueMax, queueTimeout, enableStatistics,

package/lib/poolStatistics.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2021, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2021, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -74,6 +74,7 @@ class PoolStatistics {
     this.poolPingInterval = pool.poolPingInterval;
     this.poolPingTimeout = pool.poolPingTimeout;
     this.poolTimeout = pool.poolTimeout;
+    this.maxLifetimeSession = pool.maxLifetimeSession;
     this.queueMax = pool.queueMax;
     this.queueTimeout = pool.queueTimeout;
     this.sodaMetaDataCache = pool.sodaMetaDataCache;
@@ -127,6 +128,7 @@ class PoolStatistics {
     console.log('...poolPingInterval (seconds):', this.poolPingInterval);
     console.log('...poolPingTimeout (milliseconds):', this.poolPingTimeout);
     console.log('...poolTimeout (seconds):', this.poolTimeout);
+    console.log('...maxLifetimeSession (seconds):', this.maxLifetimeSession);
     console.log('...queueMax:', this.queueMax);
     console.log('...queueTimeout (milliseconds):', this.queueTimeout);
     console.log('...sessionCallback:', this.sessionCallback);

package/lib/settings.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -64,7 +64,11 @@ class Settings {
     this.thinDriverInitialized = false;
     this.createFetchTypeMap(this.fetchAsString, this.fetchAsBuffer);
     this.fetchTypeHandler = undefined;
+    this.dbObjectTypeHandler = undefined;
     this._JsonId = types.JsonId;
+    this._SparseVector = types.SparseVector;
+    this._IntervalYM = types.IntervalYM;
+    this._IntervalDS = types.IntervalDS;
   }
 
   //---------------------------------------------------------------------------