jets 4.0.10 → 5.0.0

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::Names.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/{builders → builder}/interface.rb

@@ -2,20 +2,24 @@
 #
 #   * compose
 #   * template_path
-module Jets::Cfn::Builders
+#
+class Jets::Cfn::Builder
   module Interface
     extend Memoist
+    include Jets::Util::Camelize
 
-    def build(parent=false)
-      # Do not bother building or writing the template unless there are functions defined
-      return if @app_class && !@app_class.build?
-
-      if @options.nil? || @options[:templates] || @options[:stack_type] != :minimal || parent
-        compose # must be implemented by subclass
-      end
+    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)
@@ -28,26 +32,13 @@ module Jets::Cfn::Builders
     end
 
     def text
-      text = YAML.dump(template)
-      post_process_template(text)
-    end
-
-    # post process the text so that
-    # "!Ref IamRole" => !Ref IamRole
-    # We strip the surrounding quotes
-    def post_process_template(text)
-      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"
+      # -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)
@@ -56,7 +47,7 @@ module Jets::Cfn::Builders
 
     def add_parameters(attributes)
       attributes.each do |name,value|
-        add_parameter(name.to_s.camelize, Description: value)
+        add_parameter(name.camelize.to_sym, Description: value)
       end
     end
 
@@ -64,32 +55,35 @@ module Jets::Cfn::Builders
       defaults = { Type: "String" }
       options = defaults.merge(options)
       @template[:Parameters] ||= {}
-      @template[:Parameters][name.to_s.camelize] = Jets::Camelizer.transform(options)
+      @template[:Parameters][name.camelize.to_sym] = camelize(options)
     end
 
     def add_outputs(attributes)
       attributes.each do |name,value|
-        add_output(name.to_s.camelize, Value: value)
+        add_output(name.camelize.to_sym, Value: value)
       end
     end
 
     def add_output(name, options={})
       @template[:Outputs] ||= {}
-      @template[:Outputs][name.camelize] = Jets::Camelizer.transform(options)
+      @template[:Outputs][name.camelize.to_sym] = camelize(options)
     end
 
     def add_resources
-      @app_class.tasks.each do |task|
-        task.associated_resources.each do |associated|
-          resource = Jets::Resource.new(associated.definition, task.replacements)
+      @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::Resource::Iam classes are special treated. They are the only resources that result
-    # in creating 2 CloudFormation resources: Iam::Policy and Iam::Role.
+    # 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.
@@ -104,9 +98,9 @@ module Jets::Cfn::Builders
     def add_resource(resource)
       add_template_resource(resource.logical_id, resource.type, resource.attributes)
 
-      if resource.class.to_s.include?("Jets::Resource::Iam")
+      if resource.class.to_s.include?("Jets::Cfn::Resource::Iam")
         role = resource # for clarity: resource is a Iam::*Role class
-        iam_policy = Jets::Resource::Iam::Policy.new(role)
+        iam_policy = Jets::Cfn::Resource::Iam::Policy.new(role)
         add_template_resource(iam_policy.logical_id, iam_policy.type, iam_policy.attributes)
       end
     end
@@ -119,34 +113,34 @@ module Jets::Cfn::Builders
     # Top level options:
     #
     #   add_template_resource("MyId", "AWS::ApiGateway::RestApi",
-    #     type: "AWS::ApiGateway::RestApi",
-    #     properties: {
-    #       name: "my-api"
+    #     Type: "AWS::ApiGateway::RestApi",
+    #     Properties: {
+    #       Name: "my-api"
     #     },
-    #     depends_on: ["AnotherResource"]
+    #     DependsOn: ["AnotherResource"]
     #   )
     #
     # Simple options with properties only:
     #
     #   add_template_resource("MyId", "AWS::CloudFormationStack",
-    #     template_url: "template_url",
-    #     parameters: {},
+    #     TemplateURL: "template_url",
+    #     Parameters: {},
     #   )
     #
     def add_template_resource(logical_id, type, options)
-      options = Jets::Camelizer.transform(options)
+      options = camelize(options)
 
-      attributes = if options.include?('Type')
-                     base = { 'Type' => type }
+      attributes = if options.include?(:Type)
+                     base = { Type: type }
                      base.merge(options) # options are top-level attributes
                    else
                      {
-                       'Type' => type,
-                       'Properties' => options # options are properties
+                       Type: type,
+                       Properties: options # options are properties
                      }
                    end
 
-      @template['Resources'][logical_id] = attributes
+      @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/{builders/parent_builder.rb → builder/parent.rb}

@@ -1,7 +1,5 @@
-require 'erb'
-
-module Jets::Cfn::Builders
-  class ParentBuilder
+class Jets::Cfn::Builder
+  class Parent
     include Interface
     include Jets::AwsServices
     include Stagger
@@ -11,13 +9,13 @@ module Jets::Cfn::Builders
       @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
     end
 
-    # compose is an interface method
+    # interface method
     def compose
       build_minimal_resources
-      build_child_resources if full?
+      build_child_resources
     end
 
-    # template_path is an interface method
+    # interface method
     def template_path
       Jets::Names.parent_template_path
     end
@@ -36,38 +34,26 @@ module Jets::Cfn::Builders
       #
       # 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::Resource::S3::Bucket.new(logical_id: "s3_bucket",
-        PublicAccessBlockConfiguration: {
-          BlockPublicAcls: false,
-          # BlockPublicPolicy: false,
-          # IgnorePublicAcls: false,
-          # RestrictPublicBuckets: false
-        },
-        OwnershipControls: {
-          Rules: [{ObjectOwnership: "ObjectWriter"}]
-        },
-        bucket_encryption: {
-          server_side_encryption_configuration: [
-            server_side_encryption_by_default: {
-              sse_algorithm: "AES256"
-          }]}
-      )
+      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::Resource::Iam::ApplicationRole.new
+      resource = Jets::Cfn::Resource::Iam::ApplicationRole.new
       add_resource(resource)
       add_outputs(resource.outputs)
 
       return if Jets.poly_only?
-      resource = Jets::Resource::Lambda::GemLayer.new
+      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
@@ -75,69 +61,83 @@ module Jets::Cfn::Builders
         add_shared_resources(path)
       end
 
-      if full? and !Jets::Router.routes.empty?
-        for_each_path(:authorizers) do |path|
-          add_authorizer_resources(path)
-        end
-        add_api_gateway
-        add_api_resources
-        add_api_deployment
+      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
 
-    # Example paths:
-    #    #{Jets.build_root}/templates/demo-dev-2-shared-resources.yml
-    #    #{Jets.build_root}/templates/demo-dev-2-app-comments_controller.yml
-    #    #{Jets.build_root}/templates/demo-dev-2-authorizers-main_authorizer.yml
+    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.template_path_prefix}-#{type}-*"
+      expression = "#{Jets::Names.templates_folder}/#{type}-*"
       Dir.glob(expression).each do |path|
         next unless File.file?(path)
         yield(path)
       end
     end
 
-    def full?
-      @options[:templates] || @options[:stack_type] == :full
-    end
-
     def add_app_class_stack(path)
-      resource = Jets::Resource::ChildStack::AppClass.new(@options[:s3_bucket], path: 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::Resource::ChildStack::Authorizer.new(@options[:s3_bucket], path: path)
+      resource = Jets::Cfn::Resource::Nested::Authorizer.new(@options.merge(path: path))
       add_child_resources(resource)
     end
 
     def add_shared_resources(path)
-      resource = Jets::Resource::ChildStack::Shared.new(@options[:s3_bucket], path: 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::Resource::ChildStack::ApiGateway.new(@options[:s3_bucket])
+      resource = Jets::Cfn::Resource::Nested::Api::Gateway.new(@options)
       add_child_resources(resource)
     end
 
     def add_api_resources
-      expression = "#{Jets::Names.template_path_prefix}-api-resources-*"
-      # IE: path: #{Jets.build_root}/templates/demo-dev-2-api-resources-1.yml"
-      Dir.glob(expression).sort.each do |path|
-        next unless File.file?(path)
+      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
 
-        regexp = Regexp.new("#{Jets.config.project_namespace}-api-resources-(\\d+).yml") # tricky to escape \d pattern
-        md = path.match(regexp)
-        page = md[1]
-        resource = Jets::Resource::ChildStack::ApiResource.new(@options[:s3_bucket], page: page)
+    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::Resource::ChildStack::ApiDeployment.new(@options[:s3_bucket])
+      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