oracledb 6.8.0 → 6.10.0

package/lib/oracledb.js

@@ -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');
@@ -68,6 +68,7 @@ const poolCache = {};
 const tempUsedPoolAliases = {};
 const defaultPoolAlias = 'default';
 const registeredHooks = [];
+const registeredConfigProviderHooks = new Map();
 let configProviderCache;
 
 // save arguments for call to initOracleClient()
@@ -382,6 +383,15 @@ async function _verifyOptions(options, inCreatePool) {
     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) {
 
@@ -435,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) {
@@ -568,7 +585,10 @@ async function _verifyOptions(options, inCreatePool) {
       errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
     }
     if (outOptions.user) {
-      if (inCreatePool) {
+
+      if (inCreatePool && !settings.thin) {
+        // Thick mode currently does not allow proxy users to specified
+        // during pool creation.
         errors.throwErr(errors.ERR_WRONG_CRED_FOR_EXTAUTH);
       } else if (outOptions.user[0] !== '[' || outOptions.user.slice(-1) !== ']') {
         // username is not enclosed in [].
@@ -888,35 +908,119 @@ 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;
+  configObject.configTTL = obj.config_time_to_live;
+  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()
 //
-// Look for the config provider in the connection string and retreives
+// Look for the config provider in the connection string and retrieves
 // object stored in the config Provider.
 // Returns object based on precedence between input object and the one retrieved
 // from Config Provider.
 //-----------------------------------------------------------------------------
 async function _checkConfigProvider(options) {
   // Time for Cache entries to be deleted in milliseconds
-  const cacheEntriesDuration = settings.configProviderCacheTimeout * 1000;
-  let secondOpts;
+  let cacheEntriesDuration = settings.configProviderCacheTimeout * 1000;
+  let secondOpts, cachedConfigEntry;
   const url = options.connectString || options.connectionString;
   if (!url)
     return options;
 
-  if (configProviderCache && configProviderCache.has(url) && ((Date.now() - configProviderCache.get(url).timeAdded) < cacheEntriesDuration)) {
-    const cacheOpts1 = configProviderCache.get(url).cacheOpts;
-    secondOpts = { ...cacheOpts1};
+  if (configProviderCache && (cachedConfigEntry = configProviderCache.get(url))) {
+    const config = cachedConfigEntry.cacheOpts;
+    if (config.configTTL)
+      cacheEntriesDuration = config.configTTL * 1000;
 
-    //deobfuscate password
-    if (secondOpts.password)
-      secondOpts.password = protocolUtil.getDeobfuscatedValue(secondOpts.password.value, secondOpts.password.obfuscatedValue);
+    if ((Date.now() - cachedConfigEntry.timeAdded) < cacheEntriesDuration) {
+      secondOpts = { ...config};
 
-    //deobfuscate walletContent
-    if (secondOpts.walletContent)
-      secondOpts.walletContent = protocolUtil.getDeobfuscatedValue(secondOpts.walletContent.value, secondOpts.walletContent.obfuscatedValue);
+      //deobfuscate password
+      if (secondOpts.password)
+        secondOpts.password = protocolUtil.getDeobfuscatedValue(secondOpts.password.value, secondOpts.password.obfuscatedValue);
 
-  } else {
+      //deobfuscate walletContent
+      if (secondOpts.walletContent)
+        secondOpts.walletContent = protocolUtil.getDeobfuscatedValue(secondOpts.walletContent.value, secondOpts.walletContent.obfuscatedValue);
+    }
+  }
+  if (!secondOpts) {
     let parsedUrl = url;
     let urlExtendedPart;
     const baseRegex = new RegExp("^config-(?<provider>[A-Za-z0-9]+)(://)(?<provider_arg>[^?]+)");
@@ -928,23 +1032,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)
@@ -1057,6 +1165,19 @@ function registerProcessConfigurationHook(fn) {
   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 = {
 
@@ -1088,6 +1209,7 @@ module.exports = {
   getPool,
   initOracleClient,
   registerProcessConfigurationHook,
+  registerConfigurationProviderHook,
   shutdown: nodbUtil.callbackify(nodbUtil.wrapFn(shutdown)),
   startup: nodbUtil.callbackify(nodbUtil.wrapFn(startup)),