cloud-foundry 0.1.2__tar.gz → 0.1.4__tar.gz

cloud_foundry-0.1.4/.gitignore

@@ -0,0 +1,10 @@
+
+venv/
+__pycache__
+.pytest_cache
+.env
+.coverage
+temp/
+dist/
+volume/
+.coverage

{cloud_foundry-0.1.2 → cloud_foundry-0.1.4}/PKG-INFO

@@ -1,25 +1,26 @@
 Metadata-Version: 2.4
 Name: cloud-foundry
-Version: 0.1.2
+Version: 0.1.4
 Summary: cloud-foundry is a curated set of cloud components that can be used to assemble cloud-based applications.
+Project-URL: Documentation, https://github.com/DanRepik/cloud-foundry
+Project-URL: Source, https://github.com/DanRepik/cloud-foundry
 Author-email: Daniel Repik <danrepik@icloud.com>
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Operating System :: OS Independent
+License: Apache-2.0
 License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Requires-Dist: boto3
 Requires-Dist: pulumi
 Requires-Dist: pulumi-aws
-Requires-Dist: boto3
-Requires-Dist: pytest>=7.0 ; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0 ; extra == "dev"
-Requires-Dist: black>=23.0.0 ; extra == "dev"
-Requires-Dist: isort>=5.12.0 ; extra == "dev"
-Requires-Dist: mypy>=1.0.0 ; extra == "dev"
-Requires-Dist: flit>=3.9 ; extra == "dev"
-Project-URL: Documentation, https://github.com/DanRepik/cloud-foundry
-Project-URL: Source, https://github.com/DanRepik/cloud-foundry
 Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: flit>=3.9; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
 
 # Cloud Foundry
 
@@ -973,4 +974,3 @@ cdn_instance = cdn(
 #### **Conclusion**
 
 The `cdn` function simplifies the deployment of a Content Delivery Network using AWS CloudFront, Route 53, and ACM. It supports static sites, APIs, custom domains, and advanced features like logging and geo-restrictions. This function is ideal for building scalable, secure, and performant web applications.
-

{cloud_foundry-0.1.2 → cloud_foundry-0.1.4}/cloud_foundry/__init__.py

@@ -5,13 +5,23 @@ from cloud_foundry.pulumi.function import function  # noqa: F401
 from cloud_foundry.pulumi.python_function import python_function  # noqa: F401
 from cloud_foundry.pulumi.rest_api import RestAPI  # noqa: F401
 from cloud_foundry.pulumi.rest_api import rest_api  # noqa: F401
+from cloud_foundry.pulumi.websocket_api import WebSocketAPI  # noqa: F401
+from cloud_foundry.pulumi.websocket_function import (  # noqa: F401
+    WebSocketFunction,
+)
+from cloud_foundry.pulumi.connection_store import (  # noqa: F401
+    ConnectionStore,
+)
 
 from cloud_foundry.utils.openapi_editor import OpenAPISpecEditor  # noqa: F401
 from cloud_foundry.pulumi.site_bucket import site_bucket  # noqa: F401
 from cloud_foundry.pulumi.document_repository import document_repository  # noqa: F401
-from cloud_foundry.pulumi.cdn import cdn  # noqa: F401
+from cloud_foundry.pulumi.cdn import cdn, CDN, CDNArgs  # noqa: F401
 from cloud_foundry.pulumi.domain import domain  # noqa: F401
 
-from cloud_foundry.utils.names import resource_id  # noqa: F401
+from cloud_foundry.pulumi.queue import queue
+from cloud_foundry.pulumi.topic import topic
 
-# from cloud_foundry.mail_publisher import mail_publisher
+from cloud_foundry.utils.names import resource_id
+
+version = "0.1.4"

{cloud_foundry-0.1.2 → cloud_foundry-0.1.4}/cloud_foundry/pulumi/cdn.py

@@ -1,3 +1,99 @@
+"""CloudFront CDN Component for Cloud Foundry.
+
+This module provides a comprehensive CloudFront Content Delivery Network (CDN)
+component with support for multiple origin types, custom domains, SSL/TLS
+certificates, geo-restrictions, and advanced caching configurations.
+
+Key Features:
+    - Multiple origin types: S3 buckets, API Gateway REST APIs, custom domains
+    - Automatic SSL/TLS certificate provisioning via ACM
+    - Custom domain configuration with Route53 DNS
+    - Geo-restriction support (whitelist/blacklist countries)
+    - Origin Shield for improved cache hit ratios
+    - Apex domain support
+    - CORS and security headers via managed policies
+    - Automatic cache behaviors for API origins
+
+Origin Types:
+    1. S3 Bucket (SiteOrigin):
+        - Static website hosting
+        - Origin Access Identity for secure access
+        - Example: {"bucket": bucket_resource, "name": "site"}
+
+    2. Domain Name (ApiOrigin):
+        - Direct domain name for custom origins
+        - Path-based routing with cache behaviors
+        - Example: {"domain_name": "api.example.com", "path_pattern": "/api/*"}
+
+    3. REST API (ApiOrigin):
+        - API Gateway REST API integration
+        - Automatic domain resolution
+        - Example: {"rest_api": rest_api_resource, "path_pattern": "/api/*"}
+
+Usage:
+    from cloud_foundry.pulumi.cdn import CDN, CDNArgs
+
+    # Basic CDN with API origin
+    cdn = CDN(
+        "my-cdn",
+        CDNArgs(
+            hosted_zone_id="Z1234567890ABC",
+            subdomain="api",
+            site_domain_name="example.com",
+            origins=[
+                {
+                    "name": "api",
+                    "domain_name": api.domain,
+                    "path_pattern": "/api/*",
+                    "origin_shield_region": "us-east-1"
+                }
+            ]
+        )
+    )
+
+    # CDN with S3 bucket and API origin
+    cdn = CDN(
+        "multi-origin-cdn",
+        CDNArgs(
+            hosted_zone_id="Z1234567890ABC",
+            subdomain="cdn",
+            create_apex=True,
+            site_domain_name="example.com",
+            root_uri="index.html",
+            origins=[
+                {
+                    "name": "site",
+                    "bucket": s3_bucket,
+                    "is_target_origin": True
+                },
+                {
+                    "name": "api",
+                    "domain_name": "api.example.com",
+                    "path_pattern": "/api/*"
+                }
+            ],
+            whitelist_countries=["US", "CA", "GB"]
+        )
+    )
+
+Configuration:
+    - hosted_zone_id: Route53 hosted zone for DNS records
+    - subdomain: Subdomain for CDN distribution (e.g., "www", "cdn")
+    - site_domain_name: Base domain name for apex domain support
+    - create_apex: Create A record for apex domain (example.com)
+    - origins: List of origin configurations (see Origin Types above)
+    - error_responses: Custom error response configurations
+    - root_uri: Default root object (e.g., "index.html")
+    - whitelist_countries: ISO country codes to allow (exclusive with blacklist)
+    - blacklist_countries: ISO country codes to block (default: CN, RU, CU, KP, IR, BY)
+
+Outputs:
+    - distribution: CloudFront Distribution resource
+    - domain_name: CDN domain name (custom domain or CloudFront domain)
+    - dns_alias: Route53 A record for custom domain
+    - apex_alias: Route53 A record for apex domain (if create_apex=True)
+"""
+
 import pulumi
 import pulumi_aws as aws
 from pulumi import ResourceOptions
@@ -22,12 +118,36 @@ DEFAULT_BLACKLIST_COUNTRIES = [
 
 
 class CDNArgs:
+    """Configuration arguments for CDN component.
+
+    Attributes:
+        origins: List of origin configurations. Each origin dict can contain:
+            - name (str): Unique identifier for the origin
+            - bucket (aws.s3.Bucket): S3 bucket for static site hosting
+            - domain_name (str|Output): Custom domain name for API origin
+            - rest_api (RestAPI): API Gateway REST API resource
+            - path_pattern (str): Path pattern for cache behavior (e.g., "/api/*")
+            - origin_path (str): Optional path prefix on origin
+            - origin_shield_region (str): AWS region for Origin Shield
+            - is_target_origin (bool): Whether this is the default origin
+            - api_key_password (str): Optional API key for custom header
+        create_apex: Whether to create DNS record for apex domain (default: False)
+        hosted_zone_id: Route53 hosted zone ID for DNS records
+        subdomain: Subdomain for the CDN (e.g., "www", "cdn", "api")
+        site_domain_name: Base domain name for apex domain creation
+        error_responses: List of custom error response configurations
+        root_uri: Default root object for distribution (e.g., "index.html")
+        whitelist_countries: ISO country codes to allow (exclusive with blacklist)
+        blacklist_countries: ISO country codes to block (default: CN, RU, CU, KP, IR, BY)
+    """
+
     def __init__(
         self,
         origins: Optional[List[dict]] = None,
         create_apex: Optional[bool] = False,
         hosted_zone_id: Optional[str] = None,
         subdomain: Optional[str] = None,
+        site_domain_name: Optional[str] = None,
         error_responses: Optional[list] = None,
         root_uri: Optional[str] = None,
         whitelist_countries: Optional[List[str]] = None,
@@ -37,6 +157,7 @@ class CDNArgs:
         self.create_apex = create_apex
         self.hosted_zone_id = hosted_zone_id
         self.subdomain = subdomain
+        self.site_domain_name = site_domain_name
         self.error_responses = error_responses
         self.root_uri = root_uri
         self.whitelist_countries = whitelist_countries
@@ -44,7 +165,59 @@ class CDNArgs:
 
 
 class CDN(pulumi.ComponentResource):
+    """CloudFront CDN Component Resource.
+
+    Creates a CloudFront distribution with:
+    - Multiple origin support (S3, API Gateway, custom domains)
+    - SSL/TLS certificate provisioned via ACM
+    - Custom domain with Route53 DNS configuration
+    - Geo-restriction support
+    - Origin Shield for improved performance
+    - Managed CORS and security headers
+    - Path-based cache behaviors for API origins
+
+    The component automatically:
+    - Provisions and validates ACM certificate
+    - Creates Route53 DNS records for custom domain
+    - Configures origin-specific cache behaviors
+    - Sets up S3 bucket policies for OAI access
+    - Applies geo-restrictions
+
+    Attributes:
+        distribution: CloudFront Distribution resource
+        domain_name: CDN domain name (custom or CloudFront)
+        dns_alias: Route53 A record for subdomain
+        apex_alias: Route53 A record for apex domain (if create_apex=True)
+        site_origins: List of SiteOrigin resources
+        hosted_zone_id: Route53 hosted zone ID
+        subdomain: CDN subdomain
+
+    Example:
+        cdn = CDN(
+            "my-cdn",
+            CDNArgs(
+                hosted_zone_id="Z123456",
+                subdomain="api",
+                origins=[
+                    {
+                        "name": "api",
+                        "domain_name": legis_api.domain,
+                        "path_pattern": "/api/*",
+                        "origin_shield_region": "us-east-1"
+                    }
+                ]
+            )
+        )
+    """
+
     def __init__(self, name: str, args: CDNArgs, opts: ResourceOptions = None):
+        """Initialize CDN component.
+
+        Args:
+            name: Resource name for the CDN
+            args: CDN configuration arguments
+            opts: Pulumi resource options
+        """
         super().__init__("cloud_foundry:pulumi:CDN", name, {}, opts)
 
         self.hosted_zone_id = args.hosted_zone_id
@@ -61,17 +234,10 @@ class CDN(pulumi.ComponentResource):
             include_apex=args.create_apex,
         )
 
-        log.info("Creating CloudFront distribution")
-
-        log.info(
-            "aliases:"
-            + {
-                (
-                    [self.domain_name, args.site_domain_name]
-                    if args.create_apex
-                    else [self.domain_name]
-                )
-            }
+        aliases_list = (
+            [self.domain_name, args.site_domain_name]
+            if args.create_apex
+            else [self.domain_name]
         )
 
         origins, caches, target_origin_id = self.get_origins(name, args.origins)
@@ -86,11 +252,7 @@ class CDN(pulumi.ComponentResource):
                 include_cookies=False,
                 prefix="logs/",
             ),
-            aliases=(
-                [self.domain_name, args.site_domain_name]
-                if args.create_apex
-                else [self.domain_name]
-            ),
+            aliases=aliases_list,
             default_cache_behavior=aws.cloudfront.DistributionDefaultCacheBehaviorArgs(
                 target_origin_id=target_origin_id,
                 viewer_protocol_policy="redirect-to-https",
@@ -184,6 +346,34 @@ class CDN(pulumi.ComponentResource):
             self.domain_name = self.distribution.domain_name
 
     def get_origins(self, name: str, origins: List[dict]):
+        """Process and configure CDN origins.
+
+        Processes the origin configurations and creates appropriate origin resources
+        (SiteOrigin for S3, ApiOrigin for APIs/domains). Determines the default
+        target origin and configures cache behaviors.
+
+        Args:
+            name: Base name for origin resources
+            origins: List of origin configuration dicts with keys:
+                - bucket: S3 bucket for static sites
+                - domain_name: Custom domain name string
+                - rest_api: RestAPI resource
+                - name: Origin identifier
+                - path_pattern: Cache behavior path pattern
+                - origin_path: Path prefix on origin
+                - origin_shield_region: Origin Shield region
+                - is_target_origin: Mark as default origin
+                - api_key_password: API key for custom header
+
+        Returns:
+            Tuple of (cdn_origins, caches, target_origin_id):
+                - cdn_origins: List of DistributionOriginArgs
+                - caches: List of DistributionOrderedCacheBehaviorArgs
+                - target_origin_id: Default origin ID
+
+        Raises:
+            ValueError: If origin configuration is invalid or domain cannot be resolved
+        """
         target_origin_id = None
         cdn_origins = []
         caches = []
@@ -204,7 +394,13 @@ class CDN(pulumi.ComponentResource):
                 self.site_origins.append(cdn_origin)
 
             elif "domain_name" in origin:
-                cdn_origin = ApiOrigin(f"{name}-{origin["name"]}", origin)
+                cdn_origin = ApiOrigin(
+                    f"{name}-{origin["name"]}",
+                    domain_name=origin["domain_name"],
+                    path_pattern=origin.get("path_pattern"),
+                    origin_path=origin.get("origin_path"),
+                    shield_region=origin.get("origin_shield_region"),
+                )
                 cdn_origins.append(cdn_origin.distribution_origin)
                 caches.append(cdn_origin.cache_behavior)
 
@@ -262,6 +458,22 @@ class CDN(pulumi.ComponentResource):
     def set_up_certificate(
         self, name, domain_name, alternative_names: Optional[List[str]] = None
     ):
+        """Provision and validate ACM certificate for custom domain.
+
+        Creates an ACM certificate with DNS validation via Route53. Automatically
+        creates validation DNS records and waits for certificate validation.
+
+        Args:
+            name: Resource name prefix
+            domain_name: Primary domain name for certificate
+            alternative_names: List of Subject Alternative Names (SANs)
+
+        Returns:
+            Tuple of (certificate, validation) resources
+
+        Raises:
+            ValueError: If hosted_zone_id is not configured
+        """
         if not self.hosted_zone_id:
             raise ValueError(
                 "Hosted zone ID is required for custom domain setup. "
@@ -314,6 +526,21 @@ class CDN(pulumi.ComponentResource):
         stage_name: str,
         rest_api_id,
     ):
+        """Configure custom domain for API Gateway REST API.
+
+        Creates ACM certificate, API Gateway domain name, base path mapping,
+        and Route53 DNS record for a custom domain pointing to an API Gateway.
+
+        Args:
+            name: Resource name prefix
+            hosted_zone_id: Route53 hosted zone ID for DNS
+            domain_name: Custom domain name
+            stage_name: API Gateway stage name
+            rest_api_id: API Gateway REST API ID
+
+        Returns:
+            The configured domain name string
+        """
         certificate, validation = self.set_up_certificate(name, domain_name)
 
         custom_domain = aws.apigateway.DomainName(
@@ -354,6 +581,20 @@ class CDN(pulumi.ComponentResource):
         return domain_name
 
     def find_hosted_zone_id(self, name: str) -> str:
+        """Find Route53 hosted zone ID by domain name.
+
+        Placeholder method for looking up hosted zone ID dynamically.
+
+        Args:
+            name: Domain name to search for
+
+        Returns:
+            Hosted zone ID string
+
+        Note:
+            This method is not yet implemented. Pass hosted_zone_id
+            directly in CDNArgs instead.
+        """
         # Implement your logic to find the hosted zone ID
         pass
 
@@ -368,7 +609,39 @@ def cdn(
     root_uri: Optional[str] = None,
     opts: ResourceOptions = None,
 ) -> CDN:
-
+    """Factory function to create a CDN component.
+
+    Convenience function for creating a CDN without explicitly constructing
+    CDNArgs. Wraps the CDN component resource initialization.
+
+    Args:
+        name: Resource name for the CDN
+        origins: List of origin configuration dicts
+        hosted_zone_id: Route53 hosted zone ID for custom domain
+        subdomain: Subdomain for CDN (e.g., "www", "cdn")
+        error_responses: Custom error response configurations
+        create_apex: Create apex domain A record (default: False)
+        root_uri: Default root object (e.g., "index.html")
+        opts: Pulumi resource options
+
+    Returns:
+        CDN component resource instance
+
+    Example:
+        my_cdn = cdn(
+            "website-cdn",
+            origins=[
+                {
+                    "name": "site",
+                    "bucket": website_bucket,
+                    "is_target_origin": True
+                }
+            ],
+            hosted_zone_id="Z123456",
+            subdomain="www",
+            root_uri="index.html"
+        )
+    """
     return CDN(
         name,
         CDNArgs(

{cloud_foundry-0.1.2 → cloud_foundry-0.1.4}/cloud_foundry/pulumi/cdn_api_origin.py

@@ -52,6 +52,7 @@ class ApiOrigin(pulumi.ComponentResource):
 
         self.origin_id = f"{name}-api"
         log.info(f"Creating API origin with ID: {self.origin_id}")
+        log.info(f"Domain name type: {type(domain_name)}, value: {domain_name}")
 
         # Configure custom headers if API key is provided
         custom_headers = []
@@ -59,6 +60,13 @@ class ApiOrigin(pulumi.ComponentResource):
             custom_headers.append({"name": "X-API-Key", "value": api_key_password})
             log.debug("Custom headers configured for API key.")
 
+        # If domain_name is an Output, we need to handle it properly
+        # Pulumi should handle Output automatically, but let's ensure it's properly typed
+        if isinstance(domain_name, pulumi.Output):
+            log.info(
+                "Domain name is a Pulumi Output - will be resolved at deployment time"
+            )
+
         # Define the CloudFront distribution origin
         self.distribution_origin = aws.cloudfront.DistributionOriginArgs(
             domain_name=domain_name,

cloud_foundry-0.1.4/cloud_foundry/pulumi/connection_store.py

@@ -0,0 +1,176 @@
+# connection_store.py
+
+import pulumi
+import pulumi_aws as aws
+from cloud_foundry.utils.logger import logger
+
+log = logger(__name__)
+
+
+class ConnectionStore(pulumi.ComponentResource):
+    """
+    A DynamoDB table for managing WebSocket connections.
+
+    This component creates a DynamoDB table optimized for storing and
+    querying WebSocket connection information including:
+    - Connection IDs (primary key)
+    - User identification and metadata
+    - Connection timestamps
+    - Custom routing attributes
+    - TTL for automatic cleanup of stale connections
+    """
+
+    table: aws.dynamodb.Table
+    table_name: pulumi.Output[str]
+    table_arn: pulumi.Output[str]
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        ttl_attribute: str = "ttl",
+        ttl_enabled: bool = True,
+        read_capacity: int = 5,
+        write_capacity: int = 5,
+        billing_mode: str = "PAY_PER_REQUEST",
+        global_secondary_indexes: list[dict] = None,
+        opts=None,
+    ):
+        """
+        Initialize the ConnectionStore component.
+
+        Args:
+            name (str): Name of the connection store
+            ttl_attribute (str): Name of the TTL attribute (default: "ttl")
+            ttl_enabled (bool): Enable TTL for automatic cleanup
+                (default: True)
+            read_capacity (int): Provisioned read capacity units
+                (only used if billing_mode is PROVISIONED)
+            write_capacity (int): Provisioned write capacity units
+                (only used if billing_mode is PROVISIONED)
+            billing_mode (str): Billing mode - "PAY_PER_REQUEST" or
+                "PROVISIONED" (default: "PAY_PER_REQUEST")
+            global_secondary_indexes (list[dict]): Additional GSIs for
+                querying connections by custom attributes. Each dict should
+                have:
+                - name (str): Index name
+                - hash_key (str): Partition key attribute
+                - range_key (str, optional): Sort key attribute
+                - projection_type (str): ALL, KEYS_ONLY, or INCLUDE
+                - non_key_attributes (list, optional): For INCLUDE projection
+            opts (pulumi.ResourceOptions): Pulumi resource options
+        """
+        super().__init__("cloud_foundry:websocket:ConnectionStore", name, None, opts)
+        self.name = name
+        self.ttl_attribute = ttl_attribute
+        self.ttl_enabled = ttl_enabled
+        self.global_secondary_indexes = global_secondary_indexes or []
+
+        # Create the DynamoDB table
+        self.table = self._create_table(billing_mode, read_capacity, write_capacity)
+        self.table_name = self.table.name
+        self.table_arn = self.table.arn
+
+        # Register outputs
+        self.register_outputs(
+            {
+                "table_name": self.table_name,
+                "table_arn": self.table_arn,
+            }
+        )
+
+    def _create_table(self, billing_mode: str, read_capacity: int, write_capacity: int):
+        """
+        Create the DynamoDB table for connection storage.
+
+        Args:
+            billing_mode: Billing mode for the table
+            read_capacity: Provisioned read capacity
+            write_capacity: Provisioned write capacity
+
+        Returns:
+            aws.dynamodb.Table: The created table
+        """
+        log.info("Creating connection store table: %s", self.name)
+
+        table_name = f"{pulumi.get_project()}-{pulumi.get_stack()}-{self.name}"
+
+        # Define base attributes
+        attributes = [
+            aws.dynamodb.TableAttributeArgs(
+                name="connectionId",
+                type="S",
+            ),
+        ]
+
+        # Add attributes for GSIs
+        for gsi in self.global_secondary_indexes:
+            if gsi.get("hash_key") and not any(
+                attr.name == gsi["hash_key"] for attr in attributes
+            ):
+                attributes.append(
+                    aws.dynamodb.TableAttributeArgs(
+                        name=gsi["hash_key"],
+                        type=gsi.get("hash_key_type", "S"),
+                    )
+                )
+            if gsi.get("range_key") and not any(
+                attr.name == gsi["range_key"] for attr in attributes
+            ):
+                attributes.append(
+                    aws.dynamodb.TableAttributeArgs(
+                        name=gsi["range_key"],
+                        type=gsi.get("range_key_type", "S"),
+                    )
+                )
+
+        # Prepare GSI configurations
+        gsi_configs = []
+        for gsi in self.global_secondary_indexes:
+            gsi_config = aws.dynamodb.TableGlobalSecondaryIndexArgs(
+                name=gsi["name"],
+                hash_key=gsi["hash_key"],
+                projection_type=gsi.get("projection_type", "ALL"),
+            )
+
+            if gsi.get("range_key"):
+                gsi_config.range_key = gsi["range_key"]
+
+            if gsi.get("projection_type") == "INCLUDE":
+                gsi_config.non_key_attributes = gsi.get("non_key_attributes", [])
+
+            if billing_mode == "PROVISIONED":
+                gsi_config.read_capacity = gsi.get("read_capacity", 5)
+                gsi_config.write_capacity = gsi.get("write_capacity", 5)
+
+            gsi_configs.append(gsi_config)
+
+        # Create table configuration
+        table_config = {
+            "name": table_name,
+            "hash_key": "connectionId",
+            "attributes": attributes,
+            "billing_mode": billing_mode,
+            "global_secondary_indexes": gsi_configs if gsi_configs else None,
+        }
+
+        # Add capacity settings for PROVISIONED mode
+        if billing_mode == "PROVISIONED":
+            table_config["read_capacity"] = read_capacity
+            table_config["write_capacity"] = write_capacity
+
+        # Add TTL configuration if enabled
+        if self.ttl_enabled:
+            table_config["ttl"] = aws.dynamodb.TableTtlArgs(
+                attribute_name=self.ttl_attribute,
+                enabled=True,
+            )
+
+        # Create the table
+        table = aws.dynamodb.Table(
+            f"{self.name}-table",
+            **table_config,
+            opts=pulumi.ResourceOptions(parent=self),
+        )
+
+        return table