lambda-api-decorators-cdk 0.4.0__tar.gz → 0.4.4__tar.gz

{lambda_api_decorators_cdk-0.4.0 → lambda_api_decorators_cdk-0.4.4}/.github/workflows/release.yml

@@ -39,7 +39,7 @@ jobs:
       - name: Install test and build dependencies
         run: |
           python -m pip install --upgrade pip
-          python -m pip install build pytest setuptools-scm
+          python -m pip install build pytest setuptools-scm lambda-api-decorators
           python -m pip install .
 
       - name: Run tests

{lambda_api_decorators_cdk-0.4.0 → lambda_api_decorators_cdk-0.4.4}/.github/workflows/tests.yml

@@ -2,7 +2,9 @@ name: Tests
 
 on:
   push:
+    branches: [main]
   pull_request:
+    branches: [main]
 
 permissions:
   contents: read
@@ -27,7 +29,7 @@ jobs:
       - name: Install package and test dependencies
         run: |
           python -m pip install --upgrade pip
-          python -m pip install --editable . pytest tomli
+          python -m pip install --editable . lambda-api-decorators pytest tomli
 
       - name: Verify package import
         run: python -c "import lambda_api_decorators_cdk"

{lambda_api_decorators_cdk-0.4.0 → lambda_api_decorators_cdk-0.4.4}/AGENTS.md

@@ -10,7 +10,7 @@ The project goal is:
 
 GitHub organization:
 
-`lambda-api-decorators`
+`infrastructure-as-decorator`
 
 Package:
 
@@ -22,7 +22,7 @@ Python module:
 
 Project documentation:
 
-`https://lambda-api-decorators.github.io/`
+`https://infrastructure-as-decorator.github.io/`
 
 ## Design principles
 

lambda_api_decorators_cdk-0.4.4/PKG-INFO

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: lambda-api-decorators-cdk
+Version: 0.4.4
+Summary: AWS CDK integration for Lambda API Decorators. Generate AWS Lambda and API Gateway infrastructure from decorated Python handlers.
+Author: Mateo Marcos, Emanuel Arguinarena, Lucas Picchi
+License: MIT License
+        
+        Copyright (c) 2024 Lambda API Decorators CDK
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://infrastructure-as-decorator.github.io/
+Project-URL: Documentation, https://infrastructure-as-decorator.github.io/docs/api-reference/index
+Project-URL: Repository, https://github.com/infrastructure-as-decorator/lambda-api-decorators-cdk
+Project-URL: Bug Reports, https://github.com/infrastructure-as-decorator/lambda-api-decorators-cdk/issues
+Keywords: cdk,lambda,aws,api gateway,ast
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AWS CDK :: 2
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aws-cdk.aws-lambda-python-alpha
+Dynamic: license-file
+
+# Lambda API Decorators CDK
+
+AWS CDK integration for [Lambda API Decorators](https://github.com/infrastructure-as-decorator/lambda-api-decorators). Define API routes with Python decorators and let CDK create the Lambda functions, integrations, routes, and related configuration.
+
+The complete cross-package guides and architecture documentation are available at [infrastructure-as-decorator.github.io](https://infrastructure-as-decorator.github.io/).
+
+## Installation
+
+```bash
+pip install lambda-api-decorators-cdk
+```
+
+The package requires Python 3.10 or newer and AWS CDK v2. The `lambda-api-decorators` package provides the decorators used by the Lambda source files.
+
+## Quick start
+
+`LambdaApi` is the recommended high-level construct. It creates a REST API by default and discovers decorated handlers below `lambda_path`.
+
+```python
+from aws_cdk import Stack
+from constructs import Construct
+
+from lambda_api_decorators_cdk import LambdaApi
+
+
+class ExampleStack(Stack):
+    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
+        super().__init__(scope, construct_id, **kwargs)
+
+        LambdaApi(self, "ExampleApi", lambda_path="lambdas")
+```
+
+A handler must include an HTTP method decorator from `lambda-api-decorators`:
+
+```python
+from lambda_api_decorators import GET
+
+
+@GET("/hello")
+def hello(event, context):
+    return {"statusCode": 200, "body": "Hello, world!"}
+```
+
+`lambda_path` is resolved from the directory where CDK is run. Files without a supported route decorator are ignored.
+
+## API types and imported APIs
+
+REST is the default. Select an HTTP API with `ApiType.HTTP`, or provide an existing supported API and let the construct infer its type.
+
+```python
+from aws_cdk import aws_apigateway as apigateway
+from lambda_api_decorators_cdk import ApiType, LambdaApi
+
+
+LambdaApi(self, "HttpApi", lambda_path="lambdas", api_type=ApiType.HTTP)
+
+existing_rest_api = apigateway.RestApi(self, "ExistingRestApi")
+LambdaApi(self, "ExistingApiRoutes", lambda_path="lambdas", api=existing_rest_api)
+```
+
+Created and imported REST APIs are supported. Concrete `aws_apigatewayv2.HttpApi` instances are supported for HTTP APIs.
+
+## Reusable configuration
+
+Use `LambdaApiConfig` for defaults and named resources shared by one or more `LambdaApi` constructs. Configuration must be complete before constructing the API.
+
+```python
+from aws_cdk import Duration, aws_lambda as lambda_
+from lambda_api_decorators_cdk import LambdaApi, LambdaApiConfig
+
+
+config = LambdaApiConfig(
+    runtime=lambda_.Runtime.PYTHON_3_12,
+    timeout=Duration.seconds(30),
+    memory_size=512,
+    environment={"ENVIRONMENT": "production"},
+)
+config.add_custom_environment("PAYMENTS_URL", "https://payments.example.com")
+
+LambdaApi(self, "ConfiguredApi", lambda_path="lambdas", config=config)
+```
+
+`LambdaApiConfig` supports default and custom runtimes, roles, VPCs, subnets, layers, security groups, and environment variables. It also supports registries for DynamoDB tables, S3 buckets, and REST or HTTP authorizers. A reused configuration creates an isolated builder snapshot for each API.
+
+## Source layout and layers
+
+By default, each handler is packaged relative to the source root. For a service-oriented layout, use `SourceLayout.SERVICE`:
+
+```python
+from lambda_api_decorators_cdk import LambdaApi, SourceLayout
+
+
+LambdaApi(
+    self,
+    "ServiceApi",
+    lambda_path="services",
+    source_layout=SourceLayout.SERVICE,
+    layers_path="layers",
+)
+```
+
+When `layers_path` is provided, each visible child directory is treated as a discoverable layer source. Explicit layer configuration remains available through `LambdaApiConfig`.
+
+## Authorization and permissions
+
+Register authorizers with a logical key and select the default authorizer for routes. A handler can override the default with `@authorizer("key")` or make itself public with `@public`.
+
+```python
+from aws_cdk import aws_apigateway as apigateway
+from lambda_api_decorators_cdk import LambdaApiConfig
+
+
+authorizer = apigateway.TokenAuthorizer(self, "UsersAuthorizer", handler=authorizer_fn)
+config = LambdaApiConfig(authorizers={"users": authorizer}, default_authorizer="users")
+```
+
+The resource registries also allow decorated handlers to request least-privilege grants for registered DynamoDB tables and S3 buckets. See the [complete documentation](https://infrastructure-as-decorator.github.io/docs/api-reference/index) for decorator syntax and supported access levels.
+
+## Low-level builder
+
+`ResourceBuilder` remains a supported lower-level API for callers that need direct control over the API root or build lifecycle:
+
+```python
+from aws_cdk import Duration
+from lambda_api_decorators_cdk import ResourceBuilder
+
+
+builder = ResourceBuilder()
+builder.set_default_timeout(Duration.seconds(30))
+builder.add_common_environment("ENVIRONMENT", "production")
+builder.build(self, rest_api.root, "lambdas")
+```
+
+Prefer `LambdaApi` for new code. It owns API creation or reuse and delegates option resolution to isolated `ResourceBuilder` snapshots.
+
+## Releases
+
+The Git tag is the single source of truth for this package's version. For example, `v0.3.0` produces Python package version `0.3.0`. This repository is versioned independently from `lambda-api-decorators`.
+
+To release from `main`, push a semantic version tag:
+
+```bash
+git checkout main
+git pull
+git tag v0.3.0
+git push origin v0.3.0
+```
+
+Pushing the tag triggers the release workflow, which tests, builds, verifies the version, and publishes to PyPI using trusted publishing. The PyPI project must have a trusted publisher configured for this repository, the `release.yml` workflow, and the `pypi` GitHub environment.

lambda_api_decorators_cdk-0.4.4/README.md

@@ -0,0 +1,149 @@
+# Lambda API Decorators CDK
+
+AWS CDK integration for [Lambda API Decorators](https://github.com/infrastructure-as-decorator/lambda-api-decorators). Define API routes with Python decorators and let CDK create the Lambda functions, integrations, routes, and related configuration.
+
+The complete cross-package guides and architecture documentation are available at [infrastructure-as-decorator.github.io](https://infrastructure-as-decorator.github.io/).
+
+## Installation
+
+```bash
+pip install lambda-api-decorators-cdk
+```
+
+The package requires Python 3.10 or newer and AWS CDK v2. The `lambda-api-decorators` package provides the decorators used by the Lambda source files.
+
+## Quick start
+
+`LambdaApi` is the recommended high-level construct. It creates a REST API by default and discovers decorated handlers below `lambda_path`.
+
+```python
+from aws_cdk import Stack
+from constructs import Construct
+
+from lambda_api_decorators_cdk import LambdaApi
+
+
+class ExampleStack(Stack):
+    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
+        super().__init__(scope, construct_id, **kwargs)
+
+        LambdaApi(self, "ExampleApi", lambda_path="lambdas")
+```
+
+A handler must include an HTTP method decorator from `lambda-api-decorators`:
+
+```python
+from lambda_api_decorators import GET
+
+
+@GET("/hello")
+def hello(event, context):
+    return {"statusCode": 200, "body": "Hello, world!"}
+```
+
+`lambda_path` is resolved from the directory where CDK is run. Files without a supported route decorator are ignored.
+
+## API types and imported APIs
+
+REST is the default. Select an HTTP API with `ApiType.HTTP`, or provide an existing supported API and let the construct infer its type.
+
+```python
+from aws_cdk import aws_apigateway as apigateway
+from lambda_api_decorators_cdk import ApiType, LambdaApi
+
+
+LambdaApi(self, "HttpApi", lambda_path="lambdas", api_type=ApiType.HTTP)
+
+existing_rest_api = apigateway.RestApi(self, "ExistingRestApi")
+LambdaApi(self, "ExistingApiRoutes", lambda_path="lambdas", api=existing_rest_api)
+```
+
+Created and imported REST APIs are supported. Concrete `aws_apigatewayv2.HttpApi` instances are supported for HTTP APIs.
+
+## Reusable configuration
+
+Use `LambdaApiConfig` for defaults and named resources shared by one or more `LambdaApi` constructs. Configuration must be complete before constructing the API.
+
+```python
+from aws_cdk import Duration, aws_lambda as lambda_
+from lambda_api_decorators_cdk import LambdaApi, LambdaApiConfig
+
+
+config = LambdaApiConfig(
+    runtime=lambda_.Runtime.PYTHON_3_12,
+    timeout=Duration.seconds(30),
+    memory_size=512,
+    environment={"ENVIRONMENT": "production"},
+)
+config.add_custom_environment("PAYMENTS_URL", "https://payments.example.com")
+
+LambdaApi(self, "ConfiguredApi", lambda_path="lambdas", config=config)
+```
+
+`LambdaApiConfig` supports default and custom runtimes, roles, VPCs, subnets, layers, security groups, and environment variables. It also supports registries for DynamoDB tables, S3 buckets, and REST or HTTP authorizers. A reused configuration creates an isolated builder snapshot for each API.
+
+## Source layout and layers
+
+By default, each handler is packaged relative to the source root. For a service-oriented layout, use `SourceLayout.SERVICE`:
+
+```python
+from lambda_api_decorators_cdk import LambdaApi, SourceLayout
+
+
+LambdaApi(
+    self,
+    "ServiceApi",
+    lambda_path="services",
+    source_layout=SourceLayout.SERVICE,
+    layers_path="layers",
+)
+```
+
+When `layers_path` is provided, each visible child directory is treated as a discoverable layer source. Explicit layer configuration remains available through `LambdaApiConfig`.
+
+## Authorization and permissions
+
+Register authorizers with a logical key and select the default authorizer for routes. A handler can override the default with `@authorizer("key")` or make itself public with `@public`.
+
+```python
+from aws_cdk import aws_apigateway as apigateway
+from lambda_api_decorators_cdk import LambdaApiConfig
+
+
+authorizer = apigateway.TokenAuthorizer(self, "UsersAuthorizer", handler=authorizer_fn)
+config = LambdaApiConfig(authorizers={"users": authorizer}, default_authorizer="users")
+```
+
+The resource registries also allow decorated handlers to request least-privilege grants for registered DynamoDB tables and S3 buckets. See the [complete documentation](https://infrastructure-as-decorator.github.io/docs/api-reference/index) for decorator syntax and supported access levels.
+
+## Low-level builder
+
+`ResourceBuilder` remains a supported lower-level API for callers that need direct control over the API root or build lifecycle:
+
+```python
+from aws_cdk import Duration
+from lambda_api_decorators_cdk import ResourceBuilder
+
+
+builder = ResourceBuilder()
+builder.set_default_timeout(Duration.seconds(30))
+builder.add_common_environment("ENVIRONMENT", "production")
+builder.build(self, rest_api.root, "lambdas")
+```
+
+Prefer `LambdaApi` for new code. It owns API creation or reuse and delegates option resolution to isolated `ResourceBuilder` snapshots.
+
+## Releases
+
+The Git tag is the single source of truth for this package's version. For example, `v0.3.0` produces Python package version `0.3.0`. This repository is versioned independently from `lambda-api-decorators`.
+
+To release from `main`, push a semantic version tag:
+
+```bash
+git checkout main
+git pull
+git tag v0.3.0
+git push origin v0.3.0
+```
+
+Pushing the tag triggers the release workflow, which tests, builds, verifies the version, and publishes to PyPI using trusted publishing. The PyPI project must have a trusted publisher configured for this repository, the `release.yml` workflow, and the `pypi` GitHub environment.

{lambda_api_decorators_cdk-0.4.0 → lambda_api_decorators_cdk-0.4.4}/pyproject.toml

@@ -84,9 +84,10 @@ dependencies = [
 # maintainers, and where to support the project financially. The key is
 # what's used to render the link text on PyPI.
 [project.urls]
-"Homepage" = "https://github.com/lambda-api-decorators/lambda-api-decorators-cdk"
-"Repository" = "https://github.com/lambda-api-decorators/lambda-api-decorators-cdk"
-"Bug Reports" = "https://github.com/lambda-api-decorators/lambda-api-decorators-cdk"
+Homepage = "https://infrastructure-as-decorator.github.io/"
+Documentation = "https://infrastructure-as-decorator.github.io/docs/api-reference/index"
+Repository = "https://github.com/infrastructure-as-decorator/lambda-api-decorators-cdk"
+"Bug Reports" = "https://github.com/infrastructure-as-decorator/lambda-api-decorators-cdk/issues"
 
 # The following would provide a command line executable called `sample`
 # which executes the function `main` from this package when invoked.

{lambda_api_decorators_cdk-0.4.0 → lambda_api_decorators_cdk-0.4.4}/src/lambda_api_decorators_cdk/lambda_api_config.py

@@ -1,4 +1,5 @@
-from typing import Mapping, Optional, Sequence
+from collections.abc import Mapping
+from typing import Optional, Sequence
 
 from aws_cdk import Duration
 from aws_cdk import aws_ec2 as ec2
@@ -29,7 +30,29 @@ class LambdaApiConfig:
         s3_buckets: Optional[Mapping[str, s3.IBucket]] = None,
         authorizers: Optional[Mapping[str, object]] = None,
         default_authorizer: Optional[str] = None,
+        default_runtime: Optional[str] = None,
+        default_role: Optional[iam.IRole] = None,
+        common_environment: Optional[Mapping[str, str]] = None,
+        role_registry: Optional[Mapping[str, iam.IRole]] = None,
+        environment_registry: Optional[Mapping[str, Mapping[str, str]]] = None,
+        layer_registry: Optional[Mapping[str, lambda_.ILayerVersion]] = None,
+        security_group_registry: Optional[Mapping[str, ec2.ISecurityGroup]] = None,
+        vpc_registry: Optional[Mapping[str, ec2.IVpc]] = None,
+        dynamodb_table_registry: Optional[Mapping[str, dynamodb.ITable]] = None,
+        s3_bucket_registry: Optional[Mapping[str, s3.IBucket]] = None,
+        authorizer_registry: Optional[Mapping[str, object]] = None,
     ) -> None:
+        if default_runtime is not None:
+            self._validate_runtime_name(default_runtime)
+        if default_runtime is not None and runtime is not None:
+            raise ValueError("runtime and default_runtime cannot both be supplied")
+        if default_role is not None and role is not None:
+            raise ValueError("role and default_role cannot both be supplied")
+        if common_environment is not None and environment is not None:
+            raise ValueError(
+                "environment and common_environment cannot both be supplied"
+            )
+
         self._default_runtime = runtime
         self._default_timeout = timeout
         self._default_memory_size = memory_size
@@ -40,7 +63,13 @@ class LambdaApiConfig:
         self._common_security_groups = (
             list(security_groups) if security_groups is not None else []
         )
-        self._common_environments = dict(environment) if environment is not None else {}
+        self._common_environments = dict(
+            common_environment if common_environment is not None else environment or {}
+        )
+        if default_runtime is not None:
+            self._default_runtime = default_runtime
+        if default_role is not None:
+            self._default_role = default_role
 
         self._custom_runtimes = {}
         self._custom_roles = {}
@@ -61,6 +90,49 @@ class LambdaApiConfig:
         self._default_authorizer = None
         self.set_default_authorizer(default_authorizer)
 
+        for key, value in (role_registry or {}).items():
+            self.register_role(key, value)
+        for key, value in (environment_registry or {}).items():
+            self.register_environment(key, value)
+        for key, value in (layer_registry or {}).items():
+            self.register_layer(key, value)
+        for key, value in (security_group_registry or {}).items():
+            self.register_security_group(key, value)
+        for key, value in (vpc_registry or {}).items():
+            self.register_vpc(key, value)
+        for key, value in (dynamodb_table_registry or {}).items():
+            self.register_dynamodb_table(key, value)
+        for key, value in (s3_bucket_registry or {}).items():
+            self.register_s3_bucket(key, value)
+        for key, value in (authorizer_registry or {}).items():
+            self.register_authorizer(key, value)
+
+    @staticmethod
+    def _validate_runtime_name(runtime: str) -> None:
+        supported = {
+            "python3.10", "python3.11", "python3.12", "python3.13", "python3.14"
+        }
+        if not isinstance(runtime, str):
+            raise TypeError("runtime must be a string")
+        if runtime not in supported:
+            raise ValueError(
+                "runtime must be one of {}".format(", ".join(sorted(supported)))
+            )
+
+    @staticmethod
+    def _validate_registry_key(key: str, registry_name: str) -> None:
+        if not isinstance(key, str):
+            raise TypeError(f"{registry_name} keys must be strings")
+        if not key.strip():
+            raise ValueError(f"{registry_name} keys must not be empty or whitespace")
+
+    @classmethod
+    def _register(cls, registry: dict, key: str, value, registry_name: str) -> None:
+        cls._validate_registry_key(key, registry_name)
+        if key in registry:
+            raise ValueError(f"{registry_name} key {key!r} is already registered")
+        registry[key] = value
+
     def set_default_runtime(self, runtime: Optional[lambda_.Runtime]) -> None:
         self._default_runtime = runtime
 
@@ -90,9 +162,6 @@ class LambdaApiConfig:
         if security_group not in self._common_security_groups:
             self._common_security_groups.append(security_group)
 
-    def add_common_environment(self, key: str, value: str) -> None:
-        self._common_environments[key] = value
-
     def add_custom_runtime(self, key: str, runtime: lambda_.Runtime) -> None:
         self._custom_runtimes[key] = runtime
 
@@ -141,6 +210,50 @@ class LambdaApiConfig:
             raise ValueError(f"Authorizer key {key!r} is already registered")
         self._authorizers[key] = authorizer
 
+    def register_role(self, key: str, role: iam.IRole) -> None:
+        self._register(self._custom_roles, key, role, "role registry")
+
+    def register_environment(self, key: str, value: Mapping[str, str]) -> None:
+        if not isinstance(value, Mapping):
+            raise TypeError("environment registry values must be mappings")
+        self._register(self._custom_environments, key, dict(value), "environment registry")
+
+    def register_layer(self, key: str, layer: lambda_.ILayerVersion) -> None:
+        self._register(self._custom_layers, key, layer, "layer registry")
+
+    def register_security_group(self, key: str, security_group: ec2.ISecurityGroup) -> None:
+        self._register(
+            self._custom_security_groups, key, security_group, "security group registry"
+        )
+
+    def register_vpc(
+        self,
+        key: str,
+        vpc: ec2.IVpc,
+        vpc_subnets: Optional[ec2.SubnetSelection] = None,
+    ) -> None:
+        self._register(self._custom_vpcs, key, (vpc, vpc_subnets), "vpc registry")
+
+    def register_dynamodb_table(self, key: str, table: dynamodb.ITable) -> None:
+        self._register(self._dynamodb_tables, key, table, "dynamodb table registry")
+
+    def register_s3_bucket(self, key: str, bucket: s3.IBucket) -> None:
+        self._register(self._s3_buckets, key, bucket, "s3 bucket registry")
+
+    def register_authorizer(self, key: str, authorizer: object) -> None:
+        self._validate_registry_key(key, "authorizer registry")
+        interfaces = getattr(authorizer, "__jsii_ifaces__", ()) if authorizer is not None else ()
+        supported = {
+            "aws_cdk.aws_apigateway.IAuthorizer",
+            "aws_cdk.aws_apigatewayv2.IHttpRouteAuthorizer",
+        }
+        if not any(
+            f"{interface.__module__}.{interface.__name__}" in supported
+            for interface in interfaces
+        ):
+            raise TypeError("authorizer registry values must be CDK authorizers")
+        self._register(self._authorizers, key, authorizer, "authorizer registry")
+
     def set_default_authorizer(self, key: Optional[str]) -> None:
         if key is None:
             self._default_authorizer = None
@@ -179,7 +292,10 @@ class LambdaApiConfig:
             custom_runtimes=dict(self._custom_runtimes),
             custom_roles=dict(self._custom_roles),
             custom_layers=dict(self._custom_layers),
-            custom_environments=dict(self._custom_environments),
+            custom_environments={
+                key: dict(value) if isinstance(value, Mapping) else value
+                for key, value in self._custom_environments.items()
+            },
             custom_security_groups=dict(self._custom_security_groups),
             custom_vpcs=dict(self._custom_vpcs),
             dynamodb_tables=dict(self._dynamodb_tables),