web_plsql 1.0.0 → 1.3.0

package/src/handler/plsql/procedure.js

@@ -1,356 +0,0 @@
-/*
- *	Invoke the Oracle procedure and return the raw content of the page
- */
-
-import debugModule from 'debug';
-const debug = debugModule('webplsql:procedure');
-
-import oracledb from 'oracledb';
-import stream from 'node:stream';
-import z from 'zod';
-
-import {uploadFile} from './upload.js';
-import {getProcedureVariable} from './procedureVariable.js';
-import {getProcedureNamed} from './procedureNamed.js';
-import {parsePage} from './parsePage.js';
-import {sendResponse} from './sendResponse.js';
-import {ProcedureError} from './procedureError.js';
-import {RequestError} from './requestError.js';
-import {inspect, getBlock} from '../../util/trace.js';
-import {errorToString} from '../../util/errorToString.js';
-import {sanitizeProcName} from './procedureSanitize.js';
-
-/**
- * @typedef {import('express').Request} Request
- * @typedef {import('express').Response} Response
- * @typedef {import('oracledb').Connection} Connection
- * @typedef {import('oracledb').Result<unknown>} Result
- * @typedef {import('../../types.js').argObjType} argObjType
- * @typedef {import('../../types.js').fileUploadType} fileUploadType
- * @typedef {import('../../types.js').environmentType} environmentType
- * @typedef {import('../../types.js').configPlSqlHandlerType} configPlSqlHandlerType
- * @typedef {import('../../types.js').BindParameterConfig} BindParameterConfig
- * @typedef {import('../../util/cache.js').Cache<string>} ProcedureNameCache
- * @typedef {import('../../util/cache.js').Cache<import('./procedureNamed.js').argsType>} ArgumentCache
- */
-
-/**
- *	Get the procedure and arguments to execute
- *	@param {Request} req - The req object represents the HTTP request. (only used for debugging)
- *	@param {string} procName - The procedure to execute
- *	@param {argObjType} argObj - The arguments to pass to the procedure
- *	@param {configPlSqlHandlerType} options - The options for the middleware
- *	@param {Connection} databaseConnection - The database connection
- *	@param {ProcedureNameCache} procedureNameCache - The procedure name cache.
- *	@param {ArgumentCache} argumentCache - The argument cache.
- *	@returns {Promise<{sql: string; bind: BindParameterConfig; resolvedName?: string}>} - The SQL statement and bindings for the procedure to execute
- */
-const getProcedure = async (req, procName, argObj, options, databaseConnection, procedureNameCache, argumentCache) => {
-	// path alias
-	if (options.pathAlias?.toLowerCase() === procName.toLowerCase()) {
-		debug(`getProcedure: path alias "${options.pathAlias}" redirects to "${options.pathAliasProcedure}"`);
-		return {
-			sql: `${options.pathAliasProcedure}(p_path=>:p_path)`,
-			bind: {
-				p_path: {dir: oracledb.BIND_IN, type: oracledb.STRING, val: procName},
-			},
-		};
-	}
-
-	// check if we use variable arguments
-	const useVariableArguments = procName.startsWith('!');
-
-	// sanitize procedure name
-	const rawName = useVariableArguments ? procName.substring(1) : procName;
-	const sanitizedProcName = await sanitizeProcName(rawName, databaseConnection, options, procedureNameCache);
-
-	// run procedure
-	if (useVariableArguments) {
-		return {
-			...getProcedureVariable(req, sanitizedProcName, argObj),
-			resolvedName: sanitizedProcName,
-		};
-	} else {
-		return {
-			...(await getProcedureNamed(req, sanitizedProcName, argObj, databaseConnection, argumentCache)),
-			resolvedName: sanitizedProcName,
-		};
-	}
-};
-
-/**
- * Prepare procedure
- *
- * NOTE:
- * 	1) dbms_session.modify_package_state(dbms_session.reinitialize) is used to ensure a stateless environment by resetting package state (dbms_session.reset_package)
- *
- * @param {environmentType} cgiObj - The cgi of the procedure to invoke.
- * @param {Connection} databaseConnection - Database connection.
- * @returns {Promise<void>} Promise resolving to void.
- */
-const procedurePrepare = async (cgiObj, databaseConnection) => {
-	let sqlStatement = 'BEGIN dbms_session.modify_package_state(dbms_session.reinitialize); END;';
-	try {
-		await databaseConnection.execute(sqlStatement);
-	} catch (err) {
-		throw new ProcedureError(`procedurePrepare: error when preparing procedure\n${errorToString(err)}`, cgiObj, sqlStatement, {});
-	}
-
-	// htbuf_len: reduce this limit based on your worst-case character size.
-	// For most character sets, this will be 2 bytes per character, so the limit would be 127.
-	// For UTF8 Unicode, it's 3 bytes per character, meaning the limit should be 85.
-	// For the newer AL32UTF8 Unicode, it's 4 bytes per character, and the limit should be 63.
-	sqlStatement = 'BEGIN owa.init_cgi_env(:cgicount, :cginames, :cgivalues); htp.init; htp.htbuf_len := 63; END;';
-	/** @type {BindParameterConfig} */
-	const bindParameter = {
-		cgicount: {dir: oracledb.BIND_IN, type: oracledb.NUMBER, val: Object.keys(cgiObj).length},
-		cginames: {dir: oracledb.BIND_IN, type: oracledb.STRING, val: Object.keys(cgiObj)},
-		cgivalues: {dir: oracledb.BIND_IN, type: oracledb.STRING, val: Object.values(cgiObj)},
-	};
-	try {
-		await databaseConnection.execute(sqlStatement, bindParameter);
-	} catch (err) {
-		throw new ProcedureError(`procedurePrepare: error when preparing procedure\n${errorToString(err)}`, cgiObj, sqlStatement, bindParameter);
-	}
-};
-
-/**
- * Execute procedure
- *
- * @param {{sql: string; bind: BindParameterConfig}} para - The statement and binding to use when executing the procedure.
- * @param {Connection} databaseConnection - Database connection.
- * @returns {Promise<void>} Promise resolving to void.
- */
-const procedureExecute = async (para, databaseConnection) => {
-	const sqlStatement = `BEGIN ${para.sql}; END;`;
-
-	try {
-		await databaseConnection.execute(sqlStatement, para.bind);
-	} catch (err) {
-		throw new ProcedureError(`procedureExecute: error when executing procedure:\n${sqlStatement}\n${errorToString(err)}`, {}, para.sql, para.bind);
-	}
-};
-
-/**
- * Get page from procedure
- *
- * @param {boolean} _test - Test.
- * @param {Connection} databaseConnection - Database connection.
- * @returns {Promise<string>} Promise resolving to the returned page content.
- */
-const procedureGetPage = async (_test, databaseConnection) => {
-	const MAX_IROWS = 100000;
-
-	/** @type {BindParameterConfig} */
-	const bindParameter = {
-		lines: {dir: oracledb.BIND_OUT, type: oracledb.STRING, maxArraySize: MAX_IROWS},
-		irows: {dir: oracledb.BIND_INOUT, type: oracledb.NUMBER, val: MAX_IROWS},
-	};
-
-	const sqlStatement = 'BEGIN owa.get_page(thepage=>:lines, irows=>:irows); END;';
-
-	/** @type {Result} */
-	let result = {};
-	try {
-		result = await databaseConnection.execute(sqlStatement, bindParameter);
-	} catch (err) {
-		if (debug.enabled) {
-			debug(getBlock('procedureGetPage: results', inspect(result)));
-		}
-
-		throw new ProcedureError(`procedureGetPage: error when getting page returned by procedure\n${errorToString(err)}`, {}, sqlStatement, bindParameter);
-	}
-
-	const {lines, irows} = z.object({irows: z.number(), lines: z.array(z.string())}).parse(result.outBinds);
-
-	// Make sure that we have retrieved all the rows
-	if (irows > MAX_IROWS) {
-		/* v8 ignore next - defensive check for row limit */
-		throw new ProcedureError(`procedureGetPage: error when retrieving rows. irows="${irows}"`, {}, sqlStatement, bindParameter);
-	}
-
-	return lines.join('');
-};
-
-/**
- * Download files from procedure
- *
- * @param {oracledb.Lob} fileBlob - The blob eventually containing the file.
- * @param {Connection} databaseConnection - Database connection.
- * @returns {Promise<{fileType: string, fileSize: number, fileBlob: stream.Readable | null}>} Promise resolving to the result.
- */
-const procedureDownloadFiles = async (fileBlob, databaseConnection) => {
-	/** @type {BindParameterConfig} */
-	const bindParameter = {
-		fileType: {dir: oracledb.BIND_OUT, type: oracledb.STRING},
-		fileSize: {dir: oracledb.BIND_OUT, type: oracledb.NUMBER},
-		fileBlob: {dir: oracledb.BIND_INOUT, type: oracledb.BLOB, val: fileBlob},
-	};
-
-	const sqlStatement = `
-DECLARE
-	l_file_type		VARCHAR2(32767)	:= '';
-	l_file_size		INTEGER			:= 0;
-BEGIN
-	IF (wpg_docload.is_file_download()) THEN
-		wpg_docload.get_download_file(l_file_type);
-		IF (l_file_type = 'B') THEN
-			wpg_docload.get_download_blob(:fileBlob);
-			l_file_size := dbms_lob.getlength(:fileBlob);
-		END IF;
-	END IF;
-	:fileType := l_file_type;
-	:fileSize := l_file_size;
-END;
-`;
-
-	/** @type {Result | null} */
-	let result = null;
-	try {
-		result = await databaseConnection.execute(sqlStatement, bindParameter);
-	} catch (err) {
-		if (debug.enabled) {
-			debug(getBlock('procedureDownloadFiles: results', inspect(result)));
-		}
-
-		throw new ProcedureError(`procedureDownloadFiles: error when downloading files\n${errorToString(err)}`, {}, sqlStatement, bindParameter);
-	}
-
-	return z
-		.object({
-			fileType: z
-				.string()
-				.nullable()
-				.transform((val) => val ?? ''),
-			fileSize: z
-				.number()
-				.nullable()
-				.transform((val) => val ?? 0),
-			fileBlob: z.instanceof(stream.Readable).nullable(),
-		})
-		.parse(result.outBinds);
-};
-
-/**
- * Invoke the Oracle procedure and return the page content
- *
- * @param {Request} req - The req object represents the HTTP request.
- * @param {Response} res - The res object represents the HTTP response that an Express app sends when it gets an HTTP request.
- * @param {argObjType} argObj - - The arguments of the procedure to invoke.
- * @param {environmentType} cgiObj - The cgi of the procedure to invoke.
- * @param {fileUploadType[]} filesToUpload - Array of files to be uploaded
- * @param {configPlSqlHandlerType} options - the options for the middleware.
- * @param {Connection} databaseConnection - Database connection.
- * @param {ProcedureNameCache} procedureNameCache - The procedure name cache.
- * @param {ArgumentCache} argumentCache - The argument cache.
- * @returns {Promise<void>} Promise resolving to the page content generated by the executed procedure
- */
-export const invokeProcedure = async (req, res, argObj, cgiObj, filesToUpload, options, databaseConnection, procedureNameCache, argumentCache) => {
-	debug('invokeProcedure: begin');
-
-	// 1) upload files
-	debug(`invokeProcedure: upload "${filesToUpload.length}" files`);
-	if (filesToUpload.length > 0) {
-		if (typeof options.documentTable === 'string' && options.documentTable.length > 0) {
-			const {documentTable} = options;
-
-			await Promise.all(filesToUpload.map((file) => uploadFile(file, documentTable, databaseConnection)));
-		} else {
-			console.warn(`Unable to upload "${filesToUpload.length}" files because the option ""doctable" has not been defined`);
-		}
-	}
-
-	// 2) get procedure to execute and the arguments
-
-	debug('invokeProcedure: get procedure to execute and the arguments');
-	// Extract the raw procedure name from params
-	const rawProcName = Array.isArray(req.params.name) ? req.params.name[0] : req.params.name;
-	if (!rawProcName) {
-		throw new RequestError('No procedure name provided');
-	}
-	const para = await getProcedure(req, rawProcName, argObj, options, databaseConnection, procedureNameCache, argumentCache);
-
-	// 3) prepare the session
-
-	debug('invokeProcedure: prepare the session');
-	await procedurePrepare(cgiObj, databaseConnection);
-
-	// 4) execute the procedure
-
-	debug('invokeProcedure: execute the session');
-	try {
-		await procedureExecute(para, databaseConnection);
-	} catch (err) {
-		// Invalidation Logic
-		if (err instanceof ProcedureError) {
-			const errorString = err.toString();
-			// Check for ORA-04068, ORA-04061, ORA-04065, ORA-06550
-			if (
-				errorString.includes('ORA-04068') ||
-				errorString.includes('ORA-04061') ||
-				errorString.includes('ORA-04065') ||
-				errorString.includes('ORA-06550')
-			) {
-				debug(`invokeProcedure: detected invalidation error (${errorString}). Clearing caches.`);
-
-				// Clear name resolution cache for the input name
-				if (rawProcName) {
-					procedureNameCache.delete(rawProcName);
-				}
-
-				// Clear argument cache for the resolved name
-				if (para.resolvedName) {
-					argumentCache.delete(para.resolvedName.toUpperCase());
-				}
-			}
-		}
-		throw err;
-	}
-
-	// 5) get the page returned from the procedure
-
-	debug('invokeProcedure: get the page returned from the procedure');
-	const lines = await procedureGetPage(true, databaseConnection);
-	if (debug.enabled) {
-		debug(getBlock('data', lines));
-	}
-
-	// 6) download files
-
-	debug('invokeProcedure: download files');
-	const fileBlob = await databaseConnection.createLob(oracledb.BLOB);
-
-	try {
-		const fileDownload = await procedureDownloadFiles(fileBlob, databaseConnection);
-		if (debug.enabled) {
-			debug(getBlock('fileDownload', inspect({fileType: fileDownload.fileType, fileSize: fileDownload.fileSize})));
-		}
-
-		// 7) parse the page
-
-		debug('invokeProcedure: parse the page');
-		const pageComponents = parsePage(lines);
-
-		// add "Server" header
-		pageComponents.head.server = cgiObj.SERVER_SOFTWARE ?? '';
-
-		// add file download information
-		if (fileDownload.fileType !== '' && fileDownload.fileSize > 0 && fileDownload.fileBlob !== null) {
-			pageComponents.file.fileType = fileDownload.fileType;
-			pageComponents.file.fileSize = fileDownload.fileSize;
-			pageComponents.file.fileBlob = fileDownload.fileBlob;
-		}
-
-		// 8) send the page to browser
-
-		debug('invokeProcedure: send the page to browser');
-		await sendResponse(req, res, pageComponents);
-	} finally {
-		// 9) cleanup
-
-		debug('invokeProcedure: cleanup');
-		fileBlob.destroy();
-	}
-
-	debug('invokeProcedure: end');
-};

package/src/handler/plsql/procedureError.js

@@ -1,40 +0,0 @@
-/*
- *	RequestError
- */
-
-/**
- * @typedef {import('../../types.js').environmentType} environmentType
- * @typedef {import('../../types.js').BindParameterConfig} BindParameterConfig
- */
-
-export class ProcedureError extends Error {
-	/** @type {Date} */
-	timestamp;
-	/** @type {environmentType} */
-	environment;
-	/** @type {string} */
-	sql;
-	/** @type {BindParameterConfig} */
-	bind;
-
-	/**
-	 * @param {string} message - The error message.
-	 * @param {environmentType} environment - The environment.
-	 * @param {string} sql - The SQL to execute.
-	 * @param {BindParameterConfig} bind - The bind parameters.
-	 */
-	constructor(message, environment, sql, bind) {
-		super(message);
-
-		// Maintains proper stack trace for where our error was thrown (only available on V8)
-		if (Error.captureStackTrace) {
-			Error.captureStackTrace(this, ProcedureError);
-		}
-
-		// Custom debugging information
-		this.timestamp = new Date();
-		this.environment = environment;
-		this.sql = sql;
-		this.bind = bind;
-	}
-}

package/src/handler/plsql/procedureNamed.js

@@ -1,268 +0,0 @@
-/*
- *	Invoke the Oracle procedure and return the raw content of the page
- */
-
-import debugModule from 'debug';
-const debug = debugModule('webplsql:procedureNamed');
-
-import oracledb from 'oracledb';
-import z from 'zod';
-import {RequestError} from './requestError.js';
-import {errorToString} from '../../util/errorToString.js';
-import {stringToNumber} from '../../util/util.js';
-import {toTable, warningMessage} from '../../util/trace.js';
-
-/**
- * @typedef {import('express').Request} Request
- * @typedef {import('oracledb').Connection} Connection
- * @typedef {import('oracledb').Result<unknown>} Result
- * @typedef {import('../../types.js').configPlSqlHandlerType} configPlSqlHandlerType
- * @typedef {import('../../types.js').argObjType} argObjType
- * @typedef {import('../../types.js').BindParameterConfig} BindParameterConfig
- * @typedef {import('../../types.js').BindParameter} BindParameter
- * @typedef {Record<string, string>} argsType
- * @typedef {import('../../util/cache.js').Cache<argsType>} ArgumentCache
- */
-
-const SQL_GET_ARGUMENT = [
-	'DECLARE',
-	'	schemaName		VARCHAR2(32767);',
-	'	part1			VARCHAR2(32767);',
-	'	part2			VARCHAR2(32767);',
-	'	dblink			VARCHAR2(32767);',
-	'	objectType		NUMBER;',
-	'	objectID		NUMBER;',
-	'BEGIN',
-	'	dbms_utility.name_resolve(name=>UPPER(:name), context=>1, schema=>schemaName, part1=>part1, part2=>part2, dblink=>dblink, part1_type=>objectType, object_number=>objectID);',
-	'	IF (part1 IS NOT NULL) THEN',
-	'		SELECT argument_name, data_type BULK COLLECT INTO :names, :types FROM all_arguments WHERE owner = schemaName AND package_name = part1 AND object_name = part2 AND argument_name IS NOT NULL ORDER BY overload, sequence;',
-	'	ELSE',
-	'		SELECT argument_name, data_type BULK COLLECT INTO :names, :types FROM all_arguments WHERE owner = schemaName AND package_name IS NULL AND object_name = part2 AND argument_name IS NOT NULL ORDER BY overload, sequence;',
-	'	END IF;',
-	'END;',
-].join('\n');
-
-const DATA_TYPES = Object.freeze({
-	VARCHAR2: 'VARCHAR2',
-	CHAR: 'CHAR',
-	BINARY_INTEGER: 'BINARY_INTEGER',
-	NUMBER: 'NUMBER',
-	DATE: 'DATE',
-	CLOB: 'CLOB',
-	PL_SQL_TABLE: 'PL/SQL TABLE',
-	//	PL/SQL BOOLEAN
-	//	PL/SQL RECORD
-	//	OBJECT
-	//	TABLE
-	//	BLOB
-	//	RAW
-	//	VARRAY
-	//	REF CURSOR
-});
-
-/**
- *	Retrieve the argument types for a given procedure to be executed.
- *	This is important because if the procedure is defined to take a PL/SQL indexed table,
- *	we must provise a table, even if there is only one argument to be submitted.
- *	@param {string} procedure - The procedure
- *	@param {Connection} databaseConnection - The database connection
- *	@returns {Promise<argsType>} - The argument types
- */
-const loadArguments = async (procedure, databaseConnection) => {
-	const MAX_PARAMETER_NUMBER = 1000;
-
-	/** @type {BindParameterConfig} */
-	const bind = {
-		name: {dir: oracledb.BIND_IN, type: oracledb.STRING, val: procedure},
-		names: {dir: oracledb.BIND_OUT, type: oracledb.STRING, maxSize: 60, maxArraySize: MAX_PARAMETER_NUMBER},
-		types: {dir: oracledb.BIND_OUT, type: oracledb.STRING, maxSize: 60, maxArraySize: MAX_PARAMETER_NUMBER},
-	};
-
-	/** @type {Result} */
-	let result = {};
-	try {
-		result = await databaseConnection.execute(SQL_GET_ARGUMENT, bind);
-	} catch (err) {
-		debug('result', result);
-		const message = `Error when retrieving arguments\n${SQL_GET_ARGUMENT}\n${errorToString(err)}`;
-		throw new RequestError(message);
-	}
-
-	/** @type {{names: string[], types: string[]}} */
-	let data;
-	try {
-		data = z
-			.object({
-				names: z.array(z.string()),
-				types: z.array(z.string()),
-			})
-			.parse(result.outBinds);
-	} catch (err) {
-		debug('result.outBinds', result.outBinds);
-		const message = `Error when decoding arguments\n${SQL_GET_ARGUMENT}\n${errorToString(err)}`;
-		throw new RequestError(message);
-	}
-
-	if (data.names.length !== data.types.length) {
-		throw new RequestError('Error when decoding arguments. The number of names and types does not match');
-	}
-
-	/** @type {Record<string, string>} */
-	const argTypes = {};
-	for (let i = 0; i < data.names.length; i++) {
-		const name = data.names[i];
-		const type = data.types[i];
-		if (name && type) {
-			argTypes[name.toLowerCase()] = type;
-		}
-	}
-
-	return argTypes;
-};
-
-/**
- *	Find the argument types for a given procedure to be executed.
- *	As the arguments are cached, we first look up the cache and only if not yet available we load them.
- *	@param {string} procedure - The procedure
- *	@param {Connection} databaseConnection - The database connection
- *	@param {ArgumentCache} argumentCache - The argument cache.
- *	@returns {Promise<argsType>} - The argument types
- */
-const findArguments = async (procedure, databaseConnection, argumentCache) => {
-	const key = procedure.toUpperCase();
-
-	// lookup in the cache
-	const cachedArgs = argumentCache.get(key);
-
-	// if we found the procedure in the cache, we return it
-	if (cachedArgs) {
-		if (debug.enabled) {
-			debug(`findArguments: procedure "${procedure}" found in cache`);
-		}
-		return cachedArgs;
-	}
-
-	// load from database
-	if (debug.enabled) {
-		debug(`findArguments: procedure "${procedure}" not found in cache and must be loaded`);
-	}
-	const args = await loadArguments(procedure, databaseConnection);
-
-	// add to the cache
-	argumentCache.set(key, args);
-
-	return args;
-};
-
-/**
- *	Get the bindling for an argument.
- *	@param {string} argName - The argument name.
- *	@param {unknown} argValue - The argument value.
- *	@param {string} argType - The argument type.
- *	@returns {BindParameter} - The binding.
- */
-export const getBinding = (argName, argValue, argType) => {
-	if (argType === DATA_TYPES.VARCHAR2 || argType === DATA_TYPES.CHAR) {
-		return {dir: oracledb.BIND_IN, type: oracledb.DB_TYPE_VARCHAR, val: argValue};
-	}
-
-	if (argType === DATA_TYPES.CLOB) {
-		return {dir: oracledb.BIND_IN, type: oracledb.DB_TYPE_CLOB, val: argValue};
-	}
-
-	if (argType === DATA_TYPES.NUMBER || argType === DATA_TYPES.BINARY_INTEGER) {
-		const value = stringToNumber(argValue);
-		if (value === null) {
-			throw new Error(`Error in named parameter "${argName}": invalid value "${argValue}" for type "${argType}"`);
-		}
-
-		return {dir: oracledb.BIND_IN, type: oracledb.DB_TYPE_NUMBER, val: value};
-	}
-
-	if (argType === DATA_TYPES.DATE) {
-		if (typeof argValue !== 'string') {
-			throw new Error(`Error in named parameter "${argName}": invalid value "${argValue}" for type "${argType}"`);
-		}
-		const value = new Date(argValue);
-		if (Number.isNaN(value.getTime())) {
-			throw new Error(`Error in named parameter "${argName}": invalid value "${argValue}" for type "${argType}"`);
-		}
-
-		return {dir: oracledb.BIND_IN, type: oracledb.DB_TYPE_VARCHAR, val: value};
-	}
-
-	if (argType === DATA_TYPES.PL_SQL_TABLE || Array.isArray(argValue)) {
-		const value = typeof argValue === 'string' ? [argValue] : argValue;
-
-		return {dir: oracledb.BIND_IN, type: oracledb.DB_TYPE_DATE, val: value};
-	}
-
-	throw new Error(`Error in named parameter "${argName}": invalid binding type "${argType}"`);
-};
-
-/**
- *	Get binding table for tracing.
- *	@param {argObjType} argObj - The arguments to pass to the procedure
- *	@param {argsType} argTypes - The argument types.
- *	@returns {string} - The text.
- */
-const inspectBindings = (argObj, argTypes) => {
-	const rows = Object.entries(argObj).map(([key, value]) => {
-		return [key, value.toString(), typeof value, argTypes[key.toLowerCase()] ?? 'unknown'];
-	});
-
-	const {text} = toTable(['id', 'value', 'value type', 'argument type'], rows);
-
-	return text;
-};
-
-/**
- *	Get the sql statement and bindings for the procedure to execute for a fixed number of arguments
- *	@param {Request} req - The req object represents the HTTP request. (only used for debugging)
- *	@param {string} procName - The procedure to execute
- *	@param {argObjType} argObj - The arguments to pass to the procedure
- *	@param {Connection} databaseConnection - The database connection
- *	@param {ArgumentCache} argumentCache - The argument cache.
- *	@returns {Promise<{sql: string; bind: BindParameterConfig}>} - The SQL statement and bindings for the procedure to execute
- */
-export const getProcedureNamed = async (req, procName, argObj, databaseConnection, argumentCache) => {
-	debug(`getProcedureNamed: ${procName} arguments=`, argObj);
-
-	// get the types of the arguments
-	const argTypes = await findArguments(procName, databaseConnection, argumentCache);
-
-	/** @type {string[]} */
-	const sqlParameter = [];
-
-	/** @type {BindParameterConfig} */
-	const bindings = {};
-
-	// bindings for the statement
-	for (const key in argObj) {
-		const parameterName = `p_${key}`;
-		const argValue = argObj[key];
-		const argType = argTypes[key.toLowerCase()];
-		/** @type {BindParameter} */
-		let bind = {dir: oracledb.BIND_IN, type: oracledb.DB_TYPE_VARCHAR, val: argValue};
-
-		if (argType) {
-			bind = getBinding(key, argValue, argType);
-		} else {
-			const text = inspectBindings(argObj, argTypes);
-			warningMessage({type: 'warning', message: `Error in named parameter "${key}": invalid binding type "${argType}"\n\n${text}`, req});
-		}
-
-		sqlParameter.push(`${key}=>:${parameterName}`);
-		bindings[parameterName] = bind;
-	}
-
-	// select statement
-	const sql = `${procName}(${sqlParameter.join(', ')})`;
-
-	if (debug.enabled) {
-		debug(sql);
-		debug(inspectBindings(argObj, argTypes));
-	}
-
-	return {sql, bind: bindings};
-};