web_plsql 0.18.0 → 1.2.0

package/src/handler/plsql/owaPageStream.js

@@ -0,0 +1,93 @@
+import {Readable} from 'node:stream';
+import oracledb from 'oracledb';
+import z from 'zod';
+import debugModule from 'debug';
+import {ProcedureError} from './procedureError.js';
+import {errorToString} from '../../util/errorToString.js';
+
+const debug = debugModule('webplsql:owaPageStream');
+
+/**
+ * @typedef {import('oracledb').Connection} Connection
+ * @typedef {import('../../types.js').BindParameterConfig} BindParameterConfig
+ */
+
+export class OWAPageStream extends Readable {
+	/**
+	 * @param {Connection} databaseConnection - The database connection.
+	 */
+	constructor(databaseConnection) {
+		super({highWaterMark: 16384}); // 16KB buffer
+		this.databaseConnection = databaseConnection;
+		this.chunkSize = 1000;
+		this.isDone = false;
+	}
+
+	/**
+	 * Fetch a chunk of the page from the database.
+	 * @returns {Promise<string[]>} The array of lines fetched.
+	 */
+	async fetchChunk() {
+		if (this.isDone) return [];
+
+		/** @type {BindParameterConfig} */
+		const bindParameter = {
+			lines: {dir: oracledb.BIND_OUT, type: oracledb.STRING, maxArraySize: this.chunkSize},
+			irows: {dir: oracledb.BIND_INOUT, type: oracledb.NUMBER, val: this.chunkSize},
+		};
+
+		const sqlStatement = 'BEGIN owa.get_page(thepage=>:lines, irows=>:irows); END;';
+
+		try {
+			const result = await this.databaseConnection.execute(sqlStatement, bindParameter);
+			const {lines, irows} = z.object({irows: z.number(), lines: z.array(z.string())}).parse(result.outBinds);
+
+			debug(`fetched ${lines.length} lines (irows=${irows})`);
+
+			// If we got fewer lines than requested, OR if we got 0 lines, we are done
+			if (lines.length < this.chunkSize) {
+				this.isDone = true;
+			}
+
+			return lines;
+		} catch (err) {
+			if (err instanceof ProcedureError) {
+				throw err;
+			}
+			throw new ProcedureError(`OWAPageStream: error when getting page\n${errorToString(err)}`, {}, sqlStatement, bindParameter);
+		}
+	}
+
+	/**
+	 * @override
+	 * @param {number} _size - The size hint (unused).
+	 * @returns {void}
+	 */
+	_read(_size) {
+		this.fetchChunk()
+			.then((lines) => {
+				if (lines.length > 0) {
+					this.push(lines.join(''));
+				}
+
+				// After fetching, check if we're done
+				if (this.isDone) {
+					this.push(null);
+				}
+			})
+			.catch((/** @type {unknown} */ err) => {
+				this.destroy(err instanceof Error ? err : new Error(String(err)));
+			});
+	}
+
+	/**
+	 * Add initial body content to the stream.
+	 * @param {string} content - The initial content to prepend.
+	 * @returns {void}
+	 */
+	addBody(content) {
+		if (content && content.length > 0) {
+			this.push(content);
+		}
+	}
+}

package/src/handler/plsql/parsePage.js

@@ -155,7 +155,11 @@ const parseCookie = (text) => {
 	cookieElements = cookieElements.map((element) => element.trim());
 
 	// get name and value
-	const index = cookieElements[0].indexOf('=');
+	const firstElement = cookieElements[0];
+	if (!firstElement) {
+		return null;
+	}
+	const index = firstElement.indexOf('=');
 	/* v8 ignore next - cookie format validation */
 	if (index <= 0) {
 		// if the index is -1, there is no equal sign and if it's 0 the name is empty
@@ -164,8 +168,8 @@ const parseCookie = (text) => {
 
 	/** @type {cookieType} */
 	const cookie = {
-		name: cookieElements[0].substring(0, index).trim(),
-		value: cookieElements[0].substring(index + 1).trim(),
+		name: firstElement.substring(0, index).trim(),
+		value: firstElement.substring(index + 1).trim(),
 		options: {},
 	};
 

package/src/handler/plsql/procedure.js

@@ -15,9 +15,16 @@ 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';
+import {OWAPageStream} from './owaPageStream.js';
+import {traceManager} from '../../util/traceManager.js';
+
+/**
+ * @typedef {import('../../admin/js/types.js').TraceEntry} TraceEntry
+ */
 
 /**
  * @typedef {import('express').Request} Request
@@ -29,6 +36,8 @@ import {sanitizeProcName} from './procedureSanitize.js';
  * @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
  */
 
 /**
@@ -38,12 +47,16 @@ import {sanitizeProcName} from './procedureSanitize.js';
  *	@param {argObjType} argObj - The arguments to pass to the procedure
  *	@param {configPlSqlHandlerType} options - The options for the middleware
  *	@param {Connection} databaseConnection - The database connection
- *	@returns {Promise<{sql: string; bind: BindParameterConfig}>} - The SQL statement and bindings for the procedure to execute
+ *	@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) => {
+const getProcedure = async (req, procName, argObj, options, databaseConnection, procedureNameCache, argumentCache) => {
 	// path alias
 	if (options.pathAlias?.toLowerCase() === procName.toLowerCase()) {
+		/* v8 ignore start */
 		debug(`getProcedure: path alias "${options.pathAlias}" redirects to "${options.pathAliasProcedure}"`);
+		/* v8 ignore stop */
 		return {
 			sql: `${options.pathAliasProcedure}(p_path=>:p_path)`,
 			bind: {
@@ -56,13 +69,20 @@ const getProcedure = async (req, procName, argObj, options, databaseConnection)
 	const useVariableArguments = procName.startsWith('!');
 
 	// sanitize procedure name
-	const sanitizedProcName = await sanitizeProcName(useVariableArguments ? procName.substring(1) : procName, databaseConnection, options);
+	const rawName = useVariableArguments ? procName.substring(1) : procName;
+	const sanitizedProcName = await sanitizeProcName(rawName, databaseConnection, options, procedureNameCache);
 
 	// run procedure
 	if (useVariableArguments) {
-		return getProcedureVariable(req, sanitizedProcName, argObj);
+		return {
+			...getProcedureVariable(req, sanitizedProcName, argObj),
+			resolvedName: sanitizedProcName,
+		};
 	} else {
-		return await getProcedureNamed(req, sanitizedProcName, argObj, databaseConnection);
+		return {
+			...(await getProcedureNamed(req, sanitizedProcName, argObj, databaseConnection, argumentCache)),
+			resolvedName: sanitizedProcName,
+		};
 	}
 };
 
@@ -119,47 +139,6 @@ const procedureExecute = async (para, databaseConnection) => {
 	}
 };
 
-/**
- * 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
  *
@@ -197,9 +176,11 @@ END;
 	try {
 		result = await databaseConnection.execute(sqlStatement, bindParameter);
 	} catch (err) {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debug(getBlock('procedureDownloadFiles: results', inspect(result)));
 		}
+		/* v8 ignore stop */
 
 		throw new ProcedureError(`procedureDownloadFiles: error when downloading files\n${errorToString(err)}`, {}, sqlStatement, bindParameter);
 	}
@@ -229,81 +210,216 @@ END;
  * @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) => {
+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');
-	const para = await getProcedure(req, Array.isArray(req.params.name) ? req.params.name[0] : req.params.name, argObj, options, databaseConnection);
-
-	// 3) prepare the session
-
-	debug('invokeProcedure: prepare the session');
-	await procedurePrepare(cgiObj, databaseConnection);
-
-	// 4) execute the procedure
-
-	debug('invokeProcedure: execute the session');
-	await procedureExecute(para, databaseConnection);
-
-	// 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));
+	const startTime = Date.now();
+	/** @type {TraceEntry | null} */
+	let traceData = null;
+
+	if (traceManager.isEnabled()) {
+		traceData = {
+			id: Math.random().toString(36).substring(2, 15),
+			timestamp: new Date().toISOString(),
+			source: cgiObj.REMOTE_ADDR ?? '',
+			url: req.originalUrl,
+			method: req.method,
+			status: 'pending',
+			duration: 0,
+			cgi: cgiObj,
+			headers: /** @type {Record<string, string>} */ (req.headers),
+			cookies: req.cookies,
+			uploads: filesToUpload.map((f) => ({
+				originalname: f.originalname,
+				mimetype: f.mimetype,
+				size: f.size,
+			})),
+		};
 	}
 
-	// 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})));
+		// 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`);
+			}
 		}
 
-		// 7) parse the page
+		// 2) get procedure to execute and the arguments
 
-		debug('invokeProcedure: parse the page');
-		const pageComponents = parsePage(lines);
+		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);
 
-		// add "Server" header
-		pageComponents.head.server = cgiObj.SERVER_SOFTWARE;
+		if (traceData) {
+			traceData.procedure = para.resolvedName;
+			traceData.parameters = para.bind;
+		}
 
-		// 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;
+		// 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;
 		}
 
-		// 8) send the page to browser
+		// 5) get the page returned from the procedure
+		debug('invokeProcedure: get the page returned from the procedure');
 
-		debug('invokeProcedure: send the page to browser');
-		await sendResponse(req, res, pageComponents);
-	} finally {
-		// 9) cleanup
+		const streamInstance = new OWAPageStream(databaseConnection);
+		const lines = await streamInstance.fetchChunk();
 
-		debug('invokeProcedure: cleanup');
-		fileBlob.destroy();
+		/* v8 ignore start */
+		if (debug.enabled) {
+			debug(getBlock('data', lines.join('')));
+		}
+		/* v8 ignore stop */
+
+		// 6) download files
+
+		debug('invokeProcedure: download files');
+		const fileBlob = await databaseConnection.createLob(oracledb.BLOB);
+
+		try {
+			const fileDownload = await procedureDownloadFiles(fileBlob, databaseConnection);
+			/* v8 ignore start */
+			if (debug.enabled) {
+				debug(getBlock('fileDownload', inspect({fileType: fileDownload.fileType, fileSize: fileDownload.fileSize})));
+			}
+			/* v8 ignore stop */
+
+			// 7) parse the page
+
+			debug('invokeProcedure: parse the page');
+			// We parse the headers from the first chunk
+			const pageComponents = parsePage(lines.join(''));
+
+			// 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;
+
+				if (traceData) {
+					traceData.downloads = {
+						fileType: fileDownload.fileType,
+						fileSize: fileDownload.fileSize,
+					};
+				}
+			} else {
+				// For normal pages, we use the stream.
+				// Prepend the initial body (parsed by parsePage) to the stream
+				if (typeof pageComponents.body === 'string' && pageComponents.body.length > 0) {
+					streamInstance.addBody(pageComponents.body);
+				}
+				// Use the stream as the body
+				pageComponents.body = streamInstance;
+
+				if (traceData) {
+					// Buffer HTML if tracing enabled
+					let htmlBuffer = typeof pageComponents.body === 'string' ? pageComponents.body : lines.join('');
+					const MAX_HTML_SIZE = 1024 * 1024; // 1MB
+
+					const originalPush = streamInstance.push.bind(streamInstance);
+					streamInstance.push = (chunk) => {
+						if (chunk !== null && htmlBuffer.length < MAX_HTML_SIZE) {
+							const str = String(chunk);
+							htmlBuffer += str;
+							if (htmlBuffer.length > MAX_HTML_SIZE) {
+								htmlBuffer = htmlBuffer.substring(0, MAX_HTML_SIZE) + '... [truncated]';
+							}
+						}
+						return originalPush(chunk);
+					};
+
+					// Since we can't easily wait for the stream to finish here without blocking,
+					// we'll have to finalize traceData when the stream ends.
+					const currentTrace = traceData;
+					streamInstance.on('end', () => {
+						currentTrace.html = htmlBuffer;
+						currentTrace.status = 'success';
+						currentTrace.duration = Date.now() - startTime;
+						traceManager.addTrace(currentTrace);
+					});
+					streamInstance.on('error', (err) => {
+						currentTrace.status = 'fail';
+						currentTrace.error = err instanceof Error ? err.message : String(err);
+						currentTrace.duration = Date.now() - startTime;
+						traceManager.addTrace(currentTrace);
+					});
+				}
+			}
+
+			// 8) send the page to browser
+
+			debug('invokeProcedure: send the page to browser');
+			await sendResponse(req, res, pageComponents);
+
+			if (traceData?.downloads) {
+				traceData.status = 'success';
+				traceData.duration = Date.now() - startTime;
+				traceManager.addTrace(traceData);
+			}
+		} finally {
+			// 9) cleanup
+
+			debug('invokeProcedure: cleanup');
+			fileBlob.destroy();
+		}
+	} catch (err) {
+		if (traceData) {
+			traceData.status = err instanceof ProcedureError ? 'error' : 'fail';
+			traceData.error = err instanceof Error ? err.message : String(err);
+			traceData.duration = Date.now() - startTime;
+			traceManager.addTrace(traceData);
+		}
+		throw err;
 	}
 
 	debug('invokeProcedure: end');