oracledb 5.4.0 → 6.0.0

package/lib/thin/util.js

@@ -0,0 +1,289 @@
+// Copyright (c) 2022, 2023, 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 constants = require('../constants');
+const errors = require('../errors.js');
+
+//---------------------------------------------------------------------------
+// getMetadataMany(sql)
+//
+// Get metadata info for all the columns in the table
+//---------------------------------------------------------------------------
+function getMetadataMany(vars) {
+  const metadata = [];
+  for (const queryVar of vars) {
+    metadata.push(queryVar.fetchInfo);
+  }
+  return metadata;
+}
+
+//---------------------------------------------------------------------------
+// getOutBinds(sql)
+//
+// Get the outBinds for the sql
+//---------------------------------------------------------------------------
+function getOutBinds(bindVars, pos) {
+  let bindByPos = (bindVars[0].name === undefined);
+  let outBinds;
+  if (bindByPos) {
+    outBinds = [];
+  } else {
+    outBinds = {};
+  }
+  for (let i = 0; i < bindVars.length; i++) {
+    if (bindVars[i].dir === constants.BIND_IN)
+      continue;
+    if (bindByPos) {
+      outBinds.push(bindVars[i].values[pos]);
+    } else {
+      outBinds[bindVars[i].name] = bindVars[i].values[pos];
+    }
+  }
+  return outBinds;
+}
+
+//---------------------------------------------------------------------------
+// getExecuteManyOutBinds(sql)
+//
+// Get the outBinds for the sql when doing an executeMany call
+//---------------------------------------------------------------------------
+function getExecuteManyOutBinds(bindVars, numIters) {
+  let numOutBinds = getNumOutBinds(bindVars);
+  if (numOutBinds === 0) {
+    return;
+  }
+  let outBinds = new Array(numIters).fill(null);
+  for (let i = 0; i < numIters; i++) {
+    outBinds[i] = getOutBinds(bindVars, i);
+  }
+  return outBinds;
+}
+
+//---------------------------------------------------------------------------
+// getNumOutBinds(sql)
+//
+// Get the number of outBinds for the sql
+//---------------------------------------------------------------------------
+function getNumOutBinds(bindVars) {
+  let numOutBinds = 0;
+  for (let i = 0; i < bindVars.length; i++) {
+    if (bindVars[i].dir !== constants.BIND_IN) {
+      numOutBinds++;
+    }
+  }
+  return numOutBinds;
+}
+
+//---------------------------------------------------------------------------
+// getExecuteOutBinds(sql)
+//
+// Get the outBinds for the sql when doing an execute call
+//---------------------------------------------------------------------------
+function getExecuteOutBinds(bindVars) {
+  let numOutBinds = getNumOutBinds(bindVars);
+  if (numOutBinds === 0) {
+    return;
+  }
+  return getOutBinds(bindVars, 0);
+}
+
+//---------------------------------------------------------------------------
+// cleanSql(sql)
+//
+// Sanitize the sql to remove comment and redundant information
+//---------------------------------------------------------------------------
+function cleanSql(sql) {
+  sql = sql.trim();
+  sql = sql.replace(/\--.*(\n|$)/g, ""); // eslint-disable-line
+  sql = sql.replace(/\/\\*[\S\n ]+\\*\//g, "");
+  sql = sql.replace(/\s+/g, " ");
+  return sql;
+}
+
+//---------------------------------------------------------------------------
+// getOutBinds(sql)
+//
+// Get the bind variables from the bindInfoList of the statement object
+//---------------------------------------------------------------------------
+function getBindVars(statement) {
+  let bindVars = [];
+  for (const bindInfo of statement.bindInfoList) {
+    bindVars.push(bindInfo.bindVar);
+  }
+  return bindVars;
+}
+
+//---------------------------------------------------------------------------
+// checkProxyUserValidity()
+//
+// Check validity status for proxy authentication
+//---------------------------------------------------------------------------
+function checkProxyUserValidity(userName) {
+  let schemaUser = '', proxyUser = '';
+  let quoteFound = false, openSquareBracketFound = false;
+  let lastQuoteFoundIndex = 0;
+  let schemaUserStartIndex;
+  let result = {
+    status       : -1,
+    proxyUser    : '',
+    schemaUser   : ''
+  };
+  const userNameLength = userName.length;
+  let index = 0, i, j;
+  while (index < userNameLength) {
+    // check for double quotes
+    if (userName.charAt(index) === '"') {
+      quoteFound = !quoteFound;
+      lastQuoteFoundIndex = index;
+    }
+
+    // check for open square bracket
+    if (userName.charAt(index) === '[' && !quoteFound) {
+      openSquareBracketFound = true;
+      // skip leading space and extract proxy user name
+      if (lastQuoteFoundIndex != 0) {
+        for (i = lastQuoteFoundIndex + 1; i < index; i++) {
+          if (userName.charAt(i) !== ' ') {
+            return result;
+          }
+        }
+
+        for (i = 0; i <= lastQuoteFoundIndex; i++) {
+          proxyUser += userName.charAt(i);
+        }
+      } else {
+        for (i = 0; i < index; i++) {
+          if (userName.charAt(i) !== ' ') {
+            proxyUser += userName.charAt(i);
+          } else {
+            break;
+          }
+        }
+      }
+      break;
+    }
+    index++;
+  }
+
+  if (proxyUser.length === 0) {
+    return result;
+  } else {
+    result.proxyUser = proxyUser;
+  }
+
+  // extract schema user
+  index = index + 1;
+  quoteFound = false;
+  schemaUserStartIndex = index;
+  lastQuoteFoundIndex = 0;
+  while (index < userNameLength) {
+    // check for double quotes
+    if (userName.charAt(index) === '"') {
+      quoteFound = !quoteFound;
+      lastQuoteFoundIndex = index;
+    }
+
+    if (userName.charAt(index) === '[' && !quoteFound &&
+        openSquareBracketFound) {
+      return result;
+    }
+
+    if (userName.charAt(index) === ']' && !quoteFound) {
+      if (lastQuoteFoundIndex != schemaUserStartIndex &&
+          lastQuoteFoundIndex != 0) {
+        for (i = schemaUserStartIndex; i <= lastQuoteFoundIndex; i++) {
+          schemaUser += userName.charAt(i);
+        }
+        // check for character between double quotes and close brackets
+        for (i = lastQuoteFoundIndex + 1; i < index; i++) {
+          if (userName.charAt(i) != ' ') {
+            return result;
+          }
+        }
+      } else {
+        // skip trailing spaces
+        for (i = schemaUserStartIndex; i < index; i++) {
+          if (userName.charAt(i) != ' ') {
+            break;
+          }
+        }
+        if (i == index) {
+          return result;
+        }
+
+        for (j = i; j < index; j++) {
+          schemaUser += userName[j];
+        }
+      }
+
+      // check for character from [ till end of string
+      for (i = index + 1; i < userNameLength; i++) {
+        if (userName[i] != ' ') {
+          return result;
+        }
+      }
+    }
+    index++;
+  }
+
+  if (schemaUser.length === 0) {
+    return result;
+  } else {
+    result.schemaUser = schemaUser;
+  }
+
+  result.status = 0;
+  return result;
+}
+
+//---------------------------------------------------------------------------
+// checkCredentials()
+//
+// Check Credentials for Password Authentication
+//---------------------------------------------------------------------------
+function checkCredentials(params) {
+  if (params.token === undefined) {
+    if (params.externalAuth === true) {
+      errors.throwErr(errors.ERR_NOT_IMPLEMENTED, 'External Authentication');
+    }
+    if (params.password === undefined) {
+      errors.throwErr(errors.ERR_MISSING_CREDENTIALS);
+    }
+  }
+}
+
+module.exports = {
+  getMetadataMany,
+  cleanSql,
+  getExecuteOutBinds,
+  getExecuteManyOutBinds,
+  getOutBinds,
+  getBindVars,
+  checkProxyUserValidity,
+  checkCredentials
+};

package/lib/transformer.js

@@ -0,0 +1,250 @@
+// Copyright (c) 2023, 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 BaseDbObject = require('./dbObject.js');
+const Lob = require('./lob.js');
+const ResultSet = require('./resultset.js');
+const constants = require('./constants.js');
+const errors = require('./errors.js');
+const util = require('util');
+const types = require('./types.js');
+
+//-----------------------------------------------------------------------------
+// checkType()
+//
+// Checks that the type of the data matches one of the given types. If the type
+// has not been specified yet, the first type is assumed to be the correct one.
+//
+// A failure to match results in an exception being thrown. The data in the
+// info parameter is used to determine which error should be thrown.
+//-----------------------------------------------------------------------------
+function checkType(info, options) {
+  if (info.type === undefined && arguments.length > 2) {
+    info.type = arguments[2];
+  } else {
+    let matches = false;
+    for (let i = 2; i < arguments.length; i++) {
+      if (info.type === arguments[i]) {
+        matches = true;
+        break;
+      }
+    }
+    if (!matches) {
+      if (info.attrName) {
+        errors.throwErr(errors.ERR_WRONG_VALUE_FOR_DBOBJECT_ATTR,
+          info.attrName, info.fqn);
+      } else if (info.fqn) {
+        errors.throwErr(errors.ERR_WRONG_VALUE_FOR_DBOBJECT_ELEM, info.fqn);
+      } else if (info.isArray && info.name) {
+        errors.throwErr(errors.ERR_INCOMPATIBLE_TYPE_ARRAY_BIND, options.pos,
+          info.name);
+      } else if (info.isArray) {
+        errors.throwErr(errors.ERR_INCOMPATIBLE_TYPE_ARRAY_INDEX_BIND,
+          options.pos, info.pos);
+      } else {
+        errors.throwErr(errors.ERR_BIND_VALUE_AND_TYPE_MISMATCH);
+      }
+    }
+  }
+}
+
+//-----------------------------------------------------------------------------
+// transformJsonValue()
+//
+// Returns a normalized JSON value. Scalar values are returned unchanged.
+// Arrays are returned as a new array with transformed JSON values. Objects are
+// returned as new objects with keys "fields" and "values", both of which
+// are arrays (with the value transformed to JSON values).
+//-----------------------------------------------------------------------------
+function transformJsonValue(value) {
+
+  // handle simple scalars
+  if (value === undefined || value === null ||
+      typeof value === 'number' || typeof value === 'string' ||
+      typeof value === 'boolean' || Buffer.isBuffer(value) ||
+      util.isDate(value))
+    return value;
+
+  // arrays are transformed to a new array with processed values
+  if (Array.isArray(value)) {
+    const outValue = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      outValue[i] = transformJsonValue(value[i]);
+    }
+    return outValue;
+  }
+
+  // database objects are treated as empty objects
+  if (value instanceof BaseDbObject)
+    return {fields: [], values: []};
+
+  // all other objects are transformed to an object with two arrays (fields
+  // and values)
+  const outValue = {};
+  outValue.fields = Object.getOwnPropertyNames(value);
+  outValue.values = new Array(outValue.fields.length);
+  for (let i = 0; i < outValue.fields.length; i++) {
+    outValue.values[i] = transformJsonValue(value[outValue.fields[i]]);
+  }
+  return outValue;
+
+}
+
+//-----------------------------------------------------------------------------
+// transformValueIn()
+//
+// Processes the value supplied by the caller and returns a normalized value,
+// if necessary, for use by the implementation. All checks are performed on the
+// value to ensure it is suitable for the type information supplied. If no type
+// information is supplied, however, the value defines it instead!
+//-----------------------------------------------------------------------------
+function transformValueIn(info, value, options) {
+
+  // null and undefined can always be set so nothing needs to be done
+  if (value === undefined || value === null)
+    return undefined;
+
+  // handle setting plain JS values to database objects
+  if (info.type === types.DB_TYPE_OBJECT) {
+    let obj = value;
+    if (!(value instanceof BaseDbObject)) {
+      obj = new info.typeClass(value);
+    }
+    return obj._impl;
+
+  // handle setting plain JS values to JSON
+  } else if (info.type === types.DB_TYPE_JSON) {
+    return transformJsonValue(value);
+
+  // handle strings
+  } else if (typeof value === 'string') {
+    checkType(info, options,
+      types.DB_TYPE_VARCHAR,
+      types.DB_TYPE_NVARCHAR,
+      types.DB_TYPE_CHAR,
+      types.DB_TYPE_NCHAR,
+      types.DB_TYPE_CLOB,
+      types.DB_TYPE_NCLOB);
+    if (info.type !== types.DB_TYPE_CLOB &&
+        info.type !== types.DB_TYPE_NCLOB &&
+        info.cqn === undefined &&
+        (info.maxSize === undefined || value.length > info.maxSize)) {
+      if (info.checkSize) {
+        errors.throwErr(errors.ERR_MAX_SIZE_TOO_SMALL, info.maxSize,
+          value.length, options.pos);
+      }
+      info.maxSize = value.length;
+    }
+    return value;
+
+  // handle numbers
+  } else if (typeof value === 'number') {
+    checkType(info, options,
+      types.DB_TYPE_NUMBER,
+      types.DB_TYPE_BINARY_INTEGER,
+      types.DB_TYPE_BINARY_FLOAT,
+      types.DB_TYPE_BINARY_DOUBLE);
+    if (Number.isNaN(value) && info.type === types.DB_TYPE_NUMBER) {
+      errors.throwErr(errors.ERR_NAN_VALUE);
+    }
+    return value;
+
+  // handle booleans
+  } else if (typeof value === 'boolean') {
+    checkType(info, options, types.DB_TYPE_BOOLEAN);
+    return value;
+
+  // handle dates
+  } else if (util.isDate(value)) {
+    checkType(info, options,
+      types.DB_TYPE_TIMESTAMP,
+      types.DB_TYPE_TIMESTAMP_TZ,
+      types.DB_TYPE_TIMESTAMP_LTZ,
+      types.DB_TYPE_DATE);
+    return value;
+
+  // handle binding buffers
+  } else if (Buffer.isBuffer(value)) {
+    checkType(info, options,
+      types.DB_TYPE_RAW,
+      types.DB_TYPE_BLOB);
+    if (info.type === types.DB_TYPE_RAW && info.cqn === undefined &&
+        (info.maxSize === undefined || value.length > info.maxSize)) {
+      if (info.checkSize) {
+        errors.throwErr(errors.ERR_MAX_SIZE_TOO_SMALL, info.maxSize,
+          value.length, options.pos);
+      }
+      info.maxSize = value.length;
+    }
+    return value;
+
+  // handle result sets
+  } else if (value instanceof ResultSet) {
+    checkType(info, options, types.DB_TYPE_CURSOR);
+    return value._impl;
+
+  // handle binding LOBs
+  } else if (value instanceof Lob) {
+    checkType(info, options, value.type);
+    return value._impl;
+
+  // handle database objects
+  } else if (value instanceof BaseDbObject) {
+    checkType(info, options, types.DB_TYPE_OBJECT);
+    return value._impl;
+
+  // handle arrays
+  } else if (options.allowArray && Array.isArray(value)) {
+    info.isArray = true;
+    if (info.dir === constants.BIND_IN) {
+      info.maxArraySize = value.length || 1;
+    } else if (info.maxArraySize === undefined) {
+      errors.throwErr(errors.ERR_REQUIRED_MAX_ARRAY_SIZE);
+    } else if (value.length > info.maxArraySize) {
+      errors.throwErr(errors.ERR_INVALID_ARRAY_SIZE);
+    }
+    options.allowArray = false;
+    const transformed = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      options.pos = i;
+      transformed[i] = transformValueIn(info, value[i], options);
+    }
+    return transformed;
+  }
+
+  // no suitable bind value found
+  if (info.type === undefined)
+    errors.throwErr(errors.ERR_INVALID_BIND_DATA_TYPE, 2);
+  checkType(info, options);
+
+}
+
+// define exports
+module.exports = {
+  transformValueIn,
+};