@63klabs/cache-data 1.3.5 → 1.3.7

package/src/lib/dao-endpoint.js

@@ -11,7 +11,7 @@
  * via the APIRequest class.
  * 
  * The class itself is not exposed, instead various functions can be used
- * to access the class. For exmaple, getDataDirectFromURI(connection, data)
+ * to access the class. For exmaple, get(connection, data)
  * 
  * The connection parameter is used to pass connection information to the 
  * API (host, path, query, etc).
@@ -21,7 +21,7 @@
  * 
  * @example
  *  // access function that utilizes the class
- *  const getDataDirectFromURI = async (connection, data = null) => {
+ *  const get = async (connection, data = null) => {
  *      return (new Endpoint(connection).get());
  *  };
  */
@@ -33,19 +33,20 @@
  */
 
 /**
- * @typedef ConnectionObject
- * @property {Object} connection
- * @property {string} connection.method
- * @property {string} connection.uri
- * @property {string} connection.protocol http or https
- * @property {string} connection.host
- * @property {string} connection.path
- * @property {string} connection.body
- * @property {object} connection.parameters
- * @property {object} connection.headers
- * @property {object} connection.options
- * @property {number} connection.options.timeout
- * @property {string} connection.note
+ * Connection configuration object for making endpoint requests.
+ * 
+ * @typedef {Object} ConnectionObject
+ * @property {string} [method="GET"] - HTTP method (GET, POST, PUT, DELETE, etc.)
+ * @property {string} [uri] - Complete URI including protocol, host, and path (alternative to separate protocol/host/path)
+ * @property {string} [protocol="https"] - Protocol to use (http or https)
+ * @property {string} [host] - Hostname or IP address of the endpoint
+ * @property {string} [path] - Path portion of the URL
+ * @property {string|null} [body=null] - Request body for POST/PUT requests
+ * @property {Object.<string, string|number|boolean>|null} [parameters=null] - Query string parameters as key-value pairs
+ * @property {Object.<string, string>|null} [headers=null] - HTTP headers as key-value pairs
+ * @property {Object} [options] - Additional request options
+ * @property {number} [options.timeout] - Request timeout in milliseconds
+ * @property {string} [note="Get data from endpoint"] - Descriptive note for logging purposes
  */
 
 /*
@@ -57,27 +58,112 @@
 const tools = require("./tools/index.js");
 
 /**
+ * Makes a GET request to a remote endpoint with the specified connection configuration.
+ * 
+ * This function provides a simple interface for making HTTP requests to external APIs
+ * or services. It supports both URI-based and component-based (protocol/host/path) 
+ * connection specifications. Query parameters can be provided either in the connection
+ * object or as a separate query parameter, which will be merged together.
+ * 
+ * The response body is automatically parsed as JSON if possible, otherwise returned as text.
+ * 
+ * @param {ConnectionObject} connection - Connection configuration object specifying the endpoint details
+ * @param {Object} [query={}] - Additional query data to merge with connection parameters. If query.parameters is provided, it will be merged with connection.parameters
+ * @returns {Promise<{success: boolean, statusCode: number, body: Object|string|null, headers: Object}>} Response object containing success status, HTTP status code, parsed body, and response headers
+ * @throws {Error} Throws an error if the request fails due to network issues or invalid configuration
  * 
- * @param {ConnectionObject} connection An object with details about the connection (method, uri, host, etc)
- * @param {Object} query Additional data to perform a query for the request.
- * @returns {Object} The response
  * @example
-    const { endpoint } = require("@63klabs/cache-data");
-    const data = await endpoint.get({host: "api.example.com", path: "data"}, { parameters: {q: "Chicago" }});
+ * // Using separate host and path
+ * const { endpoint } = require("@63klabs/cache-data");
+ * const response = await endpoint.get(
+ *   { host: "api.example.com", path: "/data" },
+ *   { parameters: { q: "Chicago" } }
+ * );
+ * console.log(response.body);
+ * 
+ * @example
+ * // Using complete URI
+ * const { endpoint } = require("@63klabs/cache-data");
+ * const response = await endpoint.get(
+ *   { uri: "https://api.example.com/data" },
+ *   { parameters: { q: "Chicago" } }
+ * );
+ * console.log(response.body);
+ * 
+ * @example
+ * // With custom headers and timeout
+ * const { endpoint } = require("@63klabs/cache-data");
+ * const response = await endpoint.get({
+ *   host: "api.example.com",
+ *   path: "/secure/data",
+ *   headers: { "Authorization": "Bearer token123" },
+ *   options: { timeout: 5000 }
+ * });
+ * 
+ * @example
+ * // POST request with body
+ * const { endpoint } = require("@63klabs/cache-data");
+ * const response = await endpoint.get({
+ *   method: "POST",
+ *   uri: "https://api.example.com/submit",
+ *   body: JSON.stringify({ name: "John", age: 30 }),
+ *   headers: { "Content-Type": "application/json" }
+ * });
  */
-const get = async (connection, query = null) => {
+const get = async (connection, query = {}) => {
+	if (query === null) { query = {} };
 	return (new Endpoint(connection, query).get());
 };
 
 /**
- * A bare bones request to an endpoint. Can be used as a template to
- * create more elaborate requests. 
+ * Endpoint request class for making HTTP requests to remote APIs.
+ * 
+ * This class provides a bare-bones implementation for making API requests and can be used
+ * as a template to create more elaborate request handlers with custom logic for data
+ * manipulation before/after requests. The class handles connection configuration, parameter
+ * merging, and automatic JSON parsing of responses.
+ * 
+ * The class is typically not instantiated directly but accessed through convenience functions
+ * like `endpoint.get()`. However, it can be extended to add custom pre/post-processing logic.
+ * 
+ * @example
+ * // Direct instantiation (advanced usage)
+ * const endpoint = new Endpoint({ host: "api.example.com", path: "/data" });
+ * const response = await endpoint.get();
+ * 
+ * @example
+ * // Extending for custom logic
+ * class CustomEndpoint extends Endpoint {
+ *   async get() {
+ *     // Custom pre-processing
+ *     const response = await super.get();
+ *     // Custom post-processing
+ *     return response;
+ *   }
+ * }
  */
 class Endpoint {
 
 	/**
+	 * Creates a new Endpoint instance with the specified connection configuration.
+	 * 
+	 * The constructor initializes the request configuration by merging connection settings
+	 * with query parameters. If query.parameters are provided, they are merged with
+	 * connection.parameters. All connection properties are set with appropriate defaults.
 	 * 
-	 * @param {ConnectionObject} connection An object with connection data
+	 * @param {ConnectionObject} connection - Connection configuration object with endpoint details
+	 * @param {Object} [query={}] - Additional query data to merge with connection. If query.parameters is provided, it will be merged with connection.parameters
+	 * 
+	 * @example
+	 * // Basic constructor usage
+	 * const endpoint = new Endpoint({ host: "api.example.com", path: "/users" });
+	 * 
+	 * @example
+	 * // With query parameters
+	 * const endpoint = new Endpoint(
+	 *   { host: "api.example.com", path: "/search" },
+	 *   { parameters: { q: "javascript", limit: 10 } }
+	 * );
 	 */
 	constructor(connection, query = {}) {
 
@@ -109,12 +195,22 @@ class Endpoint {
 	};
 
 	/**
-	 * Takes the connection object, checks for the key provided and if the key 
-	 * exists it returns its value. Otherwise it returns the default value.
-	 * @param {ConnectionObject} connection The connection object to check for the existence of a key
-	 * @param {string} key The key to check for and return the value from connection
-	 * @param {*} defaultValue The value to use if the key is not found in the connection object
-	 * @returns {*} Either the value of the key if found in the connection object, or the default value
+	 * Sets a request setting from the connection object or uses a default value.
+	 * 
+	 * This internal helper method checks if a key exists in the connection object.
+	 * If the key exists, it returns the value; otherwise, it sets the key to the
+	 * default value and returns that default. This ensures all request settings
+	 * have valid values.
+	 * 
+	 * @param {ConnectionObject} connection - The connection object to check for the key
+	 * @param {string} key - The property key to check for and retrieve
+	 * @param {*} defaultValue - The default value to use if the key is not found
+	 * @returns {*} The value from the connection object if found, otherwise the default value
+	 * 
+	 * @example
+	 * // Internal usage within constructor
+	 * this.request.method = this._setRequestSetting(connection, "method", "GET");
+	 * // If connection.method exists, uses that value; otherwise uses "GET"
 	 */
 	_setRequestSetting(connection, key, defaultValue) {
 		if (!(key in connection)) {
@@ -125,18 +221,36 @@ class Endpoint {
 	};
 
 	/**
-	 * This is the function used by the accessor method after the constructor
-	 * is called.
+	 * Executes the HTTP request and returns the response.
 	 * 
-	 * As a template, it can be modified to perform additional checks, 
-	 * operations, etc before or after sending the call.
+	 * This method sends the configured request to the remote endpoint using the APIRequest
+	 * class. It automatically attempts to parse the response body as JSON. If the body is
+	 * not valid JSON, it is kept as text. The method caches the response so subsequent
+	 * calls return the same result without making additional requests.
+	 * 
+	 * This method can be overridden in subclasses to add custom pre-processing (before the
+	 * request) or post-processing (after the response) logic.
+	 * 
+	 * @returns {Promise<{success: boolean, statusCode: number, body: Object|string|null, headers: Object}>} Response object with success status, HTTP status code, parsed body, and headers
+	 * @throws {Error} Throws an error if the request fails due to network issues, timeout, or invalid configuration
+	 * 
+	 * @example
+	 * // Basic usage through the get() function
+	 * const endpoint = new Endpoint({ host: "api.example.com", path: "/data" });
+	 * const response = await endpoint.get();
+	 * if (response.success) {
+	 *   console.log(response.body);
+	 * }
 	 * 
 	 * @example
-	 *  // access function that utilizes the class
-	 *  const getDataDirectFromURI = async (connection, data = null) => {
-	 *      return (new Endpoint(connection).get());
-	 *  };
-	 * @returns {object} Response data from the completed request
+	 * // Handling errors
+	 * try {
+	 *   const endpoint = new Endpoint({ uri: "https://api.example.com/data" });
+	 *   const response = await endpoint.get();
+	 *   console.log(response.statusCode, response.body);
+	 * } catch (error) {
+	 *   console.error("Request failed:", error.message);
+	 * }
 	 */
 	async get() {
 
@@ -173,8 +287,18 @@ class Endpoint {
 	}
 
 	/**
-	 * An internal function that actually makes the call to APIRequest class
-	 * @returns {object} Response data from the completed request
+	 * Internal method that makes the actual HTTP request using the APIRequest class.
+	 * 
+	 * This method creates an APIRequest instance with the configured request settings
+	 * and sends the request. It handles errors by logging them and returning a formatted
+	 * error response. This method is called internally by the get() method.
+	 * 
+	 * @returns {Promise<{success: boolean, statusCode: number, body: Object|string|null, headers: Object}>} Response object from the APIRequest
+	 * @throws {Error} Throws an error if the APIRequest instantiation or send operation fails
+	 * 
+	 * @example
+	 * // Internal usage (not typically called directly)
+	 * const response = await this._call();
 	 */
 	async _call() {
 

package/src/lib/tools/AWS.classes.js

@@ -1,9 +1,20 @@
+/**
+ * Can a value be considered true?
+ * "true", "1", 1, and true are all true
+ * @param {boolean|number|string|null|undefined} value 
+ * @returns {boolean} Whether or not the value could be considered true
+ */
 const isTrue = (value) => {
 	return (value !== null && typeof value !== 'undefined' && 
 		(value === true || value === 1 || value === "1" || 
 		(typeof value === 'string' && value.toLowerCase() === "true")));
 };
 
+/**
+ * Should we enable X-Ray?
+ * Checks for either CacheData_AWSXRayOn or CACHE_DATA_AWS_X_RAY_ON in process.env
+ * @returns {boolean} True if X-Ray is enabled
+ */
 const USE_XRAY = isTrue(process.env?.CacheData_AWSXRayOn) || isTrue(process.env?.CACHE_DATA_AWS_X_RAY_ON);
 
 let AWSXRay = null;
@@ -88,12 +99,19 @@ class AWS {
 	static #nodeVer = [];
 	static #aws_region = null;
 
+	/**
+	 * @private
+	 * @returns {boolean} True if X-Ray is enabled and initialized
+	 */
 	static get #XRayOn() {
 		return initializeXRay() !== null;
 	}
 
 	constructor() {}
 
+	/**
+	 * @returns {number[]} Node version in array [major, minor, patch]
+	 */
 	static get nodeVersionArray() {
 		if (this.#nodeVer.length === 0) {
 			// split this.NODE_VER into an array of integers
@@ -102,6 +120,12 @@ class AWS {
 		return this.#nodeVer;
 	};
 
+	/**
+	 * Returns the AWS Region from process.env.AWS_REGION.
+	 * If not set, it will return 'us-east-1' and issue a warning.
+	 *
+	 * @returns {string} AWS Region
+	 */
 	static get region() {
 		if (this.#aws_region === null) {
 
@@ -122,17 +146,59 @@ class AWS {
 		return this.#aws_region;
 	}
 
+	/**
+	 * @returns {string} Node.js version ex: '24.12.0'
+	 */
 	static get NODE_VER() { return ( ("versions" in process && "node" in process.versions) ? process.versions.node : "0.0.0"); }
+	
+	/**
+	 * @returns {number} Node.js major version ex: 24
+	 */
 	static get NODE_VER_MAJOR() { return ( this.nodeVersionArray[0] ); }
+
+	/**
+	 * @returns {number} Node.js minor version ex: 12
+	 */
 	static get NODE_VER_MINOR() { return ( this.nodeVersionArray[1] ); }
+
+	/**
+	 * @returns {number} Node.js patch version ex: 0
+	 */
 	static get NODE_VER_PATCH() { return ( this.nodeVersionArray[2] ); }
+
+	/**
+	 * @returns {string} Node.js major.minor version ex: '24.12'
+	 */
 	static get NODE_VER_MAJOR_MINOR() { return (this.nodeVersionArray[0] + "." + this.nodeVersionArray[1]); }
+	
+	/**
+	 * @returns {number[]} Node.js version array [major, minor, patch]
+	 */
 	static get NODE_VER_ARRAY() { return (this.nodeVersionArray); }
+
+	/**
+	 * @returns {'V2'|'V3'} AWS SDK Version being used based on Node.js version. V2 for Node.js < 18, V3 for Node.js >= 18
+	 */
 	static get SDK_VER() { return ((this.NODE_VER_MAJOR < 18) ? "V2" : "V3"); }
+
+	/**
+	 * @returns {string} AWS Region
+	 */
 	static get REGION() { return ( this.region ); }
+
+	/**
+	 * @returns {boolean} True if using AWS SDK v2
+	 */
 	static get SDK_V2() { return (this.SDK_VER === "V2"); }
+
+	/**
+	 * @returns {boolean} True if using AWS SDK v3
+	 */
 	static get SDK_V3() { return (this.SDK_VER === "V3"); }
 
+	/**
+	 * @returns {object} Information about the current Node.js and AWS environment
+	 */
 	static get INFO() { 
 		return ( {
 			NODE_VER: this.NODE_VER,
@@ -149,6 +215,10 @@ class AWS {
 		});
 	}
 
+	/**
+	 * @private
+	 * @returns {object} SDK v3 objects
+	 */
 	static #SDK = (
 		function(){
 
@@ -209,6 +279,9 @@ class AWS {
 		}
 	)();
 	
+	/**
+	 * @returns {object} DynamoDB Document Client and functions for put, get, scan, delete, update
+	 */
 	static get dynamo() {
 		return {
 			client: this.#SDK.dynamo.client,
@@ -221,6 +294,9 @@ class AWS {
 		};
 	}
 
+	/**
+	 * @returns {object} S3 Client and functions for put, get
+	 */
 	static get s3() {
 		return {
 			client: this.#SDK.s3.client,
@@ -230,6 +306,9 @@ class AWS {
 		};
 	}
 
+	/**
+	 * @returns {object} SSM Client and functions for getByName, getByPath
+	 */
 	static get ssm() {
 		return {
 			client: this.#SDK.ssm.client,
@@ -239,6 +318,9 @@ class AWS {
 		};
 	}
 
+	/**
+	 * @returns {object} AWS X-Ray SDK
+	 */
 	static get XRay() {
 		return AWSXRay;
 	}

package/src/lib/tools/CachedParametersSecrets.classes.js

@@ -18,11 +18,24 @@ const Timer = require('./Timer.class');
  * https://aws.amazon.com/blogs/compute/using-the-aws-parameter-and-secrets-lambda-extension-to-cache-parameters-and-secrets/
  *************************************************************************** */
 
-/* ****************************************************************************
-	
-	
+/**
+ * @class CachedParameterSecrets - Container class for CachedParameterSecret objects
+ * @example
+ * // Create parameters and secrets
+ * const dbPassword = new CachedSSMParameter('/myapp/db/password');
+ * const apiKey = new CachedSecret('myapp-api-key');
+ * 
+ * // Prime all parameters and secrets before use
+ * await CachedParameterSecrets.prime();
+ * 
+ * // Get all names
+ * const names = CachedParameterSecrets.getNames();
+ * console.log(names); // ['/myapp/db/password', 'myapp-api-key']
+ * 
+ * // Get specific parameter
+ * const param = CachedParameterSecrets.get('/myapp/db/password');
+ * const value = await param.getValue();
  */
-
 class CachedParameterSecrets {
 	/** 
 	 * @typedef {Array<CachedParameterSecret>}
@@ -30,14 +43,14 @@ class CachedParameterSecrets {
 	static #cachedParameterSecrets = [];
 
 	/**
-	 * @param {CachedParameterSecret} The CachedParameterSecret object to add
+	 * @param {CachedParameterSecret} cachedParameterSecretObject - The CachedParameterSecret object to add
 	 */
 	static add (cachedParameterSecretObject) {
 		CachedParameterSecrets.#cachedParameterSecrets.push(cachedParameterSecretObject);
 	}
 
 	/**
-	 * @param {string} The Parameter name or Secret Id to locate
+	 * @param {string} name - The Parameter name or Secret Id to locate
 	 * @returns {CachedParameterSecret}
 	 */
 	static get (name) {
@@ -58,6 +71,9 @@ class CachedParameterSecrets {
 		return objects;
 	};
 
+	/**
+	 * @returns {object: Array<object>} An object containing an array of CachedParameterSecret.toObject()
+	 */
 	static toObject() {
 		// return an object of cachedParameterSecret.toObject()
 		return {objects: CachedParameterSecrets.toArray()};
@@ -124,7 +140,7 @@ class CachedParameterSecrets {
 }
 
 /**
- * Parent class to extend CachedSSMParameter and CachedSecret classes.
+ * @class CachedParameterSecret - Base class for CachedSSMParameter and CachedSecret
  * Accesses data through Systems Manager Parameter Store and Secrets Manager Lambda Extension
  * Since the Lambda Extension runs a localhost via http, it handles it's own http request. Also,
  * since the lambda extension needs time to boot during a cold start, it is not available during
@@ -355,6 +371,7 @@ class CachedParameterSecret {
 	 * The value comes back decrypted.
 	 * It will return the current, cached copy which may have expired.
 	 * @returns {string} The value of the Secret or Parameter
+	 * @throws {Error} If the secret is null or .get(), .getValue(), or .refresh() has not been called first
 	 */
 	sync_getValue() {
 		if (this.isValid()) {
@@ -455,7 +472,40 @@ class CachedParameterSecret {
 
 }
 
+/**
+ * CachedSSMParameter extends CachedParameterSecret and is used to retrieve parameters from AWS Systems Manager Parameter Store
+ * @extends CachedParameterSecret
+ * @example
+ * // Create a cached SSM parameter
+ * const dbPassword = new CachedSSMParameter('/myapp/db/password');
+ * 
+ * // Get the parameter value (async)
+ * const password = await dbPassword.getValue();
+ * console.log(password); // 'my-secret-password'
+ * 
+ * @example
+ * // Use with synchronous functions after priming
+ * const apiKey = new CachedSSMParameter('/myapp/api/key');
+ * 
+ * async function init() {
+ *   // Prime the parameter in the background
+ *   apiKey.prime();
+ *   
+ *   // Do other initialization work...
+ *   
+ *   // Ensure parameter is loaded before sync usage
+ *   await apiKey.prime();
+ *   
+ *   // Now safe to use in sync functions
+ *   const key = apiKey.sync_getValue();
+ *   return key;
+ * }
+ */
 class CachedSSMParameter extends CachedParameterSecret {
+	/**
+	 * Returns the URL path for the AWS Parameters and Secrets Lambda Extension to retrieve this SSM parameter
+	 * @returns {string} The URL path with encoded parameter name
+	 */
 	getPath() {
 		const uriEncodedSecret = encodeURIComponent(this.name);
 		return `/systemsmanager/parameters/get/?name=${uriEncodedSecret}&withDecryption=true`;
@@ -469,8 +519,49 @@ class CachedSSMParameter extends CachedParameterSecret {
 	}
 }
 
+/**
+ * CachedSecret extends CachedParameterSecret and is used to retrieve secrets from AWS Secrets Manager
+ * @extends CachedParameterSecret
+ * @example
+ * // Create a cached secret
+ * const dbCredentials = new CachedSecret('myapp-database-credentials');
+ * 
+ * // Get the secret value (async)
+ * const credentials = await dbCredentials.getValue();
+ * console.log(credentials); // '{"username":"admin","password":"secret"}'
+ * 
+ * @example
+ * // Use with JSON secrets
+ * const apiSecret = new CachedSecret('myapp-api-secret');
+ * 
+ * async function connectToAPI() {
+ *   const secretString = await apiSecret.getValue();
+ *   const secretData = JSON.parse(secretString);
+ *   
+ *   return {
+ *     apiKey: secretData.apiKey,
+ *     apiSecret: secretData.apiSecret
+ *   };
+ * }
+ * 
+ * @example
+ * // Prime multiple secrets at once
+ * const secret1 = new CachedSecret('secret-1');
+ * const secret2 = new CachedSecret('secret-2');
+ * 
+ * // Prime all secrets in parallel
+ * await CachedParameterSecrets.prime();
+ * 
+ * // Now all secrets are loaded and cached
+ * const value1 = secret1.sync_getValue();
+ * const value2 = secret2.sync_getValue();
+ */
 class CachedSecret extends CachedParameterSecret {
 
+	/**
+	 * Returns the URL path for the AWS Parameters and Secrets Lambda Extension to retrieve this secret
+	 * @returns {string} The URL path with encoded secret ID
+	 */
 	getPath() {
 		const uriEncodedSecret = encodeURIComponent(this.name);
 		return `/secretsmanager/get?secretId=${uriEncodedSecret}&withDecryption=true`;

package/src/lib/tools/ClientRequest.class.js

@@ -1,11 +1,48 @@
 const RequestInfo = require('./RequestInfo.class');
 const Timer = require('./Timer.class');
 const DebugAndLog = require('./DebugAndLog.class');
+const { safeClone } = require('./utils');
 
 
 /**
  * Extends RequestInfo
  * Can be used to create a custom ClientRequest object
+ * @example
+ * // Initialize ClientRequest with validations
+ * ClientRequest.init({
+ *   validations: {
+ *     referrers: ['example.com', 'myapp.com'],
+ *     parameters: {
+ *       queryStringParameters: {
+ *         limit: (value) => !isNaN(value) && value > 0 && value <= 100,
+ *         page: (value) => !isNaN(value) && value > 0
+ *       },
+ *       pathParameters: {
+ *         id: (value) => /^[a-zA-Z0-9-]+$/.test(value)
+ *       }
+ *     }
+ *   }
+ * });
+ * 
+ * @example
+ * // Use in Lambda handler
+ * exports.handler = async (event, context) => {
+ *   const clientRequest = new ClientRequest(event, context);
+ *   
+ *   if (!clientRequest.isValid()) {
+ *     return { statusCode: 400, body: 'Invalid request' };
+ *   }
+ *   
+ *   const userId = clientRequest.getPathAt(1);
+ *   const queryParams = clientRequest.getQueryStringParameters();
+ *   
+ *   // Add logging for monitoring
+ *   clientRequest.addPathLog(`users/${userId}`);
+ *   clientRequest.addQueryLog(`limit=${queryParams.limit}`);
+ *   
+ *   // Process request...
+ *   return { statusCode: 200, body: 'Success' };
+ * };
  */
 class ClientRequest extends RequestInfo { 
 
@@ -22,7 +59,7 @@ class ClientRequest extends RequestInfo {
 	/* What and who of the request */
 	#event = null;
 	#context = null;
-	#authorizations = JSON.parse(JSON.stringify(ClientRequest.#unauthenticatedAuthorizations));
+	#authorizations = safeClone(ClientRequest.#unauthenticatedAuthorizations);
 	#roles = [];
 
 	/* The request data */
@@ -83,8 +120,8 @@ class ClientRequest extends RequestInfo {
 	 * This is used to initialize the ClientRequest class for all requests.
 	 * Add ClientRequest.init(options) to the Config.init process or at the
 	 * top of the main index.js file outside of the handler.
-	 * @param {Array<string>} options.validations.referrers An array of accepted referrers. String matching goes from right to left, so ['example.com'] will allow example.com and subdomain.example.com
-	 * @param {object} options.validations.parameters An object containing functions for validating request parameters (path, querystring, headers, cookies, etc).
+	 * @param {object} options - Configuration options with validations property containing referrers and parameters
+	 * @throws {Error} If options is not an object
 	 */
 	static init(options) {
 		if (typeof options === 'object') {
@@ -193,12 +230,8 @@ class ClientRequest extends RequestInfo {
 	}
 
 
-	/**
-	 * Utility function for getPathArray and getResourceArray
-	 * @param {array<string>} arr array to slice
-	 * @param {number} n number of elements to return
-	 * @returns {array<string>} array of elements
-	 */
+	// Utility function for getPathArray and getResourceArray
+	// Returns array slice based on n parameter
 	#getArray(arr, n = 0) {
 		if (n === 0 || arr.length <= n || (n < 0 && arr.length <= (n*-1))) {
 			return arr;
@@ -352,7 +385,7 @@ class ClientRequest extends RequestInfo {
 		if (this.isAuthenticated()) {
 			return this.#authorizations;
 		} else {
-			return JSON.parse(JSON.stringify(ClientRequest.#unauthenticatedAuthorizations));
+			return safeClone(ClientRequest.#unauthenticatedAuthorizations);
 		}
 	};