jets 3.1.0 → 5.0.0

data/lib/jets/resource/api_gateway/base_path/role.rb

@@ -1,76 +0,0 @@
-module Jets::Resource::ApiGateway::BasePath
-  class Role < Jets::Resource::Base
-    extend Memoist
-    include Jets::AwsServices
-
-    def definition
-      {
-        base_path_role: {
-          type: "AWS::IAM::Role",
-          properties: {
-            role_name: role_name,
-            path: "/",
-            assume_role_policy_document: {
-              version: "2012-10-17",
-              statement: [{
-                effect: "Allow",
-                principal: {service: ["lambda.amazonaws.com"]},
-                action: ["sts:AssumeRole"]}
-              ]
-            },
-            policies: [
-              policy_name: "#{role_name}-policy",
-              policy_document: policy_document,
-            ]
-          },
-        }
-      }
-    end
-
-    def policy_document
-      project_namespace = Jets.config.project_namespace
-      default_policy_statements = Jets::Application.default_iam_policy # Array of Hashes
-      apigateway = [{
-        action: [ "apigateway:*" ],
-        effect: "Allow",
-        resource: "arn:aws:apigateway:#{Jets.aws.region}::/restapis/*", # scoped to all restapis because this changes
-      },{
-        action: [ "apigateway:*" ],
-        effect: "Allow",
-        resource: "arn:aws:apigateway:#{Jets.aws.region}::/domainnames/*", # scoped to all restapis because this changes
-      }]
-      cloudformation = [{
-        action: ["cloudformation:DescribeStacks"],
-        effect: "Allow",
-        resource: "arn:aws:cloudformation:#{Jets.aws.region}:#{Jets.aws.account}:stack/#{project_namespace}*",
-      }]
-
-      # Combine the statements
-      {
-        version: '2012-10-17',
-        statement: default_policy_statements + apigateway + cloudformation
-      }
-    end
-
-    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
-    def rest_api_id
-      stack_name = Jets::Naming.parent_stack_name
-      return "RestApi" unless stack_exists?(stack_name)
-
-      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
-
-      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
-
-      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
-      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
-      rest_api_id = lookup(stack[:outputs], "RestApi")
-    end
-    memoize :rest_api_id
-
-    def role_name
-      # TODO: dont think we should change the role name every time but have to right now because the deployment logical id changes
-      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
-      "#{Jets.config.project_namespace}-base-path-mapping-#{timestamp}"
-    end
-  end
-end

data/lib/jets/resource/api_gateway/cors.rb

@@ -1,61 +0,0 @@
-module Jets::Resource::ApiGateway
-  # Might be weird inheriting from Method because Method has Method#cors also
-  # but Cors is essentially a Method class.
-  class Cors < Method
-    def definition
-      {
-        cors_logical_id => {
-          type: "AWS::ApiGateway::Method",
-
-          properties: {
-            resource_id: "!Ref #{resource_id}",
-            rest_api_id: "!Ref #{RestApi.logical_id}",
-            authorization_type: cors_authorization_type,
-            http_method: "OPTIONS",
-            method_responses: [{
-              status_code: '200',
-              response_parameters: response_parameters(true),
-              response_models: {},
-            }],
-            request_parameters: {},
-            integration: {
-              type: "MOCK",
-              request_templates: {
-                "application/json": "{statusCode:200}",
-              },
-              integration_responses: [{
-                status_code: '200',
-                response_parameters: response_parameters,
-                response_templates: {
-                  "application/json": '',
-                },
-              }] # closes integration_responses
-            } # closes integration
-          } # closes properties
-        } # closes logical id
-      } # closes definition
-    end
-
-    def response_parameters(method_response=false)
-      cors_headers.map do |k,v|
-        k = "method.response.header.#{k}"
-        v = method_response ? true : "'#{v}'" # surround value with single quotes
-        [k,v]
-      end.to_h
-    end
-
-    # Always the pre-flight headers in this case
-    def cors_headers
-      rack = Jets::Controller::Middleware::Cors.new(Jets.application)
-      rack.cors_headers(true)
-    end
-
-    def cors_authorization_type
-      Jets.config.api.cors_authorization_type || @route.authorization_type || "NONE"
-    end
-
-    def cors_logical_id
-      "#{resource_logical_id}_cors_api_method"
-    end
-  end
-end

data/lib/jets/resource/api_gateway/method.rb

@@ -1,102 +0,0 @@
-# Converts a Jets::Route to a CloudFormation Jets::Resource::ApiGateway::Method resource
-module Jets::Resource::ApiGateway
-  class Method < Jets::Resource::Base
-    include Authorization
-
-    # also delegate permission for a method
-    delegate :permission, to: :resource
-
-    # route - Jets::Route
-    def initialize(route)
-      @route = route
-    end
-
-    def definition
-      {
-        method_logical_id => {
-          type: "AWS::ApiGateway::Method",
-          properties: props
-        }
-      }
-    end
-
-    def props
-      props = {
-        resource_id: "!Ref #{resource_id}",
-        rest_api_id: "!Ref #{RestApi.logical_id}",
-        http_method: @route.method,
-        request_parameters: {},
-        authorization_type: authorization_type,
-        api_key_required: api_key_required?,
-        integration: {
-          integration_http_method: "POST",
-          type: "AWS_PROXY",
-          uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${{namespace}LambdaFunction.Arn}/invocations"
-        },
-        method_responses: []
-      }
-      props[:authorizer_id] = authorizer_id if authorizer_id
-      props[:authorization_scopes] = authorization_scopes if authorization_scopes
-
-      props
-    end
-
-    def method_logical_id
-      # https://stackoverflow.com/questions/6104240/how-do-i-strip-non-alphanumeric-characters-from-a-string-and-keep-spaces
-      # Add path to the logical id to allow 2 different paths to be connected to the same controller action.
-      # Example:
-      #
-      #   root "jets/public#show"
-      #   any "*catchall", to: "jets/public#show"
-      #
-      # Without the path in the logical id, the logical id would be ShowApiMethod for both routes and only the
-      # last one would be created in the CloudFormation template.
-      path = @route.path.gsub('*','')
-              .gsub(/[^0-9a-z]/i, ' ')
-              .gsub(/\s+/, '_')
-      path = nil if path == ''
-      http_verb = @route.method.downcase
-      [path, "{namespace}_#{http_verb}_api_method"].compact.join('_')
-    end
-
-    def replacements
-      # mimic task to grab replacements, we want the namespace to be the lambda function's namespace
-      resources = [definition]
-      task = Jets::Lambda::Task.new(@route.controller_name, @route.action_name,
-               resources: resources)
-      task.replacements
-    end
-
-    def cors
-      Cors.new(@route)
-    end
-    memoize :cors
-
-  private
-
-    def controller_klass
-      @controller_klass ||= "#{controller_name}_controller".camelize.constantize
-    end
-
-    def controller_name
-      @controller_name ||= @route.to.split('#').first
-    end
-
-    def resource_id
-      @route.path == '' ?
-       "RootResourceId" :
-       Jets::Resource.truncate_id(resource_logical_id.camelize, "ApiResource")
-    end
-
-    # Example: Posts
-    def resource_logical_id
-      camelized_path.underscore
-    end
-
-    def camelized_path
-      path = @route.path
-      path = "homepage" if path == ''
-      path.gsub('/','_').gsub(':','').gsub('*','').gsub('.','').camelize
-    end
-  end
-end

data/lib/jets/resource/api_gateway/rest_api/routes/change.rb

@@ -1,16 +0,0 @@
-# Detects route changes
-class Jets::Resource::ApiGateway::RestApi::Routes
-  class Change
-    include Jets::AwsServices
-
-    def changed?
-      return false unless parent_stack_exists?
-
-      MediaTypes.changed? || To.changed? || Variable.changed? || Page.changed? || ENV['JETS_REPLACE_API']
-    end
-
-    def parent_stack_exists?
-      stack_exists?(Jets::Naming.parent_stack_name)
-    end
-  end
-end

data/lib/jets/resource/base.rb

@@ -1,28 +0,0 @@
-# Classes that inherit from this method should NOT define and override:
-#
-#   logical_id
-#   type
-#   properties
-#   attributes
-#
-# These are computed methods that derive their values from the resource definition itself.
-# Overriding these methods will remove the computed logical which handles things
-# like camelizing and replacements.
-#
-# The implementation of these methods are in `Jets::Resource`.
-class Jets::Resource
-  class Base
-    extend Memoist
-    delegate :logical_id, :type, :properties, :attributes, :parameters, :outputs,
-             to: :resource
-
-    def resource
-      Jets::Resource.new(definition, replacements)
-    end
-    memoize :resource
-
-    def replacements
-      @replacements || {}
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_deployment.rb

@@ -1,58 +0,0 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class ApiDeployment < Base
-    def definition
-      {
-        deployment_id => {
-          type: "AWS::CloudFormation::Stack",
-          properties: {
-            template_url: template_url,
-            parameters: parameters,
-          },
-          depends_on: depends_on,
-        }
-      }
-    end
-
-    def parameters
-      p = {
-        GemLayer: "!Ref GemLayer",
-        IamRole: "!GetAtt IamRole.Arn",
-        RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
-        S3Bucket: "!Ref S3Bucket",
-      }
-      p[:DomainName] = "!GetAtt ApiGateway.Outputs.DomainName" if Jets.custom_domain?
-      p[:BasePath] = Jets.config.domain.base_path unless Jets.config.domain.base_path.nil?
-      p
-    end
-
-    def depends_on
-      expression = "#{Jets::Naming.template_path_prefix}-*_controller*"
-      controller_logical_ids = []
-      Dir.glob(expression).each do |path|
-        next unless File.file?(path)
-
-        # map the path to a camelized logical_id. Example:
-        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
-        #   PostsController
-        regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
-        controller_name = path.sub(regexp, '').sub('.yml', '')
-        controller_logical_id = controller_name.underscore.camelize
-        controller_logical_ids << controller_logical_id
-      end
-      controller_logical_ids
-    end
-
-    def deployment_id
-      Jets::Resource::ApiGateway::Deployment.logical_id
-    end
-
-    def template_filename
-      "#{Jets.config.project_namespace}-api-deployment.yml"
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_gateway.rb

@@ -1,23 +0,0 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class ApiGateway < Base
-    def definition
-      {
-        api_gateway: {
-          type: "AWS::CloudFormation::Stack",
-          properties: {
-            template_url: template_url,
-          }
-        }
-      }
-    end
-
-    def template_filename
-      "#{Jets.config.project_namespace}-api-gateway.yml"
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_resource/page.rb

@@ -1,20 +0,0 @@
-class Jets::Resource::ChildStack::ApiResource
-  # Find the ApiResource Page that contains the AWS::ApiGateway::Resource
-  # Returns: logical id of ApiResource Page
-  class Page
-    def self.logical_id(parameter)
-      expression = "#{Jets::Naming.template_path_prefix}-api-resources-*"
-      # IE: path: #{Jets.build_root}/templates/demo-dev-2-api-resources-1.yml"
-      template_paths = Dir.glob(expression).sort.to_a
-      found_template = template_paths.detect do |path|
-        next unless File.file?(path)
-
-        template = Jets::Cfn::BuiltTemplate.get(path)
-        template['Outputs'].keys.include?(parameter)
-      end
-      md = found_template.match(/-(api-resources-\d+)/)
-
-      md[1].underscore.camelize # IE: ApiResources1
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_resource.rb

@@ -1,54 +0,0 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class ApiResource < Base
-    def initialize(*)
-      super
-      @page = @options[:page]
-    end
-
-    def definition
-      {
-        "api_resources_#{@page}" =>  {
-          type: "AWS::CloudFormation::Stack",
-          # depends_on: "ApiGateway", # CloudFormation seems to be smart enough
-          properties: {
-            template_url: template_url,
-            parameters: parameters,
-          }
-        }
-      }
-    end
-
-    def parameters
-      params = {}
-      # Since dont have all the info required.
-      # Read the template back to find the parameters required.
-      # Actually might be easier to rationalize this approach.
-      template_path = Jets::Naming.api_resources_template_path(@page)
-      template = Jets::Cfn::BuiltTemplate.get(template_path)
-      template['Parameters'].keys.each do |p|
-        case p
-        when "RestApi"
-          params[p] = "!GetAtt ApiGateway.Outputs.RestApi"
-        when "RootResourceId"
-          params[p] = "!GetAtt ApiGateway.Outputs.RootResourceId"
-        else
-          params[p] = "!GetAtt #{api_resource_page(p)}.Outputs.#{p}"
-        end
-      end
-      params
-    end
-
-    def api_resource_page(parameter)
-      Page.logical_id(parameter)
-    end
-
-    def template_filename
-      "#{Jets.config.project_namespace}-api-resources-#{@page}.yml"
-    end
-  end
-end

data/lib/jets/resource/child_stack/base.rb

@@ -1,24 +0,0 @@
-# Inheriting classes should implement:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class Base < Jets::Resource::Base
-    def initialize(s3_bucket, options={})
-      @s3_bucket = s3_bucket
-      @options = options
-    end
-
-    def outputs
-      {
-        logical_id => "!Ref #{logical_id}",
-      }
-    end
-
-    def template_url
-      basename = File.basename(template_filename)
-      "https://s3.amazonaws.com/#{@s3_bucket}/jets/cfn-templates/#{basename}"
-    end
-  end
-end

data/lib/jets/resource/iam/base_role_definition.rb

@@ -1,47 +0,0 @@
-module Jets::Resource::Iam
-  module BaseRoleDefinition
-    attr_reader :policy_definitions, :managed_policy_definitions
-
-    def definition
-      logical_id = role_logical_id
-
-      # Do not assign pretty role_name because long controller names might hit the 64-char
-      # limit. Also, IAM roles are global, so assigning role names prevents cross region deploys.
-      definition = {
-        logical_id => {
-          type: "AWS::IAM::Role",
-          properties: {
-            path: "/",
-            assume_role_policy_document: {
-              version: "2012-10-17",
-              statement: [{
-                effect: "Allow",
-                principal: {service: ["lambda.amazonaws.com"]},
-                action: ["sts:AssumeRole"]}
-              ]
-            }
-          }
-        }
-      }
-
-      definition[logical_id][:properties][:policies] = [
-        policy_name: "#{policy_name[0..127]}", # required, limited to 128-chars
-        policy_document: policy_document,
-      ] unless policy_document['Statement'].empty?
-
-      unless managed_policy_arns.empty?
-        definition[logical_id][:properties][:managed_policy_arns] = managed_policy_arns
-      end
-
-      definition
-    end
-
-    def policy_document
-      PolicyDocument.new(@policy_definitions.flatten.uniq).policy_document
-    end
-
-    def managed_policy_arns
-      ManagedPolicy.new(@managed_policy_definitions.flatten.uniq).arns
-    end
-  end
-end