@63klabs/cache-data 1.3.7 → 1.3.9

package/src/lib/tools/index.js

@@ -44,19 +44,31 @@ const { Connections, Connection, ConnectionRequest, ConnectionAuthentication } =
  */
 
 /**
- * @typedef ConnectionObject
- * @property {object} connection A connection object
- * @property {string} connection.method GET or POST
- * @property {string} connection.uri the full uri (overrides protocol, host, path, and parameters) ex https://example.com/api/v1/1004/?key=asdf&y=4
- * @property {string} connection.protocol https
- * @property {string} connection.host host/domain: example.com
- * @property {string} connection.path path of the request: /api/v1/1004
- * @property {object} connection.parameters parameters for the query string as an object in key/value pairs
- * @property {object} connection.headers headers for the request as an object in key/value pairs
- * @property {string} connection.body for POST requests, the body
- * @property {string} connection.note a note for logging
- * @property {object} connection.options https_get options
- * @property {number} connection.options.timeout timeout in milliseconds
+ * @typedef {Object} ConnectionObject
+ * @property {string} method GET or POST
+ * @property {string} uri the full uri (overrides protocol, host, path, and parameters) ex https://example.com/api/v1/1004/?key=asdf&y=4
+ * @property {string} protocol https
+ * @property {string} host host/domain: example.com
+ * @property {string} path path of the request: /api/v1/1004
+ * @property {object} parameters parameters for the query string as an object in key/value pairs
+ * @property {object} headers headers for the request as an object in key/value pairs
+ * @property {string} body for POST requests, the body
+ * @property {string} note a note for logging
+ * @property {object} options https_get options
+ * @property {number} options.timeout timeout in milliseconds
+ * @property {CacheProfileObject[]} cache
+ */
+
+/**
+ * @typedef {Object} CacheProfileObject
+ * @property {string} profile The name of the cache profile
+ * @property {boolean} overrideOriginHeaderExpiration If true, the cache expiration will be overridden by the origin header expiration
+ * @property {number} defaultExpirationInSeconds The default expiration time in seconds
+ * @property {boolean} expirationIsOnInterval If true, the cache expiration will be on an interval
+ * @property {array<string>} headersToRetain
+ * @property {string} hostId The host ID to use for the cache key
+ * @property {string} pathId The path ID to use for the cache key
+ * @property {boolean} encrypt If true, the cache data will be encrypted
  */
 
 /* ****************************************************************************
@@ -69,7 +81,7 @@ const { Connections, Connection, ConnectionRequest, ConnectionAuthentication } =
  *************************************************************************** */
 
 /**
- * _ConfigSuperClass needs to be extended by your own Config class definition.
+ * AppConfig needs to be extended by your own Config class definition.
  * 
  * This super class holds common variables and methods that can be used by any 
  * application. However, each application requires it's own methods and logic 
@@ -80,36 +92,177 @@ const { Connections, Connection, ConnectionRequest, ConnectionAuthentication } =
  * initialized.
  * 
  * @example
- * class Config extends tools._ConfigSuperClass {
+ * class Config extends tools.AppConfig {
  * 		// your custom class definition including your implementation of .init()
  * }
  * 
  * Config.init();
  */
-class _ConfigSuperClass {
+class AppConfig {
 
 	static _promise = null;
+	static _promises = [];
 	static _connections = null;
 	static _settings = null;
+	static _ssmParameters = null;
 
 	/**
-	 * Get the application settings object
+	 * Initialize the Config class with asynchronous parallel execution.
 	 * 
-	 * Returns the settings object that was initialized during Config.init(). 
-	 * This typically contains application-specific configuration values loaded 
-	 * from parameter store, environment variables, or other sources.
+	 * 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()
+	 * @param {ConnectionObject[]} options.connections Application connections that can then be retrieved by Config.getConn() or Config.getConnCacheProfile()
+	 * @param {object} options.validations ClientRequest.init() options
+	 * @param {object} options.responses Response.init() options
+	 * @param {object} options.responses.settings
+	 * @param {number} options.responses.settings.errorExpirationInSeconds
+	 * @param {number} options.responses.settings.routeExpirationInSeconds
+	 * @param {number} options.responses.settings.externalRequestHeadroomInMs
+	 * @param {object} options.responses.jsonResponses
+	 * @param {object} options.responses.htmlResponses
+	 * @param {object} options.responses.xmlResponses
+	 * @param {object} options.responses.rssResponses
+	 * @param {object} options.responses.textResponses
+	 * @param {object} options.ssmParameters Parameter Store
+	 * @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: {
+	 *     dataLimit: 1000,
+	 *     cacheTTL: 300
+	 *   },
+	 *   connections: {
+	 *     myConnection: {
+	 *       method: "GET",
+	 *       host: "example.com",
+	 *       path: "/api/v1/data",
+	 *       parameters: {
+	 *         limit: 100
+	 *       }
+	 *     }
+	 *   }
+	 * });
+	 * 
+	 * // 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 {
+
+				const debug = (options?.debug === true);
+				if (debug) {
+					DebugAndLog.debug("Config Init in debug mode");
+				}
+
+				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) {
+					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) {
+					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) {
+					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);
+				}
+
+				return true;
+
+			} 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.
+	 * @param {Promise} promise 
+	 */
+	static add(promise) {
+		AppConfig._promises.push(promise);
+	}
+
+	/**
+	 * Get the application settings object
 	 * 
 	 * @returns {object|null} Settings object containing application configuration, or null if not initialized
 	 * @example
-	 * // Access application settings
-	 * const settings = Config.settings();
-	 * if (settings) {
-	 *   console.log('App version:', settings.version);
-	 *   console.log('Environment:', settings.environment);
-	 * }
+	 * // Config extends AppConfig
+	 * const { Config } = require("./config");
+	 * const limit = Config.settings().dataLimit;
 	 */
 	static settings() {
-		return _ConfigSuperClass._settings;
+		return AppConfig._settings;
 	};
 
 	/**
@@ -117,7 +270,7 @@ class _ConfigSuperClass {
 	 * @returns {Connections}
 	 */
 	static connections() {
-		return _ConfigSuperClass._connections;
+		return AppConfig._connections;
 	};
 
 	/**
@@ -127,10 +280,10 @@ class _ConfigSuperClass {
 	 * @returns {Connection|null} Connection instance or null if not found
 	 */
 	static getConnection(name) {
-		if (_ConfigSuperClass._connections === null) {
+		if (AppConfig._connections === null) {
 			return null;
 		}
-		return _ConfigSuperClass._connections.get(name);
+		return AppConfig._connections.get(name);
 	}
 
 	/**
@@ -147,11 +300,11 @@ class _ConfigSuperClass {
 	 * )
 	 * */
 	static getConn(name) {
-		if (_ConfigSuperClass._connections === null) {
+		if (AppConfig._connections === null) {
 			return null;
 		}
 		
-		const connection = _ConfigSuperClass._connections.get(name);
+		const connection = AppConfig._connections.get(name);
 		
 		if (connection === null) {
 			return null;
@@ -175,37 +328,42 @@ class _ConfigSuperClass {
 	 */
 	static getConnCacheProfile(connectionName, cacheProfileName) {
 
-		if (_ConfigSuperClass._connections === null) {
+		if (AppConfig._connections === null) {
 			return { conn: null, cacheProfile: null };
 		}
 
-		const connection = _ConfigSuperClass._connections.get(connectionName);
+		const connection = AppConfig._connections.get(connectionName);
 
 		if (connection === null) {
 			return { conn: null, cacheProfile: null };
 		}
 
-		let cacheProfile = null;
+		let cacheProfile;
+		
 		try {
 			const profile = connection.getCacheProfile(cacheProfileName);
 			cacheProfile = (profile === undefined) ? null : profile;
-		} catch (error) {
+		} catch {
 			// getCacheProfile throws if _cacheProfiles is null
 			cacheProfile = null;
 		}
 
 		return {
 			conn: connection.toObject(),
-			cacheProfile: cacheProfile
-		};
+			cacheProfile
+		};	
+
 	}
 
 	/**
 	 * 
-	 * @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() {
-		return _ConfigSuperClass._promise;
+		if (AppConfig._promise !== null ) { // Backwards compatibility
+			AppConfig._promises.push(AppConfig._promise);
+		}
+		return Promise.all(AppConfig._promises);
 	};
 
 	
@@ -246,8 +404,6 @@ class _ConfigSuperClass {
 			return { names: names, paths: paths};
 		};
 
-		let request = [];
-
 		let pNames = paramNames();
 
 		if (pNames.names.length > 0 || pNames.paths.length > 0 ) {
@@ -352,20 +508,20 @@ class _ConfigSuperClass {
 	 *  ]
 	 * );
 	 * @param {array} parameters An array of parameter locations
-	 * @returns {object} Parameters from the parameter store
+	 * @returns {Promise<object>} Parameters from the parameter store
 	 */
 	static async _initParameters(parameters) {
 		// make the call to get the parameters and wait before proceeding to the return
 		return await this._getParameters(parameters);        
 	};
 
-	static async _initS3File(paths) {
-		return {};
-	};
+	// static async _initS3File(paths) {
+	// 	return {};
+	// };
 
-	static async _initDynamoDbRecord(query) {
-		return {};
-	};
+	// static async _initDynamoDbRecord(query) {
+	// 	return {};
+	// };
 	
 };
 
@@ -375,8 +531,11 @@ module.exports = {
 	nodeVerMinor,
 	nodeVerMajorMinor,
 	AWS,
+	Aws: AWS,
 	AWSXRay,
+	AwsXRay: AWSXRay, // Alias
 	APIRequest,
+	ApiRequest: APIRequest, // Alias
 	ImmutableObject,
 	Timer,
 	DebugAndLog,
@@ -388,8 +547,10 @@ module.exports = {
 	ClientRequest,
 	ResponseDataModel,
 	Response,
-	_ConfigSuperClass,
+	AppConfig,
+	_ConfigSuperClass: AppConfig, // Alias
 	CachedSSMParameter,
+	CachedSsmParameter: CachedSSMParameter, // Alias
 	CachedSecret,
 	CachedParameterSecret,
 	CachedParameterSecrets,

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

@@ -0,0 +1,66 @@
+/**
+ * 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.
+ * 
+ * @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 specified. 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
+	 * const isValid = ValidationExecutor.execute(
+	 *   (value) => value.length > 0,
+	 *   ['id'],
+	 *   { id: '123' }
+	 * );
+	 * 
+	 * @example
+	 * // Multi-parameter validation
+	 * 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;