pangea-aws 0.1.0

data/lib/pangea/resources/aws_batch_job_definition/types/templates.rb

@@ -0,0 +1,156 @@
+# 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
+        class BatchJobDefinitionAttributes
+          # Job definition templates
+          module Templates
+            def simple_container_job(name, image, options = {})
+              {
+                job_definition_name: name,
+                type: 'container',
+                container_properties: {
+                  image: image,
+                  vcpus: options[:vcpus] || 1,
+                  memory: options[:memory] || 512,
+                  job_role_arn: options[:job_role_arn]
+                }.compact,
+                retry_strategy: options[:retry_attempts] ? { attempts: options[:retry_attempts] } : nil,
+                timeout: options[:timeout_seconds] ? { attempt_duration_seconds: options[:timeout_seconds] } : nil,
+                platform_capabilities: options[:platform_capabilities],
+                tags: options[:tags] || {}
+              }.compact
+            end
+
+            def fargate_container_job(name, image, options = {})
+              {
+                job_definition_name: name,
+                type: 'container',
+                platform_capabilities: ['FARGATE'],
+                container_properties: {
+                  image: image,
+                  vcpus: options[:vcpus] || 1,
+                  memory: options[:memory] || 512,
+                  execution_role_arn: options[:execution_role_arn],
+                  job_role_arn: options[:job_role_arn],
+                  network_configuration: { assign_public_ip: options[:assign_public_ip] || 'DISABLED' },
+                  fargate_platform_configuration: { platform_version: options[:platform_version] || 'LATEST' }
+                }.compact,
+                retry_strategy: options[:retry_attempts] ? { attempts: options[:retry_attempts] } : nil,
+                timeout: options[:timeout_seconds] ? { attempt_duration_seconds: options[:timeout_seconds] } : nil,
+                tags: options[:tags] || {}
+              }.compact
+            end
+
+            def gpu_container_job(name, image, options = {})
+              {
+                job_definition_name: name,
+                type: 'container',
+                container_properties: {
+                  image: image,
+                  vcpus: options[:vcpus] || 4,
+                  memory: options[:memory] || 8192,
+                  job_role_arn: options[:job_role_arn],
+                  resource_requirements: [{ type: 'GPU', value: (options[:gpu_count] || 1).to_s }]
+                }.compact,
+                retry_strategy: options[:retry_attempts] ? { attempts: options[:retry_attempts] } : nil,
+                timeout: options[:timeout_seconds] ? { attempt_duration_seconds: options[:timeout_seconds] } : nil,
+                tags: (options[:tags] || {}).merge(Hardware: 'gpu'),
+                platform_capabilities: ['EC2']
+              }.compact
+            end
+
+            def multinode_job(name, image, num_nodes, options = {})
+              {
+                job_definition_name: name,
+                type: 'multinode',
+                node_properties: {
+                  main_node: options[:main_node] || 0,
+                  num_nodes: num_nodes,
+                  node_range_properties: [{
+                    target_nodes: "0:#{num_nodes - 1}",
+                    container: {
+                      image: image,
+                      vcpus: options[:vcpus] || 2,
+                      memory: options[:memory] || 2048,
+                      job_role_arn: options[:job_role_arn]
+                    }.compact
+                  }]
+                },
+                retry_strategy: options[:retry_attempts] ? { attempts: options[:retry_attempts] } : nil,
+                timeout: options[:timeout_seconds] ? { attempt_duration_seconds: options[:timeout_seconds] } : nil,
+                platform_capabilities: ['EC2'],
+                tags: (options[:tags] || {}).merge(Type: 'multinode')
+              }.compact
+            end
+
+            def data_processing_job(name, image, options = {})
+              simple_container_job(name, image, {
+                                     vcpus: options[:vcpus] || 2,
+                                     memory: options[:memory] || 4096,
+                                     retry_attempts: options[:retry_attempts] || 3,
+                                     timeout_seconds: options[:timeout_seconds] || 3600,
+                                     job_role_arn: options[:job_role_arn],
+                                     platform_capabilities: options[:platform_capabilities],
+                                     tags: (options[:tags] || {}).merge(Workload: 'data-processing', Type: 'cpu-intensive')
+                                   })
+            end
+
+            def ml_training_job(name, image, options = {})
+              gpu_container_job(name, image, {
+                                  vcpus: options[:vcpus] || 8,
+                                  memory: options[:memory] || 16_384,
+                                  gpu_count: options[:gpu_count] || 1,
+                                  retry_attempts: options[:retry_attempts] || 2,
+                                  timeout_seconds: options[:timeout_seconds] || 14_400,
+                                  job_role_arn: options[:job_role_arn],
+                                  tags: (options[:tags] || {}).merge(Workload: 'ml-training', Hardware: 'gpu', Type: 'gpu-intensive')
+                                })
+            end
+
+            def batch_processing_job(name, image, options = {})
+              simple_container_job(name, image, {
+                                     vcpus: options[:vcpus] || 1,
+                                     memory: options[:memory] || 1024,
+                                     retry_attempts: options[:retry_attempts] || 5,
+                                     timeout_seconds: options[:timeout_seconds] || 7200,
+                                     job_role_arn: options[:job_role_arn],
+                                     platform_capabilities: options[:platform_capabilities] || ['EC2'],
+                                     tags: (options[:tags] || {}).merge(Workload: 'batch-processing', Priority: 'background', Type: 'background')
+                                   })
+            end
+
+            def real_time_job(name, image, options = {})
+              fargate_container_job(name, image, {
+                                      vcpus: options[:vcpus] || 2,
+                                      memory: options[:memory] || 2048,
+                                      retry_attempts: options[:retry_attempts] || 1,
+                                      timeout_seconds: options[:timeout_seconds] || 300,
+                                      execution_role_arn: options[:execution_role_arn],
+                                      job_role_arn: options[:job_role_arn],
+                                      assign_public_ip: options[:assign_public_ip],
+                                      tags: (options[:tags] || {}).merge(Workload: 'real-time', Latency: 'critical', Type: 'latency-sensitive')
+                                    })
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# 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
+        class BatchJobDefinitionAttributes
+          # Validation methods for batch job definitions
+          module Validation
+            def self.validate_job_definition_name(name)
+              raise Dry::Struct::Error, 'Job definition name must be between 1 and 128 characters' if name.length < 1 || name.length > 128
+
+              raise Dry::Struct::Error, 'Job definition name can only contain letters, numbers, hyphens, and underscores' unless name.match?(/^[a-zA-Z0-9\-_]+$/)
+
+              true
+            end
+
+            def self.validate_container_properties(properties)
+              raise Dry::Struct::Error, 'Container properties must be a hash' unless properties.is_a?(::Hash)
+
+              raise Dry::Struct::Error, "Container properties must include a non-empty 'image' field" unless properties[:image] && properties[:image].is_a?(String) && !properties[:image].empty?
+
+              validate_vcpus(properties[:vcpus]) if properties[:vcpus]
+              validate_memory(properties[:memory]) if properties[:memory]
+              validate_role_arns(properties)
+              validate_environment_variables(properties[:environment]) if properties[:environment]
+              validate_mount_points(properties[:mount_points]) if properties[:mount_points]
+              validate_volumes(properties[:volumes]) if properties[:volumes]
+
+              true
+            end
+
+            def self.validate_vcpus(vcpus)
+              raise Dry::Struct::Error, 'vCPUs must be a positive integer' unless vcpus.is_a?(Integer) && vcpus.positive?
+            end
+
+            def self.validate_memory(memory)
+              raise Dry::Struct::Error, 'Memory must be a positive integer (MB)' unless memory.is_a?(Integer) && memory.positive?
+            end
+
+            def self.validate_role_arns(properties)
+              raise Dry::Struct::Error, 'Job role ARN must be a valid IAM role ARN' if properties[:job_role_arn] && !properties[:job_role_arn].match?(/^arn:aws:iam::/)
+
+              raise Dry::Struct::Error, 'Execution role ARN must be a valid IAM role ARN' if properties[:execution_role_arn] && !properties[:execution_role_arn].match?(/^arn:aws:iam::/)
+            end
+
+            def self.validate_node_properties(properties)
+              raise Dry::Struct::Error, 'Node properties must be a hash' unless properties.is_a?(::Hash)
+
+              raise Dry::Struct::Error, 'Node properties must include a non-negative main_node index' unless properties[:main_node] && properties[:main_node].is_a?(Integer) && properties[:main_node] >= 0
+
+              raise Dry::Struct::Error, 'Node properties must include a positive num_nodes value' unless properties[:num_nodes] && properties[:num_nodes].is_a?(Integer) && properties[:num_nodes].positive?
+
+              raise Dry::Struct::Error, 'Node properties must include node_range_properties array' unless properties[:node_range_properties] && properties[:node_range_properties].is_a?(Array)
+
+              validate_node_range_properties(properties[:node_range_properties])
+
+              true
+            end
+
+            def self.validate_node_range_properties(node_ranges)
+              node_ranges.each_with_index do |node_range, index|
+                raise Dry::Struct::Error, "Node range property #{index} must be a hash" unless node_range.is_a?(::Hash)
+
+                raise Dry::Struct::Error, "Node range property #{index} must include target_nodes string" unless node_range[:target_nodes] && node_range[:target_nodes].is_a?(String)
+
+                validate_container_properties(node_range[:container]) if node_range[:container]
+              end
+            end
+
+            def self.validate_environment_variables(env_vars)
+              raise Dry::Struct::Error, 'Environment variables must be an array' unless env_vars.is_a?(Array)
+
+              env_vars.each_with_index do |env_var, index|
+                raise Dry::Struct::Error, "Environment variable #{index} must have 'name' and 'value' fields" unless env_var.is_a?(::Hash) && env_var[:name] && env_var.key?(:value)
+              end
+
+              true
+            end
+
+            def self.validate_mount_points(mount_points)
+              raise Dry::Struct::Error, 'Mount points must be an array' unless mount_points.is_a?(Array)
+
+              mount_points.each_with_index do |mount_point, index|
+                raise Dry::Struct::Error, "Mount point #{index} must be a hash" unless mount_point.is_a?(::Hash)
+
+                %i[source_volume container_path].each do |field|
+                  raise Dry::Struct::Error, "Mount point #{index} must include non-empty '#{field}'" unless mount_point[field] && mount_point[field].is_a?(String) && !mount_point[field].empty?
+                end
+              end
+
+              true
+            end
+
+            def self.validate_volumes(volumes)
+              raise Dry::Struct::Error, 'Volumes must be an array' unless volumes.is_a?(Array)
+
+              volumes.each_with_index do |volume, index|
+                raise Dry::Struct::Error, "Volume #{index} must have a 'name' field" unless volume.is_a?(::Hash) && volume[:name] && volume[:name].is_a?(String)
+              end
+
+              true
+            end
+
+            def self.validate_retry_strategy(retry_strategy)
+              raise Dry::Struct::Error, 'Retry strategy must be a hash' unless retry_strategy.is_a?(::Hash)
+
+              if retry_strategy[:attempts]
+                raise Dry::Struct::Error, 'Retry attempts must be between 1 and 10' unless retry_strategy[:attempts].is_a?(Integer) && retry_strategy[:attempts] >= 1 && retry_strategy[:attempts] <= 10
+              end
+
+              true
+            end
+
+            def self.validate_timeout(timeout)
+              raise Dry::Struct::Error, 'Timeout must be a hash' unless timeout.is_a?(::Hash)
+
+              if timeout[:attempt_duration_seconds]
+                raise Dry::Struct::Error, 'Timeout duration must be at least 60 seconds' unless timeout[:attempt_duration_seconds].is_a?(Integer) && timeout[:attempt_duration_seconds] >= 60
+              end
+
+              true
+            end
+
+            def self.validate_platform_capabilities(capabilities)
+              raise Dry::Struct::Error, 'Platform capabilities must be an array' unless capabilities.is_a?(Array)
+
+              valid_capabilities = %w[EC2 FARGATE]
+              capabilities.each do |capability|
+                raise Dry::Struct::Error, "Invalid platform capability '#{capability}'. Valid: #{valid_capabilities.join(', ')}" unless valid_capabilities.include?(capability)
+              end
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# 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
+        # AWS Batch Job Definition attributes with validation
+        class BatchJobDefinitionAttributes < Pangea::Resources::BaseAttributes
+          require_relative 'types/validation'
+          require_relative 'types/computed'
+          require_relative 'types/templates'
+          require_relative 'types/configurations'
+
+          include Computed
+          extend Templates
+          extend Configurations
+
+          transform_keys(&:to_sym)
+
+          # Core attributes
+          attribute? :job_definition_name, Resources::Types::String.optional
+          attribute? :type, Resources::Types::String.optional
+
+          # Optional attributes
+          attribute? :container_properties, Resources::Types::Hash.optional
+          attribute? :node_properties, Resources::Types::Hash.optional
+          attribute? :retry_strategy, Resources::Types::Hash.optional
+          attribute? :timeout, Resources::Types::Hash.optional
+          attribute? :propagate_tags, Resources::Types::Bool.optional
+          attribute? :platform_capabilities, Resources::Types::Array.optional
+          attribute? :tags, Resources::Types::Hash.optional
+
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            validate_attributes(attrs)
+
+            super(attrs)
+          end
+
+          def self.validate_attributes(attrs)
+            raise Dry::Struct::Error, 'Job definition requires a type' unless attrs[:type]
+            raise Dry::Struct::Error, 'Job definition requires a job_definition_name' unless attrs[:job_definition_name]
+
+            Validation.validate_job_definition_name(attrs[:job_definition_name])
+
+            unless %w[container multinode].include?(attrs[:type])
+              raise Dry::Struct::Error, "Job definition type must be 'container' or 'multinode'"
+            end
+
+            if attrs[:type] == 'container'
+              raise Dry::Struct::Error, 'Container job requires container_properties' unless attrs[:container_properties]
+
+              Validation.validate_container_properties(attrs[:container_properties])
+            end
+
+            if attrs[:type] == 'multinode' && attrs[:node_properties]
+              Validation.validate_node_properties(attrs[:node_properties])
+            end
+
+            Validation.validate_retry_strategy(attrs[:retry_strategy]) if attrs[:retry_strategy]
+            Validation.validate_timeout(attrs[:timeout]) if attrs[:timeout]
+            Validation.validate_platform_capabilities(attrs[:platform_capabilities]) if attrs[:platform_capabilities]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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_relative 'types'
+
+module Pangea
+  module Resources
+    module AWS
+      # AWS Batch Job Queue implementation
+      # Provides type-safe function for creating job queues
+      def aws_batch_job_queue(name, attributes = {})
+        # Validate attributes using dry-struct
+        validated_attrs = Types::BatchJobQueueAttributes.new(attributes)
+        
+        # Create reference that will be returned
+        ref = ResourceReference.new(
+          type: 'aws_batch_job_queue',
+          name: name,
+          resource_attributes: validated_attrs.to_h,
+          outputs: {
+            id: "${aws_batch_job_queue.#{name}.id}",
+            arn: "${aws_batch_job_queue.#{name}.arn}",
+            name: "${aws_batch_job_queue.#{name}.name}",
+            state: "${aws_batch_job_queue.#{name}.state}",
+            priority: "${aws_batch_job_queue.#{name}.priority}",
+            tags_all: "${aws_batch_job_queue.#{name}.tags_all}"
+          }
+        )
+        
+        # Synthesize the Terraform resource
+        resource :aws_batch_job_queue, name do
+          name validated_attrs.name
+          state validated_attrs.state
+          priority validated_attrs.priority
+          
+          # Compute environment order
+          validated_attrs.compute_environment_order.each do |compute_env|
+            compute_environment_order do
+              order compute_env[:order]
+              compute_environment compute_env[:compute_environment]
+            end
+          end
+          
+          # Tags
+          if validated_attrs.tags
+            tags validated_attrs.tags
+          end
+        end
+        
+        # Return the reference
+        ref
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+require 'dry-struct'
+require 'pangea/resources/types'
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # AWS Batch Job Queue attributes with validation
+        class BatchJobQueueAttributes < Pangea::Resources::BaseAttributes
+          extend Pangea::Resources::AWS::Types::BatchJobQueueTemplates
+          transform_keys(&:to_sym)
+
+          attribute? :name, Resources::Types::String.optional
+          attribute? :state, Resources::Types::String.optional
+          attribute? :priority, Resources::Types::Integer.optional
+          attribute :compute_environment_order, Resources::Types::Array.default([].freeze)
+          attribute? :tags, Resources::Types::Hash.optional
+
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+
+            validate_job_queue_name(attrs[:name]) if attrs[:name]
+            raise Dry::Struct::Error, "Job queue state must be 'ENABLED' or 'DISABLED'" if attrs[:state] && !%w[ENABLED DISABLED].include?(attrs[:state])
+            validate_priority(attrs[:priority]) if attrs[:priority]
+            validate_compute_environment_order(attrs[:compute_environment_order]) if attrs[:compute_environment_order]
+
+            super(attrs)
+          end
+
+          def self.validate_job_queue_name(name)
+            raise Dry::Struct::Error, 'Job queue name must be between 1 and 128 characters' if name.length < 1 || name.length > 128
+            raise Dry::Struct::Error, 'Job queue name must start with an alphanumeric character' unless name.match?(/^[a-zA-Z0-9]/)
+            raise Dry::Struct::Error, 'Job queue name can only contain letters, numbers, hyphens, and underscores' unless name.match?(/^[a-zA-Z0-9\-_]+$/)
+
+            true
+          end
+
+          def self.validate_priority(priority)
+            raise Dry::Struct::Error, 'Job queue priority must be between 0 and 1000' if priority < 0 || priority > 1000
+
+            true
+          end
+
+          def self.validate_compute_environment_order(compute_envs)
+            raise Dry::Struct::Error, 'Compute environment order must be a non-empty array' unless compute_envs.is_a?(Array) && !compute_envs.empty?
+
+            compute_envs.each_with_index do |env, index|
+              raise Dry::Struct::Error, "Compute environment order item #{index} must be a hash" unless env.is_a?(::Hash)
+              raise Dry::Struct::Error, "Compute environment order item #{index} must have 'order' and 'compute_environment' fields" unless env[:order] && env[:compute_environment]
+              raise Dry::Struct::Error, 'Compute environment order must be a non-negative integer' unless env[:order].is_a?(Integer) && env[:order] >= 0
+              raise Dry::Struct::Error, 'Compute environment must be a non-empty string' unless env[:compute_environment].is_a?(String) && !env[:compute_environment].empty?
+            end
+
+            orders = compute_envs.map { |env| env[:order] }
+            raise Dry::Struct::Error, 'Compute environment orders must be unique' if orders.uniq.length != orders.length
+
+            true
+          end
+
+          def is_enabled? = state == 'ENABLED'
+          def is_disabled? = state == 'DISABLED'
+          def high_priority? = priority >= 750
+          def medium_priority? = priority >= 250 && priority < 750
+          def low_priority? = priority < 250
+          def compute_environment_count = compute_environment_order.length
+          def primary_compute_environment = compute_environment_order.min_by { |env| env[:order] }
+          def ordered_compute_environments = compute_environment_order.sort_by { |env| env[:order] }
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_batch_job_queue/types/templates.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Copyright 2025 The Pangea Authors. Licensed under Apache 2.0.
+
+module Pangea
+  module Resources
+    module AWS
+      module Types
+        # Queue configuration templates for AWS Batch Job Queue
+        module BatchJobQueueTemplates
+          module_function
+          PRIORITY_LEVELS = {
+            critical: 1000,
+            high: 900,
+            medium_high: 750,
+            medium: 500,
+            medium_low: 250,
+            low: 100,
+            background: 1
+          }.freeze
+
+          def priority_levels = PRIORITY_LEVELS
+          def critical_priority = PRIORITY_LEVELS[:critical]
+          def high_priority = PRIORITY_LEVELS[:high]
+          def medium_priority = PRIORITY_LEVELS[:medium]
+          def low_priority = PRIORITY_LEVELS[:low]
+          def background_priority = PRIORITY_LEVELS[:background]
+
+          def high_priority_queue(name, compute_environments, options = {})
+            {
+              name: name,
+              state: options[:state] || 'ENABLED',
+              priority: options[:priority] || 900,
+              compute_environment_order: build_compute_environment_order(compute_environments),
+              tags: (options[:tags] || {}).merge(Priority: 'high')
+            }
+          end
+
+          def medium_priority_queue(name, compute_environments, options = {})
+            {
+              name: name,
+              state: options[:state] || 'ENABLED',
+              priority: options[:priority] || 500,
+              compute_environment_order: build_compute_environment_order(compute_environments),
+              tags: (options[:tags] || {}).merge(Priority: 'medium')
+            }
+          end
+
+          def low_priority_queue(name, compute_environments, options = {})
+            {
+              name: name,
+              state: options[:state] || 'ENABLED',
+              priority: options[:priority] || 100,
+              compute_environment_order: build_compute_environment_order(compute_environments),
+              tags: (options[:tags] || {}).merge(Priority: 'low')
+            }
+          end
+
+          def mixed_compute_queue(name, compute_env_configs, options = {})
+            compute_order = compute_env_configs.map.with_index do |config, index|
+              { order: config[:order] || index, compute_environment: config[:env] || config[:compute_environment] }
+            end
+
+            { name: name, state: options[:state] || 'ENABLED', priority: options[:priority] || 500, compute_environment_order: compute_order, tags: options[:tags] || {} }
+          end
+
+          def build_compute_environment_order(compute_environments)
+            case compute_environments
+            when String
+              [{ order: 1, compute_environment: compute_environments }]
+            when Array
+              if compute_environments.first.is_a?(String)
+                compute_environments.map.with_index { |env, index| { order: index + 1, compute_environment: env } }
+              else
+                compute_environments
+              end
+            when Hash
+              [compute_environments]
+            else
+              raise Dry::Struct::Error, 'Invalid compute environment configuration'
+            end
+          end
+
+          def queue_naming_patterns
+            {
+              production: ->(workload) { "prod-#{workload}-queue" },
+              staging: ->(workload) { "staging-#{workload}-queue" },
+              development: ->(workload) { "dev-#{workload}-queue" },
+              priority_based: ->(priority, workload) { "#{priority}-priority-#{workload}-queue" },
+              team_based: ->(team, workload) { "#{team}-#{workload}-queue" },
+              environment_based: ->(env, priority, workload) { "#{env}-#{priority}-#{workload}-queue" }
+            }
+          end
+
+          def data_processing_queue(name, compute_environments, priority = :medium, options = {})
+            { name: name, state: 'ENABLED', priority: PRIORITY_LEVELS[priority] || priority, compute_environment_order: build_compute_environment_order(compute_environments), tags: (options[:tags] || {}).merge(Workload: 'data-processing', Type: 'batch', Priority: priority.to_s) }
+          end
+
+          def ml_training_queue(name, compute_environments, options = {})
+            { name: name, state: 'ENABLED', priority: options[:priority] || PRIORITY_LEVELS[:high], compute_environment_order: build_compute_environment_order(compute_environments), tags: (options[:tags] || {}).merge(Workload: 'ml-training', Type: 'gpu-intensive', Priority: 'high') }
+          end
+
+          def batch_processing_queue(name, compute_environments, options = {})
+            { name: name, state: 'ENABLED', priority: options[:priority] || PRIORITY_LEVELS[:medium_low], compute_environment_order: build_compute_environment_order(compute_environments), tags: (options[:tags] || {}).merge(Workload: 'batch-processing', Type: 'background', Priority: 'medium-low') }
+          end
+
+          def real_time_queue(name, compute_environments, options = {})
+            { name: name, state: 'ENABLED', priority: options[:priority] || PRIORITY_LEVELS[:critical], compute_environment_order: build_compute_environment_order(compute_environments), tags: (options[:tags] || {}).merge(Workload: 'real-time', Type: 'latency-sensitive', Priority: 'critical') }
+          end
+
+          def environment_queue_set(base_name, compute_environments_by_env, options = {})
+            priorities = { production: :high, staging: :medium, development: :low }
+            queues = {}
+
+            %i[production staging development].each do |env|
+              next unless compute_environments_by_env[env]
+
+              queues[env] = {
+                name: "#{env}-#{base_name}-queue",
+                state: 'ENABLED',
+                priority: PRIORITY_LEVELS[priorities[env]],
+                compute_environment_order: build_compute_environment_order(compute_environments_by_env[env]),
+                tags: (options[:tags] || {}).merge(Environment: env.to_s, Priority: priorities[env].to_s, Workload: base_name)
+              }
+            end
+
+            queues
+          end
+        end
+      end
+    end
+  end
+end