jets 3.1.0 → 5.0.0

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

data/lib/jets/cfn/{builders/authorizer_builder.rb → builder/authorizer.rb}

@@ -1,10 +1,5 @@
-# Implements:
-#
-#   compose
-#   template_path
-#
-module Jets::Cfn::Builders
-  class AuthorizerBuilder < BaseChildBuilder
+class Jets::Cfn::Builder
+  class Authorizer < Nested
     include Interface
     include Jets::AwsServices
 
@@ -14,6 +9,7 @@ module Jets::Cfn::Builders
       @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
     end
 
+    # interface method
     def compose
       add_common_parameters
       add_api_gateway_parameters
@@ -25,22 +21,27 @@ module Jets::Cfn::Builders
       add_cognito_outputs
     end
 
+    # interface method
+    def template_path
+      Jets::Names.authorizer_template_path(@path)
+    end
+
     def add_cognito_authorizers
       @app_class.cognito_authorizers.each do |authorizer|
-        resource = Jets::Resource.new(authorizer[:definition], authorizer[:replacements])
+        resource = Jets::Cfn::Resource.new(authorizer[:definition], authorizer[:replacements])
         add_resource(resource)
       end
     end
 
     def add_outputs
       # IE: @app_class = MainAuthorizer
-      # The associated resource is the Jets::Resource::ApiGateway::Authorizer definition built during evaluation
+      # The associated resource is the Jets::Cfn::Resource::ApiGateway::Authorizer definition built during evaluation
       # of the user defined Authorizer class. We'll use it to compute the logical id.
-      @app_class.tasks.each do |task|
-        authorizer = task.associated_resources.first
+      @app_class.definitions.each do |definition|
+        authorizer = definition.associated_resources.first
         next unless authorizer
 
-        resource = Jets::Resource.new(authorizer.definition, task.replacements)
+        resource = Jets::Cfn::Resource.new(authorizer.definition, definition.replacements)
         logical_id = resource.logical_id
         add_output(logical_id, value: "!Ref #{logical_id}")
       end
@@ -48,20 +49,16 @@ module Jets::Cfn::Builders
 
     def add_cognito_outputs
       @app_class.cognito_authorizers.each do |authorizer|
-        resource = Jets::Resource.new(authorizer[:definition], authorizer[:replacements])
+        resource = Jets::Cfn::Resource.new(authorizer[:definition], authorizer[:replacements])
         logical_id = resource.logical_id
         add_output(logical_id, value: "!Ref #{logical_id}")
       end
     end
 
     def add_api_gateway_parameters
-      return if Jets::Router.routes.empty?
+      return if Jets::Router.no_routes?
 
-      add_parameter("RestApi", Description: "RestApi")
-    end
-
-    def template_path
-      Jets::Naming.authorizer_template_path(@path)
+      add_parameter(:RestApi)
     end
   end
 end

data/lib/jets/cfn/builder/controller.rb

@@ -0,0 +1,28 @@
+class Jets::Cfn::Builder
+  class Controller < Nested
+    # interface method
+    def compose
+      add_common_parameters
+      add_api_gateway_parameters
+      add_functions
+      add_resources
+      add_outputs
+    end
+
+    def add_outputs
+      outputs = {}
+      @template[:Resources].each do |logical_id, resource|
+        next unless resource[:Type] == "AWS::Lambda::Function"
+        outputs.merge!(logical_id => {
+          Value: "!GetAtt #{logical_id}.Arn"
+        })
+      end
+      @template[:Outputs] = outputs
+    end
+
+    def add_api_gateway_parameters
+      return if Jets::Router.no_routes?
+      add_parameter(:RestApi)
+    end
+  end
+end

data/lib/jets/cfn/builder/function.rb

@@ -0,0 +1,9 @@
+class Jets::Cfn::Builder
+  class Function < Nested
+    # interface method
+    def compose
+      add_common_parameters
+      add_functions
+    end
+  end
+end

data/lib/jets/cfn/builder/interface.rb

@@ -0,0 +1,146 @@
+# The class including this module should implement these methods:
+#
+#   * compose
+#   * template_path
+#
+class Jets::Cfn::Builder
+  module Interface
+    extend Memoist
+    include Jets::Util::Camelize
+
+    def build
+      return unless build?
+      compose # must be implemented by subclass
+      write
+    end
+
+    # Do not bother building or writing the template unless there are functions defined
+    def build?
+      build = @app_class && !@app_class.build?
+      !build
+    end
+
+    def write
+      FileUtils.mkdir_p(File.dirname(template_path))
+      IO.write(template_path, text)
+    end
+
+    def template
+      # need the to_hash or the YAML dump has
+      #  !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+      @template.to_hash
+    end
+
+    def text
+      # -1 means unlimited line width, it prevents the YAML.dump from wrapping
+      # Otherwise the PostProcess class will not work properly.
+      text = YAML.dump(template, line_width: -1)
+      # post process the text so that
+      # "!Ref IamRole" => !Ref IamRole
+      # We strip the surrounding quotes
+      PostProcess.new(text).process
+    end
+
+    def add_description(desc)
+      @template[:Description] = desc
+    end
+
+    def add_parameters(attributes)
+      attributes.each do |name,value|
+        add_parameter(name.camelize.to_sym, Description: value)
+      end
+    end
+
+    def add_parameter(name, options={})
+      defaults = { Type: "String" }
+      options = defaults.merge(options)
+      @template[:Parameters] ||= {}
+      @template[:Parameters][name.camelize.to_sym] = camelize(options)
+    end
+
+    def add_outputs(attributes)
+      attributes.each do |name,value|
+        add_output(name.camelize.to_sym, Value: value)
+      end
+    end
+
+    def add_output(name, options={})
+      @template[:Outputs] ||= {}
+      @template[:Outputs][name.camelize.to_sym] = camelize(options)
+    end
+
+    def add_resources
+      @app_class.definitions.each do |definition|
+        definition.associated_resources.each do |associated|
+          resource = Jets::Cfn::Resource.new(associated.definition, definition.replacements)
+          add_resource(resource)
+          add_resource(resource.permission)
+        end
+      end
+    end
+
+    # Note: Jets::Cfn::Resource::Iam classes are special treated.
+    # They are only a few resources that result in creating 2 CloudFormation resources.
+    # Cfn::Builder::Api::Methods also creates a method, permission, and possible cors resource.
+    # Though that is more of an internal Jets resource.
+    # In this case for Iam, both Iam::Policy and Iam::Role are created.
+    # This allows the user to refer to the Lambda Function name in the IAM Policy itself.
+    # We need separate resources to avoid CloudFormation erroring with a circular dependency.
+    # Using separate IAM::Policy and IAM::Role resources allows us avoid the circular dependency error.
+    #
+    # Handling logic here also centralizes code for this special behavior.
+    # Also important to note, this does not change the user-facing interface.
+    # IE: Users still uses code like:
+    #
+    #    iam_policy("s3", "sns")
+    #
+    # and be none-the-wiser about the special behavior.
+    def add_resource(resource)
+      add_template_resource(resource.logical_id, resource.type, resource.attributes)
+
+      if resource.class.to_s.include?("Jets::Cfn::Resource::Iam")
+        role = resource # for clarity: resource is a Iam::*Role class
+        iam_policy = Jets::Cfn::Resource::Iam::Policy.new(role)
+        add_template_resource(iam_policy.logical_id, iam_policy.type, iam_policy.attributes)
+      end
+    end
+
+    # The add_resource method can take an options Hash with both with either
+    # top level attributes or properties.
+    #
+    # Example:
+    #
+    # Top level options:
+    #
+    #   add_template_resource("MyId", "AWS::ApiGateway::RestApi",
+    #     Type: "AWS::ApiGateway::RestApi",
+    #     Properties: {
+    #       Name: "my-api"
+    #     },
+    #     DependsOn: ["AnotherResource"]
+    #   )
+    #
+    # Simple options with properties only:
+    #
+    #   add_template_resource("MyId", "AWS::CloudFormationStack",
+    #     TemplateURL: "template_url",
+    #     Parameters: {},
+    #   )
+    #
+    def add_template_resource(logical_id, type, options)
+      options = camelize(options)
+
+      attributes = if options.include?(:Type)
+                     base = { Type: type }
+                     base.merge(options) # options are top-level attributes
+                   else
+                     {
+                       Type: type,
+                       Properties: options # options are properties
+                     }
+                   end
+
+      @template[:Resources][logical_id] = attributes
+    end
+  end
+end

data/lib/jets/cfn/builder/job.rb

@@ -0,0 +1,10 @@
+class Jets::Cfn::Builder
+  class Job < Nested
+    # interface method
+    def compose
+      add_common_parameters
+      add_functions
+      add_resources
+    end
+  end
+end

data/lib/jets/cfn/builder/nested.rb

@@ -0,0 +1,130 @@
+# Note: compose implemented by the classes that include this
+class Jets::Cfn::Builder
+  class Nested
+    include Interface
+
+    # The app_class is can be a controller, job or anonymous function class.
+    # IE: PostsController, HardJob
+    def initialize(app_class)
+      @app_class = app_class
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # interface method
+    def template_path
+      Jets::Names.app_template_path(@app_class)
+    end
+
+    def add_common_parameters
+      common_parameters = Jets::Cfn::Params::Common.parameters
+      common_parameters.each do |k,_|
+        add_parameter(k)
+      end
+
+      depends_on_params.each do |output_key, _|
+        add_parameter(output_key)
+      end
+    end
+
+    def depends_on_params
+      return {} if Jets.one_lambda_for_all_controllers? && @app_class.to_s.ends_with?("Controller")
+      return {} if @app_class.is_a?(Hash)
+      return {} unless @app_class.depends_on
+      depends = Jets::Stack::Depends.new(@app_class.depends_on)
+      depends.params
+    end
+
+    def add_functions
+      validate_function_names!
+      if Jets.one_lambda_per_controller? && @app_class.to_s.ends_with?("Controller")
+        one_lambda_per_controller
+      else
+        one_lambda_per_method
+      end
+    end
+
+    def one_lambda_per_method
+      add_class_iam_policy
+      @app_class.definitions.each do |definition|
+        add_function(definition)
+        add_function_iam_policy(definition)
+      end
+    end
+
+    def one_lambda_per_controller
+      add_class_iam_policy
+      definition = Jets::Lambda::Definition.new(@app_class, "lambda_handler",
+        lang: :ruby,
+      )
+      add_function(definition)
+      unless Jets::Router.no_routes?
+        controller = Jets::Cfn::Resource::Lambda::Function::Controller.new(definition)
+        add_resource(controller.permission)
+      end
+    end
+
+    def add_function(definition)
+      resource = Jets::Cfn::Resource::Lambda::Function.new(definition)
+      add_resource(resource)
+      # apigw lambda permission is also added to the controller template next to the function
+      route = Jets::Router.find_by_definition(definition)
+      if route
+        # Creates a permission more directly to set principal apigateway.amazonaws.com
+        method = Jets::Cfn::Resource::ApiGateway::Method.new(route)
+        add_resource(method.permission)
+      end
+    end
+
+    # routes scoped to this controller template.
+    def scoped_routes
+      @routes ||= Jets::Router.routes.select do |route|
+        route.controller_name == @app_class.to_s
+      end
+    end
+
+    def add_class_iam_policy
+      return unless build_class_iam_policy?
+
+      resource = Jets::Cfn::Resource::Iam::ClassRole.new(@app_class)
+      add_resource(resource)
+    end
+
+    def build_class_iam_policy?
+      should_build = false
+      klass = @app_class
+      while klass && klass != Object
+        if klass&.build_class_iam?
+          should_build = true
+          break
+        end
+        klass = klass.superclass
+      end
+      should_build
+    end
+
+    def add_function_iam_policy(definition)
+      return unless definition.build_function_iam?
+
+      resource = Jets::Cfn::Resource::Iam::FunctionRole.new(definition)
+      add_resource(resource)
+    end
+
+    def validate_function_names!
+      invalids = @app_class.definitions.reject do |definition|
+        definition.meth.to_s =~ /^[a-zA-Z][a-zA-Z0-9_]/
+      end
+      return if invalids.empty?
+      list = invalids.map do |definition|
+        "    #{definition.class_name}##{definition.meth}" # IE: PostsController#index
+      end.join("\n")
+      puts "ERROR: Detected invalid AWS Lambda function names".color(:red)
+      puts <<~EOL
+        Lambda function names must start with a letter and can only contain letters, numbers, and underscores.
+        Invalid function names:
+
+        #{list}
+      EOL
+      exit 1
+    end
+  end
+end

data/lib/jets/cfn/builder/one_controller.rb

@@ -0,0 +1,53 @@
+class Jets::Cfn::Builder
+  class OneController < Nested
+    def build?
+      true
+    end
+
+    # interface method
+    def compose
+      add_one_function
+      add_common_parameters
+      add_api_gateway_parameters
+      add_outputs
+    end
+
+    # interface method
+    def template_path
+      Jets::Names.one_controller_template_path
+    end
+
+    def add_one_function
+      resource = Jets::Cfn::Resource::One::Function.new
+      add_resource(resource)
+      add_application_controller_iam_policy
+      unless Jets::Router.no_routes?
+        permission = Jets::Cfn::Resource::One::Permission.new
+        add_resource(permission)
+      end
+    end
+
+    def add_application_controller_iam_policy
+      klass = ApplicationController
+      return unless klass.build_class_iam?
+      resource = Jets::Cfn::Resource::Iam::ClassRole.new(klass)
+      add_resource(resource)
+    end
+
+    def add_outputs
+      outputs = {}
+      @template[:Resources].each do |logical_id, resource|
+        next unless resource[:Type] == "AWS::Lambda::Function"
+        outputs.merge!(logical_id => {
+          Value: "!GetAtt #{logical_id}.Arn"
+        })
+      end
+      @template[:Outputs] = outputs
+    end
+
+    def add_api_gateway_parameters
+      return if Jets::Router.no_routes?
+      add_parameter(:RestApi)
+    end
+  end
+end

data/lib/jets/cfn/{builders/parent_builder → builder/parent}/stagger.rb

@@ -1,4 +1,4 @@
-class Jets::Cfn::Builders::ParentBuilder
+class Jets::Cfn::Builder::Parent
   module Stagger
     def add_stagger(resource)
       batch_size = stagger_batch_size # shorter convenience variable

data/lib/jets/cfn/builder/parent.rb

@@ -0,0 +1,149 @@
+class Jets::Cfn::Builder
+  class Parent
+    include Interface
+    include Jets::AwsServices
+    include Stagger
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # interface method
+    def compose
+      build_minimal_resources
+      build_child_resources
+    end
+
+    # interface method
+    def template_path
+      Jets::Names.parent_template_path
+    end
+
+    def build_minimal_resources
+      add_description("Jets: #{Jets.version} Code: #{Util::Source.version}")
+
+      # Initial s3 bucket, used to store code zipfile and templates Jets generates
+      #
+      # AWS changed the default behavior of s3 buckets to block public access
+      #   https://aws.amazon.com/blogs/aws/amazon-s3-block-public-access-another-layer-of-protection-for-your-accounts-and-buckets/
+      #   https://github.com/aws-amplify/amplify-cli/issues/12503
+      #
+      # Jets uploads assets to s3 bucket with acl: "public-read" here
+      #   https://github.com/boltops-tools/jets/blob/c5858ec2706a606665a92c3ada3f16ae4c753372/lib/jets/cfn/upload.rb#L97
+      #
+      # Use minimal s3 bucket policy to allow public read access to assets.
+      # Leave the other options as comments to help document the default behavior.
+      resource = Jets::Cfn::Resource::S3::JetsBucket.new
+      add_resource(resource)
+      add_outputs(resource.outputs)
+
+      return unless full?
+      # Add application-wide IAM policy from Jets.config.iam_role
+      resource = Jets::Cfn::Resource::Iam::ApplicationRole.new
+      add_resource(resource)
+      add_outputs(resource.outputs)
+
+      return if Jets.poly_only?
+      resource = Jets::Cfn::Resource::Lambda::GemLayer.new
+      add_resource(resource)
+      add_outputs(resource.outputs)
+    end
+
+    def build_child_resources
+      return unless full?
+
+      add_one_lambda_controller if Jets.one_lambda_for_all_controllers? && Jets.config.mode != "job"
+      for_each_path(:app) do |path|
+        add_app_class_stack(path)
+      end
+      for_each_path(:shared) do |path|
+        add_shared_resources(path)
+      end
+
+      return if Jets::Router.no_routes?
+      for_each_path(:authorizers) do |path|
+        add_authorizer_resources(path)
+      end
+      add_api_gateway
+      add_api_resources
+      add_api_methods
+      add_api_deployment
+      add_api_mapping
+    end
+
+    def full?
+      @options[:stack_type] == :full
+    end
+
+    def add_one_lambda_controller
+      resource = Jets::Cfn::Resource::Nested::OneController.new(@options)
+      add_child_resources(resource)
+    end
+
+      # Example paths:
+    #    #{Jets.build_root}/templates/shared-resources.yml
+    #    #{Jets.build_root}/templates/app-comments_controller.yml
+    #    #{Jets.build_root}/templates/authorizers-main_authorizer.yml
+    def for_each_path(type)
+      expression = "#{Jets::Names.templates_folder}/#{type}-*"
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+        yield(path)
+      end
+    end
+
+    def add_app_class_stack(path)
+      resource = Jets::Cfn::Resource::Nested::AppClass.new(@options.merge(path: path))
+      add_stagger(resource)
+      add_child_resources(resource)
+    end
+
+    def add_authorizer_resources(path)
+      resource = Jets::Cfn::Resource::Nested::Authorizer.new(@options.merge(path: path))
+      add_child_resources(resource)
+    end
+
+    def add_shared_resources(path)
+      resource = Jets::Cfn::Resource::Nested::Shared.new(@options.merge(path: path))
+      add_child_resources(resource) if resource.resources?
+    end
+
+    def add_api_gateway
+      resource = Jets::Cfn::Resource::Nested::Api::Gateway.new(@options)
+      add_child_resources(resource)
+    end
+
+    def add_api_resources
+      pages = Api::Pages::Resources.pages
+      pages.each do |page|
+        resource = Jets::Cfn::Resource::Nested::Api::Resources.new(@options.merge(page_number: page.number))
+        add_child_resources(resource)
+      end
+    end
+
+    def add_api_methods
+      pages = Api::Pages::Methods.pages
+      pages.each do |page|
+        resource = Jets::Cfn::Resource::Nested::Api::Methods.new(@options.merge(page_number: page.number))
+        add_child_resources(resource)
+      end
+    end
+
+    def add_api_deployment
+      resource = Jets::Cfn::Resource::Nested::Api::Deployment.new(@options)
+      add_child_resources(resource)
+    end
+
+    def add_api_mapping
+      return unless Jets.custom_domain?
+      resource = Jets::Cfn::Resource::Nested::Api::Mapping.new(@options)
+      add_child_resources(resource)
+    end
+
+    def add_child_resources(resource)
+      add_resource(resource)
+      add_outputs(resource.outputs)
+    end
+  end
+end

data/lib/jets/cfn/builder/post_process.rb

@@ -0,0 +1,25 @@
+# post process the text so that
+# "!Ref IamRole" => !Ref IamRole
+# We strip the surrounding quotes
+class Jets::Cfn::Builder
+  class PostProcess
+    def initialize(text)
+      @text = text
+    end
+
+    def process
+      results = @text.split("\n").map do |line|
+        if line.include?(': "!') # IE: IamRole: "!Ref IamRole",
+           # IamRole: "!Ref IamRole" => IamRole: !Ref IamRole
+          line.sub(/: "(.*)"/, ': \1')
+        elsif line.include?('- "!') # IE: - "!GetAtt Foo.Arn"
+           # IamRole: - "!GetAtt Foo.Arn" => - !GetAtt Foo.Arn
+          line.sub(/- "(.*)"/, '- \1')
+        else
+          line
+        end
+      end
+      results.join("\n") + "\n"
+    end
+  end
+end