@63klabs/cache-data 1.3.8 → 1.3.10

package/CHANGELOG.md

@@ -8,6 +8,110 @@ 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.10 (2026-03-15)
+
+### Fixes
+
+- **Security Fixes** in tests and SSM Parameter Store legacy access [Spec: 1-3-10-security-fixes-for-tests](.kiro/specs/1-3-10-security-fixes-for-tests/)
+- **GitHub Workflow fix** for testing matrix. Node24 was failing while Node 20, 22 were passing [Spec: 1-3-10-github-workflow-test-fix](.kiro/specs/1-3-10-github-workflow-test-fix/)
+
+### Changes
+
+- **Complete Mocha to Jest Test Migration** [Spec: 1-3-10-test-migration-phase-6](.kiro/specs/1-3-10-test-migration-phase-6/)
+  - Migrated all 38 remaining Mocha test files to Jest, completing the full test suite migration
+  - Jest is now the sole test framework for the project
+  - All tests use the `.jest.mjs` file extension
+  - Updated `npm test` to run Jest directly
+  - Updated all module-specific test scripts (`test:cache`, `test:config`, `test:endpoint`) to use Jest
+  - Updated CI/CD configuration to run Jest only
+  - Updated documentation (README, CONTRIBUTING, AGENTS, steering documents) to reflect Jest-only testing
+- **ApiRequest** and **CachedSsmParameter** renaming to conform to naming conventions:
+  - `APIRequest` has been renamed to `ApiRequest`.
+  - `APIRequest` is now aliased to `ApiRequest` and will still work. 
+  - `CachedSSMParameter` has been renamed to `CachedSsmParameter`.
+  - `CachedSSMParameter` is now aliased to `CachedSsmParameter` and will still work. 
+  - While there is no timeframe to deprecate and remove the old naming, it will happen with a future **major** version update.
+  - New code should use the new conventions. Old code should be updated.
+- **tools.endpoint.get()** deprecated in favor of **tools.endpoint.send()**
+  - `tools.endpoint.send()` removes any confusion about it accepting more than just `GET` requests and that it will send immediately when called.
+- **Optimized Generic Response** for easier maintenance
+
+### Added
+
+- **Enhanced Invalid Request Messaging**
+- **New Response Formatting to ApiRequest**
+
+
+### Removed
+
+- **Mocha, Chai, and Sinon Dependencies** [Spec: 1-3-10-test-migration-phase-6](.kiro/specs/1-3-10-test-migration-phase-6/)
+  - Removed `mocha` from devDependencies
+  - Removed `chai` from devDependencies
+  - Removed `sinon` from devDependencies
+  - Removed `chai-http` from devDependencies
+  - Removed all legacy Mocha test files (`*-tests.mjs`)
+  - Removed `test:all` script (no longer needed with single test framework)
+
+
+## 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
@@ -29,14 +133,14 @@ Report all vulnerabilities under the [Security menu](https://github.com/63Klabs/
   - 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
+- **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
+  - **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)
@@ -212,9 +316,9 @@ While `DebugAndLog` has also been optimized, there is no change to its results.
 
 ## 1.1.4 (2025-03-18) Added XRay sub-segment for API requests
 
-- Feature: Added XRay Segment for APIRequest class
+- Feature: Added XRay Segment for ApiRequest class
 
-When using the tools.APIRequest class, each remote request is now annotated and provided meta data.
+When using the tools.ApiRequest class, each remote request is now annotated and provided meta data.
 
 ## 1.1.3 (2025-02-17) Additional Options for Sending Parameters via Query String
 

package/CONTRIBUTING.md

@@ -26,7 +26,7 @@ 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 [AGENTS](./AGENTS.md) and Kiro steering documents are reviewed, understood, and used by both humans and AI.
 
@@ -120,13 +120,66 @@ Ensure all tests pass before submitting changes:
 npm test
 
 # Run specific test suites
-npm test -- test/documentation/
-npm test -- test/cache/
+npm test -- test/documentation
+npm test -- test/cache
 ```
 
+## Testing
+
+This project uses Jest as its test framework. All tests use the `.jest.mjs` file extension.
+
+### Test Framework
+
+- Test Runner: Jest
+- Assertions: Jest built-in (`expect`)
+- Property Testing: fast-check
+- Mocking: Jest built-in (`jest.spyOn`, `jest.fn`)
+- File Pattern: `*.jest.mjs`
+
+### Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Run specific test suites
+npm test -- test/cache
+npm test -- test/endpoint
+npm test -- test/documentation
+```
+
+### Writing Tests
+
+All tests must use Jest. Example:
+
+```javascript
+import { describe, it, expect, jest, afterEach } from '@jest/globals';
+import { Cache } from '../src/lib/dao-cache.js';
+
+describe('Cache', () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it('should generate consistent hash for same input', () => {
+        const conn = { host: 'example.com', path: '/api' };
+        const hash1 = Cache.generateIdHash(conn);
+        const hash2 = Cache.generateIdHash(conn);
+        expect(hash1).toBe(hash2);
+    });
+});
+```
+
+### Test Naming Conventions
+
+- Test files: `*-tests.jest.mjs`
+- Property tests: `*-property-tests.jest.mjs`
+- Integration tests: `*-integration-tests.jest.mjs`
+- Unit tests: `*-unit-tests.jest.mjs`
+
 ## 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
@@ -149,7 +202,7 @@ All public APIs must have complete JSDoc documentation. See [Documentation Stand
  * @example
  * const result = await CacheableDataAccess.getData(
  *   cacheProfile,
- *   endpoint.get,
+ *   endpoint.send,
  *   connection
  * );
  * console.log(result.data);

package/README.md

@@ -50,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
@@ -68,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:
 
@@ -102,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.send, conn);
+const data = cachedData.getBody(true);
 ```
 
 ### Making Endpoint Requests
@@ -130,22 +126,21 @@ if (cachedData) {
 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" } }
+const response = await endpoint.send(
+  { 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
+### Using ApiRequest with Pagination and Retry
 
 ```javascript
-const { tools } = require("@63klabs/cache-data");
+const { tools: {ApiRequest} } = require("@63klabs/cache-data");
 
 // Make a request with automatic pagination and retry
-const request = new tools.APIRequest({
+const request = new tools.ApiRequest({
   host: "api.example.com",
   path: "/users",
   parameters: {
@@ -165,23 +160,15 @@ 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`);
-
-// Check metadata
-if (response.metadata?.pagination?.occurred) {
-  console.log(`Fetched ${response.metadata.pagination.totalPages} pages`);
-}
-if (response.metadata?.retries?.occurred) {
-  console.log(`Succeeded after ${response.metadata.retries.attempts} attempts`);
-}
 ```
 
 ### 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...
@@ -190,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

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@63klabs/cache-data",
-  "version": "1.3.8",
-  "description": "Cache data from an API endpoint or application process using AWS S3 and DynamoDb",
-  "author": "Chad Leigh Kluck (https://chadkluck.me)",
+  "version": "1.3.10",
+  "description": "A package for AWS Lambda Node.js applications to access and cache data from remote API endpoints (or other sources) utilizing AWS S3 and DynamoDb for the cache storage. Also provides a simple request handling, routing, and response logging framework for running a web service with minimal dependencies.",
+  "author": "Chad Kluck (https://chadkluck.me)",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,45 +16,34 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "aws-xray-sdk-core": "^3.12.0",
     "moment-timezone": "^0.6.0",
     "object-hash": "^3.0.0"
   },
   "devDependencies": {
+    "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.7.5",
-    "sinon": "^21.0.1"
-  },
+    "jest": "^30.2.0"  },
   "overrides": {
     "fast-xml-parser": ">=5.3.4",
-    "diff": ">=8.0.3",
-    "minimatch": ">=10.2.2",
-    "glob": ">=13.0.6"
+    "glob": ">=13.0.6",
+    "minimatch": ">=10.2.2"
   },
   "scripts": {
-    "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": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:cache": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/cache",
+    "test:config": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/config",
+    "test:endpoint": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/endpoint",
+    "test:tools": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/tools",
+    "test:logging": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/logging",
+    "test:request": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/request",
+    "test:response": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/response",
+    "test:utils": "node --experimental-vm-modules node_modules/jest/bin/jest.js test/utils",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "lint:ci": "eslint . --max-warnings 0"

package/src/lib/dao-cache.js

@@ -38,9 +38,10 @@ const moment = require('moment-timezone');
  * and retrieval operations - cache expiration logic and data management are
  * handled by the CacheData class.
  * 
- * Use this class when you need direct access to S3 cache storage operations.
- * For most use cases, use the Cache or CacheableDataAccess classes instead.
+ * Used by Cache object to write and retrieve data that is larger than what
+ * we want to store in DynamoDB
  * 
+ * @private
  * @example
  * // Initialize S3Cache with bucket name
  * S3Cache.init('my-cache-bucket');
@@ -57,8 +58,13 @@ class S3Cache {
 	static #bucket = null;
 	static #objPath = "cache/";
 
-	constructor () {
-	};
+	/**
+	 * Create a new S3Cache instance.
+	 * Private constructor - instances should be created through static methods.
+	 *
+	 * @private
+	 */
+	constructor () {};
 
 	/**
 	 * Get the S3 bucket name configured for cache storage.
@@ -106,7 +112,6 @@ class S3Cache {
 	 * process.env.CACHE_DATA_S3_BUCKET = 'my-cache-bucket';
 	 * S3Cache.init();
 	 */
-
 	static init(bucket = null) {
 		if ( S3Cache.getBucket() === null ) {
 			bucket = (bucket === null) ? process.env?.CACHE_DATA_S3_BUCKET || null : bucket;
@@ -272,14 +277,14 @@ class S3Cache {
 };
 
 /**
- * Basic DynamoDb read/write for cache data. Provides low-level storage operations
+ * Basic DynamoDB read/write for cache data. Provides low-level storage operations
  * for cached data in Amazon DynamoDB. This class handles only the storage format
  * and retrieval operations - cache expiration logic and data management are
  * handled by the CacheData class.
  * 
- * Use this class when you need direct access to DynamoDB cache storage operations.
- * For most use cases, use the Cache or CacheableDataAccess classes instead.
+ * Used by Cache object to write and retrieve data in DynamoDB
  * 
+ * @private
  * @example
  * // Initialize DynamoDbCache with table name
  * DynamoDbCache.init('my-cache-table');
@@ -455,8 +460,8 @@ class DynamoDbCache {
  * coordinates storage between DynamoDB (for small items) and S3 (for large items).
  * 
  * This class is used internally by the publicly exposed Cache class and should
- * not be used directly in most cases. Use the Cache or CacheableDataAccess
- * classes instead for application-level caching.
+ * not be used directly. Use the CacheableDataAccess to access data for
+ * application-level caching.
  * 
  * Key responsibilities:
  * - Expiration time calculations and interval-based caching
@@ -464,6 +469,7 @@ class DynamoDbCache {
  * - Automatic routing between DynamoDB and S3 based on size
  * - ETag and Last-Modified header generation
  * 
+ * @private
  * @example
  * // Initialize CacheData (typically done through Cache.init())
  * CacheData.init({
@@ -508,7 +514,7 @@ class CacheData {
 	 * @param {string} [parameters.dynamoDbTable] DynamoDB table name (or use CACHE_DATA_DYNAMO_DB_TABLE env var)
 	 * @param {string} [parameters.s3Bucket] S3 bucket name (or use CACHE_DATA_S3_BUCKET env var)
 	 * @param {string} [parameters.secureDataAlgorithm='aes-256-cbc'] Encryption algorithm (or use CACHE_DATA_SECURE_DATA_ALGORITHM env var)
-	 * @param {string|Buffer|tools.Secret|tools.CachedSSMParameter|tools.CachedSecret} parameters.secureDataKey Encryption key (required, no env var for security)
+	 * @param {string|Buffer|tools.Secret|tools.CachedSsmParameter|tools.CachedSecret} parameters.secureDataKey Encryption key (required, no env var for security)
 	 * @param {number} [parameters.DynamoDbMaxCacheSize_kb=10] Max size in KB for DynamoDB storage (or use CACHE_DATA_DYNAMO_DB_MAX_CACHE_SIZE_KB env var)
 	 * @param {number} [parameters.purgeExpiredCacheEntriesAfterXHours=24] Hours after expiration to purge entries (or use CACHE_DATA_PURGE_EXPIRED_CACHE_ENTRIES_AFTER_X_HRS env var)
 	 * @param {string} [parameters.timeZoneForInterval='Etc/UTC'] Timezone for interval calculations (or use CACHE_DATA_TIME_ZONE_FOR_INTERVAL env var)
@@ -1373,26 +1379,18 @@ class CacheData {
 };
 
 /**
- * The Cache object handles the settings for the cache system
+ * The Cache object handles the settings for the cache system and is only
+ * accessed by the application during init.
  * 
- * Before using it must be initialized. 
+ * Reading of the cache is done through CacheableDataAccess.getData()
+ * 
+ * Before using the Cache, it must be initialized. 
  * 
  * Many settings can be set through Environment variables or by
  * passing parameters to Cache.init():
  * 
  * Cache.init({parameters});
  * 
- * Then you can then make a request, sending it through CacheableDataAccess:
- * 
- *  const { cache } = require("@63klabs/cache-data");
- * 
- *	const cacheObj = await cache.CacheableDataAccess.getData(
- *		cacheCfg, 
- *		yourFetchFunction,
- *		conn, 
- *		daoQuery
- *	);
- * 
  * @example
  * // Initialize the cache system
  * Cache.init({
@@ -1401,13 +1399,6 @@ class CacheData {
  *   idHashAlgorithm: 'sha256'
  * });
  * 
- * // Create a cache instance with connection and profile
- * const connection = { host: 'api.example.com', path: '/data' };
- * const cacheProfile = { 
- *   defaultExpirationInSeconds: 300,
- *   encrypt: true 
- * };
- * const cacheInstance = new Cache(connection, cacheProfile);
  */
 class Cache {
 
@@ -1526,7 +1517,7 @@ class Cache {
 	 * @param {string} parameters.dynamoDbTable Can also be set with environment variable CACHE_DATA_DYNAMO_DB_TABLE
 	 * @param {string} parameters.s3Bucket Can also be set with environment variable CACHE_DATA_S3_BUCKET
 	 * @param {string} parameters.secureDataAlgorithm Can also be set with environment variable CACHE_DATA_SECURE_DATA_ALGORITHM
-	 * @param {string|Buffer|tools.Secret|tools.CachedSSMParameter|tools.CachedSecret} parameters.secureDataKey Must be passed, will not accept an environment variable for security reasons.
+	 * @param {string|Buffer|tools.Secret|tools.CachedSsmParameter|tools.CachedSecret} parameters.secureDataKey Must be passed, will not accept an environment variable for security reasons.
 	 * @param {number} parameters.DynamoDbMaxCacheSize_kb Can also be set with environment variable CACHE_DATA_DYNAMO_DB_MAX_CACHE_SIZE_KB
 	 * @param {number} parameters.purgeExpiredCacheEntriesAfterXHours Can also be set with environment variable CACHE_DATA_PURGE_EXPIRED_CACHE_ENTRIES_AFTER_X_HRS
 	 * @param {string} parameters.timeZoneForInterval Can also be set with environment variable CACHE_DATA_TIME_ZONE_FOR_INTERVAL
@@ -1545,8 +1536,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 +1645,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);
 	};
 
 	/**
@@ -2995,7 +3003,7 @@ class Cache {
 /**
  * The CacheableDataAccess object provides an interface to 
  * the cache. It is responsible for reading from and writing to cache.
- * All requests to data go through the cache
+ * All requests to data go through CacheableDataAccess.getData
  * 
  * Before using CacheableDataAccess, the Cache must be initialized. 
  * 
@@ -3082,7 +3090,7 @@ class CacheableDataAccess {
 	 *
 	 * const cache = await CacheableDataAccess.getData(
 	 *   cachePolicy,
-	 *   endpoint.get,
+	 *   endpoint.send,
 	 *   connection,
 	 *   null,
 	 *   {path: 'users', id: '123'}