oracledb 6.10.0 → 7.0.0

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 = 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.months = obj?.months || 0;
-    this.years = obj?.years || 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");
     }
+    // Normalize the time units
     this.fseconds = obj?.fseconds || 0;
-    this.seconds = obj?.seconds || 0;
-    this.minutes = obj?.minutes || 0;
-    this.hours = obj?.hours || 0;
-    this.days = obj?.days || 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];
@@ -473,10 +473,10 @@ 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;
 }
 

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: 10,
+  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.10.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,
+};

package/plugins/configProviders/awss3/index.js

@@ -0,0 +1,138 @@
+// 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";
+
+const util = require("node:util");
+const { base } = require("../base.js");
+const {
+  createAwsCredential,
+  initAwsCommon,
+  initAwsRequestHandler,
+  resolveRegion
+} = require("../awsCommon.js");
+const oracledb = require("oracledb");
+
+let S3Client, GetObjectCommand;
+
+class AWSS3Provider extends base {
+  constructor(provider_arg, urlExtendedPart) {
+    super(urlExtendedPart);
+    const url = new URL(provider_arg);
+    this._addParam("bucket", url.hostname);
+    this._addParam("key", url.pathname.substring(1));
+  }
+
+  init() {
+    initAwsCommon();
+    ({ S3Client, GetObjectCommand } = require("@aws-sdk/client-s3"));
+    this.requestHandler = initAwsRequestHandler(this.paramMap);
+  }
+
+  async dataFromStream(stream) {
+    const chunks = [];
+    return await new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => chunks.push(chunk));
+      stream.on("end", () => {
+        try {
+          const data = Buffer.concat(chunks).toString("utf-8");
+          resolve(data);
+        } catch (error) {
+          reject(new Error(`Rejected with error: ${error.message}`));
+        }
+      });
+      stream.on("error", (error) => {
+        reject(new Error(`Stream error: ${error.message}`));
+      });
+    });
+  };
+
+  async returnConfig() {
+    const fetchRegion = await resolveRegion(this.paramMap);
+
+    this.credential = createAwsCredential(
+      this.paramMap,
+      this.requestHandler,
+      fetchRegion
+    );
+
+    const s3Client = new S3Client({
+      region: fetchRegion,
+      credentials: this.credential,
+      requestHandler: this.requestHandler,
+    });
+
+    const params = {
+      Bucket: this.paramMap.get("bucket"),
+      Key: this.paramMap.get("key"),
+    };
+
+    try {
+      const cmd = new GetObjectCommand(params);
+      const resp = await s3Client.send(cmd);
+
+      if (!resp.Body) {
+        throw new Error(`S3 response body is empty for key: ${params.Key}`);
+      }
+
+      const data = await this.dataFromStream(resp.Body);
+      return JSON.parse(data);
+    } catch (e) {
+      const errmsg = util.format(
+        "Failed to retrieve or parse config: %s\n%s",
+        e.message,
+        e.stack
+      );
+      throw new Error(errmsg);
+    } finally {
+      s3Client.destroy();
+    }
+  }
+}
+
+module.exports = AWSS3Provider;
+
+async function hookFn(args) {
+  const configProvider = new AWSS3Provider(
+    args.provider_arg,
+    args.urlExtendedPart
+  );
+  try {
+    configProvider.init();
+  } catch (err) {
+    const errmsg = util.format(
+      "AWS Config Provider failed to load required modules: %s\n%s",
+      err.message,
+      err.stack
+    );
+    throw new Error(errmsg);
+  }
+
+  const cfg = await configProvider.returnConfig();
+  // Return config object
+  return [cfg, null];
+}
+
+oracledb.registerConfigurationProviderHook("awss3", hookFn);