pangea-aws 0.1.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pangea
+  module Resources
+    module AWS
+      class GlueJobAttributes < Dry::Struct
+        @attributes: Hash[Symbol, untyped]
+        
+        attr_reader name: String
+        attr_reader role_arn: String
+        attr_reader description: String?
+        attr_reader glue_version: String?
+        attr_reader command: Hash[Symbol, untyped]
+        attr_reader default_arguments: Hash[String, String]
+        attr_reader non_overridable_arguments: Hash[String, String]
+        attr_reader connections: Array[String]
+        attr_reader max_capacity: Float?
+        attr_reader worker_type: String?
+        attr_reader number_of_workers: Integer?
+        attr_reader timeout: Integer?
+        attr_reader max_retries: Integer?
+        attr_reader security_configuration: String?
+        attr_reader notification_property: Hash[Symbol, Integer?]?
+        attr_reader execution_property: Hash[Symbol, Integer?]
+        attr_reader tags: Hash[Symbol, String]
+        
+        def self.new: (Hash[Symbol, untyped] attributes) -> GlueJobAttributes
+        
+        # Query methods
+        def uses_worker_configuration?: () -> bool
+        def is_streaming_job?: () -> bool
+        def is_python_shell_job?: () -> bool
+        def is_etl_job?: () -> bool
+        
+        # Computed properties
+        def effective_glue_version: () -> String
+        def effective_python_version: () -> String
+        def estimated_dpu_capacity: () -> Float
+        def estimated_hourly_cost_usd: () -> Float
+        def configuration_warnings: () -> Array[String]
+        
+        # Class methods for defaults and recommendations
+        def self.default_arguments_for_job_type: (String | Symbol job_type, ?Hash[Symbol, String] options) -> Hash[String, String]
+        def self.worker_recommendations_for_workload: (String | Symbol workload_type, ?Integer? data_size_gb) -> Hash[Symbol, untyped]
+        
+        def to_h: () -> Hash[Symbol, untyped]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# 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_glue_trigger/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS Glue Trigger with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] Glue Trigger attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_glue_trigger(name, attributes = {})
+        # Validate attributes using dry-struct
+        trigger_attrs = Types::GlueTriggerAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_glue_trigger, name) do
+          # Required attributes
+          trigger_name = trigger_attrs.name
+          type trigger_attrs.type
+          
+          # Description
+          description trigger_attrs.description if trigger_attrs.description
+          
+          # Enable/disable
+          enabled trigger_attrs.enabled
+          
+          # Schedule for SCHEDULED triggers
+          if trigger_attrs.is_scheduled?
+            schedule trigger_attrs.schedule
+            start_on_creation trigger_attrs.start_on_creation unless trigger_attrs.start_on_creation.nil?
+          end
+          
+          # Workflow name if specified
+          workflow_name trigger_attrs.workflow_name if trigger_attrs.workflow_name
+          
+          # Actions
+          trigger_attrs.actions.each do |action|
+            actions do
+              if action[:job_name]
+                job_name action[:job_name]
+                
+                if action[:arguments]&.any?
+                  arguments do
+                    action[:arguments].each do |key, value|
+                      public_send(key.to_s.gsub(/[^a-zA-Z0-9_]/, '_').downcase, value)
+                    end
+                  end
+                end
+                
+                timeout action[:timeout] if action[:timeout]
+                security_configuration action[:security_configuration] if action[:security_configuration]
+                
+                if action[:notification_property]
+                  notification_property do
+                    np = action[:notification_property]
+                    notify_delay_after np[:notify_delay_after] if np[:notify_delay_after]
+                  end
+                end
+              elsif action[:crawler_name]
+                crawler_name action[:crawler_name]
+              end
+            end
+          end
+          
+          # Predicate for CONDITIONAL triggers
+          if trigger_attrs.is_conditional? && trigger_attrs.predicate
+            predicate do
+              pred = trigger_attrs.predicate
+              logical pred[:logical] if pred[:logical]
+              
+              if pred[:conditions]&.any?
+                pred[:conditions].each do |condition|
+                  conditions do
+                    logical_operator condition[:logical_operator] if condition[:logical_operator]
+                    
+                    if condition[:job_name]
+                      job_name condition[:job_name]
+                      state condition[:state] if condition[:state]
+                    elsif condition[:crawler_name]
+                      crawler_name condition[:crawler_name]
+                      crawl_state condition[:crawl_state] if condition[:crawl_state]
+                    end
+                  end
+                end
+              end
+            end
+          end
+          
+          # Event batching condition
+          if trigger_attrs.event_batching_condition
+            event_batching_condition do
+              ebc = trigger_attrs.event_batching_condition
+              batch_size ebc[:batch_size]
+              batch_window ebc[:batch_window] if ebc[:batch_window]
+            end
+          end
+          
+          # Apply tags if present
+          if trigger_attrs.tags&.any?
+            tags do
+              trigger_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_glue_trigger',
+          name: name,
+          resource_attributes: trigger_attrs.to_h,
+          outputs: {
+            id: "${aws_glue_trigger.#{name}.id}",
+            name: "${aws_glue_trigger.#{name}.name}",
+            arn: "${aws_glue_trigger.#{name}.arn}",
+            state: "${aws_glue_trigger.#{name}.state}"
+          },
+          computed_properties: {
+            is_scheduled: trigger_attrs.is_scheduled?,
+            is_conditional: trigger_attrs.is_conditional?,
+            is_on_demand: trigger_attrs.is_on_demand?,
+            is_workflow_trigger: trigger_attrs.is_workflow_trigger?,
+            total_actions: trigger_attrs.total_actions,
+            job_actions_count: trigger_attrs.job_actions.size,
+            crawler_actions_count: trigger_attrs.crawler_actions.size,
+            condition_count: trigger_attrs.condition_count,
+            schedule_frequency: trigger_attrs.schedule_frequency,
+            estimated_executions_per_day: trigger_attrs.estimated_executions_per_day,
+            configuration_warnings: trigger_attrs.configuration_warnings
+          }
+        )
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_glue_trigger/types/attributes.rb

@@ -0,0 +1,91 @@
+# 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
+        module GlueTriggerTypes
+          # Core attribute definitions for AWS Glue Trigger resources
+          module Attributes
+            def self.included(base)
+              base.class_eval do
+                # Trigger name (required)
+                attribute? :name, Resources::Types::String.optional
+
+                # Trigger type (required)
+                attribute? :type, Resources::Types::String.constrained(included_in: ["SCHEDULED", "CONDITIONAL", "ON_DEMAND"]).optional
+
+                # Trigger description
+                attribute? :description, Resources::Types::String.optional
+
+                # Enable/disable trigger
+                attribute :enabled, Resources::Types::Bool.default(true)
+
+                # Schedule expression for SCHEDULED triggers
+                attribute? :schedule, Resources::Types::String.optional
+
+                # Start time for scheduled triggers
+                attribute? :start_on_creation, Resources::Types::Bool.optional
+
+                # Workflow name if part of workflow
+                attribute? :workflow_name, Resources::Types::String.optional
+
+                # Actions to execute when trigger fires
+                attribute? :actions, Resources::Types::Array.of(
+                  Resources::Types::Hash.schema(
+                    job_name?: Resources::Types::String.optional,
+                    crawler_name?: Resources::Types::String.optional,
+                    arguments?: Resources::Types::Hash.map(Resources::Types::String, Resources::Types::String).optional,
+                    timeout?: Resources::Types::Integer.optional,
+                    security_configuration?: Resources::Types::String.optional,
+                    notification_property?: Resources::Types::Hash.schema(
+                      notify_delay_after?: Resources::Types::Integer.optional
+                    ).lax.optional
+                  )
+                ).default([].freeze)
+
+                # Predicate for CONDITIONAL triggers
+                attribute? :predicate, Resources::Types::Hash.schema(
+                  logical?: Resources::Types::String.constrained(included_in: ["AND", "ANY"]).optional,
+                  conditions?: Resources::Types::Array.of(
+                    Resources::Types::Hash.schema(
+                      logical_operator?: Resources::Types::String.constrained(included_in: ["EQUALS"]).optional,
+                      job_name?: Resources::Types::String.optional,
+                      state?: Resources::Types::String.constrained(included_in: ["SUCCEEDED", "STOPPED", "FAILED", "TIMEOUT"]).optional,
+                      crawler_name?: Resources::Types::String.optional,
+                      crawl_state?: Resources::Types::String.constrained(included_in: ["SUCCEEDED", "CANCELLED", "FAILED"]).optional
+                    ).lax
+                  ).optional
+                ).optional
+
+                # Event batching configuration
+                attribute? :event_batching_condition, Resources::Types::Hash.schema(
+                  batch_size: Resources::Types::Integer.constrained(gteq: 1, lteq: 100),
+                  batch_window?: Resources::Types::Integer.constrained(gteq: 900, lteq: 900).optional
+                ).lax.optional
+
+                # Tags
+                attribute :tags, Resources::Types::AwsTags.default({}.freeze)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_glue_trigger/types/helpers/class_methods.rb

@@ -0,0 +1,109 @@
+# 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 Types
+        module GlueTriggerTypes
+          module HelpersModules
+            # Class methods for AWS Glue Trigger attributes
+            module ClassMethods
+              # Generate common schedule expressions
+              def schedule_expressions
+                {
+                  # Rate expressions
+                  every_5_minutes: "rate(5 minutes)",
+                  every_15_minutes: "rate(15 minutes)",
+                  every_30_minutes: "rate(30 minutes)",
+                  hourly: "rate(1 hour)",
+                  every_2_hours: "rate(2 hours)",
+                  every_6_hours: "rate(6 hours)",
+                  every_12_hours: "rate(12 hours)",
+                  daily: "rate(1 day)",
+                  weekly: "rate(7 days)",
+
+                  # Cron expressions for common patterns
+                  daily_at_midnight: "cron(0 0 * * ? *)",
+                  daily_at_6am: "cron(0 6 * * ? *)",
+                  daily_at_noon: "cron(0 12 * * ? *)",
+                  weekdays_at_9am: "cron(0 9 ? * MON-FRI *)",
+                  weekends_at_10am: "cron(0 10 ? * SAT,SUN *)",
+                  first_day_of_month: "cron(0 0 1 * ? *)",
+                  last_day_of_month: "cron(0 0 L * ? *)",
+
+                  # Business hours patterns
+                  business_hours_hourly: "cron(0 9-17 ? * MON-FRI *)",
+                  business_days_morning: "cron(0 9 ? * MON-FRI *)",
+                  business_days_evening: "cron(0 18 ? * MON-FRI *)"
+                }
+              end
+
+              # Generate predicate for common conditional patterns
+              def predicate_for_job_success(job_names)
+                job_names = Array(job_names)
+                conditions = job_names.map do |job_name|
+                  {
+                    logical_operator: "EQUALS",
+                    job_name: job_name,
+                    state: "SUCCEEDED"
+                  }
+                end
+
+                {
+                  logical: job_names.size > 1 ? "AND" : "ANY",
+                  conditions: conditions
+                }
+              end
+
+              def predicate_for_crawler_success(crawler_names)
+                crawler_names = Array(crawler_names)
+                conditions = crawler_names.map do |crawler_name|
+                  {
+                    logical_operator: "EQUALS",
+                    crawler_name: crawler_name,
+                    crawl_state: "SUCCEEDED"
+                  }
+                end
+
+                {
+                  logical: crawler_names.size > 1 ? "AND" : "ANY",
+                  conditions: conditions
+                }
+              end
+
+              # Generate action configurations
+              def action_for_job(job_name, options = {})
+                {
+                  job_name: job_name,
+                  arguments: options[:arguments] || {},
+                  timeout: options[:timeout],
+                  security_configuration: options[:security_configuration],
+                  notification_property: options[:notification_property]
+                }.compact
+              end
+
+              def action_for_crawler(crawler_name, _options = {})
+                {
+                  crawler_name: crawler_name
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_glue_trigger/types/helpers/instance_methods.rb

@@ -0,0 +1,140 @@
+# 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 Types
+        module GlueTriggerTypes
+          module HelpersModules
+            # Instance methods for AWS Glue Trigger attributes
+            module InstanceMethods
+              # Check if trigger is scheduled
+              def is_scheduled?
+                type == "SCHEDULED"
+              end
+
+              # Check if trigger is conditional
+              def is_conditional?
+                type == "CONDITIONAL"
+              end
+
+              # Check if trigger is on-demand
+              def is_on_demand?
+                type == "ON_DEMAND"
+              end
+
+              # Check if trigger is part of workflow
+              def is_workflow_trigger?
+                !workflow_name.nil?
+              end
+
+              # Get job actions
+              def job_actions
+                actions.select { |action| action[:job_name] }
+              end
+
+              # Get crawler actions
+              def crawler_actions
+                actions.select { |action| action[:crawler_name] }
+              end
+
+              # Get total action count
+              def total_actions
+                actions.size
+              end
+
+              # Get condition count for conditional triggers
+              def condition_count
+                return 0 unless is_conditional?
+                predicate&.dig(:conditions)&.size || 0
+              end
+
+              # Get schedule frequency (for scheduled triggers)
+              def schedule_frequency
+                return nil unless is_scheduled?
+                return nil unless schedule
+
+                case schedule
+                when /rate\((\d+)\s+(minute|minutes)\)/
+                  { type: "minutes", value: $1.to_i }
+                when /rate\((\d+)\s+(hour|hours)\)/
+                  { type: "hours", value: $1.to_i }
+                when /rate\((\d+)\s+(day|days)\)/
+                  { type: "days", value: $1.to_i }
+                when /cron\(/
+                  { type: "cron", expression: schedule }
+                else
+                  { type: "unknown", expression: schedule }
+                end
+              end
+
+              # Estimate trigger execution frequency per day
+              def estimated_executions_per_day
+                return 0 unless is_scheduled?
+
+                freq = schedule_frequency
+                return 1 unless freq
+
+                case freq[:type]
+                when "minutes"
+                  (24 * 60) / freq[:value]
+                when "hours"
+                  24 / freq[:value]
+                when "days"
+                  1.0 / freq[:value]
+                when "cron"
+                  # Complex cron expressions are hard to calculate
+                  1
+                else
+                  1
+                end
+              end
+
+              # Check if trigger configuration is optimal
+              def configuration_warnings
+                warnings = []
+
+                if is_scheduled? && estimated_executions_per_day > 1440
+                  warnings << "Very frequent scheduling (>1440/day) may impact costs and performance"
+                end
+
+                if is_conditional? && condition_count > 10
+                  warnings << "Large number of conditions may impact trigger evaluation performance"
+                end
+
+                if total_actions > 20
+                  warnings << "Large number of actions may impact trigger execution time"
+                end
+
+                if is_scheduled? && !start_on_creation
+                  warnings << "Consider setting start_on_creation=true for immediate scheduling"
+                end
+
+                job_actions.each do |action|
+                  unless action[:timeout]
+                    warnings << "Consider setting timeout for job actions to prevent long-running jobs"
+                  end
+                end
+
+                warnings
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_glue_trigger/types/helpers.rb

@@ -0,0 +1,35 @@
+# 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_relative 'helpers/instance_methods'
+require_relative 'helpers/class_methods'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        module GlueTriggerTypes
+          # Helper methods for AWS Glue Trigger resources
+          module Helpers
+            def self.included(base)
+              base.include(HelpersModules::InstanceMethods)
+              base.extend(HelpersModules::ClassMethods)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_glue_trigger/types/validation.rb

@@ -0,0 +1,97 @@
+# 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 Types
+        module GlueTriggerTypes
+          # Validation logic for AWS Glue Trigger resources
+          module Validation
+            def self.included(base)
+              base.extend(ClassMethods)
+            end
+
+            module ClassMethods
+              # Custom validation for trigger attributes
+              def new(attributes = {})
+                attrs = super(attributes)
+                validate_trigger_name(attrs)
+                validate_schedule(attrs)
+                validate_predicate(attrs)
+                validate_actions(attrs)
+                attrs
+              end
+
+              private
+
+              def validate_trigger_name(attrs)
+                # Validate trigger name format
+                unless attrs.name =~ /\A[a-zA-Z_][a-zA-Z0-9_-]*\z/
+                  raise Dry::Struct::Error, "Trigger name must start with letter or underscore and contain only alphanumeric characters, underscores, and hyphens"
+                end
+
+                # Validate trigger name length
+                if attrs.name.length > 255
+                  raise Dry::Struct::Error, "Trigger name must be 255 characters or less"
+                end
+              end
+
+              def validate_schedule(attrs)
+                return unless attrs.type == "SCHEDULED"
+
+                unless attrs.schedule
+                  raise Dry::Struct::Error, "Schedule expression is required for SCHEDULED triggers"
+                end
+
+                # Validate schedule format (cron or rate expressions)
+                schedule = attrs.schedule
+                unless schedule.match(/\A(cron|rate)\(/) || schedule.match(/\Aat\(/)
+                  raise Dry::Struct::Error, "Schedule must be a valid cron() or rate() expression"
+                end
+              end
+
+              def validate_predicate(attrs)
+                return unless attrs.type == "CONDITIONAL"
+
+                unless attrs.predicate && attrs.predicate&.dig(:conditions)&.any?
+                  raise Dry::Struct::Error, "Predicate with conditions is required for CONDITIONAL triggers"
+                end
+              end
+
+              def validate_actions(attrs)
+                # Validate actions are present
+                unless attrs.actions.any?
+                  raise Dry::Struct::Error, "At least one action must be specified"
+                end
+
+                # Validate each action has either job_name or crawler_name
+                attrs.actions.each_with_index do |action, index|
+                  unless action[:job_name] || action[:crawler_name]
+                    raise Dry::Struct::Error, "Action #{index} must specify either job_name or crawler_name"
+                  end
+
+                  if action[:job_name] && action[:crawler_name]
+                    raise Dry::Struct::Error, "Action #{index} cannot specify both job_name and crawler_name"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end