cdk-factory 0.8.1__tar.gz → 0.8.2__tar.gz

cdk_factory-0.8.2/CHANGELOG_v0.8.1.md

@@ -0,0 +1,148 @@
+# CDK Factory v0.8.1 Release Notes
+
+Released: 2025-10-09
+
+## Bug Fixes
+
+### 1. Fixed SSM Export Configuration Bug
+**Issue**: Documentation showed incorrect pattern `"exports": {"enabled": true}` which caused `AttributeError: 'bool' object has no attribute 'startswith'`
+
+**Fix**: 
+- Added type validation in `enhanced_ssm_config.py` to handle non-string values
+- Updated documentation to show correct pattern: `"auto_export": true`
+- Created comprehensive documentation in `docs/SSM_EXPORT_FIX.md`
+
+**Impact**: Prevents crashes when using incorrect SSM export configuration
+
+### 2. Fixed Cognito User Pool SSM Import for API Gateway
+**Issue**: API Gateway couldn't find Cognito User Pool ARN, causing `ValueError: User pool ID is required for API Gateway authorizer`
+
+**Fix**:
+- Enhanced SSM-based import pattern for `user_pool_arn`
+- Created comprehensive guide in `docs/API_GATEWAY_COGNITO_SSM.md`
+- Added auto-discovery support via `"user_pool_arn": "auto"`
+
+**Impact**: Enables seamless cross-stack Cognito + API Gateway integration
+
+### 3. Fixed Authorizer Creation When Not Needed
+**Issue**: API Gateway authorizer was created even when all routes were public (`authorization_type: "NONE"`), causing CDK validation error: `ValidationError: Authorizer must be attached to a RestApi`
+
+**Fix**:
+- Modified `_setup_cognito_authorizer()` to only create authorizer when at least one route requires it
+- Added `cognito_configured` flag to maintain security validation context
+- Security warnings still emitted for public endpoints when Cognito is available
+
+**Impact**: 
+- Prevents CDK synthesis errors for public-only APIs
+- Maintains security validation without creating unused resources
+- Reduces AWS resource overhead
+
+### 4. Removed Deprecated SSM Parameter Types
+**Issue**: Using deprecated `ssm.ParameterType.STRING`, `ssm.ParameterType.STRING_LIST`, and `type` parameter caused AWS CDK deprecation warnings
+
+**Fix**:
+- Replaced deprecated `ParameterType` enum with appropriate CDK constructs:
+  - `StringParameter` for regular strings (no `type` parameter needed)
+  - `StringListParameter` for string lists
+  - `CfnParameter` with `type="SecureString"` for secure strings
+- Updated `enhanced_ssm_parameter_mixin.py` to use CDK v2 best practices
+
+**Impact**: 
+- Eliminates deprecation warnings
+- Future-proofs code for CDK v3
+- Follows AWS CDK v2 best practices
+
+## Test Coverage
+
+- **153 tests passing** ✅
+- New test coverage:
+  - `test_api_gateway_export_config.py` (6 tests)
+  - `test_api_gateway_authorizer_ssm_integration.py` (5 tests)
+  - `test_cross_stack_ssm_integration.py` (3 tests)
+  - `test_api_gateway_enhanced_authorization_validation.py` (6 tests)
+
+## Documentation Added
+
+1. **docs/SSM_EXPORT_FIX.md** - SSM export configuration bug fix guide
+2. **docs/API_GATEWAY_COGNITO_SSM.md** - Comprehensive Cognito + API Gateway SSM integration guide
+3. **GEEK_CAFE_FIX.md** - Quick fix guide for geek-cafe project (example usage)
+
+## Breaking Changes
+
+None - all changes are backward compatible
+
+## Migration Guide
+
+### If you're using the old export pattern:
+
+**Before (v0.8.0 - incorrect docs):**
+```json
+{
+  "ssm": {
+    "enabled": true,
+    "exports": {
+      "enabled": true  // ❌ Wrong
+    }
+  }
+}
+```
+
+**After (v0.8.1):**
+```json
+{
+  "ssm": {
+    "enabled": true,
+    "auto_export": true  // ✅ Correct
+  }
+}
+```
+
+### If you're getting Cognito User Pool errors:
+
+Add to your API Gateway stack config:
+```json
+{
+  "api_gateway": {
+    "ssm": {
+      "imports": {
+        "user_pool_arn": "auto"  // ✅ Add this
+      }
+    }
+  }
+}
+```
+
+### If you have public-only API routes:
+
+Your config should work without changes. The authorizer will only be created if needed:
+```json
+{
+  "cognito_authorizer": {
+    "authorizer_name": "my-authorizer"  // Config present but not used
+  },
+  "routes": [
+    {
+      "path": "/public",
+      "method": "GET",
+      "authorization_type": "NONE",  // ✅ Authorizer won't be created
+      "allow_public_override": true
+    }
+  ]
+}
+```
+
+## Deployment Flow (v0.8.1+)
+
+```
+1. Cognito Stack       → Exports user_pool_arn to SSM
+2. Lambda Stack        → Exports Lambda ARNs to SSM
+3. API Gateway Stack   → Imports both, creates authorizer only if needed
+```
+
+## Known Issues
+
+None
+
+## Contributors
+
+- Eric Wilson (@geekcafe)

{cdk_factory-0.8.1 → cdk_factory-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.8.1
+Version: 0.8.2
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.8.1 → cdk_factory-0.8.2}/pyproject.toml

@@ -33,7 +33,7 @@ markers = [
 [project]
 
 name = "cdk_factory"
-version = "0.8.1"
+version = "0.8.2"
 authors = [
   { name="Eric Wilson", email="eric.wilson@geekcafe.com" }
 ]

{cdk_factory-0.8.1 → cdk_factory-0.8.2}/src/cdk_factory/interfaces/enhanced_ssm_parameter_mixin.py

@@ -142,28 +142,39 @@ class EnhancedSsmParameterMixin:
         Returns:
             Created SSM parameter
         """
-        # Handle different value types
-        if isinstance(value, list):
-            string_value = ",".join(str(v) for v in value)
-            cdk_param_type = ssm.ParameterType.STRING_LIST
-        elif param_type == "SecureString":
-            string_value = str(value)
-            cdk_param_type = ssm.ParameterType.SECURE_STRING
-        else:
-            string_value = str(value)
-            cdk_param_type = ssm.ParameterType.STRING
-            
         # Generate a unique construct ID from the path
         construct_id = f"ssm-param-{path.replace('/', '-').replace('_', '-')}"
         
-        return ssm.StringParameter(
-            self.scope,
-            construct_id,
-            parameter_name=path,
-            string_value=string_value,
-            description=description,
-            type=cdk_param_type
-        )
+        # Handle different value types - use appropriate CDK constructs
+        if isinstance(value, list):
+            # For list values, use StringListParameter
+            return ssm.StringListParameter(
+                self.scope,
+                construct_id,
+                parameter_name=path,
+                string_list_value=value,
+                description=description
+            )
+        elif param_type == "SecureString":
+            # For secure strings, use L1 CfnParameter with Type=SecureString
+            return ssm.CfnParameter(
+                self.scope,
+                construct_id,
+                name=path,
+                value=str(value),
+                type="SecureString",
+                description=description
+            )
+        else:
+            # For regular strings, use StringParameter (no type parameter needed in CDK v2)
+            return ssm.StringParameter(
+                self.scope,
+                construct_id,
+                parameter_name=path,
+                string_value=str(value),
+                description=description
+                # Note: 'type' parameter removed - deprecated in CDK v2
+            )
     
     def _import_enhanced_ssm_parameter(self, path: str, attribute: str) -> Optional[str]:
         """

{cdk_factory-0.8.1 → cdk_factory-0.8.2}/src/cdk_factory/utilities/json_loading_utility.py

@@ -61,35 +61,63 @@ class JsonLoadingUtility:
         """Resolve references in a configuration section."""
         if isinstance(section, dict):
             if self.nested_key in section:
-                nested_path = str(section.pop(self.nested_key))
-                # print(f"Resolving parent path: {nested_path}")
-                if nested_path.endswith(".json"):
-                    nested_root_path = os.path.join(self.base_path, nested_path)
-                    nested_section = self.__load_json_file(nested_root_path)
-                elif os.path.isdir(os.path.join(self.base_path, nested_path)):
-                    nested_section = []
-                    dir_path = os.path.join(self.base_path, nested_path)
-                    for filename in os.listdir(dir_path):
-                        if filename.endswith(".json"):
-                            file_path = os.path.join(dir_path, filename)
-                            # print(f"Loading file: {file_path}")
-                            file_section = self.__load_json_file(file_path)
-                            nested_section.append(file_section)
-
-                    # print("done with nested sections")
-                else:
-                    nested_section = self.get_nested_config(root_config, nested_path)
-
-                nested_section_resolved = self.resolve_references(
-                    nested_section, root_config
-                )
-                if len(section) > 0 and isinstance(nested_section_resolved, dict):
-                    nested_section_resolved.update(section)
-                elif len(section) > 0 and isinstance(nested_section_resolved, list):
+                nested_paths = section.pop(self.nested_key)
+                
+                # Support both single path (string) and multiple paths (list)
+                if isinstance(nested_paths, str):
+                    nested_paths = [nested_paths]
+                elif not isinstance(nested_paths, list):
+                    raise ValueError(f"__inherits__ must be a string or list, got {type(nested_paths)}")
+                
+                # Process each path and merge results
+                merged_section = None
+                
+                for nested_path in nested_paths:
+                    nested_path = str(nested_path)
+                    # print(f"Resolving parent path: {nested_path}")
+                    
+                    if nested_path.endswith(".json"):
+                        nested_root_path = os.path.join(self.base_path, nested_path)
+                        nested_section = self.__load_json_file(nested_root_path)
+                    elif os.path.isdir(os.path.join(self.base_path, nested_path)):
+                        nested_section = []
+                        dir_path = os.path.join(self.base_path, nested_path)
+                        for filename in os.listdir(dir_path):
+                            if filename.endswith(".json"):
+                                file_path = os.path.join(dir_path, filename)
+                                # print(f"Loading file: {file_path}")
+                                file_section = self.__load_json_file(file_path)
+                                nested_section.append(file_section)
+                        # print("done with nested sections")
+                    else:
+                        nested_section = self.get_nested_config(root_config, nested_path)
+
+                    nested_section_resolved = self.resolve_references(
+                        nested_section, root_config
+                    )
+                    
+                    # Merge resolved sections
+                    if merged_section is None:
+                        merged_section = nested_section_resolved
+                    else:
+                        # Merge logic based on type
+                        if isinstance(merged_section, dict) and isinstance(nested_section_resolved, dict):
+                            self.merge_sections(merged_section, nested_section_resolved)
+                        elif isinstance(merged_section, list) and isinstance(nested_section_resolved, list):
+                            merged_section.extend(nested_section_resolved)
+                        else:
+                            raise RuntimeError(
+                                f"Cannot merge incompatible types: {type(merged_section)} and {type(nested_section_resolved)}"
+                            )
+                
+                # Apply any additional properties from the section
+                if len(section) > 0 and isinstance(merged_section, dict):
+                    merged_section.update(section)
+                elif len(section) > 0 and isinstance(merged_section, list):
                     raise RuntimeError("we need to resolve this section")
-                    # nested_section_resolved.append(section)
+                    # merged_section.append(section)
 
-                section = nested_section_resolved
+                section = merged_section
 
             if isinstance(section, dict):
                 for key, value in section.items():

cdk_factory-0.8.2/src/cdk_factory/version.py

@@ -0,0 +1 @@
+__version__ = "0.8.2"

cdk_factory-0.8.1/src/cdk_factory/version.py

@@ -1 +0,0 @@
-__version__ = "0.8.1"