pangea-aws 0.1.0

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

@@ -0,0 +1,115 @@
+# 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_appsync_resolver/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS AppSync Resolver
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Resolver attributes
+      # @option attributes [String] :api_id The GraphQL API ID
+      # @option attributes [String] :type The GraphQL type (e.g., Query, Mutation, Subscription)
+      # @option attributes [String] :field The GraphQL field name
+      # @option attributes [String] :code JavaScript code for APPSYNC_JS runtime
+      # @option attributes [String] :data_source Data source name (for UNIT resolvers)
+      # @option attributes [String] :kind UNIT or PIPELINE
+      # @option attributes [Integer] :max_batch_size Max batch size for array operations
+      # @option attributes [Hash] :pipeline_config Pipeline configuration (for PIPELINE resolvers)
+      # @option attributes [String] :request_template VTL request mapping template
+      # @option attributes [String] :response_template VTL response mapping template
+      # @option attributes [Hash] :runtime Runtime configuration
+      # @option attributes [Hash] :caching_config Caching configuration
+      # @option attributes [Hash] :sync_config Conflict resolution configuration
+      # @return [ResourceReference] Reference object with outputs
+      def aws_appsync_resolver(name, attributes = {})
+        # Validate attributes using dry-struct
+        resolver_attrs = Types::AppSyncResolverAttributes.new(attributes)
+        
+        # Generate terraform resource block
+        resource(:aws_appsync_resolver, name) do
+          api_id resolver_attrs.api_id
+          type resolver_attrs.type
+          field resolver_attrs.field
+          
+          code resolver_attrs.code if resolver_attrs.code
+          data_source resolver_attrs.data_source if resolver_attrs.data_source
+          kind resolver_attrs.kind
+          max_batch_size resolver_attrs.max_batch_size if resolver_attrs.max_batch_size
+          
+          # Pipeline configuration
+          if resolver_attrs.pipeline_config
+            pipeline_config do
+              functions resolver_attrs.pipeline_config&.dig(:functions)
+            end
+          end
+          
+          request_template resolver_attrs.request_template if resolver_attrs.request_template
+          response_template resolver_attrs.response_template if resolver_attrs.response_template
+          
+          # Runtime configuration
+          if resolver_attrs.runtime
+            runtime do
+              name resolver_attrs.runtime&.dig(:name)
+              runtime_version resolver_attrs.runtime&.dig(:runtime_version)
+            end
+          end
+          
+          # Caching configuration
+          if resolver_attrs.caching_config
+            caching_config do
+              caching_keys resolver_attrs.caching_config&.dig(:caching_keys) if resolver_attrs.caching_config&.dig(:caching_keys)
+              ttl resolver_attrs.caching_config&.dig(:ttl) if resolver_attrs.caching_config&.dig(:ttl)
+            end
+          end
+          
+          # Sync configuration
+          if resolver_attrs.sync_config
+            sync_config do
+              conflict_detection resolver_attrs.sync_config&.dig(:conflict_detection) if resolver_attrs.sync_config&.dig(:conflict_detection)
+              conflict_handler resolver_attrs.sync_config&.dig(:conflict_handler) if resolver_attrs.sync_config&.dig(:conflict_handler)
+              
+              if resolver_attrs.sync_config&.dig(:lambda_conflict_handler_config)
+                lambda_conflict_handler_config do
+                  lambda_conflict_handler_arn resolver_attrs.sync_config&.dig(:lambda_conflict_handler_config)[:lambda_conflict_handler_arn] if resolver_attrs.sync_config&.dig(:lambda_conflict_handler_config)[:lambda_conflict_handler_arn]
+                end
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with outputs
+        ResourceReference.new(
+          type: 'aws_appsync_resolver',
+          name: name,
+          resource_attributes: resolver_attrs.to_h,
+          outputs: {
+            arn: "${aws_appsync_resolver.#{name}.arn}",
+            api_id: "${aws_appsync_resolver.#{name}.api_id}",
+            type: "${aws_appsync_resolver.#{name}.type}",
+            field: "${aws_appsync_resolver.#{name}.field}",
+            kind: "${aws_appsync_resolver.#{name}.kind}"
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# 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 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # AppSync resolver kind
+        unless const_defined?(:AppSyncResolverKind)
+        AppSyncResolverKind = Resources::Types::String.constrained(included_in: ['UNIT', 'PIPELINE'])
+        end
+
+        # AppSync runtime configuration
+        unless const_defined?(:AppSyncRuntime)
+        AppSyncRuntime = Resources::Types::Hash.schema(
+          name: Resources::Types::String.constrained(included_in: ['APPSYNC_JS']),
+          runtime_version: Resources::Types::String.constrained(format: /\A\d+\.\d+\.\d+\z/)
+        ).lax
+        end
+
+        # AppSync pipeline config
+        AppSyncPipelineConfig = Resources::Types::Hash.schema(
+          functions: Resources::Types::Array.of(Resources::Types::String).constrained(min_size: 1)
+        ).lax
+
+        # AppSync caching config
+        AppSyncCachingConfig = Resources::Types::Hash.schema(
+          caching_keys?: Resources::Types::Array.of(Resources::Types::String).optional,
+          ttl?: Resources::Types::Integer.constrained(gteq: 1, lteq: 3600).optional
+        ).lax
+
+        # AppSync sync config for subscriptions
+        AppSyncSyncConfig = Resources::Types::Hash.schema(
+          conflict_detection?: Resources::Types::String.constrained(included_in: ['VERSION', 'NONE']).optional,
+          conflict_handler?: Resources::Types::String.constrained(included_in: ['OPTIMISTIC_CONCURRENCY', 'LAMBDA', 'AUTOMERGE', 'NONE']).optional,
+          lambda_conflict_handler_config?: Resources::Types::Hash.schema(
+            lambda_conflict_handler_arn?: Resources::Types::String.constrained(format: /\Aarn:aws:lambda:/).optional
+          ).lax.optional
+        )
+
+        # AppSync Resolver resource attributes
+        class AppSyncResolverAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+
+          attribute? :api_id, Resources::Types::String.optional
+          
+          attribute? :type, Resources::Types::String.constrained(
+            format: /\A[A-Z][a-zA-Z0-9_]*\z/,
+            size: 1..65
+          )
+          
+          attribute? :field, Resources::Types::String.constrained(
+            format: /\A[a-zA-Z][a-zA-Z0-9_]*\z/,
+            size: 1..65
+          )
+          
+          attribute? :code, Resources::Types::String.optional
+          
+          attribute? :data_source, Resources::Types::String.optional
+          
+          attribute? :kind, AppSyncResolverKind.default('UNIT')
+          
+          attribute? :max_batch_size, Resources::Types::Integer.constrained(
+            gteq: 1, lteq: 2000
+          ).optional
+          
+          attribute? :pipeline_config, AppSyncPipelineConfig.optional
+          
+          attribute? :request_template, Resources::Types::String.optional
+          
+          attribute? :response_template, Resources::Types::String.optional
+          
+          attribute? :runtime, AppSyncRuntime.optional
+          
+          attribute? :caching_config, AppSyncCachingConfig.optional
+          
+          attribute? :sync_config, AppSyncSyncConfig.optional
+
+          # Custom validation
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            # Validate resolver configuration based on kind
+            if attrs[:kind] == 'PIPELINE'
+              unless attrs[:pipeline_config]
+                raise Dry::Struct::Error, "pipeline_config is required when kind is PIPELINE"
+              end
+              if attrs[:data_source]
+                raise Dry::Struct::Error, "data_source should not be specified for PIPELINE resolvers"
+              end
+            else # UNIT resolver
+              unless attrs[:data_source]
+                raise Dry::Struct::Error, "data_source is required for UNIT resolvers"
+              end
+              if attrs[:pipeline_config]
+                raise Dry::Struct::Error, "pipeline_config should not be specified for UNIT resolvers"
+              end
+            end
+
+            # Validate runtime and template configuration
+            if attrs[:runtime] && (attrs[:request_template] || attrs[:response_template])
+              raise Dry::Struct::Error, "runtime and templates (request_template/response_template) are mutually exclusive"
+            end
+
+            if attrs[:runtime] && !attrs[:code]
+              raise Dry::Struct::Error, "code is required when using runtime"
+            end
+
+            # Validate conflict handler configuration
+            if attrs[:sync_config] && attrs[:sync_config][:conflict_handler] == 'LAMBDA'
+              unless attrs[:sync_config][:lambda_conflict_handler_config]
+                raise Dry::Struct::Error, "lambda_conflict_handler_config is required when conflict_handler is LAMBDA"
+              end
+            end
+
+            super(attrs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# 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_athena_database/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Athena Database with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Athena Database attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_athena_database(name, attributes = {})
+        # Validate attributes using dry-struct
+        database_attrs = Types::AthenaDatabaseAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_athena_database, name) do
+          # Required attributes
+          database_name = database_attrs.name
+          bucket database_attrs.bucket
+          
+          # Optional comment
+          comment database_attrs.comment if database_attrs.comment
+          
+          # Properties
+          if database_attrs.properties&.any?
+            properties do
+              database_attrs.properties.each do |key, value|
+                public_send(key.tr(".", "_"), value)
+              end
+            end
+          end
+          
+          # Encryption configuration
+          if database_attrs.encryption_configuration
+            encryption_configuration do
+              encryption_option database_attrs.encryption_configuration&.dig(:encryption_option)
+              kms_key database_attrs.encryption_configuration&.dig(:kms_key) if database_attrs.encryption_configuration&.dig(:kms_key)
+            end
+          end
+          
+          # Expected bucket owner
+          expected_bucket_owner database_attrs.expected_bucket_owner if database_attrs.expected_bucket_owner
+          
+          # Force destroy
+          force_destroy database_attrs.force_destroy
+          
+          # ACL configuration
+          if database_attrs.acl_configuration
+            acl_configuration do
+              s3_acl_option database_attrs.acl_configuration&.dig(:s3_acl_option)
+            end
+          end
+          
+          # Apply tags if present
+          if database_attrs.tags&.any?
+            tags do
+              database_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_athena_database',
+          name: name,
+          resource_attributes: database_attrs.to_h,
+          outputs: {
+            id: "${aws_athena_database.#{name}.id}",
+            name: "${aws_athena_database.#{name}.name}"
+          },
+          computed_properties: {
+            encrypted: database_attrs.encrypted?,
+            encryption_type: database_attrs.encryption_type,
+            uses_kms: database_attrs.uses_kms?,
+            location_uri: database_attrs.location_uri,
+            estimated_monthly_storage_gb: database_attrs.estimated_monthly_storage_gb
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# 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
+      # Type-safe attributes for AWS Athena Database resources
+      class AthenaDatabaseAttributes < Pangea::Resources::BaseAttributes
+        # Database name (required)
+        attribute? :name, Resources::Types::String.optional
+        
+        # S3 bucket location for database storage
+        attribute? :bucket, Resources::Types::String.optional
+        
+        # Comment/description for the database
+        attribute? :comment, Resources::Types::String.optional
+        
+        # Database properties
+        attribute :properties, Resources::Types::Hash.map(Resources::Types::String, Resources::Types::String).default({}.freeze)
+        
+        # Encryption configuration
+        attribute? :encryption_configuration, Resources::Types::Hash.schema(
+          encryption_option: Resources::Types::String.constrained(included_in: ["SSE_S3", "SSE_KMS", "CSE_KMS"]),
+          kms_key?: Resources::Types::String.optional
+        ).lax.optional
+        
+        # Expected bucket owner for S3 access
+        attribute? :expected_bucket_owner, Resources::Types::String.optional
+        
+        # Force destroy database and tables when resource is destroyed
+        attribute :force_destroy, Resources::Types::Bool.default(false)
+        
+        # ACL configuration for database
+        attribute? :acl_configuration, Resources::Types::Hash.schema(
+          s3_acl_option: Resources::Types::String.constrained(included_in: ["BUCKET_OWNER_FULL_CONTROL"])
+        ).lax.optional
+        
+        # Tags
+        attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Validate database name format
+          unless attrs.name =~ /\A[a-zA-Z_][a-zA-Z0-9_]*\z/
+            raise Dry::Struct::Error, "Database name must start with letter or underscore and contain only alphanumeric characters and underscores"
+          end
+          
+          # Validate database name length
+          if attrs.name.length > 255
+            raise Dry::Struct::Error, "Database name must be 255 characters or less"
+          end
+          
+          # Validate bucket name format
+          unless attrs.bucket =~ /\A[a-z0-9][a-z0-9\-\.]*[a-z0-9]\z/
+            raise Dry::Struct::Error, "Bucket name must be valid S3 bucket format"
+          end
+          
+          # Validate KMS key if encryption is KMS
+          if attrs.encryption_configuration
+            if ["SSE_KMS", "CSE_KMS"].include?(attrs.encryption_configuration&.dig(:encryption_option)) && 
+               attrs.encryption_configuration&.dig(:kms_key).nil?
+              raise Dry::Struct::Error, "KMS key must be provided when using KMS encryption"
+            end
+          end
+
+          attrs
+        end
+
+        # Check if database uses encryption
+        def encrypted?
+          !encryption_configuration.nil?
+        end
+
+        # Get encryption type
+        def encryption_type
+          return nil unless encrypted?
+          encryption_configuration&.dig(:encryption_option)
+        end
+
+        # Check if using KMS encryption
+        def uses_kms?
+          encrypted? && ["SSE_KMS", "CSE_KMS"].include?(encryption_type)
+        end
+
+        # Generate S3 location URI
+        def location_uri
+          "s3://#{bucket}/#{name}/"
+        end
+
+        # Estimate storage requirements based on typical Athena patterns
+        def estimated_monthly_storage_gb
+          # Base estimate for metadata and common table patterns
+          base_storage = 0.1 # 100MB base
+          
+          # Add estimates based on properties
+          if properties["table_type"] == "EXTERNAL_TABLE"
+            base_storage += 0.5
+          end
+          
+          if properties["projection.enabled"] == "true"
+            base_storage += 0.2
+          end
+          
+          base_storage
+        end
+
+        # Generate default properties for common database types
+        def self.default_properties_for_type(type)
+          case type.to_s
+          when "data_lake"
+            {
+              "classification" => "data_lake",
+              "compression" => "snappy",
+              "storage_format" => "parquet"
+            }
+          when "analytics"
+            {
+              "classification" => "analytics",
+              "query_optimization" => "enabled",
+              "result_compression" => "gzip"
+            }
+          when "logs"
+            {
+              "classification" => "log_analysis",
+              "time_partitioning" => "daily",
+              "retention_days" => "90"
+            }
+          when "streaming"
+            {
+              "classification" => "streaming",
+              "partition_projection" => "enabled",
+              "time_format" => "yyyy-MM-dd-HH"
+            }
+          else
+            {}
+          end
+        end
+
+        # Helper to generate partition projection properties
+        def self.partition_projection_properties(type, options = {})
+          base_props = {
+            "projection.enabled" => "true"
+          }
+          
+          case type.to_s
+          when "date"
+            base_props.merge({
+              "projection.date.type" => "date",
+              "projection.date.range" => options[:range] || "2020-01-01,NOW",
+              "projection.date.format" => options[:format] || "yyyy-MM-dd",
+              "projection.date.interval" => options[:interval] || "1",
+              "projection.date.interval.unit" => options[:unit] || "DAYS"
+            })
+          when "integer"
+            base_props.merge({
+              "projection.id.type" => "integer",
+              "projection.id.range" => options[:range] || "1,1000000",
+              "projection.id.digits" => options[:digits] || "1"
+            })
+          when "enum"
+            base_props.merge({
+              "projection.type.type" => "enum",
+              "projection.type.values" => options[:values]&.join(",") || ""
+            })
+          else
+            base_props
+          end
+        end
+      end
+    end
+      end
+    end
+  end

data/lib/pangea/resources/aws_athena_database/types.rbs

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pangea
+  module Resources
+    module AWS
+      class AthenaDatabaseAttributes < Dry::Struct
+        @attributes: Hash[Symbol, untyped]
+        
+        attr_reader name: String
+        attr_reader bucket: String
+        attr_reader comment: String?
+        attr_reader properties: Hash[String, String]
+        attr_reader encryption_configuration: Hash[Symbol, untyped]?
+        attr_reader expected_bucket_owner: String?
+        attr_reader force_destroy: bool
+        attr_reader acl_configuration: Hash[Symbol, untyped]?
+        attr_reader tags: Hash[Symbol, String]
+        
+        def self.new: (Hash[Symbol, untyped] attributes) -> AthenaDatabaseAttributes
+        
+        # Query methods
+        def encrypted?: () -> bool
+        def encryption_type: () -> String?
+        def uses_kms?: () -> bool
+        
+        # Computed properties
+        def location_uri: () -> String
+        def estimated_monthly_storage_gb: () -> Float
+        
+        # Class methods for defaults
+        def self.default_properties_for_type: (String | Symbol type) -> Hash[String, String]
+        def self.partition_projection_properties: (String | Symbol type, ?Hash[Symbol, untyped] options) -> Hash[String, String]
+        
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# 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_athena_named_query/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Athena Named Query with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Athena Named Query attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_athena_named_query(name, attributes = {})
+        # Validate attributes using dry-struct
+        query_attrs = Types::AthenaNamedQueryAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_athena_named_query, name) do
+          # Required attributes
+          query_name = query_attrs.name
+          database query_attrs.database
+          query query_attrs.query
+          
+          # Optional description
+          description query_attrs.description if query_attrs.description
+          
+          # Workgroup
+          workgroup query_attrs.workgroup
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_athena_named_query',
+          name: name,
+          resource_attributes: query_attrs.to_h,
+          outputs: {
+            id: "${aws_athena_named_query.#{name}.id}"
+          },
+          computed_properties: {
+            is_select_query: query_attrs.is_select_query?,
+            is_ddl_query: query_attrs.is_ddl_query?,
+            is_insert_query: query_attrs.is_insert_query?,
+            is_maintenance_query: query_attrs.is_maintenance_query?,
+            query_type: query_attrs.query_type,
+            referenced_tables: query_attrs.referenced_tables,
+            uses_partitions: query_attrs.uses_partitions?,
+            uses_aggregations: query_attrs.uses_aggregations?,
+            uses_window_functions: query_attrs.uses_window_functions?,
+            query_complexity_score: query_attrs.query_complexity_score,
+            parameterized_query: query_attrs.parameterized_query,
+            documentation: query_attrs.generate_documentation
+          }
+        )
+      end
+    end
+  end
+end