pangea-aws 0.1.0

data/lib/pangea/resources/aws_codeartifact_repository/resource.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/base'
+require 'pangea/resources/reference'
+require 'pangea/resources/aws_codeartifact_repository/types'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS CodeArtifact Repository with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] CodeArtifact Repository attributes
+      # @option attributes [String] :repository The name of the repository
+      # @option attributes [String] :domain The domain containing the repository
+      # @option attributes [String] :format The package format (npm, pypi, maven, nuget)
+      # @option attributes [String] :domain_owner The domain owner (AWS account ID)
+      # @option attributes [String] :description Description of the repository
+      # @option attributes [Array<Hash>] :upstream Upstream repository configurations
+      # @option attributes [Hash] :external_connections External connection configuration
+      # @option attributes [Hash] :tags Tags to apply to the repository
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      #
+      # @example Basic npm repository
+      #   npm_repo = aws_codeartifact_repository(:npm_packages, {
+      #     repository: "npm-packages",
+      #     domain: codeartifact_domain.domain,
+      #     format: "npm",
+      #     description: "Internal npm packages",
+      #     tags: {
+      #       Format: "npm",
+      #       Team: "frontend"
+      #     }
+      #   })
+      #
+      # @example Python repository with external connection
+      #   pypi_repo = aws_codeartifact_repository(:python_packages, {
+      #     repository: "python-packages",
+      #     domain: codeartifact_domain.domain,
+      #     format: "pypi",
+      #     description: "Python packages with PyPI proxy",
+      #     external_connections: {
+      #       external_connection_name: "public:pypi"
+      #     },
+      #     tags: {
+      #       Format: "pypi",
+      #       Team: "backend"
+      #     }
+      #   })
+      #
+      # @example Maven repository with upstream
+      #   maven_repo = aws_codeartifact_repository(:maven_packages, {
+      #     repository: "maven-packages", 
+      #     domain: codeartifact_domain.domain,
+      #     format: "maven",
+      #     description: "Maven packages with upstream",
+      #     upstream: [
+      #       {
+      #         repository_name: maven_central_proxy.repository
+      #       }
+      #     ],
+      #     tags: {
+      #       Format: "maven",
+      #       Team: "platform"
+      #     }
+      #   })
+      #
+      # @example Cross-account repository
+      #   cross_account_repo = aws_codeartifact_repository(:shared_packages, {
+      #     repository: "shared-packages",
+      #     domain: "shared-domain",
+      #     domain_owner: "123456789012",
+      #     format: "npm",
+      #     description: "Shared packages from central account",
+      #     tags: {
+      #       Usage: "shared",
+      #       Source: "central-account"
+      #     }
+      #   })
+      def aws_codeartifact_repository(name, attributes = {})
+        # Validate attributes using dry-struct
+        repo_attrs = Types::CodeArtifactRepositoryAttributes.new(attributes)
+        
+        # Generate terraform resource block via terraform-synthesizer
+        resource(:aws_codeartifact_repository, name) do
+          # Repository name
+          repository repo_attrs.repository
+          
+          # Domain reference
+          domain repo_attrs.domain
+          
+          # Package format
+          format repo_attrs.format
+          
+          # Optional domain owner
+          domain_owner repo_attrs.domain_owner if repo_attrs.domain_owner
+          
+          # Optional description
+          description repo_attrs.description if repo_attrs.description
+          
+          # Upstream repositories
+          if repo_attrs.upstream&.any?
+            repo_attrs.upstream.each do |upstream_config|
+              upstream do
+                repository_name upstream_config[:repository_name]
+              end
+            end
+          end
+          
+          # External connections
+          if repo_attrs.external_connections && repo_attrs.external_connections&.dig(:external_connection_name)
+            external_connections do
+              external_connection_name repo_attrs.external_connections&.dig(:external_connection_name)
+            end
+          end
+          
+          # Apply tags if present
+          if repo_attrs.tags&.any?
+            tags do
+              repo_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+        
+        # Return resource reference with available outputs
+        ResourceReference.new(
+          type: 'aws_codeartifact_repository',
+          name: name,
+          resource_attributes: repo_attrs.to_h,
+          outputs: {
+            arn: "${aws_codeartifact_repository.#{name}.arn}",
+            repository: "${aws_codeartifact_repository.#{name}.repository}",
+            domain: "${aws_codeartifact_repository.#{name}.domain}",
+            domain_owner: "${aws_codeartifact_repository.#{name}.domain_owner}",
+            format: "${aws_codeartifact_repository.#{name}.format}",
+            description: "${aws_codeartifact_repository.#{name}.description}",
+            administrator_account: "${aws_codeartifact_repository.#{name}.administrator_account}",
+            tags_all: "${aws_codeartifact_repository.#{name}.tags_all}"
+          },
+          computed_properties: {
+            has_upstream_repositories: repo_attrs.has_upstream_repositories?,
+            upstream_count: repo_attrs.upstream_count,
+            has_external_connection: repo_attrs.has_external_connection?,
+            external_connection_type: repo_attrs.external_connection_type,
+            supports_external_connection: repo_attrs.supports_external_connection?,
+            is_private_repository: repo_attrs.is_private_repository?,
+            is_public_proxy_repository: repo_attrs.is_public_proxy_repository?,
+            package_manager_config_command: repo_attrs.package_manager_config_command,
+            estimated_monthly_cost_per_gb: repo_attrs.estimated_monthly_cost_per_gb,
+            repository_endpoint_template: repo_attrs.repository_endpoint_template
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# 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
+        # CodeArtifact Repository resource attributes with validation
+        class CodeArtifactRepositoryAttributes < Pangea::Resources::BaseAttributes
+          transform_keys(&:to_sym)
+          
+          # Required attributes
+          attribute? :repository, Resources::Types::String.optional
+          attribute? :domain, Resources::Types::String.optional
+          attribute? :format, Resources::Types::String.constrained(included_in: ['npm', 'pypi', 'maven', 'nuget']).optional
+          
+          # Optional attributes
+          attribute :domain_owner, Resources::Types::String.optional.default(nil)
+          attribute :description, Resources::Types::String.optional.default(nil)
+          attribute? :upstream, Resources::Types::Array.of(
+            Resources::Types::Hash.schema(
+              repository_name: Resources::Types::String
+            ).lax
+          ).default([].freeze)
+          attribute? :external_connections, Resources::Types::Hash.schema(
+            external_connection_name?: Resources::Types::String.optional
+          ).lax.optional.default(nil)
+          attribute? :tags, Resources::Types::AwsTags.optional
+          
+          # Validate attributes
+          def self.new(attributes)
+            attrs = attributes.is_a?(::Hash) ? attributes : {}
+            
+            # Validate repository name
+            if attrs[:repository]
+              repo = attrs[:repository]
+              unless repo.match?(/^[a-zA-Z0-9][a-zA-Z0-9._\-]{1,98}[a-zA-Z0-9]$/)
+                raise Dry::Struct::Error, "repository must be 2-100 characters, start and end with alphanumeric, contain only letters, numbers, dots, hyphens, underscores"
+              end
+              
+              if repo.length < 2 || repo.length > 100
+                raise Dry::Struct::Error, "repository must be between 2 and 100 characters"
+              end
+            end
+            
+            # Validate domain name (allow terraform references)
+            if attrs[:domain] && !attrs[:domain].match?(/^\$\{/)
+              domain = attrs[:domain]
+              unless domain.match?(/^[a-z][a-z0-9\-]{1,48}[a-z0-9]$/)
+                raise Dry::Struct::Error, "domain must be 2-50 characters, start with letter, end with letter or number, contain only lowercase letters, numbers, and hyphens"
+              end
+            end
+            
+            # Validate domain_owner if provided
+            if attrs[:domain_owner] && !attrs[:domain_owner].empty?
+              owner = attrs[:domain_owner]
+              unless owner.match?(/^\d{12}$/) || owner.match?(/^\$\{/)
+                raise Dry::Struct::Error, "domain_owner must be a 12-digit AWS account ID or terraform reference"
+              end
+            end
+            
+            # Validate external connections based on format
+            if attrs[:external_connections] && attrs[:format]
+              format = attrs[:format]
+              ext_conn = attrs[:external_connections][:external_connection_name]
+              
+              if ext_conn
+                valid_connections = {
+                  'npm' => 'public:npmjs',
+                  'pypi' => 'public:pypi',
+                  'maven' => 'public:maven-central',
+                  'nuget' => 'public:nuget-org'
+                }
+                
+                unless ext_conn == valid_connections[format]
+                  raise Dry::Struct::Error, "external_connection_name for #{format} must be '#{valid_connections[format]}'"
+                end
+              end
+            end
+            
+            super(attrs)
+          end
+          
+          # Computed properties
+          def repository_endpoint_template(region = 'us-east-1')
+            case format
+            when 'npm'
+              "https://#{domain}-#{domain_owner || '${data.aws_caller_identity.current.account_id}'}.d.codeartifact.#{region}.amazonaws.com/npm/#{repository}/"
+            when 'pypi'
+              "https://#{domain}-#{domain_owner || '${data.aws_caller_identity.current.account_id}'}.d.codeartifact.#{region}.amazonaws.com/pypi/#{repository}/simple/"
+            when 'maven'
+              "https://#{domain}-#{domain_owner || '${data.aws_caller_identity.current.account_id}'}.d.codeartifact.#{region}.amazonaws.com/maven/#{repository}/"
+            when 'nuget'
+              "https://#{domain}-#{domain_owner || '${data.aws_caller_identity.current.account_id}'}.d.codeartifact.#{region}.amazonaws.com/nuget/#{repository}/"
+            else
+              "https://#{domain}-#{domain_owner || '${data.aws_caller_identity.current.account_id}'}.d.codeartifact.#{region}.amazonaws.com/#{format}/#{repository}/"
+            end
+          end
+          
+          def has_upstream_repositories?
+            upstream.any?
+          end
+          
+          def upstream_count
+            upstream.size
+          end
+          
+          def has_external_connection?
+            external_connections && external_connections&.dig(:external_connection_name) && !external_connections&.dig(:external_connection_name).empty?
+          end
+          
+          def external_connection_type
+            return nil unless has_external_connection?
+            
+            conn = external_connections&.dig(:external_connection_name)
+            case conn
+            when 'public:npmjs' then :npm_public
+            when 'public:pypi' then :pypi_public  
+            when 'public:maven-central' then :maven_central
+            when 'public:nuget-org' then :nuget_public
+            else :unknown
+            end
+          end
+          
+          def supports_external_connection?
+            %w[npm pypi maven nuget].include?(format)
+          end
+          
+          def is_private_repository?
+            !has_external_connection?
+          end
+          
+          def is_public_proxy_repository?
+            has_external_connection?
+          end
+          
+          def package_manager_config_command(region = 'us-east-1')
+            case format
+            when 'npm'
+              "aws codeartifact login --tool npm --domain #{domain} --repository #{repository} --region #{region}"
+            when 'pypi'
+              "aws codeartifact login --tool pip --domain #{domain} --repository #{repository} --region #{region}"
+            when 'maven'
+              "aws codeartifact login --tool mvn --domain #{domain} --repository #{repository} --region #{region}"
+            when 'nuget'
+              "aws codeartifact login --tool nuget --domain #{domain} --repository #{repository} --region #{region}"
+            end
+          end
+          
+          def estimated_monthly_cost_per_gb
+            # Rough estimates per GB stored
+            case format
+            when 'npm' then 0.05
+            when 'pypi' then 0.05
+            when 'maven' then 0.05
+            when 'nuget' then 0.05
+            else 0.05
+            end
+          end
+          
+          def to_h
+            hash = {
+              repository: repository,
+              domain: domain,
+              format: format,
+              tags: tags
+            }
+            
+            hash[:domain_owner] = domain_owner if domain_owner
+            hash[:description] = description if description
+            hash[:upstream] = upstream if upstream.any?
+            hash[:external_connections] = external_connections if external_connections
+            
+            hash.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/resources/aws_codebuild_project/block_builders.rb

@@ -0,0 +1,163 @@
+# 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
+      # Block builders for AWS CodeBuild Project resource
+      # Extracts complex nested block building logic for cleaner resource definition
+      module CodeBuildBlockBuilders
+        extend self
+
+        def apply_source(ctx, source_attrs)
+          ctx.source do
+            ctx.type source_attrs[:type]
+            ctx.location source_attrs[:location] if source_attrs[:location]
+            ctx.git_clone_depth source_attrs[:git_clone_depth] if source_attrs[:git_clone_depth]
+            ctx.buildspec source_attrs[:buildspec] if source_attrs[:buildspec]
+            ctx.report_build_status source_attrs[:report_build_status] if source_attrs.key?(:report_build_status)
+            ctx.insecure_ssl source_attrs[:insecure_ssl] if source_attrs.key?(:insecure_ssl)
+
+            if source_attrs[:git_submodules_config]
+              ctx.git_submodules_config do
+                ctx.fetch_submodules source_attrs[:git_submodules_config][:fetch_submodules]
+              end
+            end
+
+            if source_attrs[:auth]
+              ctx.auth do
+                ctx.type source_attrs[:auth][:type]
+                ctx.resource source_attrs[:auth][:resource] if source_attrs[:auth][:resource]
+              end
+            end
+          end
+        end
+
+        def apply_secondary_sources(ctx, secondary_sources)
+          secondary_sources.each do |src|
+            ctx.secondary_sources do
+              ctx.source_identifier src[:source_identifier]
+              ctx.type src[:type]
+              ctx.location src[:location] if src[:location]
+              ctx.git_clone_depth src[:git_clone_depth] if src[:git_clone_depth]
+              ctx.buildspec src[:buildspec] if src[:buildspec]
+              ctx.report_build_status src[:report_build_status] if src.key?(:report_build_status)
+              ctx.insecure_ssl src[:insecure_ssl] if src.key?(:insecure_ssl)
+            end
+          end
+        end
+
+        def apply_artifacts(ctx, artifacts_attrs)
+          ctx.artifacts do
+            ctx.type artifacts_attrs[:type]
+            ctx.location artifacts_attrs[:location] if artifacts_attrs[:location]
+            ctx.name artifacts_attrs[:name] if artifacts_attrs[:name]
+            ctx.namespace_type artifacts_attrs[:namespace_type] if artifacts_attrs[:namespace_type]
+            ctx.packaging artifacts_attrs[:packaging] if artifacts_attrs[:packaging]
+            ctx.path artifacts_attrs[:path] if artifacts_attrs[:path]
+            ctx.encryption_disabled artifacts_attrs[:encryption_disabled] if artifacts_attrs.key?(:encryption_disabled)
+            ctx.artifact_identifier artifacts_attrs[:artifact_identifier] if artifacts_attrs[:artifact_identifier]
+            ctx.override_artifact_name artifacts_attrs[:override_artifact_name] if artifacts_attrs.key?(:override_artifact_name)
+          end
+        end
+
+        def apply_secondary_artifacts(ctx, secondary_artifacts)
+          secondary_artifacts.each do |art|
+            ctx.secondary_artifacts do
+              ctx.artifact_identifier art[:artifact_identifier]
+              ctx.type art[:type]
+              ctx.location art[:location] if art[:location]
+              ctx.name art[:name] if art[:name]
+              ctx.namespace_type art[:namespace_type] if art[:namespace_type]
+              ctx.packaging art[:packaging] if art[:packaging]
+              ctx.path art[:path] if art[:path]
+              ctx.encryption_disabled art[:encryption_disabled] if art.key?(:encryption_disabled)
+              ctx.override_artifact_name art[:override_artifact_name] if art.key?(:override_artifact_name)
+            end
+          end
+        end
+
+        def apply_environment(ctx, env_attrs)
+          ctx.environment do
+            ctx.type env_attrs[:type]
+            ctx.image env_attrs[:image]
+            ctx.compute_type env_attrs[:compute_type]
+            ctx.privileged_mode env_attrs[:privileged_mode] if env_attrs.key?(:privileged_mode)
+            ctx.certificate env_attrs[:certificate] if env_attrs[:certificate]
+            ctx.image_pull_credentials_type env_attrs[:image_pull_credentials_type] if env_attrs[:image_pull_credentials_type]
+
+            env_attrs[:environment_variables]&.each do |env_var|
+              ctx.environment_variable do
+                ctx.name env_var[:name]
+                ctx.value env_var[:value]
+                ctx.type env_var[:type] if env_var[:type]
+              end
+            end
+
+            if env_attrs[:registry_credential]
+              ctx.registry_credential do
+                ctx.credential env_attrs[:registry_credential][:credential]
+                ctx.credential_provider env_attrs[:registry_credential][:credential_provider]
+              end
+            end
+          end
+        end
+
+        def apply_logs_config(ctx, logs_config)
+          return unless logs_config&.any?
+
+          ctx.logs_config do
+            if logs_config[:cloudwatch_logs]
+              cw = logs_config[:cloudwatch_logs]
+              ctx.cloudwatch_logs do
+                ctx.status cw[:status] if cw[:status]
+                ctx.group_name cw[:group_name] if cw[:group_name]
+                ctx.stream_name cw[:stream_name] if cw[:stream_name]
+              end
+            end
+
+            if logs_config[:s3_logs]
+              s3 = logs_config[:s3_logs]
+              ctx.s3_logs do
+                ctx.status s3[:status] if s3[:status]
+                ctx.location s3[:location] if s3[:location]
+                ctx.encryption_disabled s3[:encryption_disabled] if s3.key?(:encryption_disabled)
+              end
+            end
+          end
+        end
+
+        def apply_build_batch_config(ctx, batch_config)
+          return unless batch_config
+
+          ctx.build_batch_config do
+            ctx.service_role batch_config[:service_role]
+            ctx.combine_artifacts batch_config[:combine_artifacts] if batch_config.key?(:combine_artifacts)
+            ctx.timeout_in_mins batch_config[:timeout_in_mins] if batch_config[:timeout_in_mins]
+
+            if batch_config[:restrictions]
+              ctx.restrictions do
+                r = batch_config[:restrictions]
+                ctx.compute_types_allowed r[:compute_types_allowed] if r[:compute_types_allowed]
+                ctx.maximum_builds_allowed r[:maximum_builds_allowed] if r[:maximum_builds_allowed]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# 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_codebuild_project/types'
+require 'pangea/resources/aws_codebuild_project/block_builders'
+require 'pangea/resource_registry'
+
+module Pangea
+  module Resources
+    module AWS
+      # Create an AWS CodeBuild Project with type-safe attributes
+      #
+      # @param name [Symbol] The resource name
+      # @param attributes [Hash] CodeBuild project attributes
+      # @return [ResourceReference] Reference object with outputs and computed properties
+      def aws_codebuild_project(name, attributes = {})
+        project_attrs = Types::CodeBuildProjectAttributes.new(attributes)
+        builders = CodeBuildBlockBuilders
+
+        resource(:aws_codebuild_project, name) do
+          name project_attrs.name
+          description project_attrs.description if project_attrs.description
+          service_role project_attrs.service_role
+
+          build_timeout project_attrs.build_timeout
+          queued_timeout project_attrs.queued_timeout
+          concurrent_build_limit project_attrs.concurrent_build_limit if project_attrs.concurrent_build_limit
+
+          badge_enabled project_attrs.badge_enabled
+          encryption_key project_attrs.encryption_key if project_attrs.encryption_key
+          resource_access_role project_attrs.resource_access_role if project_attrs.resource_access_role
+
+          builders.apply_source(self, project_attrs.source)
+          builders.apply_secondary_sources(self, project_attrs.secondary_sources)
+          builders.apply_artifacts(self, project_attrs.artifacts)
+          builders.apply_secondary_artifacts(self, project_attrs.secondary_artifacts)
+          builders.apply_environment(self, project_attrs.environment)
+
+          if project_attrs.cache&.dig(:type) != 'NO_CACHE'
+            cache do
+              type project_attrs.cache&.dig(:type)
+              location project_attrs.cache&.dig(:location) if project_attrs.cache&.dig(:location)
+              modes project_attrs.cache&.dig(:modes) if project_attrs.cache&.dig(:modes)
+            end
+          end
+
+          if project_attrs.vpc_config
+            vpc_config do
+              vpc_id project_attrs.vpc_config&.dig(:vpc_id)
+              subnets project_attrs.vpc_config&.dig(:subnets)
+              security_group_ids project_attrs.vpc_config&.dig(:security_group_ids)
+            end
+          end
+
+          builders.apply_logs_config(self, project_attrs.logs_config)
+          builders.apply_build_batch_config(self, project_attrs.build_batch_config)
+
+          project_attrs.file_system_locations.each do |fs_location|
+            file_system_locations do
+              type fs_location[:type]
+              location fs_location[:location]
+              mount_point fs_location[:mount_point]
+              identifier fs_location[:identifier]
+              mount_options fs_location[:mount_options] if fs_location[:mount_options]
+            end
+          end
+
+          if project_attrs.tags&.any?
+            tags do
+              project_attrs.tags.each do |key, value|
+                public_send(key, value)
+              end
+            end
+          end
+        end
+
+        ResourceReference.new(
+          type: 'aws_codebuild_project',
+          name: name,
+          resource_attributes: project_attrs.to_h,
+          outputs: {
+            id: "${aws_codebuild_project.#{name}.id}",
+            arn: "${aws_codebuild_project.#{name}.arn}",
+            name: "${aws_codebuild_project.#{name}.name}",
+            badge_url: "${aws_codebuild_project.#{name}.badge_url}",
+            service_role: "${aws_codebuild_project.#{name}.service_role}"
+          },
+          computed: {
+            uses_vpc: project_attrs.uses_vpc?,
+            has_secondary_sources: project_attrs.has_secondary_sources?,
+            has_secondary_artifacts: project_attrs.has_secondary_artifacts?,
+            cache_enabled: project_attrs.cache_enabled?,
+            cloudwatch_logs_enabled: project_attrs.cloudwatch_logs_enabled?,
+            s3_logs_enabled: project_attrs.s3_logs_enabled?,
+            environment_variable_count: project_attrs.environment_variable_count,
+            uses_secrets: project_attrs.uses_secrets?,
+            compute_size: project_attrs.compute_size
+          }
+        )
+      end
+    end
+  end
+end