jets-fs 1.6.10

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

@@ -0,0 +1,29 @@
+# Detects route to changes
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class To < Base
+    def self.changed?
+      new.changed?
+    end
+
+    def changed?
+      deployed_routes.each do |deployed_route|
+        new_route = find_comparable_route(deployed_route)
+        if new_route && 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.method == deployed_route.method
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# Detects route variable changes
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Variable < Base
+    def self.changed?
+      new.changed?
+    end
+
+    def changed?
+      changed = false
+      deployed_routes.each do |deployed_route|
+        parent = collision.variable_parent(deployed_route.path)
+        parent_variables = collision.parent_variables(parent, [deployed_route.path])
+        new_parent_variables = collision.parent_variables(parent, new_paths)
+
+        changed = parent_variables.size > 0 && new_parent_variables.size > 0 &&
+                  parent_variables != new_parent_variables
+        break if changed
+      end
+      changed
+    end
+
+    # Only consider paths with variables
+    def new_paths
+      new_routes.map(&:path).select {|p| p.include?(':')}.uniq
+    end
+
+    # Only consider deployed routes with variables
+    def deployed_routes
+      deployed_routes = super
+      deployed_routes.select do |route|
+        route.path.include?(':')
+      end
+    end
+
+    def collision
+      @collision ||= Jets::Resource::ApiGateway::RestApi::Routes::Collision.new
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# Detects path variable collisions
+class Jets::Resource::ApiGateway::RestApi::Routes
+  class Collision
+    autoload :VariableException, 'jets/resource/api_gateway/rest_api/routes/collision/variable_exception'
+
+    attr_reader :collisions
+    def initialize
+      @collisions = []
+    end
+
+    def collision?(paths)
+      paths = paths_with_variables(paths)
+      parents = variable_parents(paths)
+
+      collide = false
+      parents.each do |parent|
+        collide ||= variable_collision_exists?(parent, paths)
+      end
+      collide
+    end
+
+    def exception
+      VariableException.new(collision_message)
+    end
+
+    def collision_message
+      <<~EOL
+        There are routes with sibling variables under the same parent that collide.
+
+        Collisions:
+          #{@collisions.join("\n  ")}
+
+        API Gateway only allows one unique variable path You must use the same variable name within
+        the same parent route path.
+        Example: /posts/:id and /posts/:post_id/reveal should both be /posts/:id and /posts/:id/reveal.
+
+        Please check your `config/routes.rb` and remove the colliding routes.
+        More info: http://rubyonjets.com/docs/considerations-api-gateway/
+      EOL
+    end
+
+    def variable_collision_exists?(parent, paths)
+      paths = paths_with_variables(paths)
+      variables = parent_variables(parent, paths)
+      collide = variables.uniq.size > 1
+      register_collision(parent, variables) if collide
+      collide
+    end
+
+    # register collision for later display
+    # We don't register the full path but this might be more helpful.
+    def register_collision(parent, variables)
+      return unless variables.uniq.size # check again just in case
+
+      variables.each do |v|
+        @collisions << "#{parent}/#{v}"
+      end
+      @collisions.uniq!
+    end
+
+    def parent_variables(parent, paths)
+      paths = paths.select do |path|
+        parent?(parent, path)
+      end
+      paths.map do |path|
+        path.sub("#{parent}/",'').gsub(%r{/.*},'')
+      end.uniq.sort
+    end
+
+    def parent?(parent, path)
+      return false if parent == path
+
+      parent_parts = parent.split('/')
+      path_parts = path.split('/')
+
+      n = parent_parts.size-1
+      parent_parts[0..n] == path_parts[0..n]
+    end
+
+    def direct_parent?(parent, path)
+      leaf = variable_leaf(path)
+      leaf_parent = leaf.split('/')[0..-2].join('/')
+      parent == leaf_parent
+    end
+
+    def variable_parents(paths)
+      parents = []
+      paths = paths_with_variables(paths)
+      paths.each do |path|
+        parents << variable_parent(path)
+      end
+      parents.uniq.sort
+    end
+
+    # Strips the path down until only the leaf node part is a variable
+    # Example: users/:user_id/posts/:post_id/edit
+    # Returns: users/:user_id/posts
+    def variable_parent(path)
+      path = variable_leaf(path)
+      # drop last variable to leave behind the parent
+      path.split('/')[0..-2].join('/')
+    end
+
+    # Strips the path down until only the leaf node part is a variable
+    # Example: users/:user_id/posts/:post_id/edit
+    # Returns: users/:user_id/posts
+    def variable_leaf(path)
+      return '' unless path.include?(':')
+
+      parts = path.split('/')
+      is_variable = parts.last.include?(':')
+      until is_variable
+        parts.pop
+        is_variable = parts.last.include?(':')
+      end
+      parts[0..-1].join('/') # parent
+    end
+
+    def paths_with_variables(paths)
+      paths.select { |p| p.include?(':') }.uniq
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/collision/variable_exception.rb

@@ -0,0 +1,7 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Collision
+  class VariableException < RuntimeError
+    def initialize(message="Route variable collisions")
+      super(message)
+    end
+  end
+end

data/lib/jets/resource/associated.rb

@@ -0,0 +1,26 @@
+# Does not do full expansion, mainly a container that holds the definition and
+# standardizes it without camelizing it.
+class Jets::Resource
+  class Associated
+    extend Memoist
+
+    attr_reader :definition
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def logical_id
+      standardized.keys.first
+    end
+
+    def attributes
+      standardized.values.first
+    end
+
+    def standardized
+      standardizer = Standardizer.new(definition)
+      standardizer.standarize(definition) # doesnt camelize keys yet
+    end
+    memoize :standardized
+  end
+end

data/lib/jets/resource/base.rb

@@ -0,0 +1,28 @@
+# 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.rb

@@ -0,0 +1,7 @@
+module Jets::Resource::ChildStack
+  autoload :AppClass, 'jets/resource/child_stack/app_class'
+  autoload :ApiGateway, 'jets/resource/child_stack/api_gateway'
+  autoload :ApiDeployment, 'jets/resource/child_stack/api_deployment'
+  autoload :Base, 'jets/resource/child_stack/base'
+  autoload :Shared, 'jets/resource/child_stack/shared'
+end

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

@@ -0,0 +1,56 @@
+# 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 = {
+        IamRole: "!GetAtt IamRole.Arn",
+        RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      p[:DomainName] = "!GetAtt ApiGateway.Outputs.DomainName" if Jets.custom_domain?
+      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

@@ -0,0 +1,29 @@
+# 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 outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-api-gateway.yml"
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class AppClass < Base
+    def initialize(s3_bucket, options={})
+      super
+      @path = options[:path]
+    end
+
+    def definition
+      logical_id = app_logical_id
+      defintion = {
+        logical_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          }
+        }
+      }
+      defintion[logical_id][:depends_on] = depends_on if depends_on
+      defintion
+    end
+
+    def depends_on
+      klass = current_app_class.constantize
+      return unless klass.depends_on
+
+      klass.depends_on.map do |shared_stack|
+        shared_stack.to_s.camelize # logical_id
+      end
+    end
+
+    def depends_on_params
+      params = {}
+      depends_on.each do |dependency|
+        dependency_outputs(dependency).each do |output|
+          dependency_class = dependency.to_s.classify
+          params[output] = "!GetAtt #{dependency_class}.Outputs.#{output}"
+        end
+      end
+      params
+    end
+
+    def dependency_outputs(dependency)
+      dependency.to_s.classify.constantize.output_keys
+    end
+
+    def parameters
+      common = self.class.common_parameters
+      common.merge!(controller_params) if controller?
+      common.merge!(depends_on_params) if depends_on
+      common
+    end
+
+    def self.common_parameters
+      parameters = {
+        IamRole: "!GetAtt IamRole.Arn",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      parameters[:GemLayer] = "!Ref GemLayer" unless Jets.poly_only?
+      parameters
+    end
+
+    def controller_params
+      return {} if Jets::Router.routes.empty?
+
+      params = {
+        RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
+      }
+      scoped_routes.each do |route|
+        resource = Jets::Resource::ApiGateway::Resource.new(route.path)
+        params[resource.logical_id] = "!GetAtt ApiGateway.Outputs.#{resource.logical_id}"
+      end
+      params
+    end
+
+    def controller?
+      @path.include?('_controller.yml')
+    end
+
+    def scoped_routes
+      @routes ||= Jets::Router.routes.select do |route|
+        route.controller_name == current_app_class
+      end
+    end
+
+    def current_app_class
+      templates_prefix = "#{Jets::Naming.template_path_prefix}-app-"
+      @path.sub(templates_prefix, '')
+        .sub(/\.yml$/,'')
+        .gsub('-','/')
+        .classify
+    end
+
+    # map the path to a camelized logical_id. Example:
+    #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+    #   PostsController
+    def app_logical_id
+      regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
+      controller_name = @path.sub(regexp, '').sub('.yml', '')
+      controller_name.underscore.camelize
+    end
+
+    def template_filename
+      @path
+    end
+  end
+end