jets 5.0.14 → 6.0.0.beta1

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

@@ -1,41 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::Method
-  module Authorization
-  private
-    def authorizer_id
-      if @route.authorizer
-        logical_id = @route.authorizer_id
-      elsif controller_klass.authorizer
-        logical_id = controller_klass.authorizer_logical_id_for(@route.action_name)
-      end
-
-      "!Ref #{logical_id}" if logical_id
-    end
-
-    def authorization_type
-      type = @route.authorization_type ||
-             controller_klass.authorization_type || # Already handles inheritance via class_attribute, applies controller-wide
-             controller_klass.infer_authorization_type_for(@route.action_name) || # Applies specifically to route
-             Jets.config.api.authorization_type
-      type.to_s.upcase
-    end
-
-    def api_key_required?
-      api_key_required == true
-    end
-
-    def api_key_required
-      @route.api_key_required ||
-        controller_klass.api_key_required ||
-        Jets.config.api.api_key_required
-    end
-
-    def authorization_scopes
-      if @route.authorization_scopes
-        authorization_scopes = @route.authorization_scopes
-      elsif controller_klass.authorization_scopes
-        authorization_scopes = controller_klass.authorization_scopes
-      end
-      authorization_scopes
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-# Converts a Jets::Route to a CloudFormation Jets::Cfn::Resource::ApiGateway::Method resource
-module Jets::Cfn::Resource::ApiGateway
-  class Method < Jets::Cfn::Base
-    include Authorization
-
-    # route - Jets::Route
-    def initialize(route)
-      @route = route
-    end
-
-    def definition
-      {
-        method_logical_id => {
-          Type: "AWS::ApiGateway::Method",
-          Properties: props
-        }
-      }
-    end
-
-    # Note: The {namespace} in
-    #   functions/${{namespace}LambdaFunction.Arn}/invocations
-    # is replaced by Jets::Cfn::Resource::Replacer
-    #
-    #   Jets::Cfn::Resource::ApiGateway::Method
-    #     Jets::Cfn::Resource (attributes delegate to resource)
-    #     Jets::Cfn::Resource => replacer
-    #
-    def props
-      function_logical_id = Jets.one_lambda_for_all_controllers? ?
-          "JetsControllerLambdaFunction" :
-          "{namespace}LambdaFunction"
-
-      resource_id = ResourceId.new(@route.path).resource_id
-      props = {
-        ResourceId: "!Ref #{resource_id}",
-        RestApiId: "!Ref #{RestApi.logical_id}",
-        HttpMethod: @route.http_method,
-        RequestParameters: {},
-        AuthorizationType: authorization_type,
-        ApiKeyRequired: api_key_required?,
-        Integration: {
-          IntegrationHttpMethod: "POST",
-          Type: "AWS_PROXY",
-          Uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${#{function_logical_id}}/invocations"
-        },
-        MethodResponses: []
-      }
-      props[:AuthorizerId] = authorizer_id if authorizer_id
-      props[:AuthorizationScopes] = 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.http_method.downcase
-      [http_verb, path, "api_method"].compact.join('_')
-    end
-
-    def replacements
-      # Mimic task to grab replacements
-      # Use functions/${namespace} in Uri
-      resources = [definition]
-      action_name = Jets.one_lambda_per_controller? ? "lambda_handler" : @route.action_name
-      task = Jets::Lambda::Definition.new(@route.controller_name, action_name,
-               resources: resources)
-      task.replacements
-    end
-
-  private
-
-    def controller_klass
-      @controller_klass ||= "#{controller_name}_controller".camelize.constantize
-    end
-
-    def controller_name
-      @controller_name ||= @route.to.split('#').first
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway
-  class Resource < Jets::Cfn::Base
-    def initialize(path, internal: false)
-      # The original implementation uses path without the leading slash.
-      # Remove it here so the path_part is calculated correctly.
-      @path = path.delete_prefix('/') # Examples: "posts/:id/edit" or "posts"
-      @internal = internal
-    end
-
-    def definition
-      {
-        resource_logical_id => {
-          Type: "AWS::ApiGateway::Resource",
-          Properties: {
-            ParentId: parent_id,
-            PathPart: path_part,
-            RestApiId: "!Ref #{RestApi.logical_id(@internal)}",
-          }
-        }
-      }
-    end
-
-    def outputs
-      {
-        logical_id => "!Ref #{logical_id}",
-      }
-    end
-
-    def resource_logical_id
-      if @path == ''
-        # Not including ApiResource in the logical id so it doesn't collide with a
-        # user-defined ApiResource that happens to be named RootResourceId.
-        "RootResourceId"
-      else
-        Jets::Cfn::Resource.truncate_id(path_logical_id(@path), "ApiResource")
-      end
-    end
-
-    # For parameter description
-    def desc
-      path.empty? ? 'Homepage route: /' : "Route for: /#{path}"
-    end
-
-    def parent_path_parameter
-      if @path.include?('/') # posts/:id or posts/:id/edit
-        parent_path = @path.split('/')[0..-2].join('/')
-        parent_logical_id = path_logical_id(parent_path)
-        Jets::Cfn::Resource.truncate_id(parent_logical_id, "ApiResource")
-      else
-        "RootResourceId"
-      end
-    end
-
-    def parent_id
-      "!Ref " + parent_path_parameter
-    end
-
-    def path_part
-      last_part = path.split('/').last
-      last_part.split('/').map {|s| transform_capture(s) }.join('/') if last_part
-    end
-
-    # Modify the path to conform to API Gateway capture expressions
-    def path
-      @path.split('/').map {|s| transform_capture(s) }.join('/')
-    end
-
-    def transform_capture(text)
-      if text.starts_with?(':')
-        text = text.sub(':','')
-        text = "{#{text}}" # :foo => {foo}
-      end
-      if text.starts_with?('*')
-        text = text.sub('*','')
-        text = "{#{text}+}" # *foo => {foo+}
-      end
-      text
-    end
-
-  private
-    # Similar path_logical_id method in resource/route.rb
-    def path_logical_id(path)
-      path.gsub('/','_').gsub(':','').gsub('*','').gsub('-','_').gsub('.','_').camelize
-    end
-  end
-end

data/lib/jets/cfn/resource/api_gateway/resource_id.rb

@@ -1,25 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway
-  class ResourceId
-    def initialize(path)
-      @path = path
-    end
-
-    # Used by Method and Cors
-    def resource_id
-      @path == '/' ?
-        "RootResourceId" :
-        resource_logical_id.camelize + "ApiResource"
-    end
-
-    # Example: Posts
-    def resource_logical_id
-      camelized_path.underscore
-    end
-
-    def camelized_path
-      path = @path
-      path = "homepage" if path == '/'
-      path.gsub('/','_').gsub(':','').gsub('*','').gsub('.','').camelize
-    end
-  end
-end

data/lib/jets/cfn/resource/api_gateway/rest_api/change_detection.rb

@@ -1,10 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::RestApi
-  class ChangeDetection
-    extend Memoist
-    include Jets::AwsServices
-
-    def changed?
-      Routes.changed?
-    end
-  end
-end

data/lib/jets/cfn/resource/api_gateway/rest_api/logical_id/message.rb

@@ -1,59 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::RestApi::LogicalId
-  class Message
-    def routes_changed
-      <<~EOL
-      Routes Change Detection: Jets has detected that a new brand API Gateway is required to be deployed.
-      IMPORTANT: This will result in the API Gateway endpoint changing.
-      EOL
-    end
-
-    def custom_domain
-      domain_name = Jets.config.domain.name
-      if domain_name
-        <<~EOL
-        It looks like you have already set up a custom domain.
-        The domain name: #{domain_name}
-
-        So you should be good to go as the custom domain will be updated with the new API Gateway endpoint.
-        To avoid this prompt in the future, you can configure:
-
-        config/application.rb
-
-            config.api.auto_replace = true
-
-        More info: custom domain docs: https://rubyonjets.com/docs/routing/custom-domain/
-        EOL
-      else
-        <<~EOL
-        To avoid this prompt in the future, you can configure:
-
-        config/application.rb
-
-            config.api.auto_replace = true
-
-        However, you should also set up a custom domain for a "stable" endpoint.
-
-        https://rubyonjets.com/docs/routing/custom-domain/
-
-        EOL
-      end
-    end
-
-    def auto_replace_disabled
-      <<~EOL
-      It looks like `config.api.auto_replace = false`. IE:
-
-      config/application.rb
-
-          config.api.auto_replace = false
-
-      The deploy will not continue. See:
-
-      * https://rubyonjets.com/docs/app-config/reference/
-      * https://rubyonjets.com/docs/routing/custom-domain/
-
-      EOL
-    end
-  end
-end
-

data/lib/jets/cfn/resource/api_gateway/rest_api/logical_id.rb

@@ -1,98 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::RestApi
-  class LogicalId
-    extend Memoist
-    include Jets::AwsServices
-
-    def get
-      return default if ENV['JETS_NO_INTERNET']
-      return default unless stack_exists?(parent_stack_name) && api_gateway_exists?
-
-      if changed?
-        auto_replace_prompt
-        new_id
-      else
-        current
-      end
-    end
-
-    def auto_replace_prompt
-      return if ENV['JETS_API_AUTO_REPLACE']
-      return unless Jets::Command.original_cli_command == "deploy"
-      case Jets.config.api.auto_replace
-      when nil
-        puts message.routes_changed
-        puts message.custom_domain
-        print "Would you like to continue the deployment? (y/N) "
-        answer = get_answer
-        exit 1 unless answer =~ /^y/
-      when false
-        puts message.routes_changed
-        puts message.auto_replace_disabled
-        exit 1
-      end
-    end
-
-    def message
-      Message.new
-    end
-    memoize :message
-
-    TIMEOUT_PERIOD = 120
-    def get_answer
-      Timeout::timeout(TIMEOUT_PERIOD) do
-        $stdin.gets
-      end
-    rescue Timeout::Error => e
-      puts "#{e.class}: #{e.message}".color(:red)
-      puts "Deployment timeout after #{TIMEOUT_PERIOD}s. Waited too long answer. Exiting."
-      exit 1
-    end
-
-    def changed?
-      change_detection = ChangeDetection.new
-      change_detection.changed?
-    end
-
-    # Takes current logical id and increments the number that is appended to it.
-    #
-    # Examples:
-    #
-    #   RestApi => RestApi1
-    #   RestApi1 => RestApi2
-    #   RestApi2 => RestApi3
-    #   RestApi7 => RestApi8
-    def new_id
-      regexp = /(\d+)/
-      md = current.match(regexp)
-      if md
-        current.gsub(regexp,'') + (md[1].to_i + 1).to_s
-      else
-        current + "1"
-      end
-    end
-
-    def current
-      resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
-      rest_api = resources.find { |r| r.resource_type == 'AWS::ApiGateway::RestApi' }
-      rest_api.logical_resource_id
-    end
-    memoize :current
-
-    def api_gateway_stack_arn
-      stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
-      lookup(stack[:outputs], "ApiGateway") # api_gateway_stack_arn
-    end
-
-    def api_gateway_exists?
-      !!api_gateway_stack_arn
-    end
-
-    def parent_stack_name
-      Jets::Names.parent_stack_name
-    end
-
-    def default
-      "RestApi"
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Change
-  class Base
-    extend Memoist
-    include Jets::AwsServices
-
-    def self.changed?
-      new.changed?
-    end
-
-    # Recreate routes from previously deployed stored state in s3
-    def deployed_routes
-      state = Jets::Router::State.new
-      data = state.load("routes")
-      return [] if data.nil?
-
-      data.map do |item|
-        http_method = item.dig('options','method') || item.dig('options','http_method')
-        Jets::Router::Route.new(
-          http_method: http_method,
-          path: item['path'],
-          to: item['to'],
-          engine: item['engine'],
-          internal: item['internal'],
-        )
-      end
-    end
-    memoize :deployed_routes
-
-    def to(resource_id, http_method)
-      uri = method_uri(resource_id, http_method)
-      recreate_to(uri) unless uri.nil?
-    end
-
-    def method_uri(resource_id, http_method)
-      # https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html
-      resp = apigateway.get_method(
-        rest_api_id: rest_api_id,
-        resource_id: resource_id,
-        http_method: http_method
-      )
-      resp.method_integration.uri
-    end
-
-    # Parses method uri and recreates a Route to argument.
-    # So:
-    #   "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:112233445566:function:demo-test-posts_controller-new/invocations"
-    # Returns:
-    #   posts#new
-    def recreate_to(method_uri)
-      md = method_uri.match(/function:(.*)\//)
-      function_arn = md[1] # IE: demo-dev-posts_controller-new
-      controller, action = get_controller_action(function_arn)
-      "#{controller}##{action}" # IE: posts#new
-    end
-
-    def get_controller_action(function_arn)
-      if function_arn.include?('_controller-')
-        controller_action_from_string(function_arn)
-      else
-        controller_action_from_api(function_arn)
-      end
-    end
-
-    # TODO: If this hits the Lambda Rate limit, then list_functions also contains the Lambda
-    # function description. So we can paginate through list_functions results and store
-    # description from there if needed.
-    # Dont think this will be needed though because controller_action_from_string gets called
-    # most of the time. Also, user might be able to request their Lambda limit to be increased.
-    def controller_action_from_api(function_arn)
-      desc = lambda_function_description(function_arn)
-      controller, action = desc.split('#')
-      controller = controller.underscore.sub(/_controller$/,'')
-      [controller, action]
-    end
-
-    def controller_action_from_string(function_arn)
-      controller_action = function_arn.sub("#{Jets.project_namespace}-", '')
-      md = controller_action.match(/(.*)_controller-(.*)/)
-      controller = md[1]
-      controller = controller.gsub('-','/')
-      action = md[2]
-      [controller, action]
-    end
-
-    def lambda_function_description(function_arn)
-      resp = aws_lambda.get_function(function_name: function_arn)
-      resp.configuration.description # contains full info: PostsController#index
-    end
-
-    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
-    def rest_api_id
-      stack_name = Jets::Names.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
-      lookup(stack[:outputs], "RestApi") # rest_api_id
-    end
-    memoize :rest_api_id
-
-    def new_routes
-      Jets::Router.routes
-    end
-    memoize :new_routes
-  end
-end

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

@@ -1,36 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Change
-  class MediaTypes < Base
-    def changed?
-      current_binary_media_types != new_binary_media_types
-    end
-
-    def new_binary_media_types
-      rest_api = Jets::Cfn::Resource::ApiGateway::RestApi.new
-      rest_api.binary_media_types
-    end
-    memoize :new_binary_media_types
-
-    def current_binary_media_types
-      return nil unless parent_stack_exists?
-
-      stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
-
-      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
-
-      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
-      rest_api_id = lookup(stack[:outputs], "RestApi")
-
-      resp = apigateway.get_rest_api(rest_api_id: rest_api_id)
-      resp.binary_media_types
-    end
-    memoize :current_binary_media_types
-
-    def parent_stack_exists?
-      stack_exists?(parent_stack_name)
-    end
-
-    def parent_stack_name
-      Jets::Names.parent_stack_name
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-class Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Change
-  class Page < Base
-    def changed?
-      route_page_moved? || old_api_template?
-    end
-
-    def route_page_moved?
-      moved?(new_pages, deployed_pages)
-    end
-
-    # Routes page to logical ids
-    def moved?(new_pages, deployed_pages)
-      not_moved = true # page has not moved
-      new_pages.each do |logical_id, new_page_number|
-        if !deployed_pages[logical_id].nil? && deployed_pages[logical_id] != new_page_number
-          not_moved = false # page has moved
-          break
-        end
-      end
-      !not_moved # moved
-    end
-
-    def new_pages
-      local_logical_ids_map
-    end
-    memoize :new_pages
-
-    def deployed_pages
-      remote_logical_ids_map
-    end
-    memoize :deployed_pages
-
-    # logical id to page map
-    # Important: In Cfn::Builders::ApiGatewayBuilder, the add_gateway_routes and ApiResourcesBuilder needs to run
-    # before the parent add_gateway_rest_api method.
-    def local_logical_ids_map(path_expression="#{Jets::Names.templates_folder}/api-resources-*.yml")
-      logical_ids = {} # logical id => page number
-
-      Dir.glob(path_expression).each do |path|
-        md = path.match(/-api-resources-(\d+).yml/)
-        page_number = md[1]
-
-        template = Jets::Cfn::Template.load_file(path)
-        template[:Resources].keys.each do |logical_id|
-          logical_ids[logical_id] = page_number
-        end
-      end
-
-      logical_ids
-    end
-
-    # aws cloudformation describe-stack-resources --stack-name demo-dev-ApiResources1-DYGLIEY3VAWT | jq -r '.StackResources[].LogicalResourceId'
-    def remote_logical_ids_map
-      logical_ids = {} # logical id => page number
-
-      parent_resources.each do |resource|
-        stack_name = resource.physical_resource_id # full physical id can be used as stack name also
-        regexp = Regexp.new("#{Jets.project_namespace}-ApiResources(\\d+)-") # tricky to escape \d pattern
-        md = stack_name.match(regexp)
-        if md
-          page_number = md[1]
-
-          resp = cfn.describe_stack_resources(stack_name: stack_name)
-          resp.stack_resources.map(&:logical_resource_id).each do |logical_id|
-            logical_ids[logical_id] = page_number
-          end
-        end
-      end
-
-      logical_ids
-    end
-
-    def old_api_template?
-      logical_resource_ids = parent_resources.map(&:logical_resource_id)
-
-      api_gateway_found = logical_resource_ids.detect do |logical_id|
-        logical_id == "ApiGateway"
-      end
-      return false unless api_gateway_found
-
-      api_resources_found = logical_resource_ids.detect do |logical_id|
-        logical_id.match(/^ApiResources\d+$/)
-      end
-      !api_resources_found # if api_resources_found then it's the new structure. so opposite is old structure
-    end
-
-    def parent_resources
-      resp = cfn.describe_stack_resources(stack_name: Jets::Names.parent_stack_name)
-      resp.stack_resources
-    end
-    memoize :parent_resources
-  end
-end

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

@@ -1,30 +0,0 @@
-# Detects route to changes
-class Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Change
-  class To < Base
-    def changed?
-      deployed_routes.each do |deployed_route|
-        next if deployed_route.engine   # skip engine routes
-        next if deployed_route.internal # skip internal routes
-
-        new_route = find_comparable_route(deployed_route)
-        next unless new_route
-
-        if new_route.to != deployed_route.to
-          # change in already deployed route has been detected, requires bluegreen deploy
-          return true
-        end
-      end
-      false # Reaching here means no routes have been changed in a way that requires a bluegreen deploy
-    end
-
-    # Find a route that has the same path and method. This is a comparable route
-    # Then we will compare the to or controller action to see if an already
-    # deployed route has been changed.
-    def find_comparable_route(deployed_route)
-      new_routes.find do |new_route|
-        new_route.path == deployed_route.path &&
-        new_route.http_method == deployed_route.http_method
-      end
-    end
-  end
-end