pangea 0.0.45 → 0.0.46

data/lib/pangea/resources/aws_s3_bucket_lifecycle_configuration/types.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'pangea/resources/types'
-
-module Pangea
-  module Resources
-    module AWS
-      module Types
-      # S3 lifecycle rule expiration
-      class LifecycleExpiration < Dry::Struct
-        attribute :date, Resources::Types::String.optional
-        attribute :days, Resources::Types::Integer.optional
-        attribute :expired_object_delete_marker, Resources::Types::Bool.optional
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Must specify either date or days, but not both
-          if attrs.date && attrs.days
-            raise Dry::Struct::Error, "Cannot specify both 'date' and 'days' for expiration"
-          end
-          
-          if !attrs.date && !attrs.days && !attrs.expired_object_delete_marker
-            raise Dry::Struct::Error, "Must specify at least one expiration property"
-          end
-          
-          attrs
-        end
-      end
-
-      # S3 lifecycle rule noncurrent version expiration
-      class LifecycleNoncurrentVersionExpiration < Dry::Struct
-        attribute :noncurrent_days, Resources::Types::Integer.optional
-        attribute :newer_noncurrent_versions, Resources::Types::Integer.optional
-      end
-
-      # S3 lifecycle rule transition
-      class LifecycleTransition < Dry::Struct
-        attribute :date, Resources::Types::String.optional
-        attribute :days, Resources::Types::Integer.optional
-        attribute :storage_class, Resources::Types::String.enum("STANDARD_IA", "ONEZONE_IA", "REDUCED_REDUNDANCY", "GLACIER", "DEEP_ARCHIVE", "INTELLIGENT_TIERING", "GLACIER_IR")
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Must specify either date or days, but not both
-          if attrs.date && attrs.days
-            raise Dry::Struct::Error, "Cannot specify both 'date' and 'days' for transition"
-          end
-          
-          if !attrs.date && !attrs.days
-            raise Dry::Struct::Error, "Must specify either 'date' or 'days' for transition"
-          end
-          
-          attrs
-        end
-      end
-
-      # S3 lifecycle rule noncurrent version transition
-      class LifecycleNoncurrentVersionTransition < Dry::Struct
-        attribute :noncurrent_days, Resources::Types::Integer.optional
-        attribute :newer_noncurrent_versions, Resources::Types::Integer.optional
-        attribute :storage_class, Resources::Types::String.enum("STANDARD_IA", "ONEZONE_IA", "REDUCED_REDUNDANCY", "GLACIER", "DEEP_ARCHIVE", "INTELLIGENT_TIERING", "GLACIER_IR")
-      end
-
-      # S3 lifecycle rule abort incomplete multipart upload
-      class LifecycleAbortIncompleteMultipartUpload < Dry::Struct
-        attribute :days_after_initiation, Resources::Types::Integer.constrained(gt: 0)
-      end
-
-      # S3 lifecycle rule filter tag
-      class LifecycleFilterTag < Dry::Struct
-        attribute :key, Resources::Types::String
-        attribute :value, Resources::Types::String
-      end
-
-      # S3 lifecycle rule filter and block
-      class LifecycleFilterAnd < Dry::Struct
-        attribute :object_size_greater_than, Resources::Types::Integer.optional
-        attribute :object_size_less_than, Resources::Types::Integer.optional
-        attribute :prefix, Resources::Types::String.optional
-        attribute :tags, Resources::Types::Array.of(LifecycleFilterTag).optional
-      end
-
-      # S3 lifecycle rule filter
-      class LifecycleFilter < Dry::Struct
-        attribute? :and_condition, LifecycleFilterAnd.optional
-        attribute :object_size_greater_than, Resources::Types::Integer.optional
-        attribute :object_size_less_than, Resources::Types::Integer.optional
-        attribute :prefix, Resources::Types::String.optional
-        attribute? :tag, LifecycleFilterTag.optional
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Count non-nil filter conditions
-          conditions = [
-            attrs.and_condition,
-            attrs.object_size_greater_than, 
-            attrs.object_size_less_than,
-            attrs.prefix,
-            attrs.tag
-          ].compact.count
-          
-          # Can only have one top-level filter condition
-          if conditions > 1
-            raise Dry::Struct::Error, "Can only specify one top-level filter condition"
-          end
-          
-          attrs
-        end
-      end
-
-      # S3 lifecycle rule
-      class LifecycleRule < Dry::Struct
-        attribute :id, Resources::Types::String
-        attribute :status, Resources::Types::String.enum("Enabled", "Disabled")
-        attribute? :abort_incomplete_multipart_upload, LifecycleAbortIncompleteMultipartUpload.optional
-        attribute? :expiration, LifecycleExpiration.optional
-        attribute? :filter, LifecycleFilter.optional
-        attribute? :noncurrent_version_expiration, LifecycleNoncurrentVersionExpiration.optional
-        attribute :noncurrent_version_transition, Resources::Types::Array.of(LifecycleNoncurrentVersionTransition).optional
-        attribute :prefix, Resources::Types::String.optional
-        attribute :transition, Resources::Types::Array.of(LifecycleTransition).optional
-
-        # Helper methods
-        def enabled?
-          status == "Enabled"
-        end
-
-        def disabled?
-          status == "Disabled"
-        end
-
-        def has_expiration?
-          !expiration.nil?
-        end
-
-        def has_transitions?
-          !transition.nil? && transition.any?
-        end
-
-        def has_filter?
-          !filter.nil?
-        end
-      end
-
-      # Type-safe attributes for AWS S3 Bucket Lifecycle Configuration
-      class S3BucketLifecycleConfigurationAttributes < Dry::Struct
-        # S3 bucket to apply lifecycle configuration to
-        attribute :bucket, Resources::Types::String
-        
-        # Expected bucket owner (optional)
-        attribute :expected_bucket_owner, Resources::Types::String.optional
-        
-        # Lifecycle rules
-        attribute :rule, Resources::Types::Array.of(LifecycleRule).constrained(min_size: 1, max_size: 1000)
-
-        # Custom validation
-        def self.new(attributes = {})
-          attrs = super(attributes)
-          
-          # Validate unique rule IDs
-          rule_ids = attrs.rule.map(&:id)
-          if rule_ids.uniq.length != rule_ids.length
-            raise Dry::Struct::Error, "Rule IDs must be unique within lifecycle configuration"
-          end
-          
-          attrs
-        end
-
-        # Helper methods
-        def enabled_rules
-          rule.select(&:enabled?)
-        end
-
-        def disabled_rules
-          rule.select(&:disabled?)
-        end
-
-        def rules_with_expiration
-          rule.select(&:has_expiration?)
-        end
-
-        def rules_with_transitions
-          rule.select(&:has_transitions?)
-        end
-
-        def total_rules_count
-          rule.length
-        end
-      end
-    end
-      end
-    end
-  end
-end

data/lib/pangea/resources/aws_s3_bucket_notification/CLAUDE.md

@@ -1,358 +0,0 @@
-# AWS S3 Bucket Notification Configuration - Implementation Details
-
-## Resource Overview
-
-The `aws_s3_bucket_notification` resource enables comprehensive event-driven architecture patterns by configuring S3 bucket notifications to multiple AWS services simultaneously. This resource is essential for building reactive systems that respond to S3 object lifecycle events.
-
-## Architecture Patterns
-
-### Event-Driven Data Processing
-
-This resource enables sophisticated data processing pipelines where different services handle different aspects of object processing:
-
-```ruby
-aws_s3_bucket_notification(:data_processing_hub, {
-  bucket: "data-lake-raw",
-  lambda_function: [{
-    id: "metadata-extractor",
-    lambda_function_arn: lambda_metadata_extractor.outputs[:arn],
-    events: ["s3:ObjectCreated:Put"],
-    filter_prefix: "incoming/",
-    filter_suffix: ".json"
-  }],
-  queue: [{
-    id: "batch-processor",
-    queue_arn: sqs_batch_queue.outputs[:arn],
-    events: ["s3:ObjectCreated:Put"],
-    filter_prefix: "processed/"
-  }],
-  cloudwatch_configuration: [{
-    id: "monitoring",
-    topic_arn: sns_monitoring_topic.outputs[:arn],
-    events: ["s3:ObjectCreated:*", "s3:ObjectRemoved:*"]
-  }],
-  eventbridge: true
-})
-```
-
-### Multi-Tenant Notification Routing
-
-For multi-tenant applications, this resource can route events based on object prefixes:
-
-```ruby
-aws_s3_bucket_notification(:tenant_routing, {
-  bucket: "multi-tenant-storage",
-  lambda_function: [
-    {
-      id: "tenant-a-processor",
-      lambda_function_arn: lambda_tenant_a.outputs[:arn],
-      events: ["s3:ObjectCreated:*"],
-      filter_prefix: "tenant-a/"
-    },
-    {
-      id: "tenant-b-processor", 
-      lambda_function_arn: lambda_tenant_b.outputs[:arn],
-      events: ["s3:ObjectCreated:*"],
-      filter_prefix: "tenant-b/"
-    }
-  ],
-  # Global audit trail
-  queue: [{
-    id: "audit-trail",
-    queue_arn: sqs_audit_queue.outputs[:arn],
-    events: ["s3:ObjectCreated:*", "s3:ObjectRemoved:*"]
-  }]
-})
-```
-
-## Integration Patterns
-
-### Lambda Function Integration
-
-When integrating with Lambda functions, ensure proper permissions are configured:
-
-```ruby
-# Lambda function
-image_processor = aws_lambda_function(:image_processor, {
-  function_name: "image-processor",
-  runtime: "python3.9",
-  handler: "app.handler",
-  filename: "image_processor.zip",
-  timeout: 300
-})
-
-# Lambda permission for S3 invocation
-aws_lambda_permission(:s3_invoke_image_processor, {
-  statement_id: "AllowS3Invocation",
-  action: "lambda:InvokeFunction", 
-  function_name: image_processor.outputs[:function_name],
-  principal: "s3.amazonaws.com",
-  source_arn: "${aws_s3_bucket.media_bucket.arn}/*"
-})
-
-# S3 notification configuration
-aws_s3_bucket_notification(:image_processing_notifications, {
-  bucket: media_bucket.outputs[:id],
-  lambda_function: [{
-    lambda_function_arn: image_processor.outputs[:arn],
-    events: ["s3:ObjectCreated:Put", "s3:ObjectCreated:Post"],
-    filter_prefix: "images/",
-    filter_suffix: ".jpg"
-  }]
-})
-```
-
-### SQS Queue Integration
-
-For reliable, scalable processing with SQS:
-
-```ruby
-# Dead letter queue for failed processing
-dlq = aws_sqs_queue(:processing_dlq, {
-  name: "s3-processing-dlq",
-  message_retention_seconds: 1209600 # 14 days
-})
-
-# Main processing queue with DLQ
-processing_queue = aws_sqs_queue(:processing_queue, {
-  name: "s3-processing-queue",
-  visibility_timeout_seconds: 300,
-  redrive_policy: {
-    dead_letter_target_arn: dlq.outputs[:arn],
-    max_receive_count: 3
-  }
-})
-
-# SQS queue policy allowing S3 to send messages
-aws_sqs_queue_policy(:s3_send_policy, {
-  queue_url: processing_queue.outputs[:id],
-  policy: {
-    Version: "2012-10-17",
-    Statement: [{
-      Effect: "Allow",
-      Principal: { Service: "s3.amazonaws.com" },
-      Action: "sqs:SendMessage",
-      Resource: processing_queue.outputs[:arn],
-      Condition: {
-        ArnEquals: {
-          "aws:SourceArn": "${aws_s3_bucket.data_bucket.arn}"
-        }
-      }
-    }]
-  }.to_json
-})
-
-# S3 notification to SQS
-aws_s3_bucket_notification(:sqs_notifications, {
-  bucket: data_bucket.outputs[:id],
-  queue: [{
-    queue_arn: processing_queue.outputs[:arn],
-    events: ["s3:ObjectCreated:*"],
-    filter_prefix: "data/"
-  }]
-})
-```
-
-### EventBridge Integration
-
-EventBridge enables advanced event filtering and routing:
-
-```ruby
-# Enable EventBridge on the bucket
-aws_s3_bucket_notification(:eventbridge_notifications, {
-  bucket: "my-event-driven-bucket",
-  eventbridge: true
-})
-
-# EventBridge rule for specific object patterns
-aws_cloudwatch_event_rule(:image_uploaded_rule, {
-  name: "s3-image-uploaded",
-  event_pattern: {
-    source: ["aws.s3"],
-    detail_type: ["Object Created"],
-    detail: {
-      bucket: { name: ["my-event-driven-bucket"] },
-      object: { 
-        key: [{ prefix: "images/" }],
-        size: [{ numeric: [">", 1024] }] # Objects larger than 1KB
-      }
-    }
-  }.to_json
-})
-
-# EventBridge target - Lambda function
-aws_cloudwatch_event_target(:image_processor_target, {
-  rule: image_uploaded_rule.outputs[:name],
-  arn: image_processor.outputs[:arn],
-  target_id: "ImageProcessorTarget"
-})
-```
-
-## Advanced Use Cases
-
-### Compliance and Audit Logging
-
-```ruby
-aws_s3_bucket_notification(:compliance_notifications, {
-  bucket: "compliance-documents",
-  cloudwatch_configuration: [{
-    id: "compliance-audit",
-    topic_arn: sns_compliance_topic.outputs[:arn],
-    events: [
-      "s3:ObjectCreated:*",
-      "s3:ObjectRemoved:Delete",
-      "s3:ObjectRemoved:DeleteMarkerCreated"
-    ]
-  }],
-  lambda_function: [{
-    id: "document-classifier",
-    lambda_function_arn: lambda_document_classifier.outputs[:arn],
-    events: ["s3:ObjectCreated:*"],
-    filter_prefix: "incoming/"
-  }],
-  # Enable EventBridge for advanced compliance routing
-  eventbridge: true
-})
-```
-
-### Cross-Region Replication Monitoring
-
-```ruby
-aws_s3_bucket_notification(:replication_monitoring, {
-  bucket: "primary-data-bucket",
-  cloudwatch_configuration: [{
-    id: "replication-alerts",
-    topic_arn: sns_ops_alerts.outputs[:arn],
-    events: [
-      "s3:Replication:OperationFailedReplication",
-      "s3:Replication:OperationMissedThreshold"
-    ]
-  }],
-  lambda_function: [{
-    id: "replication-metrics",
-    lambda_function_arn: lambda_replication_metrics.outputs[:arn],
-    events: ["s3:Replication:*"]
-  }]
-})
-```
-
-## Performance Considerations
-
-### Event Volume Management
-
-For high-frequency buckets, consider:
-
-1. **Specific Event Types**: Use specific events instead of wildcards
-2. **Prefix Filtering**: Narrow down notifications with prefixes
-3. **Batch Processing**: Use SQS for batching events to Lambda
-4. **Rate Limiting**: Implement backpressure mechanisms
-
-```ruby
-# High-frequency bucket with optimized notifications
-aws_s3_bucket_notification(:high_frequency_notifications, {
-  bucket: "high-frequency-uploads",
-  # Use SQS for batching instead of direct Lambda invocation
-  queue: [{
-    queue_arn: batch_processing_queue.outputs[:arn],
-    events: ["s3:ObjectCreated:Put"], # Specific event only
-    filter_prefix: "processed/" # Only for processed objects
-  }],
-  # Critical alerts only
-  cloudwatch_configuration: [{
-    topic_arn: critical_alerts_topic.outputs[:arn],
-    events: ["s3:ObjectRemoved:Delete"] # Only deletions
-  }]
-})
-```
-
-## Cost Optimization
-
-### Notification Cost Management
-
-```ruby
-# Cost-optimized notification strategy
-aws_s3_bucket_notification(:cost_optimized_notifications, {
-  bucket: "cost-sensitive-bucket",
-  # Use EventBridge for complex routing (single notification stream)
-  eventbridge: true,
-  # Direct Lambda only for critical real-time processing
-  lambda_function: [{
-    lambda_function_arn: critical_processor.outputs[:arn],
-    events: ["s3:ObjectCreated:Put"],
-    filter_prefix: "critical/",
-    filter_suffix: ".urgent"
-  }]
-  # Avoid multiple SNS/SQS notifications for same events
-})
-```
-
-## Security Considerations
-
-### Principle of Least Privilege
-
-Ensure notification targets have minimal required permissions:
-
-```ruby
-# Lambda execution role with minimal S3 permissions
-lambda_execution_role = aws_iam_role(:s3_processor_role, {
-  name: "s3-processor-execution-role",
-  assume_role_policy: {
-    Version: "2012-10-17",
-    Statement: [{
-      Action: "sts:AssumeRole",
-      Effect: "Allow",
-      Principal: { Service: "lambda.amazonaws.com" }
-    }]
-  }.to_json
-})
-
-# Policy allowing only necessary S3 actions
-aws_iam_role_policy_attachment(:s3_processor_policy, {
-  role: lambda_execution_role.outputs[:name],
-  policy_arn: "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
-})
-
-aws_iam_policy(:s3_read_policy, {
-  name: "s3-processor-read-policy",
-  policy: {
-    Version: "2012-10-17",
-    Statement: [{
-      Effect: "Allow",
-      Action: ["s3:GetObject"],
-      Resource: "arn:aws:s3:::my-bucket/*"
-    }]
-  }.to_json
-})
-```
-
-## Monitoring and Debugging
-
-### CloudWatch Metrics Integration
-
-The resource automatically provides metrics through computed properties:
-
-```ruby
-notification_config = aws_s3_bucket_notification(:monitored_notifications, {
-  bucket: "monitored-bucket",
-  lambda_function: [{ /* config */ }],
-  queue: [{ /* config */ }]
-})
-
-# Create CloudWatch dashboard using computed properties
-aws_cloudwatch_dashboard(:s3_notification_dashboard, {
-  dashboard_name: "S3NotificationMetrics",
-  dashboard_body: {
-    widgets: [{
-      type: "metric",
-      properties: {
-        metrics: [
-          ["AWS/S3", "NumberOfObjects", "BucketName", "monitored-bucket"]
-        ],
-        title: "S3 Object Count - #{notification_config.computed[:total_notification_destinations]} destinations configured"
-      }
-    }]
-  }.to_json
-})
-```
-
-This resource is fundamental for building event-driven architectures with S3 as the central event source, providing type safety, comprehensive validation, and extensive integration capabilities.

data/lib/pangea/resources/aws_s3_bucket_notification/resource.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2025 The Pangea Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-require 'pangea/resources/base'
-require 'pangea/resources/reference'
-require 'pangea/resources/aws_s3_bucket_notification/types'
-require 'pangea/resource_registry'
-
-module Pangea
-  module Resources
-    module AWS
-      # Create an AWS S3 Bucket Notification Configuration with type-safe attributes
-      #
-      # @param name [Symbol] The resource name
-      # @param attributes [Hash] S3 bucket notification attributes
-      # @return [ResourceReference] Reference object with outputs and computed properties
-      def aws_s3_bucket_notification(name, attributes = {})
-        # Validate attributes using dry-struct
-        notification_attrs = Types::S3BucketNotificationAttributes.new(attributes)
-        
-        # Generate terraform resource block via terraform-synthesizer
-        resource(:aws_s3_bucket_notification, name) do
-          # Set the bucket
-          bucket notification_attrs.bucket
-          
-          # Configure EventBridge notifications
-          if notification_attrs.eventbridge
-            eventbridge true
-          end
-          
-          # Configure CloudWatch/SNS topic notifications
-          notification_attrs.cloudwatch_configuration.each_with_index do |config, index|
-            cloudwatch_configuration do
-              id config[:id] || "cloudwatch-config-#{index}"
-              topic_arn config[:topic_arn]
-              events config[:events]
-              
-              if config[:filter_prefix] || config[:filter_suffix]
-                filter do
-                  prefix config[:filter_prefix] if config[:filter_prefix]
-                  suffix config[:filter_suffix] if config[:filter_suffix]
-                end
-              end
-            end
-          end
-          
-          # Configure Lambda function notifications
-          notification_attrs.lambda_function.each_with_index do |config, index|
-            lambda_function do
-              id config[:id] || "lambda-config-#{index}"
-              lambda_function_arn config[:lambda_function_arn]
-              events config[:events]
-              
-              if config[:filter_prefix] || config[:filter_suffix]
-                filter do
-                  prefix config[:filter_prefix] if config[:filter_prefix]
-                  suffix config[:filter_suffix] if config[:filter_suffix]
-                end
-              end
-            end
-          end
-          
-          # Configure SQS queue notifications
-          notification_attrs.queue.each_with_index do |config, index|
-            queue do
-              id config[:id] || "queue-config-#{index}"
-              queue_arn config[:queue_arn]
-              events config[:events]
-              
-              if config[:filter_prefix] || config[:filter_suffix]
-                filter do
-                  prefix config[:filter_prefix] if config[:filter_prefix]
-                  suffix config[:filter_suffix] if config[:filter_suffix]
-                end
-              end
-            end
-          end
-        end
-        
-        # Return resource reference with available outputs
-        ResourceReference.new(
-          type: 'aws_s3_bucket_notification',
-          name: name,
-          resource_attributes: notification_attrs.to_h,
-          outputs: {
-            id: "${aws_s3_bucket_notification.#{name}.id}",
-            bucket: "${aws_s3_bucket_notification.#{name}.bucket}"
-          },
-          computed: {
-            total_notification_destinations: notification_attrs.total_notification_destinations,
-            has_lambda_notifications: notification_attrs.has_lambda_notifications?,
-            has_sqs_notifications: notification_attrs.has_sqs_notifications?,
-            has_sns_notifications: notification_attrs.has_sns_notifications?,
-            has_eventbridge_enabled: notification_attrs.has_eventbridge_enabled?,
-            all_configured_events: notification_attrs.all_configured_events,
-            uses_wildcard_events: notification_attrs.uses_wildcard_events?,
-            monitors_object_creation: notification_attrs.monitors_object_creation?,
-            monitors_object_removal: notification_attrs.monitors_object_removal?,
-            monitors_object_restore: notification_attrs.monitors_object_restore?,
-            monitors_replication: notification_attrs.monitors_replication?
-          }
-        )
-      end
-    end
-  end
-end
-
-# Auto-register this module when it's loaded
-Pangea::ResourceRegistry.register(:aws, Pangea::Resources::AWS)