dnrops
/
node-oracledb
mirror of https://github.com/oracle/node-oracledb
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rework how errors are thrown

This commit is contained in:
Christopher Jones 2023-02-21 12:13:36 +11:00
parent 7126ff0c9a
commit 7665061280
16 changed files with 672 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
lib/aqQueue.js
View File

@ -19,6 +19,7 @@
'use strict'; 'use strict';
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
class AqQueue { class AqQueue {
@ -33,7 +34,7 @@ class AqQueue {
// Returns a single message from the queue, if one is available. // Returns a single message from the queue, if one is available.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async deqOne() { async deqOne() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._deqOne(); return await this._deqOne();
} }
@ -44,8 +45,8 @@ class AqQueue {
// if any are available. // if any are available.
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
async deqMany(maxMessages) { async deqMany(maxMessages) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof maxMessages === 'number', 'NJS-005', 1); errors.assertParamValue(typeof maxMessages === 'number', 1);
return await this._deqMany(maxMessages); return await this._deqMany(maxMessages);
} }
@ -55,9 +56,9 @@ class AqQueue {
// Enqueues a single message into the queue. // Enqueues a single message into the queue.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async enqOne(message) { async enqOne(message) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof message === 'object' || typeof message === 'string', errors.assertParamValue(typeof message === 'object' ||
'NJS-005', 1); typeof message === 'string', 1);
return await this._enqOne(message); return await this._enqOne(message);
} }
@ -68,8 +69,8 @@ class AqQueue {
// multiple round-trips. // multiple round-trips.
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
async enqMany(messages) { async enqMany(messages) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(Array.isArray(messages), 'NJS-005', 1); errors.assertParamValue(Array.isArray(messages), 1);
return await this._enqMany(messages); return await this._enqMany(messages);
} }

146
lib/connection.js
View File

@ -22,6 +22,7 @@
const BaseDbObject = require('./dbObject.js'); const BaseDbObject = require('./dbObject.js');
const EventEmitter = require('events'); const EventEmitter = require('events');
const QueryStream = require('./queryStream.js'); const QueryStream = require('./queryStream.js');
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
const constants = require('./constants.js'); const constants = require('./constants.js');
const settings = require('./settings.js'); const settings = require('./settings.js');
@ -40,7 +41,7 @@ class Connection extends EventEmitter {
async _acquireLock() { async _acquireLock() {
if (this._inProgress) { if (this._inProgress) {
if (settings.errorOnConcurrentExecute) { if (settings.errorOnConcurrentExecute) {
throw new Error(nodbUtil.getErrorMessage('NJS-081')); errors.throwErr(errors.ERR_CONCURRENT_OPS);
} }
await new Promise((resolve, reject) => { await new Promise((resolve, reject) => {
const payload = {resolve: resolve, reject: reject}; const payload = {resolve: resolve, reject: reject};
@ -105,7 +106,7 @@ class Connection extends EventEmitter {
// Breaks the execution of the statement. // Breaks the execution of the statement.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async breakExecution() { async breakExecution() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
await this._break(); await this._break();
} }
@ -115,10 +116,10 @@ class Connection extends EventEmitter {
// Changes the password of the specified user. // Changes the password of the specified user.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async changePassword(user, password, newPassword) { async changePassword(user, password, newPassword) {
nodbUtil.checkArgCount(arguments, 3, 3); errors.assertArgCount(arguments, 3, 3);
nodbUtil.assert(typeof user === 'string', 'NJS-005', 1); errors.assertParamValue(typeof user === 'string', 1);
nodbUtil.assert(typeof password === 'string', 'NJS-005', 2); errors.assertParamValue(typeof password === 'string', 2);
nodbUtil.assert(typeof newPassword === 'string', 'NJS-005', 3); errors.assertParamValue(typeof newPassword === 'string', 3);
await this._changePassword(user, password, newPassword); await this._changePassword(user, password, newPassword);
} }
@ -130,16 +131,16 @@ class Connection extends EventEmitter {
async close(a1) { async close(a1) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
nodbUtil.assert(nodbUtil.isObject(a1), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(a1), 1);
options = a1; options = a1;
} }
// If already in the process of closing, throw an error instead of doing // If already in the process of closing, throw an error instead of doing
// a roundtrip // a roundtrip
if (this._closing) { if (this._closing) {
throw new Error (nodbUtil.getErrorMessage('NJS-003')); errors.throwErr(errors.ERR_INVALID_CONNECTION);
} }
this._closing = true; this._closing = true;
@ -162,7 +163,7 @@ class Connection extends EventEmitter {
// Commits the current transaction. // Commits the current transaction.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async commit() { async commit() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
await this._commit(); await this._commit();
} }
@ -172,8 +173,8 @@ class Connection extends EventEmitter {
// Creates a temporary LOB and returns it to the caller. // Creates a temporary LOB and returns it to the caller.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async createLob(type) { async createLob(type) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof type === 'number', 'NJS-005', 1); errors.assertParamValue(typeof type === 'number', 1);
return (await this._createLob(type)); return (await this._createLob(type));
} }
@ -186,17 +187,17 @@ class Connection extends EventEmitter {
let binds = []; let binds = [];
let executeOpts = {}; let executeOpts = {};
nodbUtil.checkArgCount(arguments, 1, 3); errors.assertArgCount(arguments, 1, 3);
nodbUtil.assert(typeof sql === 'string', 'NJS-005', 1); errors.assertParamValue(typeof sql === 'string', 1);
switch (arguments.length) { switch (arguments.length) {
case 2: case 2:
nodbUtil.assert(nodbUtil.isObjectOrArray(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObjectOrArray(a2), 2);
binds = a2; binds = a2;
break; break;
case 3: case 3:
nodbUtil.assert(nodbUtil.isObjectOrArray(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObjectOrArray(a2), 2);
nodbUtil.assert(nodbUtil.isObject(a3), 'NJS-005', 3); errors.assertParamValue(nodbUtil.isObject(a3), 3);
binds = a2; binds = a2;
executeOpts = a3; executeOpts = a3;
break; break;
@ -235,18 +236,18 @@ class Connection extends EventEmitter {
async executeMany(sql, bindsOrNumIters, a3) { async executeMany(sql, bindsOrNumIters, a3) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 2, 3); errors.assertArgCount(arguments, 2, 3);
nodbUtil.assert(typeof sql === 'string', 'NJS-005', 1); errors.assertParamValue(typeof sql === 'string', 1);
if (typeof bindsOrNumIters === 'number') { if (typeof bindsOrNumIters === 'number') {
nodbUtil.assert(Number.isInteger(bindsOrNumIters), 'NJS-005', 2); errors.assertParamValue(Number.isInteger(bindsOrNumIters), 2);
nodbUtil.assert(bindsOrNumIters > 0, 'NJS-005', 2); errors.assertParamValue(bindsOrNumIters > 0, 2);
} else { } else {
nodbUtil.assert(Array.isArray(bindsOrNumIters), 'NJS-005', 2); errors.assertParamValue(Array.isArray(bindsOrNumIters), 2);
nodbUtil.assert(bindsOrNumIters.length > 0, 'NJS-005', 2); errors.assertParamValue(bindsOrNumIters.length > 0, 2);
} }
if (arguments.length == 3) { if (arguments.length == 3) {
nodbUtil.assert(nodbUtil.isObject(a3), 'NJS-005', 3); errors.assertParamValue(nodbUtil.isObject(a3), 3);
options = a3; options = a3;
} }
@ -262,8 +263,8 @@ class Connection extends EventEmitter {
// using the fully qualified name. // using the fully qualified name.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getDbObjectClass(name) { async getDbObjectClass(name) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof name === 'string', 'NJS-005', 1); errors.assertParamValue(typeof name === 'string', 1);
let cls = this._dbObjectClasses[name]; let cls = this._dbObjectClasses[name];
if (cls) { if (cls) {
@ -280,10 +281,10 @@ class Connection extends EventEmitter {
async getQueue(name, a2) { async getQueue(name, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(typeof name === 'string', 'NJS-005', 1); errors.assertParamValue(typeof name === 'string', 1);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(nodbUtil.isObject(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(a2), 2);
options = a2; options = a2;
} }
return (await this._getQueue(name, options)); return (await this._getQueue(name, options));
@ -296,7 +297,7 @@ class Connection extends EventEmitter {
// the current connection). // the current connection).
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
getSodaDatabase() { getSodaDatabase() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return (this._getSodaDatabase()); return (this._getSodaDatabase());
} }
@ -306,7 +307,7 @@ class Connection extends EventEmitter {
// Returns information about the statement. // Returns information about the statement.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getStatementInfo(sql) { async getStatementInfo(sql) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
return (await this._getStatementInfo(sql)); return (await this._getStatementInfo(sql));
} }
@ -326,7 +327,7 @@ class Connection extends EventEmitter {
// Sends a "ping" to the database to see if it is "alive". // Sends a "ping" to the database to see if it is "alive".
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async ping() { async ping() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
await this._ping(); await this._ping();
} }
@ -338,15 +339,15 @@ class Connection extends EventEmitter {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
queryStream(sql, binding, options) { queryStream(sql, binding, options) {
nodbUtil.checkArgCount(arguments, 1, 3); errors.assertArgCount(arguments, 1, 3);
nodbUtil.assert(typeof sql === 'string', 'NJS-005', 1); errors.assertParamValue(typeof sql === 'string', 1);
if (binding) { if (binding) {
nodbUtil.assert(nodbUtil.isObjectOrArray(binding), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObjectOrArray(binding), 2);
} }
if (options) { if (options) {
nodbUtil.assert(nodbUtil.isObject(options), 'NJS-005', 3); errors.assertParamValue(nodbUtil.isObject(options), 3);
} }
binding = binding || []; binding = binding || [];
@ -358,18 +359,13 @@ class Connection extends EventEmitter {
// calling execute() via nextTick to ensure that handlers are registered // calling execute() via nextTick to ensure that handlers are registered
// prior to the events being emitted // prior to the events being emitted
process.nextTick(() => { process.nextTick(async () => {
try { try {
const p = this._execute(sql, binding, options); const result = await this._execute(sql, binding, options);
p.then(function(result) { if (!result.resultSet) {
if (!result.resultSet) { errors.throwErr(errors.ERR_NOT_A_QUERY);
stream.destroy(new Error(nodbUtil.getErrorMessage('NJS-019'))); }
} else { stream._open(result.resultSet);
stream._open(result.resultSet);
}
}, function(err) {
stream.destroy(err);
});
} catch (err) { } catch (err) {
stream.destroy(err); stream.destroy(err);
return; return;
@ -385,7 +381,7 @@ class Connection extends EventEmitter {
// Rolls back the current transaction. // Rolls back the current transaction.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async rollback() { async rollback() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
await this._rollback(); await this._rollback();
} }
@ -396,9 +392,9 @@ class Connection extends EventEmitter {
async shutdown(a1) { async shutdown(a1) {
let mode = constants.SHUTDOWN_MODE_DEFAULT; let mode = constants.SHUTDOWN_MODE_DEFAULT;
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (a1 !== undefined) { if (a1 !== undefined) {
nodbUtil.assert(typeof mode === 'number', 'NJS-005', 1); errors.assertParamValue(typeof mode === 'number', 1);
mode = a1; mode = a1;
} }
@ -412,9 +408,9 @@ class Connection extends EventEmitter {
async startup(a1) { async startup(a1) {
let opts = {}; let opts = {};
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
nodbUtil.assert(typeof opts === 'object', 'NJS-005', 1); errors.assertParamValue(typeof opts === 'object', 1);
opts = a1; opts = a1;
} }
@ -428,9 +424,9 @@ class Connection extends EventEmitter {
// changes or of AQ messages available to dequeue. // changes or of AQ messages available to dequeue.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async subscribe(name, options) { async subscribe(name, options) {
nodbUtil.checkArgCount(arguments, 2, 2); errors.assertArgCount(arguments, 2, 2);
nodbUtil.assert(typeof name === 'string', 'NJS-005', 1); errors.assertParamValue(typeof name === 'string', 1);
nodbUtil.assert(nodbUtil.isObject(options), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(options), 2);
await this._subscribe(name, options); await this._subscribe(name, options);
} }
@ -440,19 +436,19 @@ class Connection extends EventEmitter {
// Starts a two-phase-commit transaction. // Starts a two-phase-commit transaction.
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
async tpcBegin(xid, flag, timeout) { async tpcBegin(xid, flag, timeout) {
nodbUtil.checkArgCount(arguments, 1, 3); errors.assertArgCount(arguments, 1, 3);
nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isXid(xid), 1);
if (arguments.length < 3) { if (arguments.length < 3) {
timeout = 60; // seconds timeout = 60; // seconds
} else { } else {
nodbUtil.assert(typeof timeout === 'number', 'NJS-005', 3); errors.assertParamValue(typeof timeout === 'number', 3);
} }
if (arguments.length < 2) { if (arguments.length < 2) {
flag = constants.TPC_BEGIN_NEW; flag = constants.TPC_BEGIN_NEW;
} else { } else {
nodbUtil.assert(typeof flag === 'number', 'NJS-005', 2); errors.assertParamValue(typeof flag === 'number', 2);
} }
await this._tpcBegin(xid, flag, timeout); await this._tpcBegin(xid, flag, timeout);
} }
@ -463,15 +459,15 @@ class Connection extends EventEmitter {
// Commits a two-phase-commit transaction. // Commits a two-phase-commit transaction.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async tpcCommit(xid, onePhase) { async tpcCommit(xid, onePhase) {
nodbUtil.checkArgCount(arguments, 0, 2); errors.assertArgCount(arguments, 0, 2);
if (arguments.length < 2) { if (arguments.length < 2) {
onePhase = false; onePhase = false;
} else { } else {
nodbUtil.assert(typeof onePhase === 'boolean', 'NJS-005', 2); errors.assertParamValue(typeof onePhase === 'boolean', 2);
} }
if (arguments.length >= 1) { if (arguments.length >= 1) {
nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isXid(xid), 1);
} }
await this._tpcCommit(xid, onePhase); await this._tpcCommit(xid, onePhase);
} }
@ -482,16 +478,16 @@ class Connection extends EventEmitter {
// Ends a two-phase-commit transaction. // Ends a two-phase-commit transaction.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async tpcEnd(xid, flag) { async tpcEnd(xid, flag) {
nodbUtil.checkArgCount(arguments, 0, 2); errors.assertArgCount(arguments, 0, 2);
if (arguments.length < 2) { if (arguments.length < 2) {
flag = constants.TPC_END_NORMAL; flag = constants.TPC_END_NORMAL;
} else { } else {
nodbUtil.assert(typeof flag === 'number', 'NJS-005', 2); errors.assertParamValue(typeof flag === 'number', 2);
} }
if (arguments.length >= 1) { if (arguments.length >= 1) {
nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isXid(xid), 1);
} }
await this._tpcEnd(xid, flag); await this._tpcEnd(xid, flag);
@ -504,8 +500,8 @@ class Connection extends EventEmitter {
// transaction. // transaction.
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
async tpcForget(xid) { async tpcForget(xid) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isXid(xid), 1);
await this._tpcForget(xid); await this._tpcForget(xid);
} }
@ -516,9 +512,9 @@ class Connection extends EventEmitter {
// Prepares a two-phase-commit transaction for commit. // Prepares a two-phase-commit transaction for commit.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async tpcPrepare(xid) { async tpcPrepare(xid) {
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length >= 1) { if (arguments.length >= 1) {
nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isXid(xid), 1);
} }
return await this._tpcPrepare(xid); return await this._tpcPrepare(xid);
@ -530,10 +526,10 @@ class Connection extends EventEmitter {
// Returns a list of pending two-phase-commit transactions. // Returns a list of pending two-phase-commit transactions.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async tpcRecover(asString) { async tpcRecover(asString) {
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
nodbUtil.assert(typeof asString === 'boolean', 'NJS-005', 1); errors.assertParamValue(typeof asString === 'boolean', 1);
} else { } else {
asString = true; asString = true;
} }
@ -564,9 +560,9 @@ class Connection extends EventEmitter {
// Rolls back the current changes in a two-phase-commit transaction. // Rolls back the current changes in a two-phase-commit transaction.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async tpcRollback(xid) { async tpcRollback(xid) {
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
nodbUtil.assert(nodbUtil.isXid(xid), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isXid(xid), 1);
} }
await this._tpcRollback(xid); await this._tpcRollback(xid);
@ -578,8 +574,8 @@ class Connection extends EventEmitter {
// Destroy a subscription which was earlier created using subscribe(). // Destroy a subscription which was earlier created using subscribe().
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async unsubscribe(name) { async unsubscribe(name) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof name === 'string', 'NJS-005', 1); errors.assertParamValue(typeof name === 'string', 1);
await this._unsubscribe(name); await this._unsubscribe(name);
} }

385
lib/errors.js Normal file
View File

@ -0,0 +1,385 @@
// Copyright (c) 2022, Oracle and/or its affiliates.
//-----------------------------------------------------------------------------
//
// You may not use the identified files except in compliance with the Apache
// License, Version 2.0 (the "License.")
//
// You may obtain a copy of the License at
// http://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('util');
// define error prefix for all messages
const ERR_PREFIX = "NJS";
// define error number constants (used in JavaScript library)
const ERR_MISSING_CALLBACK = 1;
const ERR_INVALID_POOL = 2;
const ERR_INVALID_CONNECTION = 3;
const ERR_INVALID_PROPERTY_VALUE = 4;
const ERR_INVALID_PARAMETER_VALUE = 5;
const ERR_INVALID_PROPERTY_VALUE_IN_PARAM = 7;
const ERR_INVALID_NUMBER_OF_PARAMETERS = 9;
const ERR_UNSUPPORTED_DATA_TYPE = 10;
const ERR_BIND_VALUE_AND_TYPE_MISMATCH = 11;
const ERR_INVALID_BIND_DATA_TYPE = 12;
const ERR_INVALID_BIND_DIRECTION = 13;
const ERR_NO_TYPE_FOR_CONVERSION = 15;
const ERR_INSUFFICENT_BUFFER_FOR_BINDS = 16;
const ERR_BUSY_RS = 17;
const ERR_INVALID_RS = 18;
const ERR_NOT_A_QUERY = 19;
const ERR_INVALID_TYPE_FOR_CONVERSION = 21;
const ERR_INVALID_LOB = 22;
const ERR_BUSY_LOB = 23;
const ERR_INSUFFICIENT_MEMORY = 24;
const ERR_INVALID_TYPE_FOR_ARRAY_BIND = 34;
const ERR_REQUIRED_MAX_ARRAY_SIZE = 35;
const ERR_INVALID_ARRAY_SIZE = 36;
const ERR_INCOMPATIBLE_TYPE_ARRAY_BIND = 37;
const ERR_CONN_REQUEST_TIMEOUT = 40;
const ERR_CANNOT_CONVERT_RS_TO_STREAM = 41;
const ERR_CANNOT_INVOKE_RS_METHODS = 42;
const ERR_RS_ALREADY_CONVERTED = 43;
const ERR_INVALID_BIND_UNIT = 44;
const ERR_CANNOT_LOAD_BINARY = 45;
const ERR_POOL_WITH_ALIAS_ALREADY_EXISTS = 46;
const ERR_POOL_WITH_ALIAS_NOT_FOUND = 47;
const ERR_INCOMPATIBLE_TYPE_ARRAY_INDEX_BIND = 52;
const ERR_NON_ARRAY_PROVIDED = 53;
const ERR_MIXED_BIND = 55;
const ERR_MISSING_MAX_SIZE_BY_POS = 56;
const ERR_MISSING_MAX_SIZE_BY_NAME = 57;
const ERR_MAX_SIZE_TOO_SMALL = 58;
const ERR_MISSING_TYPE_BY_POS = 59;
const ERR_MISSING_TYPE_BY_NAME = 60;
const ERR_INVALID_SUBSCR = 61;
const ERR_MISSING_SUBSCR_CALLBACK = 62;
const ERR_MISSING_SUBSCR_SQL = 63;
const ERR_POOL_CLOSING = 64;
const ERR_POOL_CLOSED = 65;
const ERR_INVALID_SODA_DOC_CURSOR = 66;
const ERR_NO_BINARY_AVAILABLE = 67;
const ERR_INVALID_ERR_NUM = 68;
const ERR_NODE_TOO_OLD = 69;
const ERR_INVALID_AQ_MESSAGE = 70;
const ERR_CONVERT_FROM_OBJ_ELEMENT = 71;
const ERR_CONVERT_FROM_OBJ_ATTR = 72;
const ERR_CONVERT_TO_OBJ_ELEMENT = 73;
const ERR_CONVERT_TO_OBJ_ATTR = 74;
const ERR_DBL_CONNECT_STRING = 75;
const ERR_QUEUE_MAX_EXCEEDED = 76;
const ERR_CLIENT_LIB_ALREADY_INITIALIZED = 77;
const ERR_UNSUPPORTED_DATA_TYPE_IN_JSON = 78;
const ERR_CONVERT_TO_JSON_VALUE = 79;
const ERR_DBL_USER = 80;
const ERR_CONCURRENT_OPS = 81;
const ERR_POOL_RECONFIGURING = 82;
const ERR_POOL_STATISTICS_DISABLED = 83;
const ERR_TOKEN_BASED_AUTH = 84;
const ERR_POOL_TOKEN_BASED_AUTH = 85;
const ERR_CONN_TOKEN_BASED_AUTH = 86;
const ERR_TOKEN_HAS_EXPIRED = 87;
const ERR_TOKEN_CALLBACK_DUP = 88;
const messages = new Map();
messages.set(ERR_INVALID_CONNECTION,
'invalid connection');
messages.set(ERR_INVALID_POOL,
'invalid pool');
messages.set(ERR_INVALID_PROPERTY_VALUE,
'invalid value for property %s');
messages.set(ERR_MISSING_CALLBACK,
'expected callback as last parameter');
messages.set(ERR_INVALID_PARAMETER_VALUE,
'invalid value for parameter %d');
messages.set(ERR_INVALID_PROPERTY_VALUE_IN_PARAM,
'invalid value for "%s" in parameter %d');
messages.set(ERR_INVALID_NUMBER_OF_PARAMETERS,
'invalid number of parameters');
messages.set(ERR_UNSUPPORTED_DATA_TYPE,
'unsupported data type %d in column %d');
messages.set(ERR_BIND_VALUE_AND_TYPE_MISMATCH,
'encountered bind value and type mismatch');
messages.set(ERR_INVALID_BIND_DATA_TYPE,
'encountered invalid bind data type in parameter %d');
messages.set(ERR_INVALID_BIND_DIRECTION,
'invalid bind direction');
messages.set(ERR_NO_TYPE_FOR_CONVERSION,
'type was not specified for conversion');
messages.set(ERR_INSUFFICENT_BUFFER_FOR_BINDS,
'buffer is too small for OUT binds');
messages.set(ERR_BUSY_RS,
'concurrent operations on ResultSet are not allowed');
messages.set(ERR_INVALID_RS,
'invalid ResultSet');
messages.set(ERR_NOT_A_QUERY,
'ResultSet cannot be returned for non-query statements');
messages.set(ERR_INVALID_TYPE_FOR_CONVERSION,
'invalid type for conversion specified');
messages.set(ERR_INVALID_LOB,
'invalid Lob');
messages.set(ERR_BUSY_LOB,
'concurrent operations on LOB are not allowed');
messages.set(ERR_INSUFFICIENT_MEMORY,
'memory allocation failed');
messages.set(ERR_INVALID_TYPE_FOR_ARRAY_BIND,
'data type is unsupported for array bind');
messages.set(ERR_REQUIRED_MAX_ARRAY_SIZE,
'maxArraySize is required for IN OUT array bind');
messages.set(ERR_INVALID_ARRAY_SIZE,
'given array is of size greater than maxArraySize');
messages.set(ERR_INCOMPATIBLE_TYPE_ARRAY_BIND,
'invalid data type at array index %d for bind ":%"');
messages.set(ERR_CONN_REQUEST_TIMEOUT,
'connection request timeout. Request exceeded queueTimeout of %d');
messages.set(ERR_CANNOT_CONVERT_RS_TO_STREAM,
'cannot convert ResultSet to QueryStream after invoking methods');
messages.set(ERR_CANNOT_INVOKE_RS_METHODS,
'cannot invoke ResultSet methods after converting to QueryStream');
messages.set(ERR_RS_ALREADY_CONVERTED,
'ResultSet already converted to QueryStream');
messages.set(ERR_INVALID_BIND_UNIT,
'bind object must contain one of the following keys: ' +
'"dir", "type", "maxSize", or "val"');
messages.set(ERR_CANNOT_LOAD_BINARY,
'cannot load a node-oracledb binary for Node.js %s');
messages.set(ERR_POOL_WITH_ALIAS_ALREADY_EXISTS,
'pool alias "%s" already exists in the connection pool cache');
messages.set(ERR_POOL_WITH_ALIAS_NOT_FOUND,
'pool alias "%s" not found in connection pool cache');
messages.set(ERR_INCOMPATIBLE_TYPE_ARRAY_INDEX_BIND,
'invalid data type at array index %d for bind position %d');
messages.set(ERR_NON_ARRAY_PROVIDED,
'an array value was expected');
messages.set(ERR_MIXED_BIND,
'binding by position and name cannot be mixed');
messages.set(ERR_MISSING_MAX_SIZE_BY_POS,
'maxSize must be specified and not zero for bind position %d');
messages.set(ERR_MISSING_MAX_SIZE_BY_NAME,
'maxSize must be specified and not zero for bind "%s"');
messages.set(ERR_MAX_SIZE_TOO_SMALL,
'maxSize of %d is too small for value of length %d in row %d');
messages.set(ERR_MISSING_TYPE_BY_POS,
'type must be specified for bind position %d');
messages.set(ERR_MISSING_TYPE_BY_NAME,
'type must be specified for bind "%s"');
messages.set(ERR_INVALID_SUBSCR,
'invalid subscription');
messages.set(ERR_MISSING_SUBSCR_CALLBACK,
'subscription notification callback missing');
messages.set(ERR_MISSING_SUBSCR_SQL,
'subscription notification SQL missing');
messages.set(ERR_POOL_CLOSING,
'connection pool is closing');
messages.set(ERR_POOL_CLOSED,
'connection pool was closed');
messages.set(ERR_INVALID_SODA_DOC_CURSOR,
'invalid SODA document cursor');
messages.set(ERR_NO_BINARY_AVAILABLE,
'a pre-built node-oracledb binary was not found for %s');
messages.set(ERR_INVALID_ERR_NUM,
'invalid error number %d supplied');
messages.set(ERR_NODE_TOO_OLD,
'node-oracledb %s requires Node.js %s or later');
messages.set(ERR_INVALID_AQ_MESSAGE,
'message must be a string, buffer, database object or an object ' +
'containing a payload property which itself is a string, buffer or ' +
'database object');
messages.set(ERR_CONVERT_FROM_OBJ_ELEMENT,
'cannot convert from element of type "%s" to JavaScript value');
messages.set(ERR_CONVERT_FROM_OBJ_ATTR,
'cannot convert from attribute "%s" of type "%s" to JavaScript value');
messages.set(ERR_CONVERT_TO_OBJ_ELEMENT,
'cannot convert from JavaScript value to element of type %s');
messages.set(ERR_CONVERT_TO_OBJ_ATTR,
'cannot convert from JavaScript value to attribute "%s" of type "%s"');
messages.set(ERR_DBL_CONNECT_STRING,
'only one of connectString and connectionString can be used');
messages.set(ERR_QUEUE_MAX_EXCEEDED,
'connection request rejected. Pool queue length queueMax %d reached');
messages.set(ERR_CLIENT_LIB_ALREADY_INITIALIZED,
'Oracle Client library has already been initialized');
messages.set(ERR_UNSUPPORTED_DATA_TYPE_IN_JSON,
'unsupported data type %d in JSON value');
messages.set(ERR_CONVERT_TO_JSON_VALUE,
'cannot convert from JavaScript value to JSON value');
messages.set(ERR_DBL_USER,
'only one of user and username can be used');
messages.set(ERR_CONCURRENT_OPS,
'concurrent operations on a connection are disabled');
messages.set(ERR_POOL_RECONFIGURING,
'connection pool is being reconfigured');
messages.set(ERR_POOL_STATISTICS_DISABLED,
'pool statistics not enabled');
messages.set(ERR_TOKEN_BASED_AUTH,
'invalid or missing parameter with token based authentication. ' +
'The token and privateKey attributes must contain values. ' +
'Other credentials cannot be specified');
messages.set(ERR_POOL_TOKEN_BASED_AUTH,
'invalid connection pool configuration with token based authentication. ' +
'The homogeneous and externalAuth attributes must be set to true');
messages.set(ERR_CONN_TOKEN_BASED_AUTH,
'invalid standalone configuration with token based authentication. ' +
'The externalAuth attribute must be set to true');
messages.set(ERR_TOKEN_HAS_EXPIRED,
'access token has expired');
messages.set(ERR_TOKEN_CALLBACK_DUP,
'accessTokenCallback cannot be specified when accessToken is a function');
//-----------------------------------------------------------------------------
// assert()
//
// Checks the condition, and if the condition is not true, throws an exception
// using the specified error number and arguments.
//-----------------------------------------------------------------------------
function assert(condition) {
if (!condition) {
const args = Array.prototype.slice.call(arguments, 1);
throwErr(...args);
}
}
//-----------------------------------------------------------------------------
// assertArgCount()
//
// Asserts that the argument count falls between the minimum and maximum number
// of arguments.
//-----------------------------------------------------------------------------
function assertArgCount(args, minArgCount, maxArgCount) {
assert(args.length >= minArgCount && args.length <= maxArgCount,
ERR_INVALID_NUMBER_OF_PARAMETERS);
}
//-----------------------------------------------------------------------------
// assertParamPropValue()
//
// Asserts that the property value of a parmeter passes the specified
// condition.
//-----------------------------------------------------------------------------
function assertParamPropValue(condition, parameterNum, propName) {
assert(condition, ERR_INVALID_PROPERTY_VALUE_IN_PARAM, propName,
parameterNum);
}
//-----------------------------------------------------------------------------
// assertParamValue()
//
// Asserts that the parmeter value passes the specified condition.
//-----------------------------------------------------------------------------
function assertParamValue(condition, parameterNum) {
assert(condition, ERR_INVALID_PARAMETER_VALUE, parameterNum);
}
//-----------------------------------------------------------------------------
// assertPropValue()
//
// Asserts that the property value passes the specified condition.
//-----------------------------------------------------------------------------
function assertPropValue(condition, propName) {
assert(condition, ERR_INVALID_PROPERTY_VALUE, propName);
}
//-----------------------------------------------------------------------------
// throwErr()
//
// Throws an error with the given error number after formatting it with the
// given arguments.
//-----------------------------------------------------------------------------
function throwErr(errorNum) {
let baseText = messages.get(errorNum);
if (!baseText)
baseText = messages.get(ERR_INVALID_ERR_NUM);
const errorNumStr = errorNum.toString().padStart(3, '0');
const args = [...arguments];
args[0] = `${ERR_PREFIX}-${errorNumStr}: ${baseText}`;
throw new Error(util.format(...args));
}
// define exports
module.exports = {
ERR_MISSING_CALLBACK,
ERR_INVALID_POOL,
ERR_INVALID_CONNECTION,
ERR_INVALID_PROPERTY_VALUE,
ERR_INVALID_PARAMETER_VALUE,
ERR_INVALID_PROPERTY_VALUE_IN_PARAM,
ERR_INVALID_NUMBER_OF_PARAMETERS,
ERR_UNSUPPORTED_DATA_TYPE,
ERR_BIND_VALUE_AND_TYPE_MISMATCH,
ERR_INVALID_BIND_DATA_TYPE,
ERR_INVALID_BIND_DIRECTION,
ERR_NO_TYPE_FOR_CONVERSION,
ERR_INSUFFICENT_BUFFER_FOR_BINDS,
ERR_BUSY_RS,
ERR_INVALID_RS,
ERR_NOT_A_QUERY,
ERR_INVALID_TYPE_FOR_CONVERSION,
ERR_INVALID_LOB,
ERR_BUSY_LOB,
ERR_INSUFFICIENT_MEMORY,
ERR_INVALID_TYPE_FOR_ARRAY_BIND,
ERR_REQUIRED_MAX_ARRAY_SIZE,
ERR_INVALID_ARRAY_SIZE,
ERR_INCOMPATIBLE_TYPE_ARRAY_BIND,
ERR_CONN_REQUEST_TIMEOUT,
ERR_CANNOT_CONVERT_RS_TO_STREAM,
ERR_CANNOT_INVOKE_RS_METHODS,
ERR_RS_ALREADY_CONVERTED,
ERR_INVALID_BIND_UNIT,
ERR_CANNOT_LOAD_BINARY,
ERR_POOL_WITH_ALIAS_ALREADY_EXISTS,
ERR_POOL_WITH_ALIAS_NOT_FOUND,
ERR_INCOMPATIBLE_TYPE_ARRAY_INDEX_BIND,
ERR_NON_ARRAY_PROVIDED,
ERR_MIXED_BIND,
ERR_MISSING_MAX_SIZE_BY_POS,
ERR_MISSING_MAX_SIZE_BY_NAME,
ERR_MAX_SIZE_TOO_SMALL,
ERR_MISSING_TYPE_BY_POS,
ERR_MISSING_TYPE_BY_NAME,
ERR_INVALID_SUBSCR,
ERR_MISSING_SUBSCR_CALLBACK,
ERR_MISSING_SUBSCR_SQL,
ERR_POOL_CLOSING,
ERR_POOL_CLOSED,
ERR_INVALID_SODA_DOC_CURSOR,
ERR_NO_BINARY_AVAILABLE,
ERR_INVALID_ERR_NUM,
ERR_NODE_TOO_OLD,
ERR_INVALID_AQ_MESSAGE,
ERR_CONVERT_FROM_OBJ_ELEMENT,
ERR_CONVERT_FROM_OBJ_ATTR,
ERR_CONVERT_TO_OBJ_ELEMENT,
ERR_CONVERT_TO_OBJ_ATTR,
ERR_DBL_CONNECT_STRING,
ERR_QUEUE_MAX_EXCEEDED,
ERR_CLIENT_LIB_ALREADY_INITIALIZED,
ERR_UNSUPPORTED_DATA_TYPE_IN_JSON,
ERR_CONVERT_TO_JSON_VALUE,
ERR_DBL_USER,
ERR_CONCURRENT_OPS,
ERR_POOL_RECONFIGURING,
ERR_POOL_STATISTICS_DISABLED,
ERR_TOKEN_BASED_AUTH,
ERR_POOL_TOKEN_BASED_AUTH,
ERR_CONN_TOKEN_BASED_AUTH,
assert,
assertArgCount,
assertParamPropValue,
assertParamValue,
assertPropValue,
throwErr
};

7
lib/lob.js
View File

@ -22,6 +22,7 @@
const { Duplex } = require('stream'); const { Duplex } = require('stream');
const Connection = require('./connection.js'); const Connection = require('./connection.js');
const constants = require('./constants.js'); const constants = require('./constants.js');
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
class Lob extends Duplex { class Lob extends Duplex {
@ -119,7 +120,7 @@ class Lob extends Duplex {
// versions of node-oracledb. // versions of node-oracledb.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async close() { async close() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
if (this.valid) { if (this.valid) {
try { try {
await this._close(); await this._close();
@ -135,7 +136,7 @@ class Lob extends Duplex {
// Returns all of the data in the LOB as a single string or buffer. // Returns all of the data in the LOB as a single string or buffer.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getData() { async getData() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._getData(); return await this._getData();
} }
@ -151,7 +152,7 @@ class Lob extends Duplex {
} }
nodbUtil.wrap_fns(Lob.prototype, "NJS-023", nodbUtil.wrap_fns(Lob.prototype, errors.ERR_BUSY_LOB,
"close", "close",
"getData"); "getData");
Lob.prototype._serializedRead = nodbUtil.serialize(Lob.prototype.readData); Lob.prototype._serializedRead = nodbUtil.serialize(Lob.prototype.readData);

122
lib/oracledb.js
View File

@ -21,15 +21,15 @@
const constants = require('./constants.js'); const constants = require('./constants.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
const errors = require('./errors.js');
const util = require('util'); const util = require('util');
// This version of node-oracledb works with Node.js 14 or later. The test // This version of node-oracledb works with Node.js 14 or later. The test
// stops hard-to-interpret runtime errors and crashes with older Node.js // stops hard-to-interpret runtime errors and crashes with older Node.js
// versions. // versions.
let vs = process.version.substring(1).split(".").map(Number); let vs = process.version.substring(1).split(".").map(Number);
if (vs[0] < 14) { errors.assert(vs[0] >= 14, errors.ERR_NODE_TOO_OLD,
throw new Error(nodbUtil.getErrorMessage('NJS-069', nodbUtil.PACKAGE_JSON_VERSION, "14.0")); nodbUtil.PACKAGE_JSON_VERSION, "14.0");
}
const AqDeqOptions = require('./aqDeqOptions.js'); const AqDeqOptions = require('./aqDeqOptions.js');
const AqEnqOptions = require('./aqEnqOptions.js'); const AqEnqOptions = require('./aqEnqOptions.js');
@ -86,7 +86,7 @@ for (let i = 0; i < binaryLocations.length; i++) {
} else { } else {
nodeInfo = `\n Node.js require('oracledb') error was:\n ${err.message}\n ${nodbUtil.getInstallHelp()}\n`; nodeInfo = `\n Node.js require('oracledb') error was:\n ${err.message}\n ${nodbUtil.getInstallHelp()}\n`;
} }
throw new Error(nodbUtil.getErrorMessage('NJS-045', nodeInfo)); errors.throwErr(errors.ERR_CANNOT_LOAD_BINARY, nodeInfo);
} }
} }
} }
@ -101,14 +101,11 @@ async function createPool(poolAttrs) {
let poolAlias; let poolAlias;
// check arguments // check arguments
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(poolAttrs), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(poolAttrs), 1);
if (poolAttrs.poolAlias !== undefined) { if (poolAttrs.poolAlias !== undefined) {
if (typeof poolAttrs.poolAlias !== 'string' || errors.assertParamPropValue(typeof poolAttrs.poolAlias === 'string' &&
poolAttrs.poolAlias.length === 0) { poolAttrs.poolAlias.length !== 0, 1, "poolAlias");
throw new Error(nodbUtil.getErrorMessage('NJS-004',
'poolAttrs.poolAlias'));
}
poolAlias = poolAttrs.poolAlias; poolAlias = poolAttrs.poolAlias;
} else if (poolAttrs.poolAlias === undefined } else if (poolAttrs.poolAlias === undefined
&& !poolCache[defaultPoolAlias] && !poolCache[defaultPoolAlias]
@ -116,20 +113,20 @@ async function createPool(poolAttrs) {
poolAlias = defaultPoolAlias; poolAlias = defaultPoolAlias;
} }
if (poolCache[poolAlias] || tempUsedPoolAliases[poolAlias]) { if (poolCache[poolAlias] || tempUsedPoolAliases[poolAlias]) {
throw new Error(nodbUtil.getErrorMessage('NJS-046', poolAlias)); errors.throwErr(errors.ERR_POOL_WITH_ALIAS_ALREADY_EXISTS, poolAlias);
} }
if (poolAttrs.accessToken !== undefined) { if (poolAttrs.accessToken !== undefined) {
// cannot set username or password for token based authentication // cannot set username or password for token based authentication
if (poolAttrs.user !== undefined || if (poolAttrs.user !== undefined ||
poolAttrs.password !== undefined) { poolAttrs.password !== undefined) {
throw new Error(nodbUtil.getErrorMessage('NJS-084')); errors.throwErr(errors.ERR_TOKEN_BASED_AUTH);
} }
// homogeneous and externalAuth must be set to true for token based // homogeneous and externalAuth must be set to true for token based
// authentication // authentication
if (poolAttrs.homogeneous === false || if (poolAttrs.homogeneous === false ||
poolAttrs.externalAuth === false) { poolAttrs.externalAuth === false) {
throw new Error(nodbUtil.getErrorMessage('NJS-085')); errors.throwErr(errors.ERR_POOL_TOKEN_BASED_AUTH);
} }
} }
@ -152,12 +149,10 @@ async function createPool(poolAttrs) {
// token based authentication // token based authentication
if (poolAttrs.accessToken !== undefined) { if (poolAttrs.accessToken !== undefined) {
// accessTokenCallback is depricated from node-oracledb 5.5
if (poolAttrs.accessTokenCallback !== undefined && if (poolAttrs.accessTokenCallback !== undefined &&
typeof poolAttrs.accessToken === 'function') { typeof poolAttrs.accessToken === 'function') {
throw new Error(nodbUtil.getErrorMessage('NJS-088')); errors.throwErr(errors.ERR_TOKEN_CALLBACK_DUP);
} }
await nodbUtil.checkToken(adjustedPoolAttrs); await nodbUtil.checkToken(adjustedPoolAttrs);
if (typeof poolAttrs.accessToken === 'function') { if (typeof poolAttrs.accessToken === 'function') {
adjustedPoolAttrs.accessTokenCallback = poolAttrs.accessToken; adjustedPoolAttrs.accessTokenCallback = poolAttrs.accessToken;
@ -212,12 +207,11 @@ async function getConnection(a1) {
let connAttrs = {}; let connAttrs = {};
// verify the number and types of arguments // verify the number and types of arguments
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 0) { if (arguments.length == 0) {
poolAlias = defaultPoolAlias; poolAlias = defaultPoolAlias;
} else { } else {
nodbUtil.assert(typeof a1 === 'string' || nodbUtil.isObject(a1), errors.assertParamValue(typeof a1 === 'string' || nodbUtil.isObject(a1), 1);
'NJS-005', 1);
if (typeof a1 === 'string') { if (typeof a1 === 'string') {
poolAlias = a1; poolAlias = a1;
} else { } else {
@ -232,7 +226,7 @@ async function getConnection(a1) {
if (poolAlias) { if (poolAlias) {
pool = poolCache[poolAlias]; pool = poolCache[poolAlias];
if (!pool) { if (!pool) {
throw new Error(nodbUtil.getErrorMessage('NJS-047', poolAlias)); errors.throwErr(errors.ERR_POOL_WITH_ALIAS_NOT_FOUND, poolAlias);
} }
return await pool.getConnection(connAttrs); return await pool.getConnection(connAttrs);
@ -242,12 +236,12 @@ async function getConnection(a1) {
// cannot set username or password for token based authentication // cannot set username or password for token based authentication
if (connAttrs.user !== undefined || if (connAttrs.user !== undefined ||
connAttrs.password !== undefined) { connAttrs.password !== undefined) {
throw new Error(nodbUtil.getErrorMessage('NJS-084')); errors.throwErr(errors.ERR_TOKEN_BASED_AUTH);
} }
// externalAuth must be set to true for token based authentication // externalAuth must be set to true for token based authentication
if (connAttrs.externalAuth === false) { if (connAttrs.externalAuth === false) {
throw new Error(nodbUtil.getErrorMessage('NJS-086')); errors.throwErr(errors.ERR_CONN_TOKEN_BASED_AUTH);
} }
await nodbUtil.checkToken(connAttrs); await nodbUtil.checkToken(connAttrs);
@ -271,10 +265,11 @@ async function getConnection(a1) {
function getPool(poolAlias) { function getPool(poolAlias) {
let pool; let pool;
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (poolAlias) { if (poolAlias) {
nodbUtil.assert(typeof poolAlias === 'string' || typeof poolAlias === 'number', 'NJS-005', 1); errors.assertParamValue(typeof poolAlias === 'string' ||
typeof poolAlias === 'number', 1);
} }
poolAlias = poolAlias || defaultPoolAlias; poolAlias = poolAlias || defaultPoolAlias;
@ -282,7 +277,7 @@ function getPool(poolAlias) {
pool = poolCache[poolAlias]; pool = poolCache[poolAlias];
if (!pool) { if (!pool) {
throw new Error(nodbUtil.getErrorMessage('NJS-047', poolAlias)); errors.throwErr(errors.ERR_POOL_WITH_ALIAS_NOT_FOUND, poolAlias);
} }
return pool; return pool;
@ -295,9 +290,9 @@ function getPool(poolAlias) {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
function initOracleClient(arg1) { function initOracleClient(arg1) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arg1 !== undefined) { if (arg1 !== undefined) {
nodbUtil.assert(nodbUtil.isObject(arg1), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(arg1), 1);
options = arg1; options = arg1;
} }
if (_initOracleClientArgs === undefined) { if (_initOracleClientArgs === undefined) {
@ -332,14 +327,14 @@ async function shutdown(a1, a2) {
let shutdownMode = constants.SHUTDOWN_MODE_DEFAULT; let shutdownMode = constants.SHUTDOWN_MODE_DEFAULT;
// verify the number and types of arguments // verify the number and types of arguments
nodbUtil.checkArgCount(arguments, 0, 2); errors.assertArgCount(arguments, 0, 2);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(typeof a1 === 'object', 'NJS-005', 1); errors.assertParamValue(typeof a1 === 'object', 1);
nodbUtil.assert(typeof a2 === 'number', 'NJS-005', 2); errors.assertParamValue(typeof a2 === 'number', 2);
connAttr = a1; connAttr = a1;
shutdownMode = a2; shutdownMode = a2;
} else if (arguments.length == 1) { } else if (arguments.length == 1) {
nodbUtil.assert(typeof a1 === 'object', 'NJS-005', 1); errors.assertParamValue(typeof a1 === 'object', 1);
connAttr = a1; connAttr = a1;
} }
@ -375,14 +370,14 @@ async function startup(a1, a2) {
let startupAttr = {}; let startupAttr = {};
// verify the number and types of arguments // verify the number and types of arguments
nodbUtil.checkArgCount(arguments, 0, 2); errors.assertArgCount(arguments, 0, 2);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert (typeof a1 === 'object', 'NJS-005', 1); errors.assertParamValue(typeof a1 === 'object', 1);
nodbUtil.assert (typeof a2 === 'object', 'NJS-005', 2); errors.assertParamValue(typeof a2 === 'object', 2);
connAttr = a1; connAttr = a1;
startupAttr = a2; startupAttr = a2;
} else if (arguments.length == 1) { } else if (arguments.length == 1) {
nodbUtil.assert(typeof a1 === 'object', 'NJS-005', 1); errors.assertParamValue(typeof a1 === 'object', 1);
connAttr = a1; connAttr = a1;
} }
@ -731,140 +726,133 @@ module.exports = {
// property setters // property setters
set autoCommit(value) { set autoCommit(value) {
nodbUtil.assert(typeof value === 'boolean', 'NJS-004', "autoCommit"); errors.assertPropValue(typeof value === 'boolean', "autoCommit");
settings.autoCommit = value; settings.autoCommit = value;
}, },
set connectionClass(value) { set connectionClass(value) {
nodbUtil.assert(typeof value === 'string', 'NJS-004', "connectionClass"); errors.assertPropValue(typeof value === 'string', "connectionClass");
settings.connectionClass = value; settings.connectionClass = value;
}, },
set dbObjectAsPojo(value) { set dbObjectAsPojo(value) {
nodbUtil.assert(typeof value === 'boolean', 'NJS-004', "dbObjectAsPojo"); errors.assertPropValue(typeof value === 'boolean', "dbObjectAsPojo");
settings.dbObjectAsPojo = value; settings.dbObjectAsPojo = value;
}, },
set edition(value) { set edition(value) {
nodbUtil.assert(typeof value === 'string', 'NJS-004', "edition"); errors.assertPropValue(typeof value === 'string', "edition");
settings.edition = value; settings.edition = value;
}, },
set errorOnConcurrentExecute(value) { set errorOnConcurrentExecute(value) {
nodbUtil.assert(typeof value === 'boolean', 'NJS-004', errors.assertPropValue(typeof value === 'boolean',
"errorOnConcurrentExecute"); "errorOnConcurrentExecute");
settings.errorOnConcurrentExecute = value; settings.errorOnConcurrentExecute = value;
}, },
set events(value) { set events(value) {
nodbUtil.assert(typeof value === 'boolean', 'NJS-004', "events"); errors.assertPropValue(typeof value === 'boolean', "events");
settings.events = value; settings.events = value;
}, },
set externalAuth(value) { set externalAuth(value) {
nodbUtil.assert(typeof value === 'boolean', 'NJS-004', "externalAuth"); errors.assertPropValue(typeof value === 'boolean', "externalAuth");
settings.externalAuth = value; settings.externalAuth = value;
}, },
set fetchArraySize(value) { set fetchArraySize(value) {
nodbUtil.assert(Number.isInteger(value) && value > 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value > 0,
"fetchArraySize"); "fetchArraySize");
settings.fetchArraySize = value; settings.fetchArraySize = value;
}, },
set fetchAsBuffer(value) { set fetchAsBuffer(value) {
nodbUtil.assert(Array.isArray(value), 'NJS-004', "fetchAsBuffer"); errors.assertPropValue(Array.isArray(value), "fetchAsBuffer");
for (const element of value) { for (const element of value) {
nodbUtil.assert(Number.isInteger(element) && element > 0, 'NJS-004',
"fetchAsBuffer");
if (element !== constants.DB_TYPE_BLOB) { if (element !== constants.DB_TYPE_BLOB) {
throw new Error(nodbUtil.getErrorMessage('NJS-021')); errors.throwErr(errors.ERR_INVALID_TYPE_FOR_CONVERSION);
} }
} }
settings.fetchAsBuffer = value; settings.fetchAsBuffer = value;
}, },
set fetchAsString(value) { set fetchAsString(value) {
nodbUtil.assert(Array.isArray(value), 'NJS-004', "fetchAsString"); errors.assertPropValue(Array.isArray(value), "fetchAsString");
for (const element of value) { for (const element of value) {
nodbUtil.assert(Number.isInteger(element) && element > 0, 'NJS-004',
"fetchAsString");
if (element != constants.DB_TYPE_NUMBER && if (element != constants.DB_TYPE_NUMBER &&
element != constants.DB_TYPE_TIMESTAMP_LTZ && element != constants.DB_TYPE_TIMESTAMP_LTZ &&
element != constants.DB_TYPE_RAW && element != constants.DB_TYPE_RAW &&
element != constants.DB_TYPE_CLOB && element != constants.DB_TYPE_CLOB &&
element != constants.DB_TYPE_NCLOB && element != constants.DB_TYPE_NCLOB &&
element != constants.DB_TYPE_JSON) { element != constants.DB_TYPE_JSON) {
throw new Error(nodbUtil.getErrorMessage('NJS-021')); errors.throwErr(errors.ERR_INVALID_TYPE_FOR_CONVERSION);
} }
} }
settings.fetchAsString = value; settings.fetchAsString = value;
}, },
set lobPrefetchSize(value) { set lobPrefetchSize(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0,
"lobPrefetchSize"); "lobPrefetchSize");
settings.lobPrefetchSize = value; settings.lobPrefetchSize = value;
}, },
set maxRows(value) { set maxRows(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0, "maxRows");
"maxRows");
settings.maxRows = value; settings.maxRows = value;
}, },
set outFormat(value) { set outFormat(value) {
if (value !== constants.OUT_FORMAT_ARRAY && if (value !== constants.OUT_FORMAT_ARRAY &&
value !== constants.OUT_FORMAT_OBJECT) { value !== constants.OUT_FORMAT_OBJECT) {
throw new Error(nodbUtil.getErrorMessage('NJS-004', "outFormat")); errors.throwErr(errors.ERR_INVALID_PROPERTY_VALUE, "outFormat");
} }
settings.outFormat = value; settings.outFormat = value;
}, },
set poolIncrement(value) { set poolIncrement(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0,
"poolIncrement"); "poolIncrement");
settings.poolIncrement = value; settings.poolIncrement = value;
}, },
set poolMax(value) { set poolMax(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0, "poolMax");
"poolMax");
settings.poolMax = value; settings.poolMax = value;
}, },
set poolMaxPerShard(value) { set poolMaxPerShard(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0,
"poolMaxPerShard"); "poolMaxPerShard");
settings.poolMaxPerShard = value; settings.poolMaxPerShard = value;
}, },
set poolMin(value) { set poolMin(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0, "poolMin");
"poolMin");
settings.poolMin = value; settings.poolMin = value;
}, },
set poolPingInterval(value) { set poolPingInterval(value) {
nodbUtil.assert(Number.isInteger(value) && value < 2 ** 31 && errors.assertPropValue(Number.isInteger(value) && value < 2 ** 31 &&
value >= (-2) ** 31, 'NJS-004', "poolPingInterval"); value >= (-2) ** 31, "poolPingInterval");
settings.poolPingInterval = value; settings.poolPingInterval = value;
}, },
set poolTimeout(value) { set poolTimeout(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0,
"poolTimeout"); "poolTimeout");
settings.poolTimeout = value; settings.poolTimeout = value;
}, },
set prefetchRows(value) { set prefetchRows(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0,
"prefetchRows"); "prefetchRows");
settings.prefetchRows = value; settings.prefetchRows = value;
}, },
set stmtCacheSize(value) { set stmtCacheSize(value) {
nodbUtil.assert(Number.isInteger(value) && value >= 0, 'NJS-004', errors.assertPropValue(Number.isInteger(value) && value >= 0,
"stmtCacheSize"); "stmtCacheSize");
settings.stmtCacheSize = value; settings.stmtCacheSize = value;
}, },

46
lib/pool.js
View File

@ -21,6 +21,7 @@
const EventEmitter = require('events'); const EventEmitter = require('events');
const constants = require('./constants.js'); const constants = require('./constants.js');
const errors = require('./errors.js');
const settings = require('./settings.js'); const settings = require('./settings.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
const PoolStatistics = require('./poolStatistics.js'); const PoolStatistics = require('./poolStatistics.js');
@ -68,14 +69,13 @@ class Pool extends EventEmitter {
// appropriate exception if not. // appropriate exception if not.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
_checkPoolOpen(ignoreReconfiguring) { _checkPoolOpen(ignoreReconfiguring) {
// if already in reconfiguring status, nothing to do.
if (this.status === constants.POOL_STATUS_DRAINING) { if (this.status === constants.POOL_STATUS_DRAINING) {
throw new Error(nodbUtil.getErrorMessage('NJS-064')); errors.throwErr(errors.ERR_POOL_CLOSING);
} else if (this.status === constants.POOL_STATUS_CLOSED) { } else if (this.status === constants.POOL_STATUS_CLOSED) {
throw new Error(nodbUtil.getErrorMessage('NJS-065')); errors.throwErr(errors.ERR_POOL_CLOSED);
} else if (!ignoreReconfiguring) { } else if (!ignoreReconfiguring) {
if (this.status === constants.POOL_STATUS_RECONFIGURING) { if (this.status === constants.POOL_STATUS_RECONFIGURING) {
throw new Error(nodbUtil.getErrorMessage('NJS-082')); errors.throwErr(errors.ERR_POOL_RECONFIGURING);
} }
} }
} }
@ -294,14 +294,14 @@ class Pool extends EventEmitter {
let forceClose = false; let forceClose = false;
// check arguments // check arguments
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
// drain time must be a valid number; timeouts larger than a 32-bit signed // drain time must be a valid number; timeouts larger than a 32-bit signed
// integer are not supported // integer are not supported
nodbUtil.assert(typeof a1 === 'number', 'NJS-005', 1); errors.assertParamValue(typeof a1 === 'number', 1);
if (a1 < 0 || isNaN(a1) || a1 > 2 ** 31) { if (a1 < 0 || isNaN(a1) || a1 > 2 ** 31) {
throw new Error(nodbUtil.getErrorMessage('NJS-005', 1)); errors.throwErr(errors.ERR_INVALID_PARAMETER_VALUE, 1);
} }
// no need to worry about drain time if no connections are out! // no need to worry about drain time if no connections are out!
@ -349,7 +349,7 @@ class Pool extends EventEmitter {
logStatistics() { logStatistics() {
const stats = this.getStatistics(); const stats = this.getStatistics();
if (stats === null) { if (stats === null) {
throw new Error(nodbUtil.getErrorMessage('NJS-083')); errors.throwErr(errors.ERR_POOL_STATISTICS_DISABLED);
} }
stats.logStatistics(); stats.logStatistics();
} }
@ -367,9 +367,9 @@ class Pool extends EventEmitter {
let options = {}; let options = {};
// check arguments // check arguments
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
nodbUtil.assert(nodbUtil.isObject(a1), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(a1), 1);
options = a1; options = a1;
} }
@ -402,7 +402,7 @@ class Pool extends EventEmitter {
if (this._enableStatistics) { if (this._enableStatistics) {
this._totalRequestsRejected += 1; this._totalRequestsRejected += 1;
} }
throw new Error(nodbUtil.getErrorMessage('NJS-076', this._queueMax)); errors.throwErr(errors.ERR_QUEUE_MAX_EXCEEDED, this._queueMax);
} }
// if too many connections are out, wait until room is made available or // if too many connections are out, wait until room is made available or
@ -425,8 +425,12 @@ class Pool extends EventEmitter {
this._totalRequestTimeouts += 1; this._totalRequestTimeouts += 1;
this._updateWaitStatistics(payload); this._updateWaitStatistics(payload);
} }
reject(new Error(nodbUtil.getErrorMessage('NJS-040', try {
this._queueTimeout))); errors.throwErr(errors.ERR_CONN_REQUEST_TIMEOUT,
this._queueTimeout);
} catch (err) {
reject(err);
}
}, this._queueTimeout); }, this._queueTimeout);
} }
@ -524,27 +528,27 @@ class Pool extends EventEmitter {
async reconfigure(options) { async reconfigure(options) {
// check arguments // check arguments
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(options)); errors.assertParamValue(nodbUtil.isObject(options));
// reconfiguration can happen only when status is OPEN // reconfiguration can happen only when status is OPEN
this._checkPoolOpen(false); this._checkPoolOpen(false);
if ((options.queueMax !== undefined) && if ((options.queueMax !== undefined) &&
(typeof options.queueMax !== "number")) (typeof options.queueMax !== "number"))
throw new Error(nodbUtil.getErrorMessage('NJS-004', "queueMax")); errors.throwErr(errors.ERR_INVALID_PROPERTY_VALUE, "queueMax");
if ((options.queueTimeout !== undefined) && if ((options.queueTimeout !== undefined) &&
(typeof options.queueTimeout !== "number")) (typeof options.queueTimeout !== "number"))
throw new Error(nodbUtil.getErrorMessage('NJS-004', "queueTimeout")); errors.throwErr(errors.ERR_INVALID_PROPERTY_VALUE, "queueTimeout");
if ((options.enableStatistics !== undefined) && if ((options.enableStatistics !== undefined) &&
(typeof options.enableStatistics !== "boolean")) (typeof options.enableStatistics !== "boolean"))
throw new Error(nodbUtil.getErrorMessage('NJS-004', "enableStatistics")); errors.throwErr(errors.ERR_INVALID_PROPERTY_VALUE, "enableStatistics");
if ((options.resetStatistics !== undefined) && if ((options.resetStatistics !== undefined) &&
(typeof options.resetStatistics != "boolean")) (typeof options.resetStatistics != "boolean"))
throw new Error(nodbUtil.getErrorMessage('NJS-004', "resetStatistics")); errors.throwErr(errors.ERR_INVALID_PROPERTY_VALUE, "resetStatistics");
this._status = constants.POOL_STATUS_RECONFIGURING; this._status = constants.POOL_STATUS_RECONFIGURING;
try { try {
@ -586,8 +590,8 @@ class Pool extends EventEmitter {
// Set parameters for token based authentication. // Set parameters for token based authentication.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async setAccessToken(options) { async setAccessToken(options) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(options), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(options), 1);
await this._setAccessToken(options); await this._setAccessToken(options);
} }

26
lib/resultset.js
View File

@ -21,8 +21,9 @@
const QueryStream = require('./queryStream.js'); const QueryStream = require('./queryStream.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
const settings = require('./settings.js');
const constants = require('./constants.js'); const constants = require('./constants.js');
const errors = require('./errors.js');
const settings = require('./settings.js');
const Connection = require('./connection.js'); const Connection = require('./connection.js');
class ResultSet { class ResultSet {
@ -132,10 +133,10 @@ class ResultSet {
// Close the result set and make it unusable for further operations. // Close the result set and make it unusable for further operations.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async close() { async close() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
if (this._convertedToStream) { if (this._convertedToStream) {
throw new Error(nodbUtil.getErrorMessage('NJS-042')); errors.throwErr(errors.ERR_CANNOT_INVOKE_RS_METHODS);
} }
this._processingStarted = true; this._processingStarted = true;
@ -150,10 +151,10 @@ class ResultSet {
// through the thread pool that would be required if implemented in C. // through the thread pool that would be required if implemented in C.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getRow() { async getRow() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
if (this._convertedToStream && !this._allowGetRowCall) { if (this._convertedToStream && !this._allowGetRowCall) {
throw new Error(nodbUtil.getErrorMessage('NJS-042')); errors.throwErr(errors.ERR_CANNOT_INVOKE_RS_METHODS);
} }
this._allowGetRowCall = false; this._allowGetRowCall = false;
@ -177,17 +178,16 @@ class ResultSet {
async getRows(numRows) { async getRows(numRows) {
let rowsNeeded; let rowsNeeded;
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 0) { if (arguments.length == 0) {
numRows = 0; numRows = 0;
} else { } else {
nodbUtil.assert(Number.isInteger(numRows), 'NJS-005', 1); errors.assertParamValue(Number.isInteger(numRows) && numRows >= 0, 1);
nodbUtil.assert(numRows >= 0, 'NJS-005', 1);
} }
if (this._convertedToStream) { if (this._convertedToStream) {
throw new Error(nodbUtil.getErrorMessage('NJS-042')); errors.throwErr(errors.ERR_CANNOT_INVOKE_RS_METHODS);
} }
this._processingStarted = true; this._processingStarted = true;
@ -227,14 +227,14 @@ class ResultSet {
// Converts a result set to a QueryStream object. // Converts a result set to a QueryStream object.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
toQueryStream() { toQueryStream() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
if (this._processingStarted) { if (this._processingStarted) {
throw new Error(nodbUtil.getErrorMessage('NJS-041')); errors.throwErr(errors.ERR_CANNOT_CONVERT_RS_TO_STREAM);
} }
if (this._convertedToStream) { if (this._convertedToStream) {
throw new Error(nodbUtil.getErrorMessage('NJS-043')); errors.throwErr(errors.ERR_RS_ALREADY_CONVERTED);
} }
this._convertedToStream = true; this._convertedToStream = true;
@ -257,7 +257,7 @@ class ResultSet {
} }
nodbUtil.wrap_fns(ResultSet.prototype, "NJS-017", nodbUtil.wrap_fns(ResultSet.prototype, errors.ERR_BUSY_RS,
"close", "close",
"getRow", "getRow",
"getRows"); "getRows");

65
lib/sodaCollection.js
View File

@ -19,6 +19,7 @@
'use strict'; 'use strict';
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
class SodaCollection { class SodaCollection {
@ -28,7 +29,7 @@ class SodaCollection {
} }
find() { find() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return this._find(); return this._find();
} }
@ -42,8 +43,8 @@ class SodaCollection {
// Create an index on the collection. // Create an index on the collection.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async createIndex(spec) { async createIndex(spec) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(spec), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(spec), 1);
return await this._createIndex(JSON.stringify(spec)); return await this._createIndex(JSON.stringify(spec));
} }
@ -53,7 +54,7 @@ class SodaCollection {
// Drop the collection. // Drop the collection.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async drop() { async drop() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._drop(); return await this._drop();
} }
@ -65,10 +66,10 @@ class SodaCollection {
async dropIndex(indexName, a2) { async dropIndex(indexName, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(typeof indexName === 'string', 'NJS-005', 1); errors.assertParamValue(typeof indexName === 'string', 1);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(typeof a2 === 'object', 'NJS-005', 2); errors.assertParamValue(typeof a2 === 'object', 2);
options = a2; options = a2;
} }
@ -80,7 +81,7 @@ class SodaCollection {
// Return the data guide for the collection. // Return the data guide for the collection.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getDataGuide() { async getDataGuide() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._getDataGuide(); return await this._getDataGuide();
} }
@ -90,12 +91,8 @@ class SodaCollection {
// Insert an array of documents into the collection in a single round-trip. // Insert an array of documents into the collection in a single round-trip.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async insertMany(docs) { async insertMany(docs) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(Array.isArray(docs), 'NJS-005', 1); errors.assertParamValue(Array.isArray(docs) && docs.length > 0, 1);
if (docs.length == 0) {
throw new Error(nodbUtil.getErrorMessage('NJS-005', 1));
}
let actualDocs = Array(docs.length); let actualDocs = Array(docs.length);
for (let i = 0; i < docs.length; i++) { for (let i = 0; i < docs.length; i++) {
@ -118,18 +115,14 @@ class SodaCollection {
async insertManyAndGet(docs, a2) { async insertManyAndGet(docs, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(Array.isArray(docs), 'NJS-005', 1); errors.assertParamValue(Array.isArray(docs) && docs.length > 0, 1);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(nodbUtil.isObject(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(a2), 2);
options = a2; options = a2;
} }
if (docs.length == 0) {
throw new Error(nodbUtil.getErrorMessage('NJS-005', 1));
}
let actualDocs = Array(docs.length); let actualDocs = Array(docs.length);
for (let i = 0; i < docs.length; i++) { for (let i = 0; i < docs.length; i++) {
let content = docs[i]; let content = docs[i];
@ -148,9 +141,9 @@ class SodaCollection {
// Inserts a single document into the collection. // Inserts a single document into the collection.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async insertOne(content) { async insertOne(content) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(content) || errors.assertParamValue(nodbUtil.isObject(content) ||
nodbUtil.isSodaDocument(content), 'NJS-005', 1); nodbUtil.isSodaDocument(content), 1);
if (!nodbUtil.isSodaDocument(content)) { if (!nodbUtil.isSodaDocument(content)) {
content = Buffer.from(JSON.stringify(content)); content = Buffer.from(JSON.stringify(content));
@ -168,12 +161,12 @@ class SodaCollection {
async insertOneAndGet(content, a2) { async insertOneAndGet(content, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(nodbUtil.isObject(content) || errors.assertParamValue(nodbUtil.isObject(content) ||
nodbUtil.isSodaDocument(content), 'NJS-005', 1); nodbUtil.isSodaDocument(content), 1);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(nodbUtil.isObject(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(a2), 2);
options = a2; options = a2;
} }
@ -190,9 +183,9 @@ class SodaCollection {
// Saves a single document into the collection. // Saves a single document into the collection.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async save(content) { async save(content) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(content) || errors.assertParamValue(nodbUtil.isObject(content) ||
nodbUtil.isSodaDocument(content), 'NJS-005', 1); nodbUtil.isSodaDocument(content), 1);
if (!nodbUtil.isSodaDocument(content)) { if (!nodbUtil.isSodaDocument(content)) {
content = Buffer.from(JSON.stringify(content)); content = Buffer.from(JSON.stringify(content));
@ -210,12 +203,12 @@ class SodaCollection {
async saveAndGet(content, a2) { async saveAndGet(content, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(nodbUtil.isObject(content) || errors.assertParamValue(nodbUtil.isObject(content) ||
nodbUtil.isSodaDocument(content), 'NJS-005', 1); nodbUtil.isSodaDocument(content), 1);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(nodbUtil.isObject(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(a2), 2);
options = a2; options = a2;
} }
@ -232,7 +225,7 @@ class SodaCollection {
// Remove all of the documents from a collection. // Remove all of the documents from a collection.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async truncate() { async truncate() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
await this._truncate(); await this._truncate();
} }

28
lib/sodaDatabase.js
View File

@ -19,6 +19,7 @@
'use strict'; 'use strict';
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
class SodaDatabase { class SodaDatabase {
@ -35,16 +36,15 @@ class SodaDatabase {
async createCollection(name, a2) { async createCollection(name, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(typeof name === 'string', 'NJS-005', 1); errors.assertParamValue(typeof name === 'string', 1);
if (arguments.length == 2) { if (arguments.length == 2) {
nodbUtil.assert(nodbUtil.isObject(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(a2), 2);
options = a2; options = a2;
if (options.metaData) { if (options.metaData) {
if (!nodbUtil.isObject(options.metaData)) { errors.assertParamPropValue(nodbUtil.isObject(options.metaData), 2,
throw new Error(nodbUtil.getErrorMessage('NJS-005', 2)); "metaData");
}
options.metaData = JSON.stringify(options.metaData); options.metaData = JSON.stringify(options.metaData);
} }
} }
@ -60,11 +60,11 @@ class SodaDatabase {
createDocument(content, a2) { createDocument(content, a2) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 1, 2); errors.assertArgCount(arguments, 1, 2);
nodbUtil.assert(Buffer.isBuffer(content) || typeof content === 'string' || errors.assertParamValue(Buffer.isBuffer(content) ||
nodbUtil.isObject(content), 'NJS-005', 1); typeof content === 'string' || nodbUtil.isObject(content), 1);
if (arguments.length > 1) { if (arguments.length > 1) {
nodbUtil.assert(nodbUtil.isObject(a2), 'NJS-005', 2); errors.assertParamValue(nodbUtil.isObject(a2), 2);
options = a2; options = a2;
} }
@ -85,9 +85,9 @@ class SodaDatabase {
async getCollectionNames(a1) { async getCollectionNames(a1) {
let options = {}; let options = {};
nodbUtil.checkArgCount(arguments, 0, 1); errors.assertArgCount(arguments, 0, 1);
if (arguments.length == 1) { if (arguments.length == 1) {
nodbUtil.assert(nodbUtil.isObject(a1), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(a1), 1);
options = a1; options = a1;
} }
return await this._getCollectionNames(options); return await this._getCollectionNames(options);
@ -98,8 +98,8 @@ class SodaDatabase {
// Open an existing SODA collection and return it to the caller. // Open an existing SODA collection and return it to the caller.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async openCollection(name) { async openCollection(name) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof name === 'string', 'NJS-005', 1); errors.assertParamValue(typeof name === 'string', 1);
return await this._openCollection(name); return await this._openCollection(name);
} }

6
lib/sodaDocCursor.js
View File

@ -19,9 +19,9 @@
'use strict'; 'use strict';
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
class SodaDocCursor { class SodaDocCursor {
_getConnection() { _getConnection() {
@ -33,7 +33,7 @@ class SodaDocCursor {
// Return the new document available from the cursor. // Return the new document available from the cursor.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getNext() { async getNext() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._getNext(); return await this._getNext();
} }
@ -43,7 +43,7 @@ class SodaDocCursor {
// Close the cursor and make it unusable for further operations. // Close the cursor and make it unusable for further operations.
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
async close() { async close() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
await this._close(); await this._close();
} }

57
lib/sodaOperation.js
View File

@ -19,6 +19,7 @@
'use strict'; 'use strict';
const errors = require('./errors.js');
const nodbUtil = require('./util.js'); const nodbUtil = require('./util.js');
class SodaOperation { class SodaOperation {
@ -37,7 +38,7 @@ class SodaOperation {
// Return a count of the number of documents that match the search criteria. // Return a count of the number of documents that match the search criteria.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async count() { async count() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._count(this._options); return await this._count(this._options);
} }
@ -48,7 +49,7 @@ class SodaOperation {
// criteria. // criteria.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getCursor() { async getCursor() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._getCursor(this._options); return await this._getCursor(this._options);
} }
@ -57,7 +58,7 @@ class SodaOperation {
// Return an array of documents that match the search criteria. // Return an array of documents that match the search criteria.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getDocuments() { async getDocuments() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._getDocuments(this._options); return await this._getDocuments(this._options);
} }
@ -67,7 +68,7 @@ class SodaOperation {
// Return the first document that matches the search criteria. // Return the first document that matches the search criteria.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async getOne() { async getOne() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._getOne(this._options); return await this._getOne(this._options);
} }
@ -78,9 +79,9 @@ class SodaOperation {
// specified document. // specified document.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async replaceOne(content) { async replaceOne(content) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(content) || errors.assertParamValue(nodbUtil.isObject(content) ||
nodbUtil.isSodaDocument(content), 'NJS-005', 1); nodbUtil.isSodaDocument(content), 1);
if (!nodbUtil.isSodaDocument(content)) { if (!nodbUtil.isSodaDocument(content)) {
content = Buffer.from(JSON.stringify(content)); content = Buffer.from(JSON.stringify(content));
@ -96,9 +97,9 @@ class SodaOperation {
// specified document and then return a result document containing metadata. // specified document and then return a result document containing metadata.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async replaceOneAndGet(content) { async replaceOneAndGet(content) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(content) || errors.assertParamValue(nodbUtil.isObject(content) ||
nodbUtil.isSodaDocument(content), 'NJS-005', 1); nodbUtil.isSodaDocument(content), 1);
if (!nodbUtil.isSodaDocument(content)) { if (!nodbUtil.isSodaDocument(content)) {
content = Buffer.from(JSON.stringify(content)); content = Buffer.from(JSON.stringify(content));
@ -114,38 +115,38 @@ class SodaOperation {
// and return information about the operation to the caller. // and return information about the operation to the caller.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
async remove() { async remove() {
nodbUtil.checkArgCount(arguments, 0, 0); errors.assertArgCount(arguments, 0, 0);
return await this._remove(this._options); return await this._remove(this._options);
} }
// fetchArraySize - a non-terminal function that can chain further // fetchArraySize - a non-terminal function that can chain further
fetchArraySize(n) { fetchArraySize(n) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof n === 'number', 'NJS-005', 1); errors.assertParamValue(typeof n === 'number', 1);
this._options.fetchArraySize = n; this._options.fetchArraySize = n;
return this; return this;
} }
// filter property - a non-terminal function and can chain further // filter property - a non-terminal function and can chain further
filter(f) { filter(f) {
nodbUtil.checkArgCount (arguments, 1, 1); errors.assertArgCount (arguments, 1, 1);
nodbUtil.assert(nodbUtil.isObject(f), 'NJS-005', 1); errors.assertParamValue(nodbUtil.isObject(f), 1);
this._options.filter = JSON.stringify(f); this._options.filter = JSON.stringify(f);
return this; return this;
} }
// hint - a non-terminal function and can chain further // hint - a non-terminal function and can chain further
hint(val) { hint(val) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof val === 'string', 'NJS-005', 1); errors.assertParamValue(typeof val === 'string', 1);
this._options.hint = val; this._options.hint = val;
return this; return this;
} }
// key - a non-terminal function and can chain further // key - a non-terminal function and can chain further
key(k) { key(k) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof k === 'string', 'NJS-005', 1); errors.assertParamValue(typeof k === 'string', 1);
this._options.key = k; this._options.key = k;
this._options.keys = undefined; this._options.keys = undefined;
return this; return this;
@ -153,11 +154,11 @@ class SodaOperation {
// keys - a non-terminal function and can chain further // keys - a non-terminal function and can chain further
keys(arr) { keys(arr) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(Array.isArray(arr), 'NJS-005', 1); errors.assertParamValue(Array.isArray(arr), 1);
for (let i = 0; i < arr.length; i++) { for (let i = 0; i < arr.length; i++) {
nodbUtil.assert(typeof arr[i] === 'string', 'NJS-005', 1); errors.assertParamValue(typeof arr[i] === 'string', 1);
} }
this._options.keys = arr; this._options.keys = arr;
@ -167,24 +168,24 @@ class SodaOperation {
// limit property - a non-terminal function and can chain further // limit property - a non-terminal function and can chain further
limit(n) { limit(n) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof n === 'number', 'NJS-005', 1); errors.assertParamValue(typeof n === 'number', 1);
this._options.limit = n; this._options.limit = n;
return this; return this;
} }
// skip property - a non-terminal function and can chain further // skip property - a non-terminal function and can chain further
skip(n) { skip(n) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof n === 'number', 'NJS-005', 1); errors.assertParamValue(typeof n === 'number', 1);
this._options.skip = n; this._options.skip = n;
return this; return this;
} }
// version property - a non-terminal function and can chain further // version property - a non-terminal function and can chain further
version(v) { version(v) {
nodbUtil.checkArgCount(arguments, 1, 1); errors.assertArgCount(arguments, 1, 1);
nodbUtil.assert(typeof v === 'string', 'NJS-005', 1); errors.assertParamValue(typeof v === 'string', 1);
this._options.version = v; this._options.version = v;
return this; return this;
} }

85
lib/util.js
View File

@ -19,7 +19,7 @@
'use strict'; 'use strict';
const util = require('util'); const errors = require('./errors.js');
// node-oracledb version number // node-oracledb version number
let packageJSON; let packageJSON;
@ -43,38 +43,6 @@ module.exports.BINARY_FILE = BINARY_FILE;
const STAGING_DIR = 'package/Staging'; const STAGING_DIR = 'package/Staging';
module.exports.STAGING_DIR = STAGING_DIR; module.exports.STAGING_DIR = STAGING_DIR;
// errorMessages is for NJS error messages used in the JavaScript layer
const errorMessages = {
'NJS-002': 'NJS-002: invalid pool',
'NJS-004': 'NJS-004: invalid value for property %s',
'NJS-005': 'NJS-005: invalid value for parameter %d',
'NJS-009': 'NJS-009: invalid number of parameters',
'NJS-017': 'NJS-017: concurrent operations on ResultSet are not allowed',
'NJS-021': 'NJS-021: invalid type for conversion specified',
'NJS-023': 'NJS-023: concurrent operations on LOB are not allowed',
'NJS-037': 'NJS-037: incompatible type of value provided',
'NJS-040': 'NJS-040: connection request timeout. Request exceeded queueTimeout of %d',
'NJS-041': 'NJS-041: cannot convert ResultSet to QueryStream after invoking methods',
'NJS-042': 'NJS-042: cannot invoke ResultSet methods after converting to QueryStream',
'NJS-043': 'NJS-043: ResultSet already converted to QueryStream',
'NJS-045': 'NJS-045: cannot load a node-oracledb binary for Node.js ' + process.versions.node + ' (' + process.platform + ' ' + process.arch + ') %s',
'NJS-046': 'NJS-046: poolAlias "%s" already exists in the connection pool cache',
'NJS-047': 'NJS-047: poolAlias "%s" not found in the connection pool cache',
'NJS-064': 'NJS-064: connection pool is closing',
'NJS-065': 'NJS-065: connection pool was closed',
'NJS-067': 'NJS-067: a pre-built node-oracledb binary was not found for %s',
'NJS-069': 'NJS-069: node-oracledb %s requires Node.js %s or later',
'NJS-076': 'NJS-076: connection request rejected. Pool queue length queueMax %d reached',
'NJS-081': 'NJS-081: concurrent operations on a connection are disabled',
'NJS-082': 'NJS-082: connection pool is being reconfigured',
'NJS-083': 'NJS-083: pool statistics not enabled',
'NJS-084': 'NJS-084: invalid access token',
'NJS-085': 'NJS-085: invalid connection pool configuration with token based authentication. The homogeneous and externalAuth attributes must be set to true',
'NJS-086': 'NJS-086: invalid standalone configuration with token based authentication. The externalAuth attribute must be set to true',
'NJS-087': 'NJS-087: access token has expired',
'NJS-088': 'NJS-088: accessTokenCallback cannot be specified when accessToken is a function'
};
// getInstallURL returns a string with installation URL // getInstallURL returns a string with installation URL
function getInstallURL() { function getInstallURL() {
return ('Node-oracledb installation instructions: https://oracle.github.io/node-oracledb/INSTALL.html'); return ('Node-oracledb installation instructions: https://oracle.github.io/node-oracledb/INSTALL.html');
@ -137,39 +105,6 @@ function getInstallHelp() {
module.exports.getInstallHelp = getInstallHelp; module.exports.getInstallHelp = getInstallHelp;
// getErrorMessage is used to get and format error messages to make throwing
// errors a little more convenient.
function getErrorMessage(errorCode) {
let args = Array.prototype.slice.call(arguments);
args[0] = errorMessages[errorCode];
return util.format.apply(util, args);
}
module.exports.getErrorMessage = getErrorMessage;
// assert is typically used at the beginning of public functions to assert
// preconditions for the function to execute. Most commonly it is used to
// validate the number of arguments and their types and throw an error if they
// don't match what is expected.
function assert(condition, errorCode, messageArg1) {
if (!condition) {
throw new Error(getErrorMessage(errorCode, messageArg1));
}
}
module.exports.assert = assert;
// checkArgCount is used to validate the number of arguments, particularly with
// optional parameters (range of number of parameters). If the number of
// arguments is not within the given range, an error is thrown.
function checkArgCount(args, minArgCount, maxArgCount) {
if (args.length < minArgCount || args.length > maxArgCount)
throw new Error(getErrorMessage('NJS-009'));
}
module.exports.checkArgCount = checkArgCount;
// The callbackify function is used to wrap async methods to add optional // The callbackify function is used to wrap async methods to add optional
// callback support. If the last parameter passed to a method is a function, // callback support. If the last parameter passed to a method is a function,
// then it is assumed that the callback pattern is being used and the promise // then it is assumed that the callback pattern is being used and the promise
@ -230,7 +165,7 @@ module.exports.serialize = serialize;
function preventConcurrent(func, errorCode) { function preventConcurrent(func, errorCode) {
return async function() { return async function() {
if (this._isActive) if (this._isActive)
throw new Error(getErrorMessage(errorCode)); errors.throwErr(errorCode);
this._isActive = true; this._isActive = true;
try { try {
return await func.apply(this, arguments); return await func.apply(this, arguments);
@ -250,7 +185,7 @@ module.exports.preventConcurrent = preventConcurrent;
function wrap_fns(proto) { function wrap_fns(proto) {
let nameIndex = 1; let nameIndex = 1;
let preventConcurrentErrorCode; let preventConcurrentErrorCode;
if (arguments[1].startsWith('NJS-')) { if (typeof arguments[1] === 'number') {
nameIndex = 2; nameIndex = 2;
preventConcurrentErrorCode = arguments[1]; preventConcurrentErrorCode = arguments[1];
} }
@ -293,9 +228,9 @@ function isXid(value) {
module.exports.isXid = isXid; module.exports.isXid = isXid;
function isTokenExpired(token) { function isTokenExpired(token) {
assert(typeof token === 'string', 'NJS-084'); errors.assert(typeof token === 'string', errors.ERR_TOKEN_BASED_AUTH);
if (token.split('.')[1] === undefined) { if (token.split('.')[1] === undefined) {
throw new Error(getErrorMessage('NJS-084')); errors.throwErr(errors.ERR_TOKEN_BASED_AUTH);
} }
const base64Url = token.split('.')[1]; const base64Url = token.split('.')[1];
@ -304,7 +239,7 @@ function isTokenExpired(token) {
const payloadInit = buff.toString('ascii'); const payloadInit = buff.toString('ascii');
let expiry = JSON.parse(payloadInit).exp; let expiry = JSON.parse(payloadInit).exp;
assert(expiry != undefined, 'NJS-084'); errors.assert(expiry != undefined, errors.ERR_TOKEN_BASED_AUTH);
expiry = expiry * 1000; expiry = expiry * 1000;
return (new Date().getTime() > expiry); return (new Date().getTime() > expiry);
@ -316,7 +251,7 @@ function isTokenValid(accessToken) {
switch (typeof accessToken) { switch (typeof accessToken) {
case 'string': case 'string':
if (accessToken === '') { if (accessToken === '') {
throw new Error(getErrorMessage('NJS-084')); errors.throwErr(errors.ERR_TOKEN_BASED_AUTH);
} }
return !isTokenExpired(accessToken); return !isTokenExpired(accessToken);
@ -325,12 +260,12 @@ function isTokenValid(accessToken) {
accessToken.token === '' || accessToken.token === '' ||
accessToken.privateKey === undefined || accessToken.privateKey === undefined ||
accessToken.privateKey === '') { accessToken.privateKey === '') {
throw new Error(getErrorMessage('NJS-084')); errors.throwErr(errors.ERR_TOKEN_BASED_AUTH);
} }
return !isTokenExpired(accessToken.token); return !isTokenExpired(accessToken.token);
default: default:
throw new Error(getErrorMessage('NJS-084')); errors.throwErr(errors.ERR_TOKEN_BASED_AUTH);
} }
} }
@ -347,7 +282,7 @@ async function checkToken(attrs) {
accessToken = attrs.accessToken; accessToken = attrs.accessToken;
} }
if (!isTokenValid(accessToken)) { if (!isTokenValid(accessToken)) {
throw new Error(getErrorMessage('NJS-087')); errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
} }
if (typeof accessToken === 'string') { if (typeof accessToken === 'string') {
attrs.token = accessToken; attrs.token = accessToken;

24
test/fetchClobAsString3.js
View File

@ -376,21 +376,21 @@ describe('86. fetchClobAsString3.js', function() {
done(); done();
}); // 86.2.7 }); // 86.2.7
it('86.2.8 undefined in fetchAsString will throw NJS-004', function() { it('86.2.8 undefined in fetchAsString will throw NJS-021', function() {
should.throws( should.throws(
function() { function() {
oracledb.fetchAsString = [ undefined ]; oracledb.fetchAsString = [ undefined ];
}, },
/NJS-004:/ /NJS-021:/
); );
}); // 86.2.8 }); // 86.2.8
it('86.2.9 Random string in fetchAsString will throw NJS-004', function() { it('86.2.9 Random string in fetchAsString will throw NJS-021', function() {
should.throws( should.throws(
function() { function() {
oracledb.fetchAsString = [ "foobar" ]; oracledb.fetchAsString = [ "foobar" ];
}, },
/NJS-004:/ /NJS-021:/
); );
}); // 86.2.9 }); // 86.2.9
@ -403,39 +403,39 @@ describe('86. fetchClobAsString3.js', function() {
); );
}); // 86.2.10 }); // 86.2.10
it('86.2.11 Negative integer in fetchAsString will throw NJS-004', function() { it('86.2.11 Negative integer in fetchAsString will throw NJS-021', function() {
should.throws( should.throws(
function() { function() {
oracledb.fetchAsString = [ -1 ]; oracledb.fetchAsString = [ -1 ];
}, },
/NJS-004:/ /NJS-021:/
); );
}); // 86.2.11 }); // 86.2.11
it('86.2.12 Random float in fetchAsString will throw NJS-004', function() { it('86.2.12 Random float in fetchAsString will throw NJS-021', function() {
should.throws( should.throws(
function() { function() {
oracledb.fetchAsString = [ 3.1415 ]; oracledb.fetchAsString = [ 3.1415 ];
}, },
/NJS-004:/ /NJS-021:/
); );
}); // 86.2.12 }); // 86.2.12
it('86.2.13 Array in fetchAsString will throw NJS-004', function() { it('86.2.13 Array in fetchAsString will throw NJS-021', function() {
should.throws( should.throws(
function() { function() {
oracledb.fetchAsString = [ [3] ]; oracledb.fetchAsString = [ [3] ];
}, },
/NJS-004:/ /NJS-021:/
); );
}); // 86.2.13 }); // 86.2.13
it('86.2.14 Object in fetchAsString will throw NJS-004', function() { it('86.2.14 Object in fetchAsString will throw NJS-021', function() {
should.throws( should.throws(
function() { function() {
oracledb.fetchAsString = [ {1:1} ]; oracledb.fetchAsString = [ {1:1} ];
}, },
/NJS-004:/ /NJS-021:/
); );
}); // 86.2.14 }); // 86.2.14

18
test/poolCache.js
View File

@ -166,7 +166,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err, pool) { oracledb.createPool(dbConfig, function(err, pool) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
should.not.exist(pool); should.not.exist(pool);
@ -554,7 +554,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
done(); done();
}); });
@ -567,8 +567,8 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
// NJS-004: invalid value for property poolAttrs.poolAlias
done(); done();
}); });
}); });
@ -580,7 +580,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
done(); done();
}); });
@ -593,7 +593,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
done(); done();
}); });
@ -606,7 +606,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
done(); done();
}); });
@ -619,7 +619,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
done(); done();
}); });
@ -632,7 +632,7 @@ describe('67. poolCache.js', function() {
oracledb.createPool(dbConfig, function(err) { oracledb.createPool(dbConfig, function(err) {
should.exist(err); should.exist(err);
(err.message).should.startWith('NJS-004:'); (err.message).should.startWith('NJS-007:');
done(); done();
}); });

2
test/soda1.js
View File

@ -432,7 +432,7 @@ describe('164. soda1.js', () => {
await testsUtil.assertThrowsAsync( await testsUtil.assertThrowsAsync(
async () => await sd.createCollection(t_collname, options), async () => await sd.createCollection(t_collname, options),
/NJS-005:/ /NJS-007:/
); );
} catch (err) { } catch (err) {

11
test/stream2.js
View File

@ -338,10 +338,7 @@ describe('14. stream2.js', function() {
var metaDataRead = false; var metaDataRead = false;
stream.on('metadata', function(metaData) { stream.on('metadata', function(metaData) {
should.deepEqual( should.equal(metaData[0].name, 'EMPLOYEE_NAME');
metaData,
[ { name: 'EMPLOYEE_NAME' } ]
);
metaDataRead = true; metaDataRead = true;
}); });
@ -567,10 +564,8 @@ describe('14. stream2.js', function() {
var metaDataRead = false; var metaDataRead = false;
stream.on('metadata', function(metaData) { stream.on('metadata', function(metaData) {
should.deepEqual( should.equal(metaData[0].name, 'A');
metaData, should.equal(metaData[1].name, 'B');
[ { name: 'A' }, { name: 'B' } ]
);
metaDataRead = true; metaDataRead = true;
}); });