cdk-factory 0.7.31__py3-none-any.whl → 0.8.1__py3-none-any.whl

cdk_factory/configurations/cdk_config.py

@@ -70,10 +70,13 @@ class CdkConfig:
         relative_config_path = ""
         # is this a relative path or a real path
         if not config_path.startswith("."):
-
-            root_path = os.path.commonpath([config_path, runtime_directory])
-            if root_path in config_path:
-                relative_config_path = config_path.replace(root_path, ".")
+            # Ensure both paths are absolute to avoid mixing absolute and relative paths
+            abs_config_path = os.path.abspath(config_path)
+            abs_runtime_directory = os.path.abspath(runtime_directory)
+            
+            root_path = os.path.commonpath([abs_config_path, abs_runtime_directory])
+            if root_path in abs_config_path:
+                relative_config_path = abs_config_path.replace(root_path, ".")
 
             print(f"👉 Relative Config: {relative_config_path}")
         else:

cdk_factory/configurations/enhanced_base_config.py

@@ -55,10 +55,15 @@ class EnhancedBaseConfig(BaseConfig):
         """Check if SSM parameter integration is enabled"""
         return self._enhanced_ssm.enabled if self._enhanced_ssm else False
     
+    @property
+    def ssm_workload(self) -> str:
+        """Get the workload name for SSM parameter paths"""
+        return self._enhanced_ssm.workload if self._enhanced_ssm else "cdk-factory"
+    
     @property
     def ssm_organization(self) -> str:
-        """Get the organization name for SSM parameter paths"""
-        return self._enhanced_ssm.organization if self._enhanced_ssm else "cdk-factory"
+        """Deprecated: Use ssm_workload instead. Kept for backward compatibility."""
+        return self.ssm_workload
     
     @property
     def ssm_environment(self) -> str:
@@ -68,7 +73,7 @@ class EnhancedBaseConfig(BaseConfig):
     @property
     def ssm_pattern(self) -> str:
         """Get the SSM parameter path pattern"""
-        return self._enhanced_ssm.pattern if self._enhanced_ssm else "/{organization}/{environment}/{stack_type}/{resource_name}/{attribute}"
+        return self._enhanced_ssm.pattern if self._enhanced_ssm else "/{workload}/{environment}/{stack_type}/{resource_name}/{attribute}"
     
     @property
     def ssm_auto_export(self) -> bool:
@@ -98,7 +103,7 @@ class EnhancedBaseConfig(BaseConfig):
         # Fallback to simple path generation
         if custom_path and custom_path.startswith("/"):
             return custom_path
-        return f"/{self.ssm_organization}/{self.ssm_environment}/{attribute}"
+        return f"/{self.ssm_workload}/{self.ssm_environment}/{attribute}"
     
     def get_export_definitions(self, context: Dict[str, Any] = None) -> List[SsmParameterDefinition]:
         """

cdk_factory/configurations/enhanced_ssm_config.py

@@ -42,8 +42,10 @@ class EnhancedSsmConfig:
         return self.config.get("enabled", True)
 
     @property
-    def organization(self) -> str:
-        return self.config.get("organization", "default")
+    def workload(self) -> str:
+        """Get workload name for SSM parameter paths (backward compatible with 'organization')"""
+        # Try 'workload' first, fall back to 'organization' for backward compatibility
+        return self.config.get("workload", self.config.get("organization", "default"))
 
     @property
     def environment(self) -> str:
@@ -58,7 +60,7 @@ class EnhancedSsmConfig:
     def pattern(self) -> str:
         return self.config.get(
             "pattern",
-            "/{organization}/{environment}/{stack_type}/{resource_name}/{attribute}",
+            "/{workload}/{environment}/{stack_type}/{resource_name}/{attribute}",
         )
 
 
@@ -84,15 +86,18 @@ class EnhancedSsmConfig:
         self, attribute: str, custom_path: Optional[str] = None
     ) -> str:
         """Generate SSM parameter path using pattern or custom path"""
-        if custom_path and custom_path.startswith("/"):
+        # Handle custom_path - must be a string starting with "/"
+        # Protect against incorrect config like: "exports": {"enabled": true}
+        if custom_path and isinstance(custom_path, str) and custom_path.startswith("/"):
             return custom_path
 
         # Convert underscore attribute names to hyphen format for consistent SSM paths
         formatted_attribute = attribute.replace("_", "-")
 
-        # Use enhanced pattern
+        # Use enhanced pattern (support both workload and organization for backward compatibility)
         return self.pattern.format(
-            organization=self.organization,
+            workload=self.workload,
+            organization=self.workload,  # Backward compatibility
             environment=self.environment,
             stack_type=self.resource_type,
             resource_name=self.resource_name,
@@ -236,7 +241,7 @@ class EnhancedSsmConfig:
         formatted_resource_name = source_resource_name.replace("_", "-")
         formatted_resource_type = source_resource_type.replace("_", "-")
         
-        return f"/{self.organization}/{self.environment}/{formatted_resource_type}/{formatted_resource_name}/{formatted_attribute}"
+        return f"/{self.workload}/{self.environment}/{formatted_resource_type}/{formatted_resource_name}/{formatted_attribute}"
 
 
 # Resource type definitions for auto-discovery

cdk_factory/stack_library/api_gateway/api_gateway_stack.py

@@ -304,9 +304,28 @@ class ApiGatewayStack(IStack, EnhancedSsmParameterMixin):
         )
 
     def _setup_cognito_authorizer(self, api_gateway, api_id):
-        """Setup Cognito authorizer if configured"""
+        """Setup Cognito authorizer if configured AND if any routes need it"""
         if not self.api_config.cognito_authorizer:
             return None
+        
+        # Check if any routes actually need the authorizer
+        # Don't create it if all routes are public (authorization_type: NONE)
+        routes = self.api_config.routes or []
+        needs_authorizer = any(
+            route.get("authorization_type") != "NONE" 
+            for route in routes
+        )
+        
+        # If we're not creating an authorizer but Cognito is configured,
+        # inform the integration utility so it can still perform security validations
+        if not needs_authorizer:
+            logger.info(
+                "Cognito authorizer configured but no routes require authorization. "
+                "Skipping authorizer creation but maintaining security validation context."
+            )
+            # Set a flag so the integration utility knows Cognito was available
+            self.integration_utility.cognito_configured = True
+            return None
 
         route_config = ApiGatewayConfigRouteConfig({})
         return self.integration_utility.get_or_create_authorizer(
@@ -316,10 +335,112 @@ class ApiGatewayStack(IStack, EnhancedSsmParameterMixin):
     def _setup_lambda_routes(self, api_gateway, api_id, routes, authorizer):
         """Setup Lambda routes and integrations"""
         for route in routes:
-            self._setup_single_lambda_route(api_gateway, api_id, route, authorizer)
+            # Check if this route references an existing Lambda via SSM
+            lambda_arn_ssm_path = route.get("lambda_arn_ssm_path")
+            lambda_name_ref = route.get("lambda_name")
+            
+            if lambda_arn_ssm_path or lambda_name_ref:
+                # Import existing Lambda from SSM
+                self._setup_existing_lambda_route(api_gateway, api_id, route, authorizer)
+            else:
+                # Create new Lambda (legacy pattern)
+                self._setup_single_lambda_route(api_gateway, api_id, route, authorizer)
+
+    def _setup_existing_lambda_route(self, api_gateway, api_id, route, authorizer):
+        """
+        Setup API Gateway route with existing Lambda function imported from SSM.
+        This is the NEW PATTERN for separating Lambda and API Gateway stacks.
+        """
+        route_path = route["path"]
+        suffix = route_path.strip("/").replace("/", "-") or "health"
+        
+        # Get Lambda ARN from SSM Parameter Store
+        lambda_arn = self._get_lambda_arn_from_ssm(route)
+        
+        if not lambda_arn:
+            raise ValueError(
+                f"Could not resolve Lambda ARN for route {route_path}. "
+                f"Ensure Lambda stack has deployed and exported ARN to SSM."
+            )
+        
+        # Import Lambda function from ARN
+        lambda_fn = _lambda.Function.from_function_arn(
+            self,
+            f"{api_id}-imported-lambda-{suffix}",
+            lambda_arn
+        )
+        
+        logger.info(f"Imported Lambda for route {route_path}: {lambda_arn}")
+        
+        # Setup API Gateway resource
+        resource = (
+            api_gateway.root.resource_for_path(route_path)
+            if route_path != "/"
+            else api_gateway.root
+        )
+        
+        # Setup Lambda integration
+        self._setup_lambda_integration(
+            api_gateway, api_id, route, lambda_fn, authorizer, suffix
+        )
+        
+        # Setup CORS using centralized utility
+        self.integration_utility.setup_route_cors(resource, route_path, route)
+    
+    def _get_lambda_arn_from_ssm(self, route: dict) -> str:
+        """
+        Get Lambda ARN from SSM Parameter Store.
+        Supports both explicit SSM paths and auto-discovery via lambda_name.
+        """
+        # Option 1: Explicit SSM path provided
+        lambda_arn_ssm_path = route.get("lambda_arn_ssm_path")
+        if lambda_arn_ssm_path:
+            logger.info(f"Looking up Lambda ARN from SSM: {lambda_arn_ssm_path}")
+            try:
+                param = ssm.StringParameter.from_string_parameter_name(
+                    self,
+                    f"lambda-arn-param-{hash(lambda_arn_ssm_path) % 10000}",
+                    lambda_arn_ssm_path
+                )
+                return param.string_value
+            except Exception as e:
+                logger.error(f"Failed to retrieve Lambda ARN from SSM path {lambda_arn_ssm_path}: {e}")
+                raise
+        
+        # Option 2: Auto-discovery via lambda_name
+        lambda_name = route.get("lambda_name")
+        if lambda_name:
+            # Build SSM path using convention from lambda_stack
+            ssm_imports_config = self.stack_config.dictionary.get("api_gateway", {}).get("ssm", {}).get("imports", {})
+            # Try 'workload' first, fall back to 'organization' for backward compatibility
+            workload = ssm_imports_config.get("workload", ssm_imports_config.get("organization", self.deployment.workload_name))
+            environment = ssm_imports_config.get("environment", self.deployment.environment)
+            
+            ssm_path = f"/{workload}/{environment}/lambda/{lambda_name}/arn"
+            logger.info(f"Auto-discovering Lambda ARN from SSM: {ssm_path}")
+            
+            try:
+                param = ssm.StringParameter.from_string_parameter_name(
+                    self,
+                    f"lambda-arn-{lambda_name}-param",
+                    ssm_path
+                )
+                return param.string_value
+            except Exception as e:
+                logger.error(f"Failed to auto-discover Lambda ARN for '{lambda_name}' from {ssm_path}: {e}")
+                raise ValueError(
+                    f"Lambda ARN not found in SSM for '{lambda_name}'. "
+                    f"Ensure the Lambda stack has deployed and exported the ARN to: {ssm_path}"
+                )
+        
+        return None
 
     def _setup_single_lambda_route(self, api_gateway, api_id, route, authorizer):
-        """Setup a single Lambda route with integration and CORS"""
+        """
+        Setup a single Lambda route with integration and CORS.
+        LEGACY PATTERN: Creates a new Lambda function inline.
+        Prefer _setup_existing_lambda_route for new implementations.
+        """
         suffix = route["path"].strip("/").replace("/", "-") or "health"
         src = route.get("src")
         handler = route.get("handler")

cdk_factory/stack_library/aws_lambdas/lambda_stack.py

@@ -34,11 +34,7 @@ from cdk_factory.configurations.resources.lambda_function import (
     SQS as SQSConfig,
 )
 
-from cdk_factory.utilities.api_gateway_integration_utility import (
-    ApiGatewayIntegrationUtility,
-)
-from aws_cdk import aws_apigateway as apigateway
-from aws_cdk import aws_cognito as cognito
+from aws_cdk import aws_ssm as ssm
 
 from cdk_factory.utilities.docker_utilities import DockerUtilities
 from cdk_factory.stack.stack_module_registry import register_stack
@@ -71,8 +67,7 @@ class LambdaStack(IStack):
         self.stack_config: StackConfig | None = None
         self.deployment: DeploymentConfig | None = None
         self.workload: WorkloadConfig | None = None
-        self.api_gateway_integrations: list = []
-        self.integration_utility = None
+        self.exported_lambda_arns: dict = {}  # Store exported Lambda ARNs
 
         self.__nag_rule_suppressions()
 
@@ -90,8 +85,9 @@ class LambdaStack(IStack):
         self.deployment = deployment
         self.workload = workload
 
-        # Initialize integration utility for consistent API Gateway behavior
-        self.integration_utility = ApiGatewayIntegrationUtility(self)
+        # Check for deprecated API Gateway configuration in lambda resources
+        self.__check_for_deprecated_api_config(stack_config)
+
         resources = stack_config.dictionary.get("resources", [])
         if len(resources) == 0:
             resources = stack_config.dictionary.get("lambdas", [])
@@ -100,14 +96,13 @@ class LambdaStack(IStack):
 
         lambda_functions: List[LambdaFunctionConfig] = []
         for resource in resources:
-
             config = LambdaFunctionConfig(config=resource, deployment=deployment)
             lambda_functions.append(config)
 
         self.functions = self.__setup_lambdas(lambda_functions)
         
-        # Trigger API Gateway deployment after all integrations are added
-        self.__finalize_api_gateway_deployments()
+        # Export Lambda ARNs to SSM Parameter Store for API Gateway integration
+        self.__export_lambda_arns_to_ssm()
 
     def __nag_rule_suppressions(self):
         pass
@@ -191,12 +186,12 @@ class LambdaStack(IStack):
                             f"A resource policy for {rp.get('principal')} has not been defined"
                         )
 
-            # Handle API Gateway integration if configured
-            if function_config.api:
-                self.__setup_api_gateway_integration(
-                    lambda_function=lambda_function,
-                    function_config=function_config,
-                )
+            # Store Lambda function for SSM export
+            self.exported_lambda_arns[function_config.name] = {
+                "arn": lambda_function.function_arn,
+                "name": lambda_function.function_name,
+                "function": lambda_function,
+            }
 
             functions.append(lambda_function)
 
@@ -299,66 +294,117 @@ class LambdaStack(IStack):
 
             rule.add_target(aws_events_targets.LambdaFunction(lambda_function))
 
-    def __setup_api_gateway_integration(
-        self, lambda_function: _lambda.Function, function_config: LambdaFunctionConfig
-    ) -> None:
-        """Setup API Gateway integration for Lambda function using shared utility"""
-        api_config = function_config.api
-
-        if not api_config:
-            raise ValueError("API Gateway config is missing in Lambda function config")
-
-        # Get or create API Gateway using shared utility
-        api_gateway = self.integration_utility.get_or_create_api_gateway(
-            api_config, self.stack_config, self.api_gateway_integrations
-        )
-
-        # Setup the integration using shared utility
-        integration_info = self.integration_utility.setup_lambda_integration(
-            lambda_function, api_config, api_gateway, self.stack_config
-        )
-
-        # Setup CORS for the route using shared utility
-        route_config = {"cors": api_config.cors} if hasattr(api_config, 'cors') and api_config.cors else {}
-        if route_config.get("cors"):
-            self.integration_utility.setup_route_cors(
-                integration_info["resource"], 
-                api_config.routes, 
-                route_config
-            )
-
-        # Store integration info for potential cross-stack references
-        integration_info["function_name"] = function_config.name
-        self.api_gateway_integrations.append(integration_info)
-
-        logger.info(f"Created API Gateway integration for {function_config.name}")
-
-    def __finalize_api_gateway_deployments(self):
-        """Create deployments and stages for API Gateways after all integrations are added"""
-        if not self.api_gateway_integrations:
+    def __check_for_deprecated_api_config(self, stack_config: StackConfig) -> None:
+        """
+        Check for deprecated API Gateway configuration in lambda resources.
+        Raises an error with migration guidance if found.
+        """
+        resources = stack_config.dictionary.get("resources", [])
+        if not resources:
+            resources = stack_config.dictionary.get("lambdas", [])
+        
+        deprecated_configs = []
+        for resource in resources:
+            # Check for 'api' key in resource configuration
+            if "api" in resource or "api_gateway" in stack_config.dictionary:
+                deprecated_configs.append(resource.get("name", "unnamed"))
+        
+        if deprecated_configs:
+            error_msg = f"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ 🚨 DEPRECATED CONFIGURATION DETECTED                                         ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+Your lambda_stack configuration includes API Gateway setup, which is now 
+deprecated. This pattern caused deployment issues and violated AWS best practices.
+
+📋 AFFECTED RESOURCES:
+{chr(10).join(f"   • {name}" for name in deprecated_configs)}
+
+🔧 REQUIRED MIGRATION (Breaking Change v2.0+):
+
+Lambda stacks should ONLY create Lambda functions. API Gateway integration 
+should be handled in a separate api_gateway_stack.
+
+NEW PATTERN:
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ 1. Lambda Stack (lambda_stack)                                              │
+│    • Creates Lambda functions                                               │
+│    • Exports Lambda ARNs to SSM Parameter Store                             │
+│    • NO API Gateway configuration                                           │
+│                                                                              │
+│ 2. API Gateway Stack (api_gateway_stack)                                    │
+│    • Imports Lambda ARNs from SSM                                           │
+│    • Creates API Gateway                                                    │
+│    • Wires Lambda integrations                                              │
+│    • Manages stages, deployments, and domains                               │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+📚 MIGRATION GUIDE:
+https://github.com/geek-cafe/cdk-factory/blob/main/docs/MIGRATION_V2.md
+
+💡 QUICK FIX:
+1. Remove 'api' configuration from lambda resources
+2. Remove 'api_gateway' from stack config  
+3. Create new api_gateway_stack configuration
+4. Update pipeline: lambdas deploy first, then api_gateway
+
+❓ NEED HELP?
+See examples: cdk-factory/examples/separate-api-gateway/
+
+════════════════════════════════════════════════════════════════════════════════
+"""
+            raise ValueError(error_msg)
+
+    def __export_lambda_arns_to_ssm(self) -> None:
+        """
+        Export Lambda ARNs to SSM Parameter Store for cross-stack references.
+        This enables the API Gateway stack to import and integrate with these Lambdas.
+        """
+        if not self.exported_lambda_arns:
+            logger.info("No Lambda functions to export to SSM")
             return
         
-        # Use consolidated utility for deployment and stage creation
-        api_gateway = self.api_gateway_integrations[0].get("api_gateway")
+        # Get SSM export configuration
+        ssm_config = self.stack_config.dictionary.get("ssm", {})
+        if not ssm_config.get("enabled", False):
+            logger.info("SSM export is not enabled for this stack")
+            return
         
-        # Use consolidated deployment and stage creation
-        stage = self.integration_utility.finalize_api_gateway_deployment(
-            api_gateway=api_gateway,
-            integrations=self.api_gateway_integrations,
-            stack_config=self.stack_config,
-            api_config=None,  # Lambda stack doesn't have ApiGatewayConfig
-            construct_scope=self,
-            counter=1
-        )
-
-    def _get_api_gateway_stage_name(self) -> str:
-        """Get the API Gateway stage name from configuration"""
-        # Check if there's an API Gateway configuration in the stack config
-        api_gateway_config = self.stack_config.dictionary.get("api_gateway", {})
-        name = api_gateway_config.get("stage", {}).get("name")
-        if name:
-            return name
-        return api_gateway_config.get("stage_name", "prod")
+        # Build SSM parameter prefix
+        # Try 'workload' first, fall back to 'organization' for backward compatibility
+        workload = ssm_config.get("workload", ssm_config.get("organization", self.deployment.workload_name))
+        environment = ssm_config.get("environment", self.deployment.environment)
+        prefix = f"/{workload}/{environment}/lambda"
+        
+        logger.info(f"Exporting {len(self.exported_lambda_arns)} Lambda functions to SSM under {prefix}")
+        
+        for lambda_name, lambda_info in self.exported_lambda_arns.items():
+            # Create SSM parameter for Lambda ARN
+            param_name = f"{prefix}/{lambda_name}/arn"
+            ssm.StringParameter(
+                self,
+                f"ssm-export-{lambda_name}-arn",
+                parameter_name=param_name,
+                string_value=lambda_info["arn"],
+                description=f"Lambda ARN for {lambda_name}",
+                tier=ssm.ParameterTier.STANDARD,
+            )
+            
+            # Also export function name for convenience
+            param_name_fname = f"{prefix}/{lambda_name}/function-name"
+            ssm.StringParameter(
+                self,
+                f"ssm-export-{lambda_name}-name",
+                parameter_name=param_name_fname,
+                string_value=lambda_info["name"],
+                description=f"Lambda function name for {lambda_name}",
+                tier=ssm.ParameterTier.STANDARD,
+            )
+            
+            logger.info(f"✅ Exported Lambda '{lambda_name}' to SSM: {param_name}")
+        
+        print(f"📤 Exported {len(self.exported_lambda_arns)} Lambda function(s) to SSM Parameter Store")
 
     def __setup_lambda_docker_file(
         self, lambda_config: LambdaFunctionConfig

cdk_factory/utilities/api_gateway_integration_utility.py

@@ -40,6 +40,7 @@ class ApiGatewayIntegrationUtility:
         self.account = scope.account
         self.api_gateway = None
         self.authorizer = None
+        self.cognito_configured = False  # Flag for when Cognito is configured but authorizer not created
         self._log_group = None
         self._log_role = None
 
@@ -55,8 +56,10 @@ class ApiGatewayIntegrationUtility:
             raise ValueError("API Gateway config is missing in Lambda function config")
 
         # Validate authorization configuration for security
+        # Check if Cognito is available (either authorizer created OR configured but not created)
         has_cognito_authorizer = (
             self.authorizer is not None
+            or self.cognito_configured
             or self._get_existing_authorizer_id_with_ssm_fallback(
                 api_config, stack_config
             )
@@ -614,6 +617,10 @@ class ApiGatewayIntegrationUtility:
             authorizer_name=authorizer_name,
             identity_source=identity_source,
         )
+        
+        # The authorizer is automatically attached to the API Gateway when used in a method
+        # But we need to ensure it's created in the context of the API's scope
+        # The actual attachment happens when the authorizer is referenced in method creation
 
         return self.authorizer
 

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.7.31"
+__version__ = "0.8.1"

{cdk_factory-0.7.31.dist-info → cdk_factory-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.7.31
+Version: 0.8.1
 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.7.31.dist-info → cdk_factory-0.8.1.dist-info}/RECORD

@@ -1,16 +1,16 @@
 cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/app.py,sha256=xv863N7O6HPKznB68_t7O4la9JacrkG87t9TjoDUk7s,2827
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
-cdk_factory/version.py,sha256=CtvyqFRtdJwNvYSDVmaT9l1R18bsaIwflR8r696jttk,23
+cdk_factory/version.py,sha256=Ocl79hbbH8_jdr5dGC90VR1cAvZc05Rc0tkZttUnMjo,22
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=JKjhNsy0RCUZy1s8n5D_aXXI-upR9izaLtCTfKYiV9k,9624
-cdk_factory/configurations/cdk_config.py,sha256=ex7NYvgEu78cfyiiP81cKtlhZZu2PSzJesSWGADpDh8,8549
+cdk_factory/configurations/cdk_config.py,sha256=eYboaXcz9CUx4rJbEagX8ppgtIERUlopcJXii7Vn8Ws,8796
 cdk_factory/configurations/deployment.py,sha256=LO2gd1yv1nqlX_2MIjRXptylFybWiTKsMKZU0N58rSM,12110
 cdk_factory/configurations/deployment_wave.py,sha256=TFX7CYgr5SmLyziEb-R_OTteFWtlMHB4pT53ekV3d1Y,233
 cdk_factory/configurations/devops.py,sha256=PG-s2ldZmMULheWdKf2lf2LSugLoKiOKyLELTZJJxu8,2506
-cdk_factory/configurations/enhanced_base_config.py,sha256=4QWNaUYDaHkIIIzRMYwsgzKhV7ERcLjhA0A6tqSq9sU,6498
-cdk_factory/configurations/enhanced_ssm_config.py,sha256=mJRNMOLQ-75MdXuRZcXqmEHN6syeU4j1oYfSfJhzIWg,12390
+cdk_factory/configurations/enhanced_base_config.py,sha256=Y1gcGZxyf_O2KFnVpCBORSGHWHqHxw0vNx_ijMad_QA,6654
+cdk_factory/configurations/enhanced_ssm_config.py,sha256=VDmIUSrj8nYS6fE9DdOp5yi9jUfMfitz5A7kCuPS-kI,12895
 cdk_factory/configurations/management.py,sha256=TSOIyxO9hGNxbgiTsS8a3pz03ungXiNqPPtZtfOpr8M,1373
 cdk_factory/configurations/pipeline.py,sha256=3RmRP1GIk42rjYZ-A9H3357RcO13IA47N-2IQcBkySQ,4939
 cdk_factory/configurations/pipeline_stage.py,sha256=eAT-FoIepIuv5tObk4TXlCN47FaatQO2rrFchgbMdXU,3415
@@ -73,10 +73,10 @@ cdk_factory/stack/stack_module_registry.py,sha256=J14-A75VZESzRQa8p-Fepdap7Z8T7m
 cdk_factory/stack/stack_modules.py,sha256=kgEK-j0smZPozVwTCfM1g1V17EyTBT0TXAQZq4vZz0o,784
 cdk_factory/stack_library/__init__.py,sha256=5Y9TpIe8ZK1688G60PGcuP-hM0RvYEY_3Hl2qJCJJrw,581
 cdk_factory/stack_library/stack_base.py,sha256=tTleSFmlf26DuKVF_ytftf8P7IVWb5iex8cYfYupfvQ,4940
-cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=83oV1pSFfb68mH4CH3mz0SERiiihpbPCsKK9zHgjvyE,32490
+cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=5rWHwLc6kI99YHUA1xqLtzcEhDmMB4p-xB9gLQ6o8JE,37916
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=UsFqUb_3XPJAlmZ6F75nXna3elOggD1KuFmmdmhi0Lg,19070
-cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=xT8-799fSXMpYaRhRKytxsbpb5EG3g2h6L822_RpRSk,22956
+cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
 cdk_factory/stack_library/code_artifact/code_artifact_stack.py,sha256=vySYIjWGTdVfMcUOyJdW6gTL1maHWq9ThzfrN_rVL5A,6290
@@ -100,7 +100,7 @@ cdk_factory/stack_library/vpc/__init__.py,sha256=7pIqP97Gf2AJbv9Ebp1WbQGHYhgEbWJ
 cdk_factory/stack_library/vpc/vpc_stack.py,sha256=zdDiGilf03esxuya5Z8zVYSVMAIuZBeD-ZKgfnEd6aw,10077
 cdk_factory/stack_library/websites/static_website_stack.py,sha256=KBQiV6PI09mpHGtH-So5Hk3uhfFLDepoXInGbfin0cY,7938
 cdk_factory/stages/websites/static_website_stage.py,sha256=X4fpKXkhb0zIbSHx3QyddBhVSLBryb1vf1Cg2fMTqog,755
-cdk_factory/utilities/api_gateway_integration_utility.py,sha256=xzKOdoKrd8AxuBWtV8uFa3r6I7wSKdC74m7tewBhzT8,62933
+cdk_factory/utilities/api_gateway_integration_utility.py,sha256=yblKiMIHGXqKb7JK5IbzGM_TXjX9j893BMqgqBT44DE,63449
 cdk_factory/utilities/commandline_args.py,sha256=0FiNEJFbWVN8Ct7r0VHnJEx7rhUlaRKT7R7HMNJBSTI,2216
 cdk_factory/utilities/configuration_loader.py,sha256=z0ZdGLNbTO4_yfluB9zUh_i_Poc9qj-7oRyjMRlNkN8,1522
 cdk_factory/utilities/docker_utilities.py,sha256=9r8C-lXYpymqEfi3gTeWCQzHldvfjttPqn6p3j2khTE,8111
@@ -112,7 +112,7 @@ cdk_factory/utilities/lambda_function_utilities.py,sha256=j3tBdv_gC2MdEwBINDwAqY
 cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITEP7EuSU,1019
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/workload/workload_factory.py,sha256=yBUDGIuB8-5p_mGcVFxsD2ZoZIziak3yh3LL3JvS0M4,5903
-cdk_factory-0.7.31.dist-info/METADATA,sha256=4M-frbniUr3CWM1NoNqV5rdJ9vZH_1nZADAJzyOEB78,2451
-cdk_factory-0.7.31.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.7.31.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.7.31.dist-info/RECORD,,
+cdk_factory-0.8.1.dist-info/METADATA,sha256=QzIZhYxS_Mu7hgXTGdT4yN4K0gtJP6Z1Cn1C7onszAg,2450
+cdk_factory-0.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.8.1.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.8.1.dist-info/RECORD,,