@63klabs/cache-data 1.3.8 → 1.3.10

package/src/lib/tools/generic.response.xml.js

@@ -1,121 +1,17 @@
-contentType = "application/xml";
+const { createGenericResponseModule } = require("./generic.response");
 
-headers = {
-	"Content-Type": contentType
-};
-
-xml = (body) => {
+const xml = (body) => {
 	return `<?xml version="1.0" encoding="UTF-8" ?>${body}`;
-}
-
-response200 = {
-	statusCode: 200,
-	headers: headers,
-	body: xml("<hello>Success</hello>")
-};
-
-response400 = {
-	statusCode: 400,
-	headers: headers,
-	body: xml("<error>Bad Request</error>")
-};
-
-response401 = {
-	statusCode: 401,
-	headers: headers,
-	body: xml("<error>Unauthorized</error>")
-};
-
-response403 = {
-	statusCode: 403,
-	headers: headers,
-	body: xml("<error>Forbidden</error>")
 };
 
-response404 = {
-	statusCode: 404,
-	headers: headers,
-	body: xml("<error>Not Found</error>")
-};
-
-response405 = {
-	statusCode: 405,
-	headers: headers,
-	body: xml("<error>Method Not Allowed</error>")
-};
-
-response408 = {
-	statusCode: 408,
-	headers: headers,
-	body: xml("<error>Request Timeout</error>")
-};
-
-response418 = {
-	statusCode: 418,
-	headers: headers,
-	body: xml("<error>418 I'm a teapot</error>")
-};
-
-response427 = {
-	statusCode: 427,
-	headers: headers,
-	body: xml("<error>Too Many Requests</error>")
-};
-
-response500 = {
-	statusCode: 500,
-	headers: headers,
-	body: xml("<error>Internal Server Error</error>")
-};
-
-/**
- * 
- * @param {number|string} statusCode 
- * @returns {{statusCode: number, headers: object, body: Array|Object|string}}
- */
-response = function (statusCode) {
-	// convert to int
-	statusCode = parseInt(statusCode, 10);
-
-	switch (statusCode) {
-		case 200:
-			return this.response200;
-		case 400:
-			return this.response400;
-		case 401:
-			return this.response401;
-		case 403:
-			return this.response403;
-		case 404:
-			return this.response404;
-		case 405:
-			return this.response405;
-		case 408:
-			return this.response408;
-		case 418:
-			return this.response418;
-		case 427:
-			return this.response427;
-		case 500:
-			return this.response500;
-		default:
-			return this.response500;
+const xmlBodyFormatter = (statusCode, message) => {
+	if (statusCode === 200) {
+		return xml("<hello>" + message + "</hello>");
 	}
+	const msg = statusCode === 418 ? "418 " + message : message;
+	return xml("<error>" + msg + "</error>");
 };
 
-module.exports = {
-	contentType,
-	headers,
-	xml,
-	response200,
-	response400,
-	response401,
-	response403,
-	response404,
-	response405,
-	response408,
-	response418,
-	response427,
-	response500,
-	response
-}
+const mod = createGenericResponseModule("application/xml", xmlBodyFormatter);
+
+module.exports = { ...mod, xml };

package/src/lib/tools/index.js

@@ -20,7 +20,7 @@
 
 const { nodeVer, nodeVerMajor, nodeVerMinor, nodeVerMajorMinor } = require('./vars');
 const { AWS, AWSXRay } = require('./AWS.classes');
-const APIRequest = require("./APIRequest.class");
+const ApiRequest = require("./ApiRequest.class");
 const RequestInfo = require("./RequestInfo.class");
 const ClientRequest = require("./ClientRequest.class");
 const ResponseDataModel = require("./ResponseDataModel.class");
@@ -34,7 +34,7 @@ const xmlGenericResponse = require('./generic.response.xml');
 const rssGenericResponse = require('./generic.response.rss');
 const textGenericResponse = require('./generic.response.text');
 const { printMsg, sanitize, obfuscate, hashThisData} = require('./utils');
-const { CachedParameterSecrets, CachedParameterSecret, CachedSSMParameter, CachedSecret } = require('./CachedParametersSecrets.classes')
+const { CachedParameterSecrets, CachedParameterSecret, CachedSsmParameter, CachedSecret } = require('./CachedParametersSecrets.classes')
 const { Connections, Connection, ConnectionRequest, ConnectionAuthentication } = require('./Connections.classes')
 
 /*
@@ -107,7 +107,11 @@ class AppConfig {
 	static _ssmParameters = null;
 
 	/**
-	 * Initialize the Config class
+	 * Initialize the Config class with asynchronous parallel execution.
+	 * 
+	 * This method returns immediately (synchronously) while initialization operations
+	 * execute asynchronously in parallel. Use AppConfig.promise() to wait for all
+	 * initialization to complete before accessing initialized configuration.
 	 *
 	 * @param {object} options Configuration options
 	 * @param {object} options.settings Application settings retrieved by Config.settings()
@@ -124,8 +128,10 @@ class AppConfig {
 	 * @param {object} options.responses.rssResponses
 	 * @param {object} options.responses.textResponses
 	 * @param {object} options.ssmParameters Parameter Store
-	 * @returns {Promise<void>}
+	 * @param {boolean} [options.debug=false] Enable debug logging
+	 * @returns {boolean} True if initialization started successfully, false on synchronous error
 	 * @example
+	 * // Initialize configuration (returns immediately)
 	 * const { Config } = require("./config");
 	 * Config.init({
 	 *   settings: {
@@ -143,48 +149,100 @@ class AppConfig {
 	 *     }
 	 *   }
 	 * });
+	 * 
+	 * // Wait for all initialization to complete
+	 * await Config.promise();
+	 * 
+	 * // Now safe to access initialized configuration
+	 * const settings = Config.settings();
+	 * const conn = Config.getConn('myConnection');
 	 */
 	static init(options = {}) {
 
-		try {
+			try {
 
-			const debug = (options?.debug === true);
-			if (debug) {
-				DebugAndLog.debug("Config Init in debug mode");
-			}
+				const debug = (options?.debug === true);
+				if (debug) {
+					DebugAndLog.debug("Config Init in debug mode");
+				}
 
-			if (options.settings) {
-				AppConfig._settings = options.settings;
-				if (debug) { DebugAndLog.debug("Settings initialized", AppConfig._settings); }
-			}
+				if (options.settings) {
+					const settingsPromise = new Promise((resolve) => {
+						try {
+							AppConfig._settings = options.settings;
+							if (debug) {
+								DebugAndLog.debug("Settings initialized", AppConfig._settings);
+							}
+							resolve(true);
+						} catch (error) {
+							DebugAndLog.error(`Settings initialization failed: ${error.message}`, error.stack);
+							resolve(false);
+						}
+					});
+					AppConfig.add(settingsPromise);
+				}
 
-			if (options.connections) {
-				AppConfig._connections = new Connections(options.connections);
-				if (debug) { DebugAndLog.debug("Connections initialized", AppConfig._connections.info()); }
-			}
+				if (options.connections) {
+					const connectionsPromise = new Promise((resolve) => {
+						try {
+							AppConfig._connections = new Connections(options.connections);
+							if (debug) {
+								DebugAndLog.debug("Connections initialized", AppConfig._connections.info());
+							}
+							resolve(true);
+						} catch (error) {
+							DebugAndLog.error(`Connections initialization failed: ${error.message}`, error.stack);
+							resolve(false);
+						}
+					});
+					AppConfig.add(connectionsPromise);
+				}
 
-			if (options.validations) {
-				ClientRequest.init(options.validations);
-				if (debug) { DebugAndLog.debug("ClientRequest initialized", ClientRequest.info()); }
-			}
+				if (options.validations) {
+					const validationsPromise = new Promise((resolve) => {
+						try {
+							ClientRequest.init(options.validations);
+							if (debug) {
+								DebugAndLog.debug("ClientRequest initialized", ClientRequest.info());
+							}
+							resolve(true);
+						} catch (error) {
+							DebugAndLog.error(`ClientRequest initialization failed: ${error.message}`, error.stack);
+							resolve(false);
+						}
+					});
+					AppConfig.add(validationsPromise);
+				}
 
-			if (options.responses) {
-				Response.init(options.responses);
-				if (debug) { DebugAndLog.debug("Response initialized", Response.info()); }
-			}
+				if (options.responses) {
+					const responsesPromise = new Promise((resolve) => {
+						try {
+							Response.init(options.responses);
+							if (debug) {
+								DebugAndLog.debug("Response initialized", Response.info());
+							}
+							resolve(true);
+						} catch (error) {
+							DebugAndLog.error(`Response initialization failed: ${error.message}`, error.stack);
+							resolve(false);
+						}
+					});
+					AppConfig.add(responsesPromise);
+				}
 
-			if (options.ssmParameters) {
-				AppConfig._ssmParameters = AppConfig._initParameters(options.ssmParameters);
-				AppConfig.add(AppConfig._ssmParameters);
-			}
+				if (options.ssmParameters) {
+					AppConfig._ssmParameters = AppConfig._initParameters(options.ssmParameters);
+					AppConfig.add(AppConfig._ssmParameters);
+				}
 
-			return true;
+				return true;
 
-		} catch (error) {
-			DebugAndLog.error(`Could not initialize Config ${error.message}`, error.stack);
-			return false;
+			} catch (error) {
+				DebugAndLog.error(`Could not initialize Config ${error.message}`, error.stack);
+				return false;
+			}
 		}
-	};
+;
 
 	/**
 	 * Add a promise to AppConfig. Use AppConfig.promise() to ensure all are resolved.
@@ -237,7 +295,7 @@ class AppConfig {
 	 * const conn = Config.getConn('myConnection');
 	 * const cacheObj = await CacheableDataAccess.getData(
 	 *    cacheProfile,
-	 *    endpoint.get
+	 *    endpoint.send
 	 *    conn
 	 * )
 	 * */
@@ -264,7 +322,7 @@ class AppConfig {
 	 * const { conn, cacheProfile } = Config.getConnCacheProfile('myConnection', 'myCacheProfile');
 	 * const cacheObj = await CacheableDataAccess.getData(
 	 *    cacheProfile,
-	 *    endpoint.get
+	 *    endpoint.send
 	 *    conn
 	 * )
 	 */
@@ -299,13 +357,13 @@ class AppConfig {
 
 	/**
 	 * 
-	 * @returns {Promise} A promise that resolves when the Config class has finished initializing
+	 * @returns {Promise<array>} A promise that resolves when the Config class has finished initializing
 	 */
 	static promise() {
 		if (AppConfig._promise !== null ) { // Backwards compatibility
 			AppConfig._promises.push(AppConfig._promise);
 		}
-		return Promise.all[AppConfig._promises];
+		return Promise.all(AppConfig._promises);
 	};
 
 	
@@ -405,6 +463,14 @@ class AppConfig {
 				// put the parameter into its group
 				const obj = parameters.find(o => o.path === groupPath);
 				const group = obj.group;
+
+				// >! Guard against prototype pollution (CWE-471)
+				const DANGEROUS_KEYS = ['__proto__', 'constructor', 'prototype'];
+				if (DANGEROUS_KEYS.includes(group) || DANGEROUS_KEYS.includes(name)) {
+					DebugAndLog.warn(`Skipping dangerous parameter key: group="${group}", name="${name}"`);
+					return;
+				}
+
 				if ( !(group in paramstore)) {
 					paramstore[group] = {};
 				}
@@ -473,8 +539,12 @@ module.exports = {
 	nodeVerMinor,
 	nodeVerMajorMinor,
 	AWS,
+	Aws: AWS,
 	AWSXRay,
-	APIRequest,
+	AwsXRay: AWSXRay, // Alias
+	ApiRequest,
+	/** @deprecated Use ApiRequest instead */
+	APIRequest: ApiRequest, // Alias
 	ImmutableObject,
 	Timer,
 	DebugAndLog,
@@ -487,8 +557,11 @@ module.exports = {
 	ResponseDataModel,
 	Response,
 	AppConfig,
+	/** @deprecated Use AppConfig instead */
 	_ConfigSuperClass: AppConfig, // Alias
-	CachedSSMParameter,
+	CachedSsmParameter,
+	/** @deprecated Use CachedSsmParameter instead */
+	CachedSSMParameter: CachedSsmParameter, // Alias
 	CachedSecret,
 	CachedParameterSecret,
 	CachedParameterSecrets,

package/src/lib/utils/ValidationExecutor.class.js

@@ -0,0 +1,70 @@
+/**
+ * ValidationExecutor - Executes validation functions with appropriate interfaces
+ * 
+ * This class provides static methods for executing validation functions with either
+ * single-parameter or multi-parameter interfaces. It handles errors gracefully and
+ * logs validation failures.
+ * 
+ * The interface is determined by the params array length:
+ * - params.length === 1: Pass value directly (single-parameter interface)
+ * - params.length > 1: Pass object (multi-parameter interface)
+ * 
+ * @private
+ * @class ValidationExecutor
+ */
+class ValidationExecutor {
+	/**
+	 * Execute validation function with appropriate interface.
+	 * 
+	 * Determines whether to pass a single value or an object based on the number
+	 * of parameters in the params array. Handles validation errors gracefully by 
+	 * catching exceptions and logging them.
+	 * 
+	 * @param {Function} validateFn - Validation function to execute
+	 * @param {Array<string>} paramNames - Parameter names to validate
+	 * @param {Object} paramValues - All parameter values available
+	 * @returns {boolean} True if validation passes, false if fails or throws
+	 * 
+	 * @example
+	 * // Single parameter validation (params.length === 1)
+	 * const isValid = ValidationExecutor.execute(
+	 *   (value) => value.length > 0,
+	 *   ['id'],
+	 *   { id: '123' }
+	 * );
+	 * 
+	 * @example
+	 * // Multi-parameter validation (params.length > 1)
+	 * const isValid = ValidationExecutor.execute(
+	 *   ({page, limit}) => page >= 1 && limit >= 1 && limit <= 100,
+	 *   ['page', 'limit'],
+	 *   { page: 1, limit: 10 }
+	 * );
+	 */
+	static execute(validateFn, paramNames, paramValues) {
+		try {
+			if (paramNames.length === 1) {
+				// Single parameter: pass value directly
+				const value = paramValues[paramNames[0]];
+				return validateFn(value);
+			} else {
+				// Multiple parameters: pass object
+				const paramObj = {};
+				for (const name of paramNames) {
+					paramObj[name] = paramValues[name];
+				}
+				return validateFn(paramObj);
+			}
+		} catch (error) {
+			// Log error and treat as validation failure
+			const tools = require("../tools/index.js");
+			tools.DebugAndLog.error(
+				`Validation function threw error for parameters [${paramNames.join(", ")}]: ${error?.message || "Unknown error"}`,
+				error?.stack
+			);
+			return false;
+		}
+	}
+}
+
+module.exports = ValidationExecutor;