web_plsql 0.17.1 → 1.0.0

package/src/handler/plsql/sendResponse.js

@@ -5,6 +5,7 @@
 import debugModule from 'debug';
 const debug = debugModule('webplsql:sendResponse');
 
+import stream from 'node:stream';
 import {getBlock} from '../../util/trace.js';
 
 /**
@@ -17,12 +18,12 @@ import {getBlock} from '../../util/trace.js';
 
 /**
  *	Send "default" response to the browser
- *	@param {Request} req - The req object represents the HTTP request.
+ *	@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 {pageType} page - The page to send.
- *	@returns {void}
+ *	@returns {Promise<void>}
  */
-export const sendResponse = (req, res, page) => {
+export const sendResponse = async (_req, res, page) => {
 	/** @type {string[]} */
 	const debugText = [];
 
@@ -57,20 +58,51 @@ export const sendResponse = (req, res, page) => {
 
 	// If this is a file download, we eventually set the "Content-Type" and the file content and then return.
 	if (page.file.fileType === 'B' || page.file.fileType === 'F') {
+		/** @type {Record<string, string>} */
+		const headers = {};
+
 		if (typeof page.head.contentType === 'string' && page.head.contentType.length > 0) {
-			if (debug.enabled) {
-				debugText.push(`res.writeHead("Content-Type", "${page.head.contentType}")`);
-			}
+			headers['Content-Type'] = page.head.contentType;
+		}
 
-			res.writeHead(200, {'Content-Type': page.head.contentType});
+		if (typeof page.file.fileSize === 'number' && page.file.fileSize > 0) {
+			headers['Content-Length'] = page.file.fileSize.toString();
 		}
 
-		if (debug.enabled) {
-			debugText.push(`res.end("${page.file.fileType}")`);
-			debug(getBlock('RESPONSE', debugText.join('\n')));
+		if (Object.keys(headers).length > 0) {
+			if (debug.enabled) {
+				debugText.push(`res.writeHead(200, ${JSON.stringify(headers)})`);
+			}
+			res.writeHead(200, headers);
 		}
 
-		res.end(page.file.fileBlob, 'binary');
+		// Check if fileBlob is a stream
+		if (page.file.fileBlob instanceof stream.Readable) {
+			if (debug.enabled) {
+				debugText.push(`res.pipe("${page.file.fileType}") - streaming`);
+				debug(getBlock('RESPONSE', debugText.join('\n')));
+			}
+
+			/** @type {Promise<void>} */
+			const streamComplete = new Promise((resolve, reject) => {
+				if (page.file.fileBlob instanceof stream.Readable) {
+					page.file.fileBlob.pipe(res);
+					page.file.fileBlob.on('end', () => resolve());
+					/* v8 ignore next - error handler */
+					page.file.fileBlob.on('error', (/** @type {Error} */ err) => reject(err));
+					/* v8 ignore next - error handler */
+					res.on('close', () => resolve());
+				}
+			});
+			await streamComplete;
+		} else {
+			if (debug.enabled) {
+				debugText.push(`res.end("${page.file.fileType}") - buffer`);
+				debug(getBlock('RESPONSE', debugText.join('\n')));
+			}
+
+			res.end(page.file.fileBlob, 'binary');
+		}
 		return;
 	}
 

package/src/handler/plsql/stream.js

@@ -21,7 +21,7 @@ export const streamToBuffer = async (readable) => {
 		});
 
 		readable.on('error', (err) => {
-			// istanbul ignore next
+			/* v8 ignore next - error handler */
 			reject(err);
 		});
 	});

package/src/handler/plsql/upload.js

@@ -70,7 +70,7 @@ export const getFiles = (req) => {
 export const uploadFile = async (file, doctable, databaseConnection) => {
 	debug(`uploadFile`, file, doctable);
 
-	/* istanbul ignore next */
+	/* v8 ignore next - defensive validation */
 	if (typeof doctable !== 'string' || doctable.length === 0) {
 		throw new Error(`Unable to upload file "${file.filename}" because the option ""doctable" has not been defined`);
 	}

package/src/server/config.js

@@ -17,6 +17,7 @@ export const showConfig = (config) => {
 	console.log(LINE);
 
 	console.log(`Server port:            ${config.port}`);
+	console.log(`Admin route:            ${config.adminRoute ?? '/admin'}${config.adminUser ? ' (authenticated)' : ''}`);
 	console.log(`Access log:             ${config.loggerFilename.length > 0 ? config.loggerFilename : ''}`);
 	console.log(`Upload file size limit: ${typeof config.uploadFileSizeLimit === 'number' ? `${config.uploadFileSizeLimit} bytes` : 'any'}`);
 

package/src/server/server.js

@@ -2,6 +2,8 @@ import debugModule from 'debug';
 const debug = debugModule('webplsql:server');
 import http from 'node:http';
 import https from 'node:https';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
 import express from 'express';
 import cookieParser from 'cookie-parser';
 import compression from 'compression';
@@ -11,8 +13,13 @@ import {poolCreate, poolsClose} from '../util/oracle.js';
 import {handlerUpload} from '../handler/handlerUpload.js';
 import {handlerLogger} from '../handler/handlerLogger.js';
 import {handlerWebPlSql} from '../handler/plsql/handlerPlSql.js';
+import {handlerAdmin} from '../handler/handlerAdmin.js';
 import {readFileSyncUtf8, getJsonFile} from '../util/file.js';
 import {showConfig} from './config.js';
+import {Cache} from '../util/cache.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 /**
  * @typedef {import('node:net').Socket} Socket
@@ -23,7 +30,34 @@ import {showConfig} from './config.js';
  * @typedef {import('oracledb').Pool} Pool
  * @typedef {import('../types.js').environmentType} environmentType
  * @typedef {import('../types.js').configType} configType
+ * @typedef {import('../handler/plsql/procedureNamed.js').argsType} argsType
+ */
+
+/**
+ * @typedef {import('express').RequestHandler & {
+ *   procedureNameCache: Cache<string>;
+ *   argumentCache: Cache<argsType>;
+ * }} ExtendedRequestHandler
+ */
+
+/**
+ * Global Admin Context
  */
+export const AdminContext = {
+	startTime: new Date(),
+	/** @type {configType | null} */
+	config: null,
+	/** @type {Pool[]} */
+	pools: [],
+	/** @type {Array<{poolName: string, procedureNameCache: Cache<string>, argumentCache: Cache<argsType>}>} */
+	caches: [],
+	paused: false,
+	metrics: {
+		requestCount: 0,
+		errorCount: 0,
+		totalDuration: 0,
+	},
+};
 
 /**
  * @typedef {object} webServer - Web server interface.
@@ -40,6 +74,42 @@ import {showConfig} from './config.js';
  * @property {string} certFilename - cert filename.
  */
 
+/**
+ * Admin basic auth middleware
+ * @param {Request} req - The request.
+ * @param {Response} res - The response.
+ * @param {NextFunction} next - The next function.
+ */
+const adminAuth = (req, res, next) => {
+	const adminRoute = AdminContext.config?.adminRoute ?? '/admin';
+
+	// Simple pause check for all PL/SQL routes (not admin)
+	if (AdminContext.paused && !req.path.startsWith(adminRoute)) {
+		res.status(503).send('Server Paused');
+		return;
+	}
+
+	// Basic Auth for Admin Route
+	if (req.path.startsWith(adminRoute)) {
+		const user = AdminContext.config?.adminUser;
+		const pass = AdminContext.config?.adminPassword;
+
+		if (user && pass) {
+			const auth = {login: user, password: pass};
+			const b64auth = (req.headers.authorization ?? '').split(' ')[1] ?? '';
+			const [login, password] = Buffer.from(b64auth, 'base64').toString().split(':');
+
+			if (login !== auth.login || password !== auth.password) {
+				res.set('WWW-Authenticate', 'Basic realm="Admin Console"');
+				res.status(401).send('Authentication required.');
+				return;
+			}
+		}
+	}
+
+	next();
+};
+
 /**
  * Create HTTPS server.
  * @param {Express} app - express application
@@ -67,17 +137,27 @@ export const startServer = async (config, ssl) => {
 	debug('startServer: BEGIN', config, ssl);
 
 	const internalConfig = /** @type {configType} */ (z$configType.parse(config));
+	AdminContext.config = internalConfig;
 
 	showConfig(internalConfig);
 
 	// Create express app
 	const app = express();
 
+	// Pause & Admin Auth middleware
+	app.use(adminAuth);
+
 	// Access log
 	if (internalConfig.loggerFilename.length > 0) {
 		app.use(handlerLogger(internalConfig.loggerFilename));
 	}
 
+	// Admin console
+	const adminRoute = internalConfig.adminRoute ?? '/admin';
+	const adminDirectory = path.resolve(__dirname, '../admin');
+	app.use(adminRoute, handlerAdmin);
+	app.use(adminRoute, express.static(adminDirectory));
+
 	// Serving static files
 	for (const i of internalConfig.routeStatic) {
 		app.use(i.route, express.static(i.directoryPath));
@@ -92,6 +172,8 @@ export const startServer = async (config, ssl) => {
 
 	/** @type {Pool[]} */
 	const connectionPools = [];
+	AdminContext.pools = connectionPools;
+	AdminContext.caches = [];
 
 	// Oracle pl/sql express middleware
 	for (const i of internalConfig.routePlSql) {
@@ -99,7 +181,25 @@ export const startServer = async (config, ssl) => {
 		const pool = await poolCreate(i.user, i.password, i.connectString);
 		connectionPools.push(pool);
 
-		app.use([`${i.route}/:name`, i.route], handlerWebPlSql(pool, i));
+		const handler = handlerWebPlSql(pool, i);
+
+		// Capture caches for admin console
+		AdminContext.caches.push({
+			poolName: i.route,
+			procedureNameCache: handler.procedureNameCache,
+			argumentCache: handler.argumentCache,
+		});
+
+		app.use([`${i.route}/:name`, i.route], (req, res, next) => {
+			AdminContext.metrics.requestCount++;
+			const start = process.hrtime();
+			res.on('finish', () => {
+				const diff = process.hrtime(start);
+				const duration = diff[0] * 1000 + diff[1] / 1_000_000;
+				AdminContext.metrics.totalDuration += duration;
+			});
+			handler(req, res, next);
+		});
 	}
 
 	// create server
@@ -150,7 +250,13 @@ export const startServer = async (config, ssl) => {
 					resolve();
 				})
 				.on('error', (err) => {
-					console.error(err);
+					if ('code' in err) {
+						if (err.code === 'EADDRINUSE') {
+							err.message = `Port ${internalConfig.port} is already in use`;
+						} else if (err.code === 'EACCES') {
+							err.message = `Port ${internalConfig.port} requires elevated privileges`;
+						}
+					}
 					reject(err);
 				});
 		})

package/src/types.js

@@ -82,6 +82,9 @@ export const z$configPlSqlType = z.strictObject({
  * @property {configPlSqlType[]} routePlSql - The PL/SQL routes.
  * @property {number} [uploadFileSizeLimit] - Maximum size of each uploaded file in bytes or no limit if omitted.
  * @property {string} loggerFilename - name of the request logger filename or '' if not required.
+ * @property {string} [adminRoute] - Optional route for the admin console (defaults to /admin).
+ * @property {string} [adminUser] - Optional username for admin console basic auth.
+ * @property {string} [adminPassword] - Optional password for admin console basic auth.
  */
 export const z$configType = z.strictObject({
 	port: z.number(),
@@ -89,6 +92,9 @@ export const z$configType = z.strictObject({
 	routePlSql: z.array(z$configPlSqlType),
 	uploadFileSizeLimit: z.number().optional(),
 	loggerFilename: z.string(),
+	adminRoute: z.string().optional(),
+	adminUser: z.string().optional(),
+	adminPassword: z.string().optional(),
 });
 
 /**
@@ -140,5 +146,5 @@ export const z$configType = z.strictObject({
  * @property {object} file - The file.
  * @property {string | null} file.fileType - The file type.
  * @property {number | null} file.fileSize - The file size.
- * @property {Buffer | null} file.fileBlob - The file blob.
+ * @property {import('node:stream').Readable | Buffer | null} file.fileBlob - The file blob.
  */

package/src/util/cache.js

@@ -0,0 +1,123 @@
+/**
+ * @template T
+ * @typedef {{hitCount: number, value: T}} cacheEntryType
+ */
+
+/**
+ * Generic Cache class with LFU (Least Frequently Used) eviction policy.
+ * @template T
+ */
+export class Cache {
+	/**
+	 * @param {number} maxSize - Maximum number of entries in the cache.
+	 */
+	constructor(maxSize = 10000) {
+		/** @type {Map<string, cacheEntryType<T>>} */
+		this.cache = new Map();
+		this.maxSize = maxSize;
+		this.hits = 0;
+		this.misses = 0;
+	}
+
+	/**
+	 * Get an entry from the cache.
+	 * @param {string} key - The key.
+	 * @returns {T | undefined} - The value or undefined if not found.
+	 */
+	get(key) {
+		const entry = this.cache.get(key);
+		if (entry) {
+			entry.hitCount++;
+			this.hits++;
+			return entry.value;
+		}
+		this.misses++;
+		return undefined;
+	}
+
+	/**
+	 * Set an entry in the cache.
+	 * @param {string} key - The key.
+	 * @param {T} value - The value.
+	 */
+	set(key, value) {
+		// If updating an existing key, preserve its hitCount?
+		// Typically LFU implies resetting or keeping.
+		// For simplicity and avoiding complex aging, if we set it again, we reset hitCount or keep it?
+		// The requirement is "cache invalidation" (delete) or "cache loading" (set).
+		// If we overwrite, it's usually a new value. Let's reset hitCount to 0 for a fresh start or 1.
+
+		// Ensure we have space
+		if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+			this.prune();
+		}
+
+		this.cache.set(key, {hitCount: 0, value});
+	}
+
+	/**
+	 * Delete an entry from the cache.
+	 * @param {string} key - The key.
+	 */
+	delete(key) {
+		this.cache.delete(key);
+	}
+
+	/**
+	 * Clear the cache.
+	 */
+	clear() {
+		this.cache.clear();
+		this.hits = 0;
+		this.misses = 0;
+	}
+
+	/**
+	 * Prune the cache by removing the least frequently used entries.
+	 * Removes 10% of the cache size.
+	 */
+	prune() {
+		// Convert cache entries to an array
+		const entries = Array.from(this.cache.entries());
+
+		// Sort entries by hitCount in ascending order
+		entries.sort((a, b) => a[1].hitCount - b[1].hitCount);
+
+		// Remove the bottom 10%
+		const removeCount = Math.max(1, Math.floor(this.maxSize * 0.1));
+		const keysToRemove = entries.slice(0, removeCount).map(([key]) => key);
+
+		for (const key of keysToRemove) {
+			this.cache.delete(key);
+		}
+	}
+
+	/**
+	 * Get the size of the cache.
+	 * @returns {number} - The size.
+	 */
+	get size() {
+		return this.cache.size;
+	}
+
+	/**
+	 * Get all keys in the cache.
+	 * @returns {string[]} - The keys.
+	 */
+	keys() {
+		return Array.from(this.cache.keys());
+	}
+
+	/**
+	 * Get cache statistics.
+	 * @returns {{size: number, maxSize: number, hits: number, misses: number}} - The statistics.
+	 */
+	getStats() {
+		return {
+			size: this.cache.size,
+			maxSize: this.maxSize,
+			hits: this.hits,
+			misses: this.misses,
+		};
+	}
+}

package/src/util/file.js

@@ -10,7 +10,6 @@ export const readFileSyncUtf8 = (filePath) => {
 	try {
 		return readFileSync(filePath, 'utf8');
 	} catch (err) {
-		/* istanbul ignore next */
 		throw new Error(`Unable to read file "${filePath}"`);
 	}
 };
@@ -21,11 +20,10 @@ export const readFileSyncUtf8 = (filePath) => {
  * @param {string} filePath - File name.
  * @returns {Promise<Buffer>} The buffer.
  */
-export const readFile = (filePath) => {
+export const readFile = async (filePath) => {
 	try {
-		return fs.readFile(filePath);
+		return await fs.readFile(filePath);
 	} catch (err) {
-		/* istanbul ignore next */
 		throw new Error(`Unable to read file "${filePath}"`);
 	}
 };
@@ -36,11 +34,10 @@ export const readFile = (filePath) => {
  * @param {string} filePath - File name.
  * @returns {Promise<void>}.
  */
-export const removeFile = (filePath) => {
+export const removeFile = async (filePath) => {
 	try {
-		return fs.unlink(filePath);
+		return await fs.unlink(filePath);
 	} catch (err) {
-		/* istanbul ignore next */
 		throw new Error(`Unable to remove file "${filePath}"`);
 	}
 };
@@ -52,9 +49,8 @@ export const removeFile = (filePath) => {
  * @returns {unknown} The json object.
  */
 export const getJsonFile = (filePath) => {
-	const fileContent = readFileSync(filePath, 'utf8');
-
 	try {
+		const fileContent = readFileSync(filePath, 'utf8');
 		return JSON.parse(fileContent);
 	} catch (err) {
 		throw new Error(`Unable to load file "${filePath}"`);

package/src/util/jsonLogger.js

@@ -0,0 +1,47 @@
+import * as rotatingFileStream from 'rotating-file-stream';
+
+/**
+ * @typedef {object} LogEntry
+ * @property {string} timestamp - ISO string
+ * @property {'error'|'info'|'warning'} type - Log level
+ * @property {string} message - Error message
+ * @property {object} [req] - Request details
+ * @property {object} [details] - Additional details (stack, sql, etc)
+ */
+
+export class JsonLogger {
+	constructor(filename = 'error.json.log') {
+		this.stream = rotatingFileStream.createStream(filename, {
+			size: '10M', // rotate every 10 MegaBytes written
+			interval: '1d', // rotate daily
+			maxFiles: 10, // maximum number of rotated files to keep
+			compress: 'gzip', // compress rotated files
+		});
+	}
+
+	/**
+	 * Log an entry as NDJSON.
+	 * @param {LogEntry} entry - The entry to log.
+	 */
+	log(entry) {
+		try {
+			// Ensure timestamp exists
+			if (!entry.timestamp) {
+				entry.timestamp = new Date().toISOString();
+			}
+			const line = JSON.stringify(entry);
+			this.stream.write(line + '\n');
+		} catch (err) {
+			console.error('JsonLogger: Failed to write log', err);
+		}
+	}
+
+	/**
+	 * Close the stream.
+	 */
+	close() {
+		this.stream.end();
+	}
+}
+
+export const jsonLogger = new JsonLogger();

package/src/util/shutdown.js

@@ -12,8 +12,12 @@ export const installShutdown = (handler) => {
 	/*
 	 *	The 'unhandledRejection' event is emitted whenever a Promise is rejected and no error handler is attached to the promise within a turn of the event loop.
 	 */
-	process.on('unhandledRejection', (reason, p) => {
-		console.log('\nUnhandled promise rejection. Graceful shutdown...', reason, p);
+	process.on('unhandledRejection', (reason) => {
+		if (reason instanceof Error) {
+			console.error(`\n${reason.message}. Graceful shutdown...`);
+		} else {
+			console.error('\nUnhandled promise rejection. Graceful shutdown...', reason);
+		}
 		void handler();
 	});
 

package/src/util/trace.js

@@ -57,7 +57,7 @@ export const toTable = (head, body) => {
 
 	// Calculate column widths
 	const widths = head.map((h, i) => {
-		const bodyMax = Math.max(0, ...body.map((row) => (row[i] || '').length));
+		const bodyMax = Math.max(0, ...body.map((row) => (row[i] ?? '').length));
 		return Math.max(h.length, bodyMax);
 	});
 
@@ -68,13 +68,13 @@ export const toTable = (head, body) => {
 	 *	@returns {string} - The result
 	 */
 	const padCell = (cell, width) => cell.padEnd(width, ' ');
-	const textHeader = head.map((h, i) => padCell(h, widths[i])).join(' | ');
-	const textSeparator = widths.map((w) => '-'.repeat(w)).join('-+-');
-	const textRows = body.map((row) => head.map((_, i) => padCell(row[i] || '', widths[i])).join(' | '));
+	const textHeader = head.map((h, i) => padCell(h, widths[i] ?? 0)).join(' | ');
+	const textSeparator = widths.map((w) => '-'.repeat(w ?? 0)).join('-+-');
+	const textRows = body.map((row) => head.map((_, i) => padCell(row[i] ?? '', widths[i] ?? 0)).join(' | '));
 	const text = [textHeader, textSeparator, ...textRows].join('\n');
 
 	const htmlHead = head.map((h) => `<th>${escapeHtml(h)}</th>`).join('');
-	const htmlBody = body.map((row) => `<tr>${head.map((_, i) => `<td>${escapeHtml(row[i] || '')}</td>`).join('')}</tr>`).join('');
+	const htmlBody = body.map((row) => `<tr>${head.map((_, i) => `<td>${escapeHtml(row[i] ?? '')}</td>`).join('')}</tr>`).join('');
 	const html = `<table><thead><tr>${htmlHead}</tr></thead><tbody>${htmlBody}</tbody></table>`;
 
 	return {text, html};

package/src/version.js

@@ -2,4 +2,4 @@
  * Returns the current library version
  * @returns {string} - Version.
  */
-export const getVersion = () => '0.17.1';
+export const getVersion = () => '1.0.0';

package/types/handler/handlerAdmin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @typedef {import('express').Request} Request
+ * @typedef {import('express').Response} Response
+ * @typedef {import('express').NextFunction} NextFunction
+ */
+export const handlerAdmin: import("express-serve-static-core").Router;
+export type Request = import("express").Request;
+export type Response = import("express").Response;
+export type NextFunction = import("express").NextFunction;

package/types/handler/plsql/errorPage.d.ts

@@ -8,3 +8,4 @@ export type outputType = {
     html: string;
     text: string;
 };
+export type messageType = import("../../util/trace.js").messageType;

package/types/handler/plsql/handlerPlSql.d.ts

@@ -1,4 +1,4 @@
-export function handlerWebPlSql(connectionPool: Pool, config: configPlSqlHandlerType): RequestHandler;
+export function handlerWebPlSql(connectionPool: Pool, config: configPlSqlHandlerType): WebPlSqlRequestHandler;
 export type RequestHandler = import("express").RequestHandler;
 export type Request = import("express").Request;
 export type Response = import("express").Response;
@@ -6,3 +6,8 @@ export type NextFunction = import("express").NextFunction;
 export type Pool = import("oracledb").Pool;
 export type environmentType = import("../../types.js").environmentType;
 export type configPlSqlHandlerType = import("../../types.js").configPlSqlHandlerType;
+export type WebPlSqlRequestHandler = import("express").RequestHandler & {
+    procedureNameCache: Cache<string>;
+    argumentCache: Cache<import("./procedureNamed.js").argsType>;
+};
+import { Cache } from '../../util/cache.js';

package/types/handler/plsql/procedure.d.ts

@@ -1,4 +1,4 @@
-export function invokeProcedure(req: Request, res: Response, argObj: argObjType, cgiObj: environmentType, filesToUpload: fileUploadType[], options: configPlSqlHandlerType, databaseConnection: Connection): Promise<void>;
+export function invokeProcedure(req: Request, res: Response, argObj: argObjType, cgiObj: environmentType, filesToUpload: fileUploadType[], options: configPlSqlHandlerType, databaseConnection: Connection, procedureNameCache: ProcedureNameCache, argumentCache: ArgumentCache): Promise<void>;
 export type Request = import("express").Request;
 export type Response = import("express").Response;
 export type Connection = import("oracledb").Connection;
@@ -8,3 +8,5 @@ export type fileUploadType = import("../../types.js").fileUploadType;
 export type environmentType = import("../../types.js").environmentType;
 export type configPlSqlHandlerType = import("../../types.js").configPlSqlHandlerType;
 export type BindParameterConfig = import("../../types.js").BindParameterConfig;
+export type ProcedureNameCache = import("../../util/cache.js").Cache<string>;
+export type ArgumentCache = import("../../util/cache.js").Cache<import("./procedureNamed.js").argsType>;

package/types/handler/plsql/procedureNamed.d.ts

@@ -1,5 +1,5 @@
 export function getBinding(argName: string, argValue: unknown, argType: string): BindParameter;
-export function getProcedureNamed(req: Request, procName: string, argObj: argObjType, databaseConnection: Connection): Promise<{
+export function getProcedureNamed(req: Request, procName: string, argObj: argObjType, databaseConnection: Connection, argumentCache: ArgumentCache): Promise<{
     sql: string;
     bind: BindParameterConfig;
 }>;
@@ -11,7 +11,4 @@ export type argObjType = import("../../types.js").argObjType;
 export type BindParameterConfig = import("../../types.js").BindParameterConfig;
 export type BindParameter = import("../../types.js").BindParameter;
 export type argsType = Record<string, string>;
-export type cacheEntryType = {
-    hitCount: number;
-    args: argsType;
-};
+export type ArgumentCache = import("../../util/cache.js").Cache<argsType>;

package/types/handler/plsql/procedureSanitize.d.ts

@@ -1,4 +1,4 @@
-export function sanitizeProcName(procName: string, databaseConnection: Connection, options: configPlSqlHandlerType): Promise<string>;
+export function sanitizeProcName(procName: string, databaseConnection: Connection, options: configPlSqlHandlerType, procedureNameCache: ProcedureNameCache): Promise<string>;
 export type Request = import("express").Request;
 export type Response = import("express").Response;
 export type Connection = import("oracledb").Connection;
@@ -8,7 +8,4 @@ export type fileUploadType = import("../../types.js").fileUploadType;
 export type environmentType = import("../../types.js").environmentType;
 export type configPlSqlHandlerType = import("../../types.js").configPlSqlHandlerType;
 export type BindParameterConfig = import("../../types.js").BindParameterConfig;
-export type cacheEntryType = {
-    hitCount: number;
-    valid: boolean;
-};
+export type ProcedureNameCache = import("../../util/cache.js").Cache<string>;

package/types/handler/plsql/procedureVariable.d.ts

@@ -1,4 +1,4 @@
-export function getProcedureVariable(req: Request, procName: string, argObj: argObjType): {
+export function getProcedureVariable(_req: Request, procName: string, argObj: argObjType): {
     sql: string;
     bind: BindParameterConfig;
 };