@63klabs/cache-data 1.3.7 → 1.3.9

package/CHANGELOG.md

@@ -8,9 +8,128 @@ To report an issue, or to see proposed and upcoming enhancements, check out [63K
 
 Report all vulnerabilities under the [Security menu](https://github.com/63Klabs/cache-data/security/advisories) in the Cache-Data GitHub repository.
 
-## v1.3.8 (unreleased)
+## v1.3.9 (unreleased)
 
-- Nothing yet
+- Unreleased
+
+## v1.3.9 (2026-03-09)
+
+### Added
+- **Body Parameter Validation for ClientRequest** [Spec: 1-3-9-body-validation-and-header-format-fix](.kiro/specs/1-3-9-body-validation-and-header-format-fix/)
+  - **Body Parameter Validation**: ClientRequest now validates body parameters using the same validation framework as path, query, header, and cookie parameters
+    - Automatic JSON parsing with error handling for request bodies
+    - Support for both API Gateway v1 and v2 formats
+    - Validation using existing ValidationMatcher and ValidationExecutor classes
+    - Body validation integrated into validation chain after cookie validation
+    - `getBodyParameters()` method now returns validated body parameters
+  - **Header Key Conversion Utility**: New static method `convertHeaderKeyToCamelCase(headerKey)` helps developers determine correct validation rule keys
+    - Converts HTTP header names from kebab-case to camelCase (e.g., `content-type` → `contentType`)
+    - Handles multiple hyphens and uppercase input correctly
+    - Documented with examples of common HTTP headers
+  - **Enhanced Documentation**: Comprehensive JSDoc documentation for header key conversion behavior
+    - Header key conversion reference table showing HTTP headers and their camelCase equivalents
+    - Detailed explanation of conversion algorithm and why it's necessary
+    - Examples showing validation configuration with converted header keys
+    - Complete body validation examples with error handling
+  - **Backwards Compatible**: All new features are opt-in and maintain full backwards compatibility
+    - Existing code continues to work without modification
+    - Body validation only activates when configured
+    - No changes to existing validation behavior for other parameter types
+  - **Comprehensive Testing**: 8 property-based tests and extensive unit/integration tests validate correctness properties
+    - Body validation round-trip property
+    - Validation failure propagation
+    - JSON parsing precondition
+    - Header key conversion correctness
+    - Backwards compatibility preservation
+    - Common validation pattern support
+    - Multi-parameter validation interface
+
+### Security
+- **Fixed npm security vulnerabilities in serialize-javascript dependency** [Spec: 1-3-9-npm-security-vulnerabilities-fix](.kiro/specs/1-3-9-npm-security-vulnerabilities-fix/)
+  - Fixed 2 high severity vulnerabilities in serialize-javascript (RCE via RegExp.flags and Date.prototype.toISOString)
+  - Added npm override for serialize-javascript >=7.0.3 to force secure version
+  - No breaking changes to public APIs
+  - All existing tests pass
+
+### Added
+- **Enhanced Validation System for ClientRequest** [Spec: 1-3-9-improve-validations-object](.kiro/specs/1-3-9-improve-validations-object/)
+  - **Route-Specific Validations**: Define different validation rules for the same parameter name in different routes (e.g., `id` in `/product/{id}` vs `/employee/{id}`)
+  - **Method-Specific Validations**: Define different validation rules based on HTTP method (e.g., stricter validation for `POST` than `GET`)
+  - **Method-and-Route Validations**: Most precise control with validation rules for specific method-route combinations (e.g., `POST:join/{id}`)
+  - **Multi-Parameter Validations**: Validate multiple parameters together to enforce cross-parameter constraints
+  - **Clear Priority Order**: Four-tier priority system (method-and-route > route-only > method-only > global)
+  - **Backwards Compatible**: Existing global parameter validations continue to work without any code changes
+  - **Performance Optimized**: Pattern normalization caching and early exit optimization for minimal overhead
+  - **Comprehensive Testing**: 15 correctness properties validated through property-based testing
+
+### Enhancement
+- **AppConfig Async Initialization Optimization** [Spec: 1-3-9-appconfig-async-init-optimization](.kiro/specs/1-3-9-appconfig-async-init-optimization/)
+  - **Parallel Initialization**: All AppConfig.init() operations now execute asynchronously in parallel, improving Lambda cold start performance by 10-20%
+  - **Backwards Compatible**: No API changes - existing code continues to work without modifications
+  - **Optimized Operations**: Settings, connections, validations, responses, and SSM parameters all initialize concurrently
+  - **Error Resilient**: Individual initialization failures don't block other operations
+  - **Transparent**: Debug logging and error handling work identically to previous implementation
+  - **Performance**: Cold start time reduced from 62-212ms to 50-200ms (sequential to parallel execution)
+
+## v1.3.8 (2026-03-02)
+
+### Security
+- **Updated the way dependencies are listed reduce npm Security Vulnerabilities** [Spec: 1-3-8-npm-security-vulnerabilities-fix](.kiro/specs/1-3-8-npm-security-vulnerabilities-fix/)
+  - Fixed 1 low, 20 high, and 1 critical severity vulnerabilities in development dependencies
+  - Updated devDependencies to specific secure versions:
+    - `@aws-sdk/client-dynamodb`, `@aws-sdk/client-s3`, `@aws-sdk/client-ssm`, `@aws-sdk/lib-dynamodb`: Updated from `3.x` to `^3.995.0`
+    - `mocha`: Updated from `^11.x` to `^11.7.5`
+    - `chai`: Updated from `^6.x` to `^6.2.2`
+    - `chai-http`: Updated from `^5.x` to `^5.1.2`
+    - `sinon`: Updated from `^21.x` to `^21.0.1`
+    - `fast-check`: Updated from `^4.x` to `^4.5.3`
+  - Added npm overrides for transitive dependencies:
+    - `diff`: `>=8.0.3` (fixes low severity DoS vulnerability)
+    - `minimatch`: `>=10.2.2` (fixes high severity ReDoS vulnerability)
+    - `glob`: `>=13.0.6` (fixes transitive vulnerabilities)
+  - No breaking changes to public APIs
+  - All existing tests pass
+  - Production dependencies remain secure (0 vulnerabilities)
+
+### Added
+- **APIRequest Pagination, Retry, and X-Ray Enhancements** [Spec: 1-3-8-api-request-pagination-retries-xray](.kiro/specs/1-3-8-api-request-pagination-retries-xray/) addresses [#171](https://github.com/63Klabs/cache-data/issues/171), [#172](https://github.com/63Klabs/cache-data/issues/172), [#173](https://github.com/63Klabs/cache-data/issues/173)
+  - **Automatic Pagination**: APIRequest now supports automatic pagination for APIs that return paginated results
+    - Configurable pagination labels for different API response structures
+    - Batch processing for concurrent page requests
+    - Support for both offset-based and token-based pagination
+    - Automatic result combination into single response
+    - Pagination metadata in response (total pages, total items, incomplete status)
+  - **Automatic Retry Logic**: APIRequest now includes built-in retry functionality for transient failures
+    - Configurable retry attempts (default: 1 retry after initial attempt)
+    - Automatic retry on network errors, empty responses, parse errors, and 5xx status codes
+    - Optional retry on 4xx status codes (disabled by default)
+    - Retry metadata in response (attempts made, final attempt number)
+  - **Enhanced X-Ray Subsegments**: Improved AWS X-Ray tracing for better observability
+    - Unique subsegment names for each request using timestamps
+    - Retry and pagination metadata included in X-Ray traces
+    - Separate subsegments for each paginated request
+    - Detailed annotations and metadata for debugging
+  - **Response Metadata**: New optional metadata field in responses
+    - Retry information (occurred, attempts, final attempt)
+    - Pagination information (occurred, total pages, total items, incomplete status)
+    - Only present when retries or pagination occur
+  - **Backwards Compatibility Maintained**: All new features are opt-in via configuration
+    - Existing code continues to work without modification
+    - No breaking changes to public API
+    - Default behavior unchanged when new features not configured
+  - See documentation: [Pagination Guide](docs/features/tools/api-request-pagination.md), [Retry Guide](docs/features/tools/api-request-retry.md), [X-Ray Guide](docs/features/tools/api-request-xray.md)
+- **tools.AppConfig** replaces `tools._ConfigSuperClass` and receives an `.init()` to simplify initialization
+  - Updated documentation to reflect how `Config` can be implemented to extend `tools._ConfigSuperClass`
+  - Instead of separate `Response.init()`, `ClientRequest.init()` and `Connections.init()` a single `AppConfig.init()` can be used within the `Config.init()`
+
+### Enhancement
+
+- **Expanded Generic Responses** - Additional responses for status codes
+  - Added responses for 408, 418, and 427
+  - Ensured all generic responses have the same statuses
+- **Revised Documentation** - Clarified and revised documentation
+  - Reviewed all code examples
+  - Reviewed implementation instructions
 
 ## v1.3.7 (2026-02-06)
 

package/CONTRIBUTING.md

@@ -26,9 +26,9 @@ Spec-Driven, AI-Assisted Engineering (SD-AI) is a software development methodolo
 
 Code must be reviewed, understood, and tested by a human before being merged.
 
-Kiro is the required AI coding assistant for final integrations, documentation, and testing, as it is in the AWS Ecosystem and this project is deveoped to deploy on the AWS platform. Just like test suites, Kiro ensures the proper tests, documentation, and guardrails are in place. Kiro is as important as commit-hooks and tests as it is a tool that ensures quality checks and should not be bypassed.
+Kiro is the required AI coding assistant for final integrations, documentation, and testing, as it is in the AWS Ecosystem and this project is developed to deploy on the AWS platform. Just like test suites, Kiro ensures the proper tests, documentation, and guardrails are in place. Kiro is as important as commit-hooks and tests as it is a tool that ensures quality checks and should not be bypassed.
 
-Ensure [AI Context](./AI_CONTEXT.md) and [Kiro steering documents](.kiro/steering/ai-context-reference.md) are reviewed, understood, and used by both humans and AI.
+Ensure [AGENTS](./AGENTS.md) and Kiro steering documents are reviewed, understood, and used by both humans and AI.
 
 ## Development Setup
 
@@ -126,7 +126,7 @@ npm test -- test/cache/
 
 ## Documentation Standards
 
-All public APIs must have complete JSDoc documentation. See [Documentation Standards](.kiro/steering/documentation-standards.md) for detailed requirements.
+All public APIs must have complete JSDoc documentation. See [JSDoc Documentation Standards](.kiro/steering/documentation-standards-jsdoc.md) for detailed requirements.
 
 **Required JSDoc tags:**
 - Description of what the function/class does
@@ -162,6 +162,5 @@ Thank you to the following people who have contributed to this project:
 
 Chad Kluck\
 DevOps & Developer Experience Engineer\
-AWS Certified Cloud Practitioner | AWS Certified Developer - Associate | AWS
-Certified Solutions Architect - Associate\
+AWS Certified Developer and Solutions Architect\
 [Website](https://chadkluck.me)

package/README.md

@@ -29,7 +29,10 @@ The @63klabs/cache-data package provides three main modules:
 - **Cache Profiles**: Configure multiple cache profiles with different expiration policies
 
 ### Endpoint Module
-- **HTTP/HTTPS Requests**: Make requests to external APIs and endpoints with built-in retry logic
+- **HTTP/HTTPS Requests**: Make requests to external APIs and endpoints with automatic pagination, retry logic, and X-Ray tracing
+- **Automatic Pagination**: Fetch all pages from paginated APIs automatically with configurable batch processing
+- **Automatic Retry**: Retry failed requests with configurable conditions (network errors, server errors, empty responses)
+- **Enhanced X-Ray Tracing**: Detailed monitoring and debugging with AWS X-Ray subsegments
 - **Connection Management**: Define and manage multiple endpoint connections with authentication
 - **Request Caching**: Automatically cache endpoint responses to reduce API calls and improve performance
 - **Flexible Configuration**: Support for custom headers, query parameters, request bodies, and timeouts
@@ -47,7 +50,7 @@ The @63klabs/cache-data package provides three main modules:
 
 ### Requirements
 
-- Node.js >=20.0.0 runtime on Lambda
+- Node.js >=22.0.0 runtime on Lambda
 - AWS Services:
   - **AWS Lambda**: For running your serverless functions
   - **Amazon S3**: For storing large cached objects
@@ -65,7 +68,7 @@ Install the package using npm:
 npm install @63klabs/cache-data
 ```
 
-The simplest way to get started is to use the [63klabs Atlantis Templates and Script platform](https://github.com/63Klabs/atlantis-cfn-configuration-repo-for-serverless-deployments) to deploy this and other ready-to-run solutions via CI/CD.
+The simplest way to get started is to use the [63klabs Atlantis Templates and Script Platform](https://github.com/63Klabs/atlantis) to deploy this and other ready-to-run solutions via CI/CD.
 
 However, if you want to write your own templates and code, follow the following steps:
 
@@ -99,26 +102,22 @@ It is recommended that you use the quick-start method when implementing for the
 ### Basic Caching Example
 
 ```javascript
-const { cache } = require("@63klabs/cache-data");
+const { cache: {CacheableDataAccess, Cache}, endpoint } = require("@63klabs/cache-data");
 
 // Initialize cache with your S3 bucket and DynamoDB table
 cache.Cache.init({
-  s3Bucket: process.env.CACHE_DATA_S3_BUCKET,
-  dynamoDbTable: process.env.CACHE_DATA_DYNAMODB_TABLE,
-  securityKey: process.env.CACHE_DATA_SECURITY_KEY
+  s3Bucket: process.env.CACHE_DATA_S3_BUCKET, // Cache.init will check this env variable automatically if not provided here
+  dynamoDbTable: process.env.CACHE_DATA_DYNAMODB_TABLE, // Cache.init will check this env variable automatically if not provided here
+  securityKey: process.env.CACHE_DATA_SECURITY_KEY // don't do this, use SSM Parameter Store - example only
 });
 
-// Cache some data
-const cacheKey = "my-data-key";
-const dataToCache = { message: "Hello, World!", timestamp: Date.now() };
-
-await cache.Cache.put(cacheKey, dataToCache, 3600); // Cache for 1 hour
+// 
 
 // Retrieve cached data
-const cachedData = await cache.Cache.get(cacheKey);
-if (cachedData) {
-  console.log("Retrieved from cache:", cachedData);
-}
+const conn = { host: "api.example.com", path: "api/users"};
+const cacheProfile = {/* cache parameters */};
+const cachedData = await CacheableDataAccess.getData(cacheProfile, endpoint.get, conn);
+const data = cachedData.getBody(true);
 ```
 
 ### Making Endpoint Requests
@@ -128,21 +127,48 @@ const { endpoint } = require("@63klabs/cache-data");
 
 // Make a simple GET request to an API
 const response = await endpoint.get(
-  { host: "api.example.com", path: "/data" },
-  { parameters: { q: "search-term" } }
+  { host: "api.example.com", path: "/data", parameters: { q: "search-term" } }
 );
 
 console.log("API Response:", response.body);
 console.log("Status Code:", response.statusCode);
 ```
 
+### Using APIRequest with Pagination and Retry
+
+```javascript
+const { tools: {APIRequest} } = require("@63klabs/cache-data");
+
+// Make a request with automatic pagination and retry
+const request = new tools.APIRequest({
+  host: "api.example.com",
+  path: "/users",
+  parameters: {
+    limit: 100  // Items per page
+  },
+  pagination: {
+    enabled: true  // Automatically fetch all pages
+  },
+  retry: {
+    enabled: true,
+    maxRetries: 2  // Retry failed requests up to 2 times
+  }
+});
+
+const response = await request.send();
+
+// Response contains all users from all pages
+const allUsers = JSON.parse(response.body).items;
+console.log(`Retrieved ${allUsers.length} total users`);
+```
+
 ### Using Utility Tools
 
 ```javascript
-const { tools } = require("@63klabs/cache-data");
+const { tools: {DebugAndLog, Timer} } = require("@63klabs/cache-data");
 
 // Create a timer to measure performance
-const timer = new tools.Timer("my-operation");
+const timer = new Timer("my-operation");
 timer.start();
 
 // Your code here...
@@ -151,9 +177,8 @@ timer.stop();
 console.log(`Operation took ${timer.elapsed()}ms`);
 
 // Use the logger
-const logger = new tools.DebugAndLog("MyApp");
-logger.info("Application started");
-logger.error("An error occurred", { details: "error info" });
+DebugAndLog.debug("MyApp");
+DebugAndLog.error("Error in Service", error.msg);
 ```
 
 ## Help
@@ -198,8 +223,8 @@ This will install dependencies, configure the pre-commit hook for documentation
 
 ## AI Context
 
-See [AI_CONTEXT.md](AI_CONTEXT.md) for important context and guidelines for AI-generated code in this repository.
+See [AGENTS.md](AGENTS.md) for important context and guidelines for AI-generated code in this repository.
 
 The context file is also helpful (and perhaps essential) for HUMANS developing within the application's structured platform as well.
 
-AI Assisted Engineering of this solution was provided by [Kiro](https://kiro.dev/). Steering documents are provided in the repository's [.kiro](.kiro/steering/ai-context-reference.md) directory. Because testing is tightly coupled with the implementation, it is suggested all documents, code, and tests are thoroughly reviewed before, and updated after, any changes.
+AI Assisted Engineering of this solution was provided by [Kiro](https://kiro.dev/). Steering documents are provided in the repository's `.kiro/steering/` directory. Because testing is tightly coupled with the implementation, it is suggested all documents, code, and tests are thoroughly reviewed before, and updated after, any changes.

package/eslint.config.js

@@ -0,0 +1,53 @@
+import js from '@eslint/js';
+
+export default [
+	js.configs.recommended,
+	{
+		languageOptions: {
+			ecmaVersion: 'latest',
+			sourceType: 'module',
+			globals: {
+				// Node.js globals
+				console: 'readonly',
+				process: 'readonly',
+				Buffer: 'readonly',
+				__dirname: 'readonly',
+				__filename: 'readonly',
+				exports: 'writable',
+				module: 'writable',
+				require: 'readonly',
+				global: 'readonly',
+				// Mocha globals
+				describe: 'readonly',
+				it: 'readonly',
+				before: 'readonly',
+				after: 'readonly',
+				beforeEach: 'readonly',
+				afterEach: 'readonly',
+				// ES2021 globals
+				globalThis: 'readonly'
+			}
+		},
+		rules: {
+			'no-template-curly-in-string': 'error',
+			'no-eval': 'error',
+			'no-implied-eval': 'error',
+			'no-new-func': 'error'
+		}
+	},
+	{
+		files: ['test/**/*.mjs', 'test/**/*.js', 'scripts/**/*.mjs', 'scripts/**/*.js', 'src/**/*.js'],
+		rules: {
+			'no-restricted-imports': ['error', {
+				patterns: [{
+					group: ['child_process'],
+					importNames: ['exec', 'execSync'],
+					message: 'Use execFile or execFileSync instead of exec/execSync to prevent shell injection. See .kiro/steering/secure-coding-practices.md'
+				}]
+			}]
+		}
+	},
+	{
+		ignores: ['node_modules/**', 'coverage/**', 'coverage-jest/**', '.git/**']
+	}
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@63klabs/cache-data",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "Cache data from an API endpoint or application process using AWS S3 and DynamoDb",
   "author": "Chad Leigh Kluck (https://chadkluck.me)",
   "license": "MIT",
@@ -16,37 +16,49 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "aws-xray-sdk-core": "^3.12.0",
     "moment-timezone": "^0.6.0",
     "object-hash": "^3.0.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "3.x",
-    "@aws-sdk/client-s3": "3.x",
-    "@aws-sdk/client-ssm": "3.x",
-    "@aws-sdk/lib-dynamodb": "3.x",
-    "chai": "^6.x",
-    "chai-http": "^5.x",
-    "fast-check": "^4.x",
+    "aws-xray-sdk-core": "^3.12.0",
+    "@aws-sdk/client-dynamodb": "^3.995.0",
+    "@aws-sdk/client-s3": "^3.995.0",
+    "@aws-sdk/client-ssm": "^3.995.0",
+    "@aws-sdk/lib-dynamodb": "^3.995.0",
+    "@eslint/js": "^10.0.1",
+    "chai": "^6.2.2",
+    "chai-http": "^5.1.2",
+    "eslint": "^10.0.1",
+    "fast-check": "^4.5.3",
     "jest": "^30.2.0",
-    "mocha": "^11.x",
-    "sinon": "^21.x"
+    "mocha": "^11.7.5",
+    "sinon": "^21.0.1"
   },
   "overrides": {
-    "fast-xml-parser": ">=5.3.4"
+    "diff": ">=8.0.3",
+    "fast-xml-parser": ">=5.3.4",
+    "glob": ">=13.0.6",
+    "minimatch": ">=10.2.2",
+    "serialize-javascript": ">=7.0.3"
   },
   "scripts": {
-    "test": "mocha 'test/**/*-tests.mjs'",
+    "test": "mocha 'test/**/*-tests.mjs' --exclude 'test/migration/property/test-execution-equivalence-property-tests.mjs'",
     "test:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:all": "npm test && npm run test:jest",
+    "test:migration:validation": "mocha test/migration/property/test-execution-equivalence-property-tests.mjs",
     "test:cache": "mocha 'test/cache/**/*-tests.mjs'",
     "test:cache:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/cache",
     "test:config": "mocha 'test/config/**/*-tests.mjs'",
     "test:endpoint": "mocha 'test/endpoint/**/*-tests.mjs'",
+    "test:endpoint:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/endpoint",
+    "test:tools:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/tools",
     "test:logging": "mocha 'test/logging/**/*-tests.mjs'",
     "test:request": "mocha 'test/request/**/*-tests.mjs'",
     "test:response": "mocha 'test/response/**/*-tests.mjs'",
-    "test:utils": "mocha 'test/utils/**/*-tests.mjs'"
+    "test:utils": "mocha 'test/utils/**/*-tests.mjs'",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "lint:ci": "eslint . --max-warnings 0"
   },
   "keywords": [
     "api",

package/src/lib/dao-cache.js

@@ -1545,8 +1545,8 @@ class Cache {
 			("CACHE_DATA_USE_TOOLS_HASH" in process.env ? Cache.bool(process.env.CACHE_DATA_USE_TOOLS_HASH_METHOD) : false);
 		
 		// Initialize in-memory cache feature flag
-		this.#useInMemoryCache = parameters.useInMemoryCache || 
-			(process.env.CACHE_USE_IN_MEMORY === 'true') || 
+		this.#useInMemoryCache = Cache.bool(parameters.useInMemoryCache) || 
+			Cache.bool(process.env.CACHE_USE_IN_MEMORY) || 
 			false;
 		
 		// Initialize InMemoryCache if enabled
@@ -1654,34 +1654,51 @@ class Cache {
 	};
 
 	/**
-	 * Convert a value to boolean with special handling for the string "false".
+	 * Convert a value to boolean with strict handling for string values.
 	 * 
 	 * JavaScript's Boolean() function treats any non-empty string as true, including
-	 * the string "false". This method adds special handling for the string "false"
-	 * (case-insensitive) to return false, which is useful when dealing with JSON data,
-	 * query parameters, or configuration strings.
+	 * the string "false". This method provides strict boolean conversion where:
+	 * - The string "true" (case-insensitive) returns true
+	 * - The string "1" returns true
+	 * - The number 1 returns true
+	 * - The boolean true returns true
+	 * - All other values return false (including "false", "0", "no", whitespace, empty strings, null, undefined)
 	 * 
-	 * All other values are evaluated using JavaScript's standard Boolean() conversion.
+	 * This is useful when dealing with environment variables, JSON data, query parameters,
+	 * or configuration strings where only explicit "true" or "1" should enable a feature.
 	 * 
 	 * @param {*} value A value to convert to boolean
-	 * @returns {boolean} The boolean representation of the value, with "false" string treated as false
+	 * @returns {boolean} True only if value is explicitly truthy ("true", "1", 1, or true), false otherwise
 	 * @example
 	 * Cache.bool(true);      // true
 	 * Cache.bool(false);     // false
 	 * Cache.bool("true");    // true
-	 * Cache.bool("false");   // false (special handling)
-	 * Cache.bool("FALSE");   // false (case-insensitive)
+	 * Cache.bool("TRUE");    // true (case-insensitive)
+	 * Cache.bool("1");       // true
 	 * Cache.bool(1);         // true
+	 * Cache.bool("false");   // false
+	 * Cache.bool("0");       // false
+	 * Cache.bool("no");      // false
+	 * Cache.bool(" ");       // false (whitespace)
+	 * Cache.bool("  ");      // false (whitespace)
 	 * Cache.bool(0);         // false
 	 * Cache.bool(null);      // false
+	 * Cache.bool(undefined); // false
 	 * Cache.bool("");        // false
 	 */
 	static bool (value) {
 
-		if ( typeof value === 'string') { value = value.toLowerCase(); }
+		// >! Handle strings with strict true/false logic
+		// >! Only "true" and "1" are considered truthy strings
+		if ( typeof value === 'string') { 
+			value = value.trim().toLowerCase();
+			return value === 'true' || value === '1';
+		}
 
-		// Boolean("false") is true so we need to code for it. As long as it is not "false", trust Boolean()
-		return  (( value !== "false") ? Boolean(value) : false ); 
+		// >! For non-strings, use standard Boolean conversion
+		// >! This handles: true, 1, objects, arrays
+		// >! And returns false for: false, 0, null, undefined, NaN
+		return Boolean(value);
 	};
 
 	/**
@@ -3200,7 +3217,6 @@ class TestHarness {
 	 * WARNING: This method is for testing only and should never be used in production.
 	 * 
 	 * @returns {{CacheData: typeof CacheData, S3Cache: typeof S3Cache, DynamoDbCache: typeof DynamoDbCache}} Object containing internal classes
-	 * @private
 	 * @example
 	 * // In tests only - DO NOT use in production
 	 * const { CacheData, S3Cache, DynamoDbCache } = TestHarness.getInternals();