pangea-aws 0.1.0

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

@@ -0,0 +1,173 @@
+# 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 Key Pair resources
+      class KeyPairAttributes < Pangea::Resources::BaseAttributes
+        # The name for the key pair (required)
+        attribute? :key_name, Resources::Types::String.optional
+        
+        # Creates a unique name beginning with the specified prefix (optional)
+        attribute? :key_name_prefix, Resources::Types::String.optional
+        
+        # The public key material (required)
+        attribute? :public_key, Resources::Types::String.optional
+        
+        # Tags to apply to the resource
+        attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+
+        # Custom validation
+        def self.new(attributes = {})
+          attrs = super(attributes)
+          
+          # Either key_name or key_name_prefix must be specified, but not both
+          if attrs.key_name && attrs.key_name_prefix
+            raise Dry::Struct::Error, "Cannot specify both 'key_name' and 'key_name_prefix'"
+          end
+          
+          unless attrs.key_name || attrs.key_name_prefix
+            raise Dry::Struct::Error, "Must specify either 'key_name' or 'key_name_prefix'"
+          end
+          
+          # Validate key_name format (AWS requirements)
+          if attrs.key_name && !valid_key_name?(attrs.key_name)
+            raise Dry::Struct::Error, "Invalid key_name format. Must be 1-255 characters, alphanumeric, spaces, dashes, and underscores only"
+          end
+          
+          # Validate key_name_prefix format
+          if attrs.key_name_prefix && !valid_key_name?(attrs.key_name_prefix)
+            raise Dry::Struct::Error, "Invalid key_name_prefix format. Must be 1-255 characters, alphanumeric, spaces, dashes, and underscores only"
+          end
+          
+          # Validate public key format
+          unless valid_public_key_format?(attrs.public_key)
+            raise Dry::Struct::Error, "Invalid public key format. Must be a valid SSH public key"
+          end
+          
+          attrs
+        end
+
+        # Check if using key name prefix
+        def uses_prefix?
+          !key_name_prefix.nil?
+        end
+        
+        # Check if using explicit key name
+        def uses_explicit_name?
+          !key_name.nil?
+        end
+        
+        # Get the effective key identifier
+        def key_identifier
+          key_name || key_name_prefix
+        end
+        
+        # Determine the key type from public key
+        def key_type
+          case public_key
+          when /^ssh-rsa\s/
+            :rsa
+          when /^ssh-dss\s/
+            :dsa
+          when /^ecdsa-sha2-nistp\d+\s/
+            :ecdsa
+          when /^ssh-ed25519\s/
+            :ed25519
+          else
+            :unknown
+          end
+        end
+        
+        # Check if key is RSA
+        def rsa_key?
+          key_type == :rsa
+        end
+        
+        # Check if key is ECDSA
+        def ecdsa_key?
+          key_type == :ecdsa
+        end
+        
+        # Check if key is Ed25519
+        def ed25519_key?
+          key_type == :ed25519
+        end
+        
+        # Estimate key size for RSA keys
+        def estimated_key_size
+          return nil unless rsa_key?
+          
+          # Basic estimation based on public key length
+          # This is approximate as actual parsing would require OpenSSL
+          key_data = public_key.split[1]
+          case key_data.length
+          when 200..400
+            1024
+          when 400..600
+            2048
+          when 600..800
+            3072
+          when 800..1200
+            4096
+          else
+            nil
+          end
+        end
+
+        private
+
+        # Validate AWS key pair name format
+        def self.valid_key_name?(name)
+          return false if name.nil? || name.empty?
+          return false if name.length > 255
+          
+          # AWS allows alphanumeric characters, spaces, dashes, and underscores
+          name.match?(/\A[a-zA-Z0-9\s\-_]+\z/)
+        end
+        
+        # Validate SSH public key format
+        def self.valid_public_key_format?(public_key)
+          return false if public_key.nil? || public_key.strip.empty?
+          
+          # Basic SSH public key format validation
+          # Format: <key-type> <key-data> [comment]
+          parts = public_key.strip.split(/\s+/)
+          return false if parts.length < 2
+          
+          key_type = parts[0]
+          key_data = parts[1]
+          
+          # Check supported key types
+          supported_types = %w[ssh-rsa ssh-dss ecdsa-sha2-nistp256 ecdsa-sha2-nistp384 ecdsa-sha2-nistp521 ssh-ed25519]
+          return false unless supported_types.include?(key_type)
+          
+          # Key data should be base64
+          return false unless key_data.match?(/\A[A-Za-z0-9+\/]+=*\z/)
+          
+          # Minimum reasonable length for key data
+          return false if key_data.length < 50
+          
+          true
+        end
+      end
+    end
+      end
+    end
+  end

data/lib/pangea/resources/aws_kinesis_analytics_application/builders/application_code_builder.rb

@@ -0,0 +1,62 @@
+# 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.
+
+module Pangea
+  module Resources
+    module AWS
+      module KinesisAnalyticsApplication
+        module Builders
+          # Builds the application_code_configuration block for Kinesis Analytics
+          module ApplicationCodeBuilder
+            extend self
+
+            # Build the application code configuration block
+            # @param context [Object] The DSL context for building Terraform blocks
+            # @param code_config [Hash] The application code configuration hash
+            def build(context, code_config)
+              return unless code_config
+
+              context.application_code_configuration do
+                context.code_content_type code_config[:code_content_type]
+
+                context.code_content do
+                  content = code_config[:code_content]
+                  build_code_content(context, content)
+                end
+              end
+            end
+
+            private
+
+            def build_code_content(context, content)
+              context.text_content content[:text_content] if content[:text_content]
+              context.zip_file_content content[:zip_file_content] if content[:zip_file_content]
+
+              build_s3_content_location(context, content[:s3_content_location]) if content[:s3_content_location]
+            end
+
+            def build_s3_content_location(context, s3_location)
+              context.s3_content_location do
+                context.bucket_arn s3_location[:bucket_arn]
+                context.file_key s3_location[:file_key]
+                context.object_version s3_location[:object_version] if s3_location[:object_version]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_kinesis_analytics_application/builders/flink_builder.rb

@@ -0,0 +1,76 @@
+# 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.
+
+module Pangea
+  module Resources
+    module AWS
+      module KinesisAnalyticsApplication
+        module Builders
+          # Builds the flink_application_configuration block for Kinesis Analytics
+          module FlinkBuilder
+            extend self
+
+            # Build the Flink application configuration block
+            # @param context [Object] The DSL context for building Terraform blocks
+            # @param flink_config [Hash] The Flink configuration hash
+            def build(context, flink_config)
+              return unless flink_config
+
+              context.flink_application_configuration do
+                build_checkpoint_configuration(context, flink_config[:checkpoint_configuration])
+                build_monitoring_configuration(context, flink_config[:monitoring_configuration])
+                build_parallelism_configuration(context, flink_config[:parallelism_configuration])
+              end
+            end
+
+            private
+
+            def build_checkpoint_configuration(context, checkpoint_config)
+              return unless checkpoint_config
+
+              context.checkpoint_configuration do
+                context.configuration_type checkpoint_config[:configuration_type]
+                context.checkpointing_enabled checkpoint_config[:checkpointing_enabled] if checkpoint_config.key?(:checkpointing_enabled)
+                context.checkpoint_interval checkpoint_config[:checkpoint_interval] if checkpoint_config[:checkpoint_interval]
+                context.min_pause_between_checkpoints checkpoint_config[:min_pause_between_checkpoints] if checkpoint_config[:min_pause_between_checkpoints]
+              end
+            end
+
+            def build_monitoring_configuration(context, monitor_config)
+              return unless monitor_config
+
+              context.monitoring_configuration do
+                context.configuration_type monitor_config[:configuration_type]
+                context.log_level monitor_config[:log_level] if monitor_config[:log_level]
+                context.metrics_level monitor_config[:metrics_level] if monitor_config[:metrics_level]
+              end
+            end
+
+            def build_parallelism_configuration(context, parallel_config)
+              return unless parallel_config
+
+              context.parallelism_configuration do
+                context.configuration_type parallel_config[:configuration_type]
+                context.parallelism parallel_config[:parallelism] if parallel_config[:parallelism]
+                context.parallelism_per_kpu parallel_config[:parallelism_per_kpu] if parallel_config[:parallelism_per_kpu]
+                context.auto_scaling_enabled parallel_config[:auto_scaling_enabled] if parallel_config.key?(:auto_scaling_enabled)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_kinesis_analytics_application/builders/sql_builder.rb

@@ -0,0 +1,219 @@
+# 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.
+
+module Pangea
+  module Resources
+    module AWS
+      module KinesisAnalyticsApplication
+        module Builders
+          # Builds the sql_application_configuration block for Kinesis Analytics
+          module SqlBuilder
+            extend self
+
+            # Build the SQL application configuration block
+            # @param context [Object] The DSL context for building Terraform blocks
+            # @param sql_config [Hash] The SQL configuration hash
+            def build(context, sql_config)
+              return unless sql_config
+
+              context.sql_application_configuration do
+                build_inputs(context, sql_config[:inputs])
+                build_outputs(context, sql_config[:outputs])
+                build_reference_data_sources(context, sql_config[:reference_data_sources])
+              end
+            end
+
+            private
+
+            def build_inputs(context, inputs)
+              return unless inputs
+
+              input_array = inputs.map do |input_config|
+                input_hash = { name_prefix: input_config[:name_prefix] }
+                input_hash[:input_parallelism] = input_config[:input_parallelism] if input_config[:input_parallelism]
+                input_hash[:input_schema] = build_input_schema_hash(input_config[:input_schema]) if input_config[:input_schema]
+                input_hash[:kinesis_streams_input] = input_config[:kinesis_streams_input] if input_config[:kinesis_streams_input]
+                input_hash[:kinesis_firehose_input] = input_config[:kinesis_firehose_input] if input_config[:kinesis_firehose_input]
+                input_hash
+              end
+              context.input input_array
+            end
+
+            def build_input_parallelism(context, parallelism)
+              return unless parallelism
+
+              context.input_parallelism do
+                context.count parallelism[:count] if parallelism[:count]
+              end
+            end
+
+            def build_input_schema(context, schema_config)
+              context.input_schema do
+                context.record_encoding schema_config[:record_encoding] if schema_config[:record_encoding]
+                build_record_columns(context, schema_config[:record_columns])
+                build_record_format(context, schema_config[:record_format])
+              end
+            end
+
+            def build_kinesis_input_sources(context, input_config)
+              if input_config[:kinesis_streams_input]
+                context.kinesis_streams_input do
+                  context.resource_arn input_config[:kinesis_streams_input][:resource_arn]
+                end
+              end
+
+              return unless input_config[:kinesis_firehose_input]
+
+              context.kinesis_firehose_input do
+                context.resource_arn input_config[:kinesis_firehose_input][:resource_arn]
+              end
+            end
+
+            def build_input_schema_hash(schema_config)
+              schema = {}
+              schema[:record_encoding] = schema_config[:record_encoding] if schema_config[:record_encoding]
+              schema[:record_column] = schema_config[:record_columns].map { |c| { name: c[:name], sql_type: c[:sql_type], mapping: c[:mapping] }.compact } if schema_config[:record_columns]
+              schema[:record_format] = build_record_format_hash(schema_config[:record_format]) if schema_config[:record_format]
+              schema
+            end
+
+            def build_record_format_hash(format_config)
+              fmt = { record_format_type: format_config[:record_format_type] }
+              if format_config[:mapping_parameters]
+                mp = {}
+                mp[:json_mapping_parameters] = format_config[:mapping_parameters][:json_mapping_parameters] if format_config[:mapping_parameters][:json_mapping_parameters]
+                mp[:csv_mapping_parameters] = format_config[:mapping_parameters][:csv_mapping_parameters] if format_config[:mapping_parameters][:csv_mapping_parameters]
+                fmt[:mapping_parameters] = mp
+              end
+              fmt
+            end
+
+            def build_outputs(context, outputs)
+              return unless outputs
+
+              output_array = outputs.map do |output_config|
+                output_hash = { name: output_config[:name] }
+                output_hash[:destination_schema] = output_config[:destination_schema] if output_config[:destination_schema]
+                output_hash[:kinesis_streams_output] = output_config[:kinesis_streams_output] if output_config[:kinesis_streams_output]
+                output_hash[:kinesis_firehose_output] = output_config[:kinesis_firehose_output] if output_config[:kinesis_firehose_output]
+                output_hash[:lambda_output] = output_config[:lambda_output] if output_config[:lambda_output]
+                output_hash
+              end
+              context.output output_array
+            end
+
+            def build_destination_schema(context, schema)
+              context.destination_schema do
+                context.record_format_type schema[:record_format_type]
+              end
+            end
+
+            def build_output_destinations(context, output_config)
+              if output_config[:kinesis_streams_output]
+                context.kinesis_streams_output do
+                  context.resource_arn output_config[:kinesis_streams_output][:resource_arn]
+                end
+              end
+
+              if output_config[:kinesis_firehose_output]
+                context.kinesis_firehose_output do
+                  context.resource_arn output_config[:kinesis_firehose_output][:resource_arn]
+                end
+              end
+
+              return unless output_config[:lambda_output]
+
+              context.lambda_output do
+                context.resource_arn output_config[:lambda_output][:resource_arn]
+              end
+            end
+
+            def build_reference_data_sources(context, ref_sources)
+              return unless ref_sources
+
+              ref_sources.each do |ref_source|
+                context.reference_data_source do
+                  context.table_name ref_source[:table_name]
+                  build_reference_schema(context, ref_source[:reference_schema])
+                  build_s3_reference_source(context, ref_source[:s3_reference_data_source])
+                end
+              end
+            end
+
+            def build_reference_schema(context, schema_config)
+              context.reference_schema do
+                context.record_encoding schema_config[:record_encoding] if schema_config[:record_encoding]
+                build_record_columns(context, schema_config[:record_columns])
+                build_record_format(context, schema_config[:record_format])
+              end
+            end
+
+            def build_s3_reference_source(context, s3_source)
+              return unless s3_source
+
+              context.s3_reference_data_source do
+                context.bucket_arn s3_source[:bucket_arn]
+                context.file_key s3_source[:file_key]
+              end
+            end
+
+            def build_record_columns(context, columns)
+              columns.each do |column|
+                context.record_column do
+                  context.name column[:name]
+                  context.sql_type column[:sql_type]
+                  context.mapping column[:mapping] if column[:mapping]
+                end
+              end
+            end
+
+            def build_record_format(context, format_config)
+              context.record_format do
+                context.record_format_type format_config[:record_format_type]
+                build_mapping_parameters(context, format_config[:mapping_parameters])
+              end
+            end
+
+            def build_mapping_parameters(context, mapping_params)
+              return unless mapping_params
+
+              context.mapping_parameters do
+                build_json_mapping(context, mapping_params[:json_mapping_parameters])
+                build_csv_mapping(context, mapping_params[:csv_mapping_parameters])
+              end
+            end
+
+            def build_json_mapping(context, json_params)
+              return unless json_params
+
+              context.json_mapping_parameters do
+                context.record_row_path json_params[:record_row_path]
+              end
+            end
+
+            def build_csv_mapping(context, csv_params)
+              return unless csv_params
+
+              context.csv_mapping_parameters do
+                context.record_row_delimiter csv_params[:record_row_delimiter]
+                context.record_column_delimiter csv_params[:record_column_delimiter]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# 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_kinesis_analytics_application/types'
+require 'pangea/resources/aws_kinesis_analytics_application/builders/application_code_builder'
+require 'pangea/resources/aws_kinesis_analytics_application/builders/flink_builder'
+require 'pangea/resources/aws_kinesis_analytics_application/builders/sql_builder'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Kinesis Analytics Application for real-time stream processing
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Kinesis Analytics Application attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_kinesis_analytics_application(name, attributes = {})
+        # Validate attributes using dry-struct
+        analytics_attrs = Types::KinesisAnalyticsApplicationAttributes.new(attributes)
+
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_kinesisanalyticsv2_application, name) do
+          name analytics_attrs.name
+          runtime_environment analytics_attrs.runtime_environment
+          service_execution_role analytics_attrs.service_execution_role
+          start_application analytics_attrs.start_application
+          description analytics_attrs.description if analytics_attrs.description
+
+          # Application configuration
+          build_application_configuration(self, analytics_attrs.application_configuration)
+
+          # Apply tags if present
+          build_aws_kinesis_analytics_application_tags(self, analytics_attrs.tags)
+        end
+
+        # Return resource reference with available outputs
+        build_aws_kinesis_analytics_application_resource_reference(name, analytics_attrs)
+      end
+
+      private
+
+      def build_application_configuration(context, app_config)
+        return unless app_config
+
+        context.application_configuration do
+          KinesisAnalyticsApplication::Builders::ApplicationCodeBuilder.build(
+            self, app_config[:application_code_configuration]
+          )
+          KinesisAnalyticsApplication::Builders::FlinkBuilder.build(
+            self, app_config[:flink_application_configuration]
+          )
+          KinesisAnalyticsApplication::Builders::SqlBuilder.build(
+            self, app_config[:sql_application_configuration]
+          )
+          build_environment_properties(self, app_config[:environment_properties])
+          build_vpc_configuration(self, app_config[:vpc_configuration])
+        end
+      end
+
+      def build_environment_properties(context, env_props)
+        return unless env_props
+
+        context.environment_properties do
+          groups_array = env_props[:property_groups].map do |prop_group|
+            {
+              property_group_id: prop_group[:property_group_id],
+              property_map: prop_group[:property_map]
+            }
+          end
+          property_group groups_array
+        end
+      end
+
+      def build_vpc_configuration(context, vpc_config)
+        return unless vpc_config
+
+        context.vpc_configuration do
+          subnet_ids vpc_config[:subnet_ids]
+          security_group_ids vpc_config[:security_group_ids]
+        end
+      end
+
+      def build_aws_kinesis_analytics_application_tags(context, tags)
+        return unless tags&.any?
+
+        context.tags do
+          tags.each do |key, value|
+            public_send(key, value)
+          end
+        end
+      end
+
+      def build_aws_kinesis_analytics_application_resource_reference(name, analytics_attrs)
+        ResourceReference.new(
+          type: 'aws_kinesisanalyticsv2_application',
+          name: name,
+          resource_attributes: analytics_attrs.to_h,
+          outputs: {
+            id: "${aws_kinesisanalyticsv2_application.#{name}.id}",
+            name: "${aws_kinesisanalyticsv2_application.#{name}.name}",
+            arn: "${aws_kinesisanalyticsv2_application.#{name}.arn}",
+            version_id: "${aws_kinesisanalyticsv2_application.#{name}.version_id}",
+            status: "${aws_kinesisanalyticsv2_application.#{name}.status}",
+            create_timestamp: "${aws_kinesisanalyticsv2_application.#{name}.create_timestamp}",
+            last_update_timestamp: "${aws_kinesisanalyticsv2_application.#{name}.last_update_timestamp}",
+            tags_all: "${aws_kinesisanalyticsv2_application.#{name}.tags_all}"
+          }
+        )
+      end
+    end
+  end
+end