jets 4.0.10 → 5.0.0.beta1

data/lib/jets/cfn/base.rb

@@ -0,0 +1,82 @@
+# 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.
+module Jets::Cfn
+  class Base
+    extend Memoist
+    include Jets::Util::Camelize
+
+    # interface method
+    def replacements
+      @replacements || {}
+    end
+
+    def replacer
+      Resource::Replacer.new(replacements)
+    end
+    memoize :replacer
+
+    def template
+      standarize(definition)
+    end
+    memoize :template
+
+    # CloudFormation Resources reference: https://amzn.to/2NKg6ip
+    def standarize(*definition)
+      Resource::Standardizer.new(definition).template
+    end
+
+    def logical_id
+      id = template.keys.first
+      id = replacer.replace_value(id) # IE: replace possible {namespace} in the logical id
+      Jets::Camelizer.camelize(id) # logical id limit is 256 chars
+    end
+
+    def type
+      attributes[:Type]
+    end
+
+    def properties
+      attributes[:Properties]
+    end
+
+    def attributes
+      attributes = template.values.first
+      attributes = replacer.replace_placeholders(attributes)
+      camelize(attributes)
+    end
+
+    def parameters
+      {}
+    end
+
+    def outputs
+      {}
+    end
+
+    def permission
+      Resource::Lambda::Permission.new(replacements, self)
+    end
+    memoize :permission
+
+    class << self
+      def truncate_id(id, postfix = '')
+        # Api Gateway resource name has a limit of 64 characters.
+        # Yet it throws not found when ID is longer than 62 characters and I don't know why.
+        # To keep it safe, let's stick to the 62 characters limit.
+        if id.size + postfix.size > 62
+          "#{id[0..(55 - postfix.size)]}#{Digest::MD5.hexdigest(id)[0..5]}#{postfix}"
+        else
+          "#{id}#{postfix}"
+        end
+      end
+    end
+  end
+end

data/lib/jets/cfn/builder/api/base.rb

@@ -0,0 +1,12 @@
+module Jets::Cfn::Builder::Api
+  class Base
+    extend Memoist
+    include Jets::Cfn::Builder::Interface
+    include Jets::AwsServices
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+  end
+end

data/lib/jets/cfn/{builders/api_deployment_builder.rb → builder/api/deployment.rb}

@@ -1,21 +1,11 @@
-module Jets::Cfn::Builders
-  class ApiDeploymentBuilder
-    include Interface
-    include Jets::AwsServices
-
-    def initialize(options={})
-      @options = options
-      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
-    end
-
-    # compose is an interface method
+module Jets::Cfn::Builder::Api
+  class Deployment < Base
+    # interface method
     def compose
-      deployment = Jets::Resource::ApiGateway::Deployment.new
+      deployment = Jets::Cfn::Resource::ApiGateway::Deployment.new
       add_resource(deployment)
       add_parameters(deployment.parameters)
       add_outputs(deployment.outputs)
-
-      add_base_path_mapping
     end
 
     # Because Jets generates a new timestamped logical id for the API Deployment
@@ -30,27 +20,27 @@ module Jets::Cfn::Builders
     def add_base_path_mapping
       return unless Jets.custom_domain?
 
-      function = Jets::Resource::ApiGateway::BasePath::Function.new
+      function = Jets::Cfn::Resource::ApiGateway::BasePath::Function.new
       add_resource(function)
       add_outputs(function.outputs)
 
-      mapping = Jets::Resource::ApiGateway::BasePath::Mapping.new
+      mapping = Jets::Cfn::Resource::ApiGateway::BasePath::Mapping.new
       add_resource(mapping)
       add_outputs(mapping.outputs)
 
-      iam_role = Jets::Resource::ApiGateway::BasePath::Role.new
+      iam_role = Jets::Cfn::Resource::ApiGateway::BasePath::Role.new
       add_resource(iam_role)
       add_outputs(iam_role.outputs)
     end
 
-    # template_path is an interface method
+    # interface method
     def template_path
       Jets::Names.api_deployment_template_path
     end
 
-    # do not bother writing a template if routes are empty
+    # do not write a template if routes are empty
     def write
-      super unless Jets::Router.routes.empty?
+      super unless Jets::Router.no_routes?
     end
   end
 end

data/lib/jets/cfn/{builders/api_gateway_builder.rb → builder/api/gateway.rb}

@@ -1,40 +1,30 @@
-module Jets::Cfn::Builders
-  class ApiGatewayBuilder
-    extend Memoist
-    include Interface
-    include Jets::AwsServices
-
-    def initialize(options={})
-      @options = options
-      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
-    end
-
-    # compose is an interface method
+module Jets::Cfn::Builder::Api
+  class Gateway < Base
+    # interface method
     def compose
-      add_gateway_routes # "child template": build before add_gateway_rest_api. RestApi logical id and change detection is dependent on it.
       add_gateway_rest_api # changes parent template
       add_custom_domain    # changes parent template
     end
 
-    # template_path is an interface method
+    # interface method
     def template_path
       Jets::Names.api_gateway_template_path
     end
 
-    # do not bother writing a template if routes are empty
+    # do write a template if routes are empty
     def write
-      super unless Jets::Router.routes.empty?
+      super unless Jets::Router.no_routes?
     end
 
     # If the are routes in config/routes.rb add Gateway API in parent stack
     def add_gateway_rest_api
-      rest_api = Jets::Resource::ApiGateway::RestApi.new
+      rest_api = Jets::Cfn::Resource::ApiGateway::RestApi.new
       add_resource(rest_api)
       add_outputs(rest_api.outputs)
 
-      deployment = Jets::Resource::ApiGateway::Deployment.new
+      deployment = Jets::Cfn::Resource::ApiGateway::Deployment.new
       outputs = deployment.outputs(true)
-      add_output("RestApiUrl", Value: outputs["RestApiUrl"])
+      add_output(:RestApiUrl, Value: outputs[:RestApiUrl])
     end
 
     def add_custom_domain
@@ -48,7 +38,7 @@ module Jets::Cfn::Builders
     end
 
     def add_route53_dns
-      dns = Jets::Resource::Route53::RecordSet.new
+      dns = Jets::Cfn::Resource::Route53::RecordSet.new
       if !existing_domain_name?(dns.domain_name) or existing_dns_record_on_stack?
         add_resource(dns)
         add_outputs(dns.outputs)
@@ -56,10 +46,10 @@ module Jets::Cfn::Builders
     end
 
     def create_domain_name
-      resource = Jets::Resource::ApiGateway::DomainName.new
+      resource = Jets::Cfn::Resource::ApiGateway::DomainName.new
 
       return {
-        "DomainName" => resource.domain_name
+        DomainName: resource.domain_name
       } if (existing_domain_name?(resource) and !existing_domain_name_on_stack?)
 
       add_resource(resource)
@@ -67,9 +57,9 @@ module Jets::Cfn::Builders
     end
 
     def existing_domain_name?(resource)
-      apigateway.get_domain_name({
+      apigateway.get_domain_name(
         domain_name: resource.domain_name
-      })
+      )
       true
     # IE: Aws::APIGateway::Errors::NotFoundException Invalid domain name identifier specified
     rescue Aws::APIGateway::Errors::NotFoundException
@@ -110,18 +100,5 @@ module Jets::Cfn::Builders
       nil
     end
     memoize :api_gateway_physical_resource_id
-
-    # Adds route related Resources and Outputs
-    # Delegates to ApiResourcesBuilder
-    PAGE_LIMIT = Integer(ENV['JETS_AWS_OUTPUTS_LIMIT'] || 200) # Allow override for testing
-    def add_gateway_routes
-      # Reject homepage. Otherwise we have 200 - 1 resources on the first page.
-      # There's a next call in ApiResources.add_gateway_resources to skip the homepage.
-      page_builder = Jets::Cfn::Builders::PageBuilder.new
-      pages = page_builder.build
-      pages.each_with_index do |paths, i|
-        ApiResourcesBuilder.new(@options, paths, i+1).build
-      end
-    end
   end
 end

data/lib/jets/cfn/builder/api/mapping.rb

@@ -0,0 +1,54 @@
+module Jets::Cfn::Builder::Api
+  class Mapping < Base
+    # interface method
+    def compose
+      add_parameters(parameters)
+      add_base_path_mapping
+    end
+
+    def parameters
+      p = {
+        GemLayer: "GemLayer",
+        IamRole: "IamRole",
+        RestApi: "RestApi",
+        S3Bucket: "S3Bucket",
+      }
+      p[:DomainName] = "DomainName" if Jets.custom_domain?
+      p[:BasePath] = "BasePath"
+      p
+    end
+
+    # Because Jets generates a new timestamped logical id for the API Deployment
+    # resource it also creates a new root base path mapping and fails.  Additionally,
+    # the base path mapping depends on the API Deploy for the stage name.
+    #
+    # We resolve this by using a custom resource that does an in-place update.
+    #
+    # Note, also tried to change the domain name of to something like demo-dev-[random].mydomain.com
+    # but that does not work because the domain name has to match the route53 record exactly.
+    #
+    def add_base_path_mapping
+      function = Jets::Cfn::Resource::ApiGateway::BasePath::Function.new
+      add_resource(function)
+      add_outputs(function.outputs)
+
+      mapping = Jets::Cfn::Resource::ApiGateway::BasePath::Mapping.new
+      add_resource(mapping)
+      add_outputs(mapping.outputs)
+
+      iam_role = Jets::Cfn::Resource::ApiGateway::BasePath::Role.new
+      add_resource(iam_role)
+      add_outputs(iam_role.outputs)
+    end
+
+    # interface method
+    def template_path
+      Jets::Names.api_mapping_template_path
+    end
+
+    # do not write a template unless custom domain is used
+    def write
+      super if Jets.custom_domain?
+    end
+  end
+end

data/lib/jets/cfn/builder/api/methods.rb

@@ -0,0 +1,72 @@
+module Jets::Cfn::Builder::Api
+  class Methods < Paged
+    # interface method
+    def compose
+      return if routes.empty?
+      add_api_methods
+      add_api_gateway_parameters
+    end
+
+    # Resources Example (only showing keys we care about):
+    #
+    #   UpIndexGetApiMethod:
+    #     Type: AWS::ApiGateway::Method
+    #     Properties:
+    #       ResourceId: !Ref UpApiResource
+    #       RestApiId: !Ref RestApi
+    #       Integration:
+    #         Uri: !Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${UpControllerIndexLambdaFunction}/invocations
+    #
+    def add_api_methods
+      routes.each_with_index do |route, i|
+        method = Jets::Cfn::Resource::ApiGateway::Method.new(route)
+        add_resource(method)
+      end
+    end
+
+    def add_api_gateway_parameters
+      api_methods = Jets::Cfn::Params::Api::Methods.new(template: @template)
+      api_methods.params.each do |key, _|
+        add_parameter(key)
+      end
+    end
+
+    def routes
+      ensure_one_apigw_method_proxy_routes!
+      @items.map do |uid|
+        Jets::Router.routes.find do |route|
+          route.path == "/" && route.path == uid.split('|').last || # root route. any http method works
+          "#{route.http_method}|#{route.path}" == uid # Match the method and path. IE: GET|posts/:id
+        end
+      end.compact
+    end
+    memoize :routes
+
+    # Only add missing root route with one_apigw_method_for_all_routes setting.
+    # Add the root route because that's how it works locally.
+    # With one_apigw_method_for_all_routes, it all goes to one lambda function
+    # and routing is determined by config/routes.rb
+    def ensure_one_apigw_method_proxy_routes!
+      return unless Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
+
+      # find before modifications
+      catchall_route = Jets::Router.routes.find { |route| route.path =~ /^\/\*/ }
+      root_route = Jets::Router.routes.find { |route| route.http_method == "GET" && route.path == "/" }
+
+      # modifications
+      unless catchall_route
+        # Note: catchall to route does not matter. In one_apigw_method_for_all_routes mode it all goes to one lambda function
+        # and then gets routed by config/routes.rb
+        Jets::Router.routes << Jets::Router::Route.new(path: '/*catchall', http_method: 'ANY', to: 'jets/public#show')
+      end
+      if !root_route && catchall_route
+        Jets::Router.routes << Jets::Router::Route.new(path: '/', http_method: 'GET', to: catchall_route.to)
+      end
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Names.api_methods_template_path(@page_number)
+    end
+  end
+end

data/lib/jets/cfn/builder/api/paged.rb

@@ -0,0 +1,30 @@
+module Jets::Cfn::Builder::Api
+  class Paged < Base
+    class << self
+      def build_pages(options={})
+        # IE: Pages::Methods.pages Pages::Resources.pages
+        pages_class.pages.each do |page|
+          # Key builder here:
+          #   Jets::Cfn::Builder::Api::Methods
+          #   Jets::Cfn::Builder::Api::Resources
+          new(options.merge(page: page)).build
+        end
+      end
+
+      # Examples:
+      #   Pages::Methods.new(options)
+      #   Pages::Resources.new(options)
+      def pages_class
+        class_name = self.to_s.gsub(/.*::Api::/, '') # IE: Methods or Resources
+        "Jets::Cfn::Builder::Api::Pages::#{class_name}".constantize
+      end
+    end
+
+    def initialize(options={})
+      super
+      @page = options[:page]
+      @items = @page.items        # interface method: Cors: paths, Resources: paths, Methods: routes
+      @page_number = @page.number # interface method
+    end
+  end
+end

data/lib/jets/cfn/builder/api/pages/base.rb

@@ -0,0 +1,105 @@
+module Jets::Cfn::Builder::Api::Pages
+  class Base
+    class_attribute :pages
+    @@pages = {}
+
+    class << self
+      extend Memoist
+
+      # Returns: Array<Page>
+      def pages
+        return @@pages[self.name] if @@pages[self.name]
+
+        pages = []
+        uids_map = build_uids_map
+        uids_map.each do |uid, existing_page|
+          if existing_page
+            pages[existing_page] ||= []
+            pages[existing_page] << uid
+          end
+        end
+        pages.compact! # not using page 0 so need to compact to remove the first nil element
+
+        # Remove existing uids from uids_map. Leave behind new uids
+        pages.each do |page|
+          page.each do |i|
+            uids_map.delete(i)
+          end
+        end
+
+        # Fill up available space in each page so all existing pages are full
+        keys = uids_map.keys
+        pages.each do |page|
+          break if keys.empty?
+          while page.size < page_limit
+            uid = keys.shift
+            break if uid.nil?
+            page << uid
+          end
+        end
+
+        # Add remaining slices to new additional pages
+        pages += keys.each_slice(page_limit).to_a
+
+        @@pages[self.name] = []
+        pages.each_with_index do |uids, i|
+          # Note: page number starts at 1
+          # Because of this we need to do a pages.compact! above to remove the first nil element. Feel this is easier for follow for us humans.
+          @@pages[self.name] << Page.new(items: uids, number: i+1)
+        end
+
+        @@pages[self.name]
+      end
+
+      # Build map that has uids as keys and page number as value
+      # For Resources, the uid is the path
+      #   Example: {"a1"=>0, "a2"=>0, "b1"=>1, "b2"=>1, "c1"=>2, "c2"=>2}
+      # For Methods, the uid is the method|path
+      #   Example: {"GET|a1"=>0, "GET|a2"=>0, "GET|b1"=>1, "GET|b2"=>1, "GET|c1"=>2, "GET|c2"=>2}
+      def build_uids_map
+        map = {}
+        # uids is interface method
+        uids.each do |uid|
+          map[uid] = find_page_index(uid)
+        end
+        map
+      end
+
+      def find_page_index(new_uid)
+        slices = previously_deployed || []
+        slices.each_with_index do |slice, page_number|
+          items = slice["items"]
+          items.find do |old_uid|
+            return page_number if old_uid == new_uid # found
+          end
+        end
+        nil # not found
+      end
+
+      def previously_deployed
+        state = Jets::Router::State.new
+        name = self.to_s.split('::').last.downcase
+        deployed = state.load(name) # IE: state.load("resources") or state.load("methods")
+        deployed
+      end
+      memoize :previously_deployed
+
+      # Relevant CloudFormation limits:
+      #    Resources 500
+      #    Parameters 200
+      #    Outputs 200
+      # For API Gateway Methods template,
+      # Lambda Functions and APIGW Resources are passed in as parameters.
+      # Each APIGW Method can use 2 parameters.
+      # So use page limit of 100 to provide a buffer.
+      # Technically, can use a different limit for Resources and Cors templates,
+      # but keeping all at 100 for consistency.
+      #
+      # JETS_API_PAGE_LIMIT is based on that
+      # https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
+      def page_limit
+        Integer(ENV['JETS_API_PAGE_LIMIT'] || 100)
+      end
+    end
+  end
+end

data/lib/jets/cfn/builder/api/pages/methods.rb

@@ -0,0 +1,17 @@
+module Jets::Cfn::Builder::Api::Pages
+  class Methods < Base
+    class << self
+      # interface method
+      def uids
+        if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
+          return ['ANY|/', 'ANY|/*catchall']
+        end
+
+        routes = Jets::Router.routes
+        routes.map do |route|
+          "#{route.http_method}|#{route.path}"  # IE: GET|posts/:id
+        end
+      end
+    end
+  end
+end

data/lib/jets/cfn/builder/api/pages/page.rb

@@ -0,0 +1,19 @@
+module Jets::Cfn::Builder::Api::Pages
+  # Note: Do not use, it behaves differently in Ruby 2 v Ruby 3
+  # Page = Struct.new(:items, :number)
+  #
+  # In Ruby 2, assigning an Array to items creates an extra :items key in the structure
+  #
+  #    #<struct Page items={:items=>["*catchall", "posts"],
+  #
+  # In Ruby 3, assigning an Array to items.
+  #
+  #    #<struct Page items=["*catchall", "posts"], number=1>
+  #
+  class Page
+    attr_accessor :items, :number
+    def initialize(items:, number:)
+      @items, @number = items, number
+    end
+  end
+end

data/lib/jets/cfn/builder/api/pages/resources.rb

@@ -0,0 +1,21 @@
+module Jets::Cfn::Builder::Api::Pages
+  class Resources < Base
+    class << self
+      # interface method
+      def uids
+        if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
+          return ['/', '/*catchall']
+        end
+
+        # Note: Do not use
+        #     Jets::Router.routes.map(&:path)
+        # It does not include all the top of the leaves.  Example:
+        #   admin is not included
+        #   admin/new is included
+        # Also, do not include the root/homepage path. It's already created
+        # in api-gateway.yml
+        Jets::Router.all_paths.reject { |p| p.blank? }
+      end
+    end
+  end
+end

data/lib/jets/cfn/builder/api/resources.rb

@@ -0,0 +1,40 @@
+module Jets::Cfn::Builder::Api
+  class Resources < Paged
+    # interface method
+    def compose
+      add_gateway_resources
+      add_rest_api_parameter
+    end
+
+    # interface method
+    def template_path
+      Jets::Names.api_resources_template_path(@page_number)
+    end
+
+    def add_rest_api_parameter
+      add_parameter(:RestApi)
+    end
+
+    def add_gateway_resources
+      @items.each do |path|
+        # IE: resource = Jets::Cfn::Resource::ApiGateway::Resource.new(path)
+        next if path == '/' || path == '' # skip root path
+        resource = api_gateway_resource_class.new(path)
+        add_resource(resource)
+        add_outputs(resource.outputs)
+
+        parent_path = resource.parent_path_parameter
+        add_parameter(parent_path) unless part_of_template?(parent_path)
+      end
+    end
+
+    # interface method
+    def api_gateway_resource_class
+      Jets::Cfn::Resource::ApiGateway::Resource
+    end
+
+    def part_of_template?(parent_path)
+      @template[:Resources].key?(parent_path)
+    end
+  end
+end