web_plsql 1.0.0 → 1.2.0

package/src/handler/plsql/procedure.js

@@ -19,6 +19,12 @@ 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
@@ -48,7 +54,9 @@ import {sanitizeProcName} from './procedureSanitize.js';
 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: {
@@ -131,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
  *
@@ -209,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);
 	}
@@ -248,108 +217,209 @@ END;
 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;
+	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,
+			})),
+		};
+	}
 
-			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`);
+	try {
+		// 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
+		// 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);
+		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
+		if (traceData) {
+			traceData.procedure = para.resolvedName;
+			traceData.parameters = para.bind;
+		}
 
-	debug('invokeProcedure: prepare the session');
-	await procedurePrepare(cgiObj, databaseConnection);
+		// 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;
+		}
 
-	// 4) execute the procedure
+		// 5) get the page returned from the procedure
+		debug('invokeProcedure: get the page returned from 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);
-				}
+		const streamInstance = new OWAPageStream(databaseConnection);
+		const lines = await streamInstance.fetchChunk();
 
-				// Clear argument cache for the resolved name
-				if (para.resolvedName) {
-					argumentCache.delete(para.resolvedName.toUpperCase());
-				}
-			}
+		/* v8 ignore start */
+		if (debug.enabled) {
+			debug(getBlock('data', lines.join('')));
 		}
-		throw err;
-	}
+		/* v8 ignore stop */
 
-	// 5) get the page returned from the procedure
+		// 6) download files
 
-	debug('invokeProcedure: get the page returned from the procedure');
-	const lines = await procedureGetPage(true, databaseConnection);
-	if (debug.enabled) {
-		debug(getBlock('data', lines));
-	}
+		debug('invokeProcedure: download files');
+		const fileBlob = await databaseConnection.createLob(oracledb.BLOB);
 
-	// 6) download files
+		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 */
 
-	debug('invokeProcedure: download files');
-	const fileBlob = await databaseConnection.createLob(oracledb.BLOB);
+			// 7) parse the page
 
-	try {
-		const fileDownload = await procedureDownloadFiles(fileBlob, databaseConnection);
-		if (debug.enabled) {
-			debug(getBlock('fileDownload', inspect({fileType: fileDownload.fileType, fileSize: fileDownload.fileSize})));
-		}
+			debug('invokeProcedure: parse the page');
+			// We parse the headers from the first chunk
+			const pageComponents = parsePage(lines.join(''));
 
-		// 7) parse the page
+			// add "Server" header
+			pageComponents.head.server = cgiObj.SERVER_SOFTWARE ?? '';
 
-		debug('invokeProcedure: parse the page');
-		const pageComponents = parsePage(lines);
+			// 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;
 
-		// add "Server" header
-		pageComponents.head.server = cgiObj.SERVER_SOFTWARE ?? '';
+				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);
+					});
+				}
+			}
 
-		// 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
 
-		// 8) send the page to browser
+			debug('invokeProcedure: send the page to browser');
+			await sendResponse(req, res, pageComponents);
 
-		debug('invokeProcedure: send the page to browser');
-		await sendResponse(req, res, pageComponents);
-	} finally {
-		// 9) cleanup
+			if (traceData?.downloads) {
+				traceData.status = 'success';
+				traceData.duration = Date.now() - startTime;
+				traceManager.addTrace(traceData);
+			}
+		} finally {
+			// 9) cleanup
 
-		debug('invokeProcedure: cleanup');
-		fileBlob.destroy();
+			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');

package/src/handler/plsql/procedureNamed.js

@@ -83,22 +83,28 @@ const loadArguments = async (procedure, databaseConnection) => {
 	try {
 		result = await databaseConnection.execute(SQL_GET_ARGUMENT, bind);
 	} catch (err) {
+		/* v8 ignore start */
 		debug('result', result);
+		/* v8 ignore stop */
+
 		const message = `Error when retrieving arguments\n${SQL_GET_ARGUMENT}\n${errorToString(err)}`;
 		throw new RequestError(message);
 	}
 
-	/** @type {{names: string[], types: string[]}} */
+	/** @type {{names: (string | null)[], types: (string | null)[]}} */
 	let data;
 	try {
 		data = z
 			.object({
-				names: z.array(z.string()),
-				types: z.array(z.string()),
+				names: z.array(z.string().nullable()),
+				types: z.array(z.string().nullable()),
 			})
 			.parse(result.outBinds);
 	} catch (err) {
+		/* v8 ignore start */
 		debug('result.outBinds', result.outBinds);
+		/* v8 ignore stop */
+
 		const message = `Error when decoding arguments\n${SQL_GET_ARGUMENT}\n${errorToString(err)}`;
 		throw new RequestError(message);
 	}
@@ -136,16 +142,22 @@ const findArguments = async (procedure, databaseConnection, argumentCache) => {
 
 	// if we found the procedure in the cache, we return it
 	if (cachedArgs) {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debug(`findArguments: procedure "${procedure}" found in cache`);
 		}
+		/* v8 ignore stop */
+
 		return cachedArgs;
 	}
 
 	// load from database
+	/* v8 ignore start */
 	if (debug.enabled) {
 		debug(`findArguments: procedure "${procedure}" not found in cache and must be loaded`);
 	}
+	/* v8 ignore stop */
+
 	const args = await loadArguments(procedure, databaseConnection);
 
 	// add to the cache
@@ -259,10 +271,12 @@ export const getProcedureNamed = async (req, procName, argObj, databaseConnectio
 	// select statement
 	const sql = `${procName}(${sqlParameter.join(', ')})`;
 
+	/* v8 ignore start */
 	if (debug.enabled) {
 		debug(sql);
 		debug(inspectBindings(argObj, argTypes));
 	}
+	/* v8 ignore stop */
 
 	return {sql, bind: bindings};
 };

package/src/handler/plsql/procedureSanitize.js

@@ -95,7 +95,10 @@ const resolveProcedureName = async (procName, databaseConnection, procedureNameC
 
 		return resolved;
 	} catch (err) {
+		/* v8 ignore start */
 		debug(`resolveProcedureName: Error resolving "${procName}"`, err);
+		/* v8 ignore stop */
+
 		// Rethrow as RequestError to indicate 404/403
 		throw new RequestError(`Procedure "${procName}" not found or not accessible.\n${errorToString(err)}`);
 	}
@@ -123,7 +126,10 @@ export const sanitizeProcName = async (procName, databaseConnection, options, pr
 	for (const i of DEFAULT_EXCLUSION_LIST) {
 		if (finalProcName.startsWith(i)) {
 			const error = `Procedure name "${procName}" is in default exclusion list "${DEFAULT_EXCLUSION_LIST.join(',')}"`;
+			/* v8 ignore start */
 			debug(error);
+			/* v8 ignore stop */
+
 			throw new RequestError(error);
 		}
 	}
@@ -133,7 +139,10 @@ export const sanitizeProcName = async (procName, databaseConnection, options, pr
 		for (const i of options.exclusionList) {
 			if (finalProcName.startsWith(i)) {
 				const error = `Procedure name "${procName}" is in custom exclusion list "${options.exclusionList.join(',')}"`;
+				/* v8 ignore start */
 				debug(error);
+				/* v8 ignore stop */
+
 				throw new RequestError(error);
 			}
 		}
@@ -148,7 +157,10 @@ export const sanitizeProcName = async (procName, databaseConnection, options, pr
 		const valid = await requestValidationFunction(finalProcName, options.requestValidationFunction, databaseConnection);
 		if (!valid) {
 			const error = `Procedure name "${procName}" is not valid according to the request validation function "${options.requestValidationFunction}"`;
+			/* v8 ignore start */
 			debug(error);
+			/* v8 ignore stop */
+
 			throw new RequestError(error);
 		}
 	}
@@ -209,7 +221,10 @@ const loadRequestValid = async (procName, requestValidationFunction, databaseCon
 	try {
 		result = await databaseConnection.execute(SQL, bind);
 	} catch (err) {
+		/* v8 ignore start */
 		debug('result', result);
+		/* v8 ignore stop */
+
 		const message = `Error when validating procedure name "${procName}"\n${SQL}\n${errorToString(err)}`;
 		throw new RequestError(message);
 	}
@@ -218,7 +233,10 @@ const loadRequestValid = async (procName, requestValidationFunction, databaseCon
 		const data = z.strictObject({valid: z.number()}).parse(result.outBinds);
 		return data.valid === 1;
 	} catch (err) {
+		/* v8 ignore start */
 		debug('result', result.outBinds);
+		/* v8 ignore stop */
+
 		const message = `Internal error when parsing ${result.outBinds}\n${errorToString(err)}`;
 		throw new Error(message);
 	}
@@ -243,16 +261,22 @@ const requestValidationFunction = async (procName, requestValidationFunction, da
 
 	// if we found the procedure in the cache, we return it (hitCount already incremented by get)
 	if (cacheEntry !== undefined) {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debug(`requestValidationFunction: procedure "${procName}" found in cache`);
 		}
+		/* v8 ignore stop */
+
 		return cacheEntry.valid;
 	}
 
 	// load from database
+	/* v8 ignore start */
 	if (debug.enabled) {
 		debug(`requestValidationFunction: procedure "${procName}" not found in cache and must be loaded`);
 	}
+	/* v8 ignore stop */
+
 	const valid = await loadRequestValid(procName, requestValidationFunction, databaseConnection);
 
 	// add to the cache

package/src/handler/plsql/procedureVariable.js

@@ -24,9 +24,11 @@ import oracledb from 'oracledb';
  *	@returns {{sql: string; bind: BindParameterConfig}} - The SQL statement and bindings for the procedure to execute
  */
 export const getProcedureVariable = (_req, procName, argObj) => {
+	/* v8 ignore start */
 	if (debug.enabled) {
 		debug(`getProcedureVariable: ${procName} arguments=`, argObj);
 	}
+	/* v8 ignore stop */
 
 	const names = [];
 	const values = [];

package/src/handler/plsql/sendResponse.js

@@ -29,19 +29,23 @@ export const sendResponse = async (_req, res, page) => {
 
 	// Send the "cookies"
 	page.head.cookies.forEach((cookie) => {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debugText.push(`res.cookie: name="${cookie.name}" value="${cookie.value}" options=${JSON.stringify(cookie.options)}`);
 		}
+		/* v8 ignore stop */
 
 		res.cookie(cookie.name, cookie.value, cookie.options);
 	});
 
 	// If there is a "redirectLocation" header, we immediately redirect and return
 	if (typeof page.head.redirectLocation === 'string' && page.head.redirectLocation.length > 0) {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debugText.push(`res.redirect(302, "${page.head.redirectLocation}")`);
 			debug(getBlock('RESPONSE', debugText.join('\n')));
 		}
+		/* v8 ignore stop */
 
 		res.redirect(302, page.head.redirectLocation);
 		return;
@@ -49,9 +53,11 @@ export const sendResponse = async (_req, res, page) => {
 
 	// Send all the "otherHeaders"
 	for (const key in page.head.otherHeaders) {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debugText.push(`res.set("${key}", "${page.head.otherHeaders[key]}")`);
 		}
+		/* v8 ignore stop */
 
 		res.set(key, page.head.otherHeaders[key]);
 	}
@@ -70,18 +76,23 @@ export const sendResponse = async (_req, res, page) => {
 		}
 
 		if (Object.keys(headers).length > 0) {
+			/* v8 ignore start */
 			if (debug.enabled) {
 				debugText.push(`res.writeHead(200, ${JSON.stringify(headers)})`);
 			}
+			/* v8 ignore stop */
+
 			res.writeHead(200, headers);
 		}
 
 		// Check if fileBlob is a stream
 		if (page.file.fileBlob instanceof stream.Readable) {
+			/* v8 ignore start */
 			if (debug.enabled) {
 				debugText.push(`res.pipe("${page.file.fileType}") - streaming`);
 				debug(getBlock('RESPONSE', debugText.join('\n')));
 			}
+			/* v8 ignore stop */
 
 			/** @type {Promise<void>} */
 			const streamComplete = new Promise((resolve, reject) => {
@@ -96,10 +107,12 @@ export const sendResponse = async (_req, res, page) => {
 			});
 			await streamComplete;
 		} else {
+			/* v8 ignore start */
 			if (debug.enabled) {
 				debugText.push(`res.end("${page.file.fileType}") - buffer`);
 				debug(getBlock('RESPONSE', debugText.join('\n')));
 			}
+			/* v8 ignore stop */
 
 			res.end(page.file.fileBlob, 'binary');
 		}
@@ -108,29 +121,54 @@ export const sendResponse = async (_req, res, page) => {
 
 	// Is the a "contentType" header
 	if (typeof page.head.contentType === 'string' && page.head.contentType.length > 0) {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debugText.push(`res.set("Content-Type", "${page.head.contentType}")`);
 		}
+		/* v8 ignore stop */
 
 		res.set('Content-Type', page.head.contentType);
 	}
 
 	// If we have a "Status" header, we send the header and then return.
 	if (typeof page.head.statusCode === 'number') {
+		/* v8 ignore start */
 		if (debug.enabled) {
 			debugText.push(`res.status(page.head.statusCode).send("${page.head.statusDescription}")`);
 			debug(getBlock('RESPONSE', debugText.join('\n')));
 		}
+		/* v8 ignore stop */
 
 		res.status(page.head.statusCode).send(page.head.statusDescription);
 		return;
 	}
 
 	// Send the body
+	/* v8 ignore start */
 	if (debug.enabled) {
-		debugText.push(`${'-'.repeat(60)}\n${page.body}`);
+		if (page.body instanceof stream.Readable) {
+			debugText.push(`${'-'.repeat(60)}\n[Stream Body]`);
+		} else {
+			debugText.push(`${'-'.repeat(60)}\n${page.body}`);
+		}
 		debug(getBlock('RESPONSE', debugText.join('\n')));
 	}
-
-	res.send(page.body);
+	/* v8 ignore stop */
+
+	if (page.body instanceof stream.Readable) {
+		/** @type {Promise<void>} */
+		const streamComplete = new Promise((resolve, reject) => {
+			if (page.body instanceof stream.Readable) {
+				page.body.pipe(res);
+				page.body.on('end', () => resolve());
+				/* v8 ignore next - error handler */
+				page.body.on('error', (/** @type {Error} */ err) => reject(err));
+				/* v8 ignore next - error handler */
+				res.on('close', () => resolve());
+			}
+		});
+		await streamComplete;
+	} else {
+		res.send(page.body);
+	}
 };

package/src/index.js

@@ -11,7 +11,6 @@ export * from './util/shutdown.js';
 export {handlerWebPlSql} from './handler/plsql/handlerPlSql.js';
 export {handlerLogger} from './handler/handlerLogger.js';
 export {handlerUpload} from './handler/handlerUpload.js';
-export {handlerMetrics} from './handler/handlerMetrics.js';
 
 // oracle
 export * from './util/oracle.js';