oracledb 6.7.2 → 6.9.0

package/lib/types.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -33,6 +33,7 @@ const util = require('util');
 const dbTypeByNum = new Map();
 const dbTypeByOraTypeNum = new Map();
 const dbTypeByColumnTypeName = new Map();
+const MAX_UINT32 = Math.pow(2, 32) - 1;
 
 // define class used for database types
 class DbType {
@@ -145,7 +146,7 @@ const DB_TYPE_INTERVAL_DS = new DbType(2015,
   { oraTypeNum: 183, bufferSizeFactor: 11 });
 const DB_TYPE_INTERVAL_YM = new DbType(2016,
   "DB_TYPE_INTERVAL_YM", "INTERVAL YEAR TO MONTH",
-  { oraTypeNum: 182 });
+  { oraTypeNum: 182, bufferSizeFactor: 5 });
 const DB_TYPE_JSON = new DbType(2027,
   "DB_TYPE_JSON", "JSON",
   { oraTypeNum: 119 });
@@ -321,14 +322,9 @@ const DB_TYPE_FETCH_TYPE_MAP = new Map([
 ]);
 
 // additional aliases for types by column type name
-dbTypeByColumnTypeName.set("DOUBLE PRECISION", DB_TYPE_NUMBER);
-dbTypeByColumnTypeName.set("FLOAT", DB_TYPE_NUMBER);
-dbTypeByColumnTypeName.set("INTEGER", DB_TYPE_NUMBER);
 dbTypeByColumnTypeName.set("PL/SQL BOOLEAN", DB_TYPE_BOOLEAN);
 dbTypeByColumnTypeName.set("PL/SQL BINARY INTEGER", DB_TYPE_BINARY_INTEGER);
 dbTypeByColumnTypeName.set("PL/SQL PLS INTEGER", DB_TYPE_BINARY_INTEGER);
-dbTypeByColumnTypeName.set("REAL", DB_TYPE_NUMBER);
-dbTypeByColumnTypeName.set("SMALLINT", DB_TYPE_NUMBER);
 dbTypeByColumnTypeName.set("TIMESTAMP WITH LOCAL TZ", DB_TYPE_TIMESTAMP_LTZ);
 dbTypeByColumnTypeName.set("TIMESTAMP WITH TZ", DB_TYPE_TIMESTAMP_TZ);
 
@@ -339,6 +335,219 @@ class JsonId extends Uint8Array {
   }
 }
 
+// Represents the SparseVector.
+// indices must be an regular Array
+// values can be regular or typedArray.
+class SparseVector {
+  constructor(input) {
+    this._indices = new Uint32Array(0);
+    this._values = new Float64Array(0);
+    this._numDimensions = 0;
+
+    if (!input) {
+      return;
+    }
+    if (typeof input === 'object' &&
+      "numDimensions" in input &&
+      "indices" in input &&
+      "values" in input
+    ) {
+      // Object has valid properties for Sparse.
+      this._fromObject(input);
+    } else if (typeof input === 'string') {
+      // initialize from string.
+      this._fromString(input);
+    } else if (this._validDenseArray(input)) {
+      // dense array
+      this._fromDense(input);
+    } else {
+      errors.throwErr(errors.ERR_VECTOR_SPARSE_INVALID_INPUT);
+    }
+  }
+
+  _validDenseArray(value) {
+    return (value instanceof Float32Array ||
+      value instanceof Float64Array ||
+      value instanceof Int8Array || (Object.getPrototypeOf(value)
+        === Uint8Array.prototype) || Array.isArray(value));
+  }
+
+  // Check if indexArray and valuesArray have the same length
+  static _validateLengths(indices, values) {
+    if (indices.length !== values.length) {
+      if (!(values instanceof Uint8Array)) {
+      // Skip for binary vector format
+        errors.throwErr(errors.ERR_VECTOR_SPARSE_INDICES_VALUES_NOT_EQUAL);
+      }
+    }
+  }
+
+  _updateProperties(dims, indices, values) {
+    if (!this._validDenseArray(values)) {
+      errors.throwErr(errors.ERR_VECTOR_SPARSE_VALUES_IS_NOT_ARRAY);
+    }
+    if (!(indices instanceof Uint32Array) && !Array.isArray(indices)) {
+      errors.throwErr(errors.ERR_VECTOR_SPARSE_INDICES_IS_NOT_ARRAY);
+    }
+    SparseVector._validateLengths(indices, values);
+    if (!(typeof dims === 'number' && Number.isInteger(dims) && dims > 0)) {
+      errors.throwErr(errors.ERR_VECTOR_SPARSE_DIMS_IS_NOT_INTEGER);
+    }
+
+    this._numDimensions = dims;
+    this._indices = indices;
+    this._values = values;
+    this._convertToTypedArrays();
+  }
+
+  _fromObject(input) {
+    this._updateProperties(input.numDimensions, input.indices, input.values);
+  }
+
+  _convertToTypedArrays() {
+    // convert to typed arrays.
+    if (!(this._indices instanceof Uint32Array)) {
+      // validate elements are valid uint32 type.
+      const indices = new Uint32Array(this._indices.map((x, index) => {
+        if (typeof x !== 'number' || !Number.isInteger(x)) {
+          errors.throwErr(errors.ERR_VECTOR_SPARSE_INDICES_ELEM_IS_NOT_VALID, index);
+        }
+        if (x < 0 || x > MAX_UINT32 || x > (this.numDimensions - 1)) {
+          errors.throwErr(errors.ERR_VECTOR_SPARSE_INDICES_ELEM_IS_NOT_VALID,
+            index);
+        }
+        return x;
+      }));
+      this._indices = indices;
+    }
+
+    this._values = Array.isArray(this._values) ? new Float64Array(this._values)
+      : this._values;
+  }
+
+  // Initialize the state using the dense array.
+  // The length of input is assumed to be same as
+  // dimensions of sparse Vector column.
+  // values will be an array even if input is a typedArray.
+  _fromDense(input) {
+    this._indices = [];
+    this._values = [];
+
+    for (let i = 0; i < input.length; i++) {
+      if (input[i] !== 0) {
+        this._indices.push(i);
+        this._values.push(input[i]);
+      }
+    }
+    this._numDimensions = input.length;
+    this._convertToTypedArrays();
+  }
+
+  // parse a string input into a sparse vector
+  _fromString(str) {
+    let data;
+
+    // verify it is a valid JSON
+    try {
+      // use simple tokenizer?
+      data = JSON.parse(str);
+    } catch (e) {
+      errors.throwErr(errors.ERR_VECTOR_SPARSE_INVALID_JSON);
+    }
+
+    // Check if data is an array with exactly 3 elements
+    if (!Array.isArray(data) || data.length !== 3) {
+      errors.throwErr(errors.ERR_VECTOR_SPARSE_INVALID_STRING);
+    }
+
+    const [dims, indices, values] = data;
+    this._updateProperties(dims, indices, values);
+  }
+
+  // Internal method to create an instance
+  static create(sparseValue) {
+    SparseVector._validateLengths(sparseValue.indices, sparseValue.values);
+    const instance = Object.create(this.prototype);
+    instance._numDimensions = sparseValue.numDimensions;
+    instance._indices = sparseValue.indices;
+    instance._values = sparseValue.values;
+    return instance;
+  }
+
+  get indices() {
+    return this._indices;
+  }
+
+  get values() {
+    return this._values;
+  }
+
+  get numDimensions() {
+    return this._numDimensions;
+  }
+
+  toJSON() {
+    return {
+      numDimensions: this._numDimensions,
+      indices: this._indices,
+      values: this._values,
+    };
+  }
+
+  // It always constructs a typedArray.
+  _createEmptyArray(input, len) {
+    if (Array.isArray(input)) {
+      return new Float64Array(len);
+    } else {
+      // same typedArray of input type.
+      return new input.constructor(len);
+    }
+  }
+
+  // Convert sparse vector to a dense vector
+  // It returns typed array.
+  dense() {
+    if (this._numDimensions === 0) {
+      return null;
+    }
+    const dense = this._createEmptyArray(this._values, this._numDimensions);
+    this._indices.forEach((index, i) => {
+      dense[index] = this._values[i];
+    });
+    return dense;
+  }
+}
+
+// Interval Year-to-Month Class
+class IntervalYM {
+  constructor(obj) {
+    if (obj) {
+      errors.assertParamPropInt(obj, 1, "years");
+      errors.assertParamPropInt(obj, 1, "months");
+    }
+    this.years = obj?.years || 0;
+    this.months = obj?.months || 0;
+  }
+}
+
+// Interval Day-to-Second Class
+class IntervalDS {
+  constructor(obj) {
+    if (obj) {
+      errors.assertParamPropInt(obj, 1, "days");
+      errors.assertParamPropInt(obj, 1, "hours");
+      errors.assertParamPropInt(obj, 1, "minutes");
+      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;
+    this.fseconds = obj?.fseconds || 0;
+  }
+}
+
 module.exports = {
   DbType,
   DB_TYPE_BFILE,
@@ -376,5 +585,8 @@ module.exports = {
   getTypeByColumnTypeName,
   getTypeByNum,
   getTypeByOraTypeNum,
-  JsonId
+  JsonId,
+  SparseVector,
+  IntervalYM,
+  IntervalDS
 };

package/lib/util.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2016, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2016, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -33,6 +33,26 @@ const util = require('util');
 const types = require('./types.js');
 const constants = require('./constants.js');
 const traceHandler = require('./traceHandler.js');
+const crypto = require("crypto");
+
+const pemHeaders = [
+  '-----BEGIN CERTIFICATE-----',
+  '-----BEGIN PUBLIC KEY-----',
+  '-----BEGIN PRIVATE KEY-----',
+  '-----BEGIN RSA PRIVATE KEY-----',
+  '-----BEGIN DSA PRIVATE KEY-----',
+  '-----BEGIN EC PRIVATE KEY-----',
+  '-----BEGIN ENCRYPTED PRIVATE KEY-----'
+];
+const pemFooters = [
+  '-----END CERTIFICATE-----',
+  '-----END PUBLIC KEY-----',
+  '-----END PRIVATE KEY-----',
+  '-----END RSA PRIVATE KEY-----',
+  '-----END DSA PRIVATE KEY-----',
+  '-----END EC PRIVATE KEY-----',
+  '-----END ENCRYPTED PRIVATE KEY-----'
+];
 
 // set of valid network characters
 const validNetworkCharacterSet = new Set(['A', 'B', 'C', 'D', 'E', 'F', 'G',
@@ -80,6 +100,13 @@ function getInstallURL() {
   return ('Node-oracledb installation instructions: https://node-oracledb.readthedocs.io/en/latest/user_guide/installation.html');
 }
 
+// check if a file has contents of a .pem file
+function isPemFile(content) {
+  //remove any line breaks at the end of the content
+  content = content.trim();
+  return pemHeaders.some(header => content.includes(header)) &&
+       pemFooters.some(footer => content.endsWith(footer));
+}
 
 // getInstallHelp returns a string with installation usage tips that may be helpful
 function getInstallHelp() {
@@ -372,6 +399,21 @@ function isShardingKey(value) {
   return true;
 }
 
+function isAppContext(value) {
+  if (!Array.isArray(value))
+    return false;
+  for (let i = 0; i < value.length; i++) {
+    const element = value[i];
+    if (!Array.isArray(element) || element.length !== 3)
+      return false;
+    for (let j = 0; j < 3; j++) {
+      if (typeof element[j] !== 'string')
+        return false;
+    }
+  }
+  return true;
+}
+
 function isSodaDocument(value) {
   return (value != null && value._sodaDocumentMarker);
 }
@@ -414,6 +456,34 @@ function normalizeXid(value) {
   return normalizedXid;
 }
 
+//---------------------------------------------------------------------------
+// isTransactionId()
+//
+// Validates if the given value is a sessionless transactionId
+//---------------------------------------------------------------------------
+function isTransactionId(value) {
+  return Buffer.isBuffer(value) || (typeof value === 'string');
+}
+
+//---------------------------------------------------------------------------
+// normalizeTransactionId()
+//
+// Returns the normalized value of a sessionless transactionId as a buffer
+// In case the value is null a random 36-byte UUID buffer is returned
+//---------------------------------------------------------------------------
+function normalizeTransactionId(value) {
+  let normalizedTransactionId = value;
+  if (normalizedTransactionId === undefined)
+    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);
+  }
+  return normalizedTransactionId;
+}
+
 function verifySodaDoc(content) {
   if (isSodaDocument(content))
     return content._impl;
@@ -501,7 +571,7 @@ function isVectorValue(value) {
   return (value instanceof Float32Array ||
     value instanceof Float64Array ||
     value instanceof Int8Array || (Object.getPrototypeOf(value)
-      === Uint8Array.prototype));
+      === Uint8Array.prototype) || value instanceof types.SparseVector);
 }
 
 //-----------------------------------------------------------------------------
@@ -573,15 +643,19 @@ module.exports = {
   isObjectOrArray,
   isPrivilege,
   isShardingKey,
+  isAppContext,
   isSodaDocument,
   isTokenExpired,
   isTokenValid,
+  isTransactionId,
   isVectorValue,
   isXid,
+  normalizeTransactionId,
   normalizeXid,
   makeDate,
   sanitize,
   verifySodaDoc,
   wrapFn,
-  wrapFns
+  wrapFns,
+  isPemFile
 };

package/lib/version.js

@@ -30,7 +30,7 @@
 
 module.exports = {
   VERSION_MAJOR: 6,
-  VERSION_MINOR: 7,
-  VERSION_PATCH: 2,
+  VERSION_MINOR: 9,
+  VERSION_PATCH: 0,
   VERSION_SUFFIX: ''
 };

package/package/install.js

@@ -68,7 +68,7 @@ function warn(message) { // eslint-disable-line
   console.error.apply(console, args);
 }
 
-// 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.
@@ -76,8 +76,8 @@ function warn(message) { // eslint-disable-line
 // Keep this code in sync with lib/oracledb.js
 function checkVersion() {
   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");
 }
 
 // Check for the binary node-oracledb module needed for "Thick mode".

package/package/prunebinaries.js

@@ -1,4 +1,4 @@
-/* Copyright (c) 2019, 2023, Oracle and/or its affiliates. */
+/* Copyright (c) 2019, 2025, Oracle and/or its affiliates. */
 
 /******************************************************************************
  *
@@ -47,11 +47,11 @@ const nodbUtil = require('../lib/util.js');
 
 const dir = nodbUtil.RELEASE_DIR; // contains the binaries
 
-let re = new RegExp(nodbUtil.BINARY_FILE);
+const re = new RegExp(nodbUtil.BINARY_FILE);
 
 try {
-  let f = fs.readdirSync(dir);
-  let opt = process.argv[2];
+  const f = fs.readdirSync(dir);
+  const opt = process.argv[2];
 
   if (opt) {
     // 'npm run prune <option>' is called
@@ -76,18 +76,12 @@ try {
   console.error(err.message);
 }
 
-async function removeFileorDir(fileOrDirPath) {
+function removeFileorDir(fileOrDirPath) {
   try {
     const isDir = fs.statSync(fileOrDirPath).isDirectory();
     if (isDir) {
       // Remove the directory and its files recursively
-      // Use fs.promises for Node.js versions 14.6-14.13,
-      // which do not support fs.rmSync()
-      const vs = process.version.substring(1).split(".").map(Number);
-      if (vs[0] > 14 || (vs[0] === 14 && vs[1] >= 14))
-        fs.rmSync(fileOrDirPath, { recursive: true, force: true });
-      else
-        await fs.promises.rmdir(fileOrDirPath, { recursive: true, force: true });
+      fs.rmSync(fileOrDirPath, { recursive: true, force: true });
     } else {
       // Remove the file or the symlink synchronously
       fs.unlinkSync(fileOrDirPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oracledb",
-  "version": "6.7.2",
+  "version": "6.9.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/",
@@ -34,7 +34,7 @@
     "prune": "node package/prunebinaries.js"
   },
   "engines": {
-    "node": ">=14.6"
+    "node": ">=14.17"
   },
   "maintainers": [
     {