oracledb 6.9.0 → 7.0.0

package/lib/thin/sqlnet/packet.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -353,6 +353,7 @@ function MarkerPacket(isLargeSDU) {
    */
   this.fromPacket = function(packet, nsi) {
     this.type = packet.buf.readUInt8(constants.NSPMKTYP);
+    let expectedFlag = constants.NIQRMARK;
 
     switch (this.type) {
       case constants.NSPMKTD0:
@@ -361,9 +362,11 @@ function MarkerPacket(isLargeSDU) {
       case constants.NSPMKTD1:
         this.data = packet.buf.readUInt8(constants.NSPMKDAT);
         nsi.isBreak = true;
-        if (this.data == constants.NIQRMARK) {
+        if (nsi.pipelineEnabled) {
+          expectedFlag = constants.NIQBMARK;
+        }
+        if (this.data == expectedFlag) {
           nsi.isReset = true;
-          nsi.isBreak = true;
         }
         break;
       default:
@@ -398,10 +401,16 @@ function ControlPacket() {
     let emfi;
     let err1;
     let err2;
+    if (packet.buf.length < constants.NSPCTLCMD + 2) {
+      errors.throwErr(errors.ERR_INVALID_PACKET);
+    }
 
     this.cmd = packet.buf.readUInt16BE(constants.NSPCTLCMD);
     switch (this.cmd) {
       case constants.NSPCTL_SERR:
+        if (packet.buf.length < constants.NSPCTLDAT + 12) {
+          errors.throwErr(errors.ERR_INVALID_PACKET);
+        }
         emfi = packet.buf.readUInt32BE(constants.NSPCTLDAT);
         err1 = packet.buf.readUInt32BE(constants.NSPCTLDAT + 4);
         err2 = packet.buf.readUInt32BE(constants.NSPCTLDAT + 8);
@@ -411,8 +420,20 @@ function ControlPacket() {
         } else if (err1 == NSESENDMESG) {
           this.errno = err1;
           this.notifLen = err2;
+          const copyStart = constants.NSPCTLDAT + 12;
+          const payloadAvailable = packet.buf.length - copyStart;
+          const maxNotifBytes = this.sAtts && this.sAtts.largeSDU
+            ? constants.NSPABSSDULN
+            : constants.NSPMXSDULN;
+          // Ensure notification length fits in the packet body and negotiated SDU to avoid over-allocation.
+          if (err2 < 0 || err2 > payloadAvailable || err2 > maxNotifBytes) {
+            errors.throwErr(
+              errors.ERR_INVALID_PACKET,
+              `Invalid notification length ${err2}`
+            );
+          }
           this.notif = Buffer.allocUnsafe(err2 + 1).fill(0);
-          this.buf.copy(this.notif, 0, constants.NSPCTLDAT + 12, constants.NSPCTLDAT + 12 + err2);
+          packet.buf.copy(this.notif, 0, copyStart, copyStart + err2);
         } else {
           this.errno = err1;
           if (emfi == ORA_ERROR_EMFI_NUMBER) {

package/lib/thin/sqlnet/paramParser.js

@@ -99,8 +99,16 @@ class NLParamParser {
       return tnsFileStruct.aliasht;
     }
     tnsFileStruct.readInProgress = true;
-    await this.start(file_path, 0, tnsFileStruct); //start with 0 depth (tnsnames.ora)
-    this.tnsnamesHT.set(file_path, tnsFileStruct);
+    try {
+      await this.start(file_path, 0, tnsFileStruct); // start with 0 depth (tnsnames.ora)
+      this.tnsnamesHT.set(file_path, tnsFileStruct);
+    } finally {
+      tnsFileStruct.readInProgress = false;
+      let waiter;
+      while ((waiter = tnsFileStruct.waiters.pop())) {
+        waiter();
+      }
+    }
     return tnsFileStruct.aliasht;
   }
 
@@ -156,11 +164,6 @@ class NLParamParser {
       await this.addNLPListElement(nvElem, depth, tnsFileStruct);
       nvElem = "";      // clear nvElem buffer after added
     }
-    tnsFileStruct.readInProgress = false;
-    let waiter;
-    while ((waiter = tnsFileStruct.waiters.pop())) {
-      waiter();
-    }
   }
   /**
    * Given a string, this method looks if the '#' character is present.

package/lib/thin/statementCache.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2024, Oracle and/or its affiliates.
+// Copyright (c) 2024, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -105,7 +105,7 @@ class StatementCache {
   }
 
   //---------------------------------------------------------------------------
-  // get_statement()
+  // getStatement()
   // Get a statement from the statement cache, or prepare a new statement
   // for use. If a statement is already in use or the statement is not
   // supposed to be cached, a copy will be made (and not returned to the
@@ -126,14 +126,12 @@ class StatementCache {
         this._cachedStatements.set(sql, stmt);
         this._adjustCache();
       }
-      this._openCursors.add(stmt);
     } else if (forceNew || stmt.inUse) {
       if (!cacheStatement) {
         this._addCursorToClose(stmt);
         this._cachedStatements.delete(sql);
       }
       stmt = stmt._copy();
-      this._openCursors.add(stmt);
     } else if (!cacheStatement) {
       this._cachedStatements.delete(sql);
       stmt.returnToCache = false;

package/lib/traceHandler.js

@@ -27,17 +27,20 @@
 'use strict';
 
 /**
- * TraceHandler interface defination which application needs to implement
+ * TraceHandler interface definition which application needs to implement
  * the hooks defined. The hooks will be called by the driver with traceContext
  * data.
  *
  * TraceContext Data details.
  * connectLevelConfig - Connection Config details.
- *      protcol         - tcp/tcps protocol.
+ *      protocol        - tcp/tcps protocol.
  *      user            - user/schema associated.
+ *      dbName          - Database Name.
  *      instanceName    - instance Name.
  *      pdbName         - PDB name.
+ *      domainName      - Domain name.
  *      serviceName     - service name.
+ *      dbUniqueName    - Database unique name.
  *      connectString   - connect string passed.
  *      hostName        - host name.
  *      port            - port number.
@@ -100,6 +103,60 @@ class TraceHandlerBase {
   onEndRoundTrip(/*traceContext*/) {
   }
 
+  /**
+   * Called when the pool expands by creating new connections.
+   * Useful for tracking pool growth or initialization activity.
+   */
+  onPoolExpand(/*pool*/) {}
+
+  /**
+   * Called when the pool shrinks and a connection is removed,
+   * such as during timeouts or pool resizing. Useful for
+   * monitoring resource cleanup or shrink events.
+   */
+  onPoolShrink(/*pool*/) {}
+
+  /**
+   * Called when a connection is successfully acquired from the pool.
+   * Useful for tracking active usage or checkout activity.
+   */
+  onPoolAcquire(/*pool*/) {}
+
+  /**
+   * Called when a connection is released back to the pool.
+   * Useful for monitoring returned or idle connections.
+   */
+  onPoolRelease(/*pool*/) {}
+
+  /**
+   * Called when a connection request is queued because the pool
+   * cannot grow further. Useful for monitoring queued requests.
+   */
+  onPoolWait(/*pool*/) {}
+
+  /**
+   * Called when a queued connection request times out before it
+   * can be served. Useful for tracking request timeouts or failures.
+   */
+  onPoolRequestTimeout(/*pool*/) {}
+
+  /**
+   * Called when a requested connection is obtained from the pool's
+   * free list (cache hit). Useful for analyzing connection reuse.
+   */
+  onPoolConnectionHit(/*pool*/) {}
+
+  /**
+   * Called when a connection request requires creating a new
+   * connection (cache miss). Useful for monitoring connection creation.
+   */
+  onPoolConnectionMiss(/*pool*/) {}
+
+  /**
+   * Called when the pool is closed. Useful for tracking shutdown
+   * events or resetting counters.
+   */
+  onPoolClose(/*pool*/) {}
 }
 
 // singleton object pointing to traceHandler instance.

package/lib/transformer.js

@@ -158,9 +158,13 @@ function transformValueIn(info, value, options) {
       types.DB_TYPE_CHAR,
       types.DB_TYPE_NCHAR,
       types.DB_TYPE_CLOB,
-      types.DB_TYPE_NCLOB);
+      types.DB_TYPE_NCLOB,
+      types.DB_TYPE_LONG,
+      types.DB_TYPE_LONG_NVARCHAR);
     if (info.type !== types.DB_TYPE_CLOB &&
-        info.type !== types.DB_TYPE_NCLOB) {
+        info.type !== types.DB_TYPE_NCLOB &&
+        info.type !== types.DB_TYPE_LONG &&
+        info.type !== types.DB_TYPE_LONG_NVARCHAR) {
       const valueLen = Buffer.byteLength(value);
       if (info.maxSize === undefined || valueLen > info.maxSize) {
         if (info.checkSize) {
@@ -212,7 +216,8 @@ function transformValueIn(info, value, options) {
   } else if (Buffer.isBuffer(value)) {
     checkType(info, options,
       types.DB_TYPE_RAW,
-      types.DB_TYPE_BLOB);
+      types.DB_TYPE_BLOB,
+      types.DB_TYPE_LONG_RAW);
     if (info.type === types.DB_TYPE_RAW &&
         (info.maxSize === undefined || value.length > info.maxSize)) {
       if (info.checkSize) {

package/lib/types.js

@@ -45,9 +45,15 @@ class DbType {
     this._bufferSizeFactor = options.bufferSizeFactor || 0;
     this._oraTypeNum = options.oraTypeNum || 0;
     this._csfrm = options.csfrm || 0;
+    this._is_fast = options.is_fast || true;
     dbTypeByNum.set(num, this);
-    const key = (options.csfrm || 0) * 256 + options.oraTypeNum;
+    const key = this._csfrm * 256 + this._oraTypeNum;
     dbTypeByOraTypeNum.set(key, this);
+    // add a second key for LONG metadata which doesn't always contain the
+    // character set form value in metadata received by the database
+    if (this._oraTypeNum === 8 && this._csfrm === constants.CSFRM_IMPLICIT) {
+      dbTypeByOraTypeNum.set(this._oraTypeNum, this);
+    }
     dbTypeByColumnTypeName.set(columnTypeName, this);
   }
 
@@ -113,7 +119,7 @@ function getTypeByOraTypeNum(oraTypeNum, csfrm) {
 
 const DB_TYPE_BFILE = new DbType(2020,
   "DB_TYPE_BFILE", "BFILE",
-  { oraTypeNum: 114, bufferSizeFactor: 4000 });
+  { oraTypeNum: 114, bufferSizeFactor: 4000, is_fast: false });
 const DB_TYPE_BINARY_DOUBLE = new DbType(2008,
   "DB_TYPE_BINARY_DOUBLE", "BINARY_DOUBLE",
   { oraTypeNum: 101, bufferSizeFactor: 8 });
@@ -125,7 +131,7 @@ const DB_TYPE_BINARY_INTEGER = new DbType(2009,
   { oraTypeNum: 3, bufferSizeFactor: 22 });
 const DB_TYPE_BLOB = new DbType(2019,
   "DB_TYPE_BLOB", "BLOB",
-  { oraTypeNum: 113, bufferSizeFactor: 112 });
+  { oraTypeNum: 113, bufferSizeFactor: 112, is_fast: false });
 const DB_TYPE_BOOLEAN = new DbType(2022,
   "DB_TYPE_BOOLEAN", "BOOLEAN",
   { oraTypeNum: 252, bufferSizeFactor: 4 });
@@ -134,10 +140,11 @@ const DB_TYPE_CHAR = new DbType(2003,
   { oraTypeNum: 96, csfrm: constants.CSFRM_IMPLICIT, bufferSizeFactor: 4 });
 const DB_TYPE_CLOB = new DbType(2017,
   "DB_TYPE_CLOB", "CLOB",
-  { oraTypeNum: 112, csfrm: constants.CSFRM_IMPLICIT, bufferSizeFactor: 112 });
+  { oraTypeNum: 112, csfrm: constants.CSFRM_IMPLICIT, bufferSizeFactor: 112,
+    is_fast: false });
 const DB_TYPE_CURSOR = new DbType(2021,
   "DB_TYPE_CURSOR", "CURSOR",
-  { oraTypeNum: 102, bufferSizeFactor: 4 });
+  { oraTypeNum: 102, bufferSizeFactor: 4, is_fast: false });
 const DB_TYPE_DATE = new DbType(2011,
   "DB_TYPE_DATE", "DATE",
   { oraTypeNum: 12, bufferSizeFactor: 7 });
@@ -149,24 +156,25 @@ const DB_TYPE_INTERVAL_YM = new DbType(2016,
   { oraTypeNum: 182, bufferSizeFactor: 5 });
 const DB_TYPE_JSON = new DbType(2027,
   "DB_TYPE_JSON", "JSON",
-  { oraTypeNum: 119 });
+  { oraTypeNum: 119, is_fast: false });
 const DB_TYPE_LONG = new DbType(2024,
   "DB_TYPE_LONG", "LONG",
   { oraTypeNum: 8, csfrm: constants.CSFRM_IMPLICIT,
-    bufferSizeFactor: 2 ** 31 - 1 });
+    bufferSizeFactor: 2 ** 31 - 1, is_fast: false });
 const DB_TYPE_LONG_NVARCHAR = new DbType(2031,
   "DB_TYPE_LONG_NVARCHAR", "LONG",
   { oraTypeNum: 8, csfrm: constants.CSFRM_NCHAR,
-    bufferSizeFactor: 2 ** 31 - 1 });
+    bufferSizeFactor: 2 ** 31 - 1, is_fast: false });
 const DB_TYPE_LONG_RAW = new DbType(2025,
   "DB_TYPE_LONG_RAW", "LONG RAW",
-  { oraTypeNum: 24, bufferSizeFactor: 2 ** 31 - 1 });
+  { oraTypeNum: 24, bufferSizeFactor: 2 ** 31 - 1, is_fast: false });
 const DB_TYPE_NCHAR = new DbType(2004,
   "DB_TYPE_NCHAR", "NCHAR",
   { oraTypeNum: 96, csfrm: constants.CSFRM_NCHAR, bufferSizeFactor: 4 });
 const DB_TYPE_NCLOB = new DbType(2018,
   "DB_TYPE_NCLOB", "NCLOB",
-  { oraTypeNum: 112, csfrm: constants.CSFRM_NCHAR, bufferSizeFactor: 112 });
+  { oraTypeNum: 112, csfrm: constants.CSFRM_NCHAR, bufferSizeFactor: 112,
+    is_fast: false });
 const DB_TYPE_NUMBER = new DbType(2010,
   "DB_TYPE_NUMBER", "NUMBER",
   { oraTypeNum: 2, bufferSizeFactor: 22 });
@@ -181,7 +189,7 @@ const DB_TYPE_RAW = new DbType(2006,
   { oraTypeNum: 23, bufferSizeFactor: 1 });
 const DB_TYPE_ROWID = new DbType(2005,
   "DB_TYPE_ROWID", "ROWID",
-  { oraTypeNum: 11, bufferSizeFactor: 18 });
+  { oraTypeNum: 11, bufferSizeFactor: 18, is_fast: false });
 const DB_TYPE_TIMESTAMP = new DbType(2012,
   "DB_TYPE_TIMESTAMP", "TIMESTAMP",
   { oraTypeNum: 180, bufferSizeFactor: 11 });
@@ -190,19 +198,20 @@ const DB_TYPE_TIMESTAMP_LTZ = new DbType(2014,
   { oraTypeNum: 231, bufferSizeFactor: 11 });
 const DB_TYPE_TIMESTAMP_TZ = new DbType(2013,
   "DB_TYPE_TIMESTAMP_TZ", "TIMESTAMP WITH TIME ZONE",
-  { oraTypeNum: 181, bufferSizeFactor: 13 });
+  { oraTypeNum: 181, bufferSizeFactor: 13, is_fast: false });
 const DB_TYPE_UROWID = new DbType(2030,
   "DB_TYPE_UROWID", "UROWID",
-  { oraTypeNum: 208 });
+  { oraTypeNum: 208, is_fast: false });
 const DB_TYPE_VARCHAR = new DbType(2001,
   "DB_TYPE_VARCHAR", "VARCHAR2",
   { oraTypeNum: 1, csfrm: constants.CSFRM_IMPLICIT, bufferSizeFactor: 4 });
 const DB_TYPE_XMLTYPE = new DbType(2032,
   "DB_TYPE_XMLTYPE", "XMLTYPE",
-  { oraTypeNum: 109, csfrm: constants.CSFRM_IMPLICIT, bufferSizeFactor: 2147483647 });
+  { oraTypeNum: 109, csfrm: constants.CSFRM_IMPLICIT,
+    bufferSizeFactor: 2147483647, is_fast: false });
 const DB_TYPE_VECTOR = new DbType(2033,
   "DB_TYPE_VECTOR", "VECTOR",
-  { oraTypeNum: 127 });
+  { oraTypeNum: 127, is_fast: false });
 
 // database type conversion map: the top level key refers to the database
 // type being fetched and the value is another map; this map's key is the
@@ -451,7 +460,7 @@ class SparseVector {
     try {
       // use simple tokenizer?
       data = JSON.parse(str);
-    } catch (e) {
+    } catch {
       errors.throwErr(errors.ERR_VECTOR_SPARSE_INVALID_JSON);
     }
 
@@ -525,8 +534,9 @@ class IntervalYM {
       errors.assertParamPropInt(obj, 1, "years");
       errors.assertParamPropInt(obj, 1, "months");
     }
-    this.years = obj?.years || 0;
-    this.months = obj?.months || 0;
+    // Normalize the months and years
+    this.months = (obj?.months || 0) % 12;
+    this.years = (obj?.years || 0) + Math.trunc((obj?.months || 0) / 12);
   }
 }
 
@@ -540,11 +550,15 @@ class IntervalDS {
       errors.assertParamPropInt(obj, 1, "seconds");
       errors.assertParamPropInt(obj, 1, "fseconds");
     }
-    this.days = obj?.days || 0;
-    this.hours = obj?.hours || 0;
-    this.minutes = obj?.minutes || 0;
-    this.seconds = obj?.seconds || 0;
+    // Normalize the time units
     this.fseconds = obj?.fseconds || 0;
+    this.seconds = (obj?.seconds || 0) % 60;
+    const totalMinutes = (obj?.minutes || 0) +
+      Math.trunc((obj?.seconds || 0) / 60);
+    this.minutes = totalMinutes % 60;
+    const totalHours = (obj?.hours || 0) + Math.trunc(totalMinutes / 60);
+    this.hours = totalHours % 24;
+    this.days = (obj?.days || 0) + Math.trunc(totalHours / 24);
   }
 }
 

package/lib/util.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2016, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2016, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -67,7 +67,7 @@ const validNetworkCharacterSet = new Set(['A', 'B', 'C', 'D', 'E', 'F', 'G',
 let packageJSON;
 try {
   packageJSON = require('../package.json');
-} catch (err) {
+} catch {
   errors.throwErr(errors.ERR_MISSING_FILE, 'package.json');
 }
 const PACKAGE_JSON_VERSION = packageJSON.version;
@@ -386,7 +386,7 @@ function isPrivilege(value) {
 }
 
 function isShardingKey(value) {
-  if (!Array.isArray(value))
+  if (!Array.isArray(value) || value.length > 255)
     return false;
   for (let i = 0; i < value.length; i++) {
     const element = value[i];
@@ -414,10 +414,6 @@ function isAppContext(value) {
   return true;
 }
 
-function isSodaDocument(value) {
-  return (value != null && value._sodaDocumentMarker);
-}
-
 function isXid(value) {
   return (isObject(value) && Number.isInteger(value.formatId) &&
     (Buffer.isBuffer(value.globalTransactionId) ||
@@ -477,20 +473,13 @@ function normalizeTransactionId(value) {
     normalizedTransactionId = crypto.randomUUID();
   if (typeof normalizedTransactionId === 'string') {
     normalizedTransactionId = Buffer.from(normalizedTransactionId);
-    const len = normalizedTransactionId.length;
-    if ((len === 0) || (len > 64))
-      errors.throwErr(errors.ERR_INVALID_TRANSACTION_SIZE, len);
   }
+  const len = normalizedTransactionId.length;
+  if ((len === 0) || (len > 64))
+    errors.throwErr(errors.ERR_INVALID_TRANSACTION_SIZE, len);
   return normalizedTransactionId;
 }
 
-function verifySodaDoc(content) {
-  if (isSodaDocument(content))
-    return content._impl;
-  errors.assertParamValue(isObject(content), 1);
-  return Buffer.from(JSON.stringify(content));
-}
-
 function isTokenExpired(token) {
   errors.assert(typeof token === 'string', errors.ERR_TOKEN_BASED_AUTH);
   if (token.split('.')[1] === undefined) {
@@ -644,7 +633,6 @@ module.exports = {
   isPrivilege,
   isShardingKey,
   isAppContext,
-  isSodaDocument,
   isTokenExpired,
   isTokenValid,
   isTransactionId,
@@ -654,7 +642,6 @@ module.exports = {
   normalizeXid,
   makeDate,
   sanitize,
-  verifySodaDoc,
   wrapFn,
   wrapFns,
   isPemFile

package/lib/version.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, 2025, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -29,8 +29,8 @@
 // Leave the suffix an empty string for production releases.
 
 module.exports = {
-  VERSION_MAJOR: 6,
-  VERSION_MINOR: 9,
+  VERSION_MAJOR: 7,
+  VERSION_MINOR: 0,
   VERSION_PATCH: 0,
   VERSION_SUFFIX: ''
 };

package/package/install.js

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, 2023, Oracle and/or its affiliates. */
+/* Copyright (c) 2017, 2025, Oracle and/or its affiliates. */
 
 /******************************************************************************
  *
@@ -48,21 +48,21 @@ let arch;
 let thickModeErrMsg;
 
 // Log standard output with an 'oracledb' prefix
-function log(message) { // eslint-disable-line
+function log() {
   const args = Array.from(arguments);
   args.unshift('oracledb');
   console.log.apply(console, args);
 }
 
 // Log errors. It combines 'oracledb' with a stylized 'ERR' prefix
-function error(message) { // eslint-disable-line
+function error() {
   const args = Array.from(arguments);
   args.unshift('oracledb \x1b[31mERR!\x1b[0m');
   console.error.apply(console, args);
 }
 
 // Log warnings. It combines 'oracledb' with a stylized 'WARN' prefix
-function warn(message) { // eslint-disable-line
+function warn() {
   const args = Array.from(arguments);
   args.unshift('oracledb \x1b[31mWARN!\x1b[0m');
   console.error.apply(console, args);
@@ -85,7 +85,7 @@ function checkVersion() {
 function checkThickMode() {
   try {
     fs.statSync(nodbUtil.RELEASE_DIR + '/' + nodbUtil.BINARY_FILE);
-  } catch (err) {
+  } catch {
     errors.throwErr(errors.ERR_NO_BINARY_AVAILABLE, process.platform + ' ' + process.arch);
   }
 }

package/package/prunebinaries.js

@@ -86,7 +86,7 @@ function removeFileorDir(fileOrDirPath) {
       // Remove the file or the symlink synchronously
       fs.unlinkSync(fileOrDirPath);
     }
-  } catch (err) {
+  } catch {
     throw new Error('Invalid File or Directory: ' + `'${fileOrDirPath}'`);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oracledb",
-  "version": "6.9.0",
+  "version": "7.0.0",
   "description": "A Node.js module for Oracle Database access from JavaScript and TypeScript",
   "license": "(Apache-2.0 OR UPL-1.0)",
   "homepage": "http://oracle.github.io/node-oracledb/",

package/plugins/configProviders/awsCommon.js

@@ -0,0 +1,125 @@
+// Copyright (c) 2026, Oracle and/or its affiliates.
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+"use strict";
+
+
+let fromNodeProviderChain;
+let loadSharedConfigFiles;
+let NodeHttpHandler;
+let HttpsProxyAgent;
+
+function initAwsCommon() {
+  if (fromNodeProviderChain) {
+    return;
+  }
+
+  ({ fromNodeProviderChain } = require("@aws-sdk/credential-providers"));
+  ({ loadSharedConfigFiles } = require("@smithy/shared-ini-file-loader"));
+  ({ NodeHttpHandler } = require("@smithy/node-http-handler"));
+  ({ HttpsProxyAgent } = require("hpagent"));
+}
+
+function resolveProxy(paramMap) {
+  const proxyHost = paramMap.get("https_proxy") ||
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy;
+
+  const proxyPort = paramMap.get("https_proxy_port") ||
+    process.env.HTTPS_PROXY_PORT ||
+    process.env.https_proxy_port;
+
+  if (!proxyHost) {
+    return null;
+  }
+
+  const proxy = /^[a-z][a-z0-9+.-]*:\/\//i.test(proxyHost) ?
+    proxyHost :
+    `http://${proxyHost}`;
+
+  if (!proxyPort) {
+    return proxy;
+  }
+
+  const proxyUrl = new URL(proxy);
+  if (!proxyUrl.port) {
+    proxyUrl.port = proxyPort;
+  }
+
+  return proxyUrl.toString().replace(/\/$/, "");
+}
+
+function initAwsRequestHandler(paramMap) {
+  const proxy = resolveProxy(paramMap);
+
+  if (proxy) {
+    const agent = new HttpsProxyAgent({ proxy });
+    return new NodeHttpHandler({
+      httpAgent: agent,
+      httpsAgent: agent,
+    });
+  }
+
+  return new NodeHttpHandler();
+}
+
+async function resolveRegion(paramMap) {
+  if (paramMap.get("aws_region")) return paramMap.get("aws_region");
+  if (process.env.AWS_REGION) return process.env.AWS_REGION;
+  let region = null;
+  try {
+    const { configFile, credentialsFile } = await loadSharedConfigFiles();
+    const profile = paramMap.get("aws_profile") || process.env.AWS_PROFILE || "default";
+    region = configFile[profile]?.region || credentialsFile[profile]?.region;
+
+    if (!region) {
+      throw new Error(`Region not found in AWS config/credentials for profile: ${profile}`);
+    }
+
+    return region;
+  } catch (err) {
+    throw new Error(
+      `AWS Region Resolution Failed: ${err.message}. Ensure AWS_REGION is set or ~/.aws/config is accessible.`
+    );
+  }
+}
+
+function createAwsCredential(paramMap, requestHandler, region) {
+  return fromNodeProviderChain({
+    profile: paramMap.get("aws_profile") || process.env.AWS_PROFILE || "default",
+    clientConfig: {
+      requestHandler,
+      region
+    }
+  });
+}
+
+module.exports = {
+  createAwsCredential,
+  initAwsCommon,
+  initAwsRequestHandler,
+  resolveProxy,
+  resolveRegion,
+};