jets 4.0.17 → 5.0.0.beta1

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
 

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

data/lib/jets/cfn/{builders/rule_builder.rb → builder/rule.rb}

@@ -1,10 +1,6 @@
-# Implements:
-#
-#   compose
-#   template_path
-#
-module Jets::Cfn::Builders
-  class RuleBuilder < BaseChildBuilder
+class Jets::Cfn::Builder
+  class Rule < Nested
+    # interface method
     def compose
       add_common_parameters
       add_functions
@@ -16,7 +12,7 @@ module Jets::Cfn::Builders
     # List of AWS Config Managed Rules: https://amzn.to/2BOt9KN
     def add_managed_rules
       @app_class.managed_rules.each do |rule|
-        resource = Jets::Resource.new(rule[:definition], rule[:replacements])
+        resource = Jets::Cfn::Resource.new(rule[:definition], rule[:replacements])
         add_resource(resource)
       end
     end

data/lib/jets/cfn/{builders/shared_builder.rb → builder/shared.rb}

@@ -1,12 +1,13 @@
-module Jets::Cfn::Builders
-  class SharedBuilder < BaseChildBuilder
+class Jets::Cfn::Builder
+  class Shared < Nested
+    # interface method
     def compose
       stack = @app_class.new # @app_class is subclass. IE: Alarm < Jets::Stack
       builder = Jets::Stack::Builder.new(stack)
       @template = builder.template # overwrite entire @template
     end
 
-    # template_path is an interface method for Interface module
+    # interface method
     def template_path
       Jets::Names.shared_template_path(@app_class)
     end

data/lib/jets/cfn/{builders → builder}/util/source.rb

@@ -1,4 +1,4 @@
-module Jets::Cfn::Builders::Util
+module Jets::Cfn::Builder::Util
   class Source
     class << self
       def version

data/lib/jets/{commands/build.rb → cfn/builder.rb}

@@ -1,72 +1,64 @@
-require 'digest'
-
-module Jets::Commands
-  class Build
-    include StackInfo
+module Jets::Cfn
+  class Builder
+    extend Memoist
+    include Jets::AwsServices
 
     def initialize(options)
-      @options = options.dup
-    end
-
-    def run
-      puts "Building project for Lambda..."
-
-      return if @options[:noop]
-      # run gets called from the CLI and does not have all the stack_options yet.
-      # We compute it and change the options early here.
-      @options.merge!(stack_type: stack_type, s3_bucket: s3_bucket)
-      build
+      @options = options
     end
 
     def build
-      build_code unless @options[:templates]
-      build_templates
-    end
-
-    def build_code
-      Jets::Builders::CodeBuilder.new.build unless @options[:noop]
-    end
-
-    def build_templates
-      puts "Building CloudFormation templates."
+      puts "Building CloudFormation templates"
       clean_templates
-      build_minimal_template
-      build_all_templates if full?
-      puts "Generated CloudFormation templates at #{Jets.build_root}/templates"
+      build_minimal_parent_template
+      if @options[:stack_type] == :full
+        build_all_templates
+        build_full_parent_template # must be called at the end
+      end
+      Jets::Router::State.save_apigw_state if ENV['JETS_API_STATE_DEBUG']
+      puts "Built CloudFormation templates at #{Jets.build_root}/templates"
     end
 
-    def full?
-      @options[:templates] || @options[:stack_type] == :full
+    def build_minimal_parent_template
+      Parent.new(@options.merge(stack_type: :minimal)).build
     end
 
     def build_all_templates
       # CloudFormation templates
       # 1. Shared and authorizer templates - child templates needs them
-      build_api_gateway_templates
+      build_api_gateway_templates unless Jets::Router.no_routes?
       build_authorizer_templates # controllers can use these
       # 2. Child templates - parent template needs them
+      build_one_lambda_for_all_controllers
       build_app_child_templates
-      # 2. Child templates - parent template needs them
+      # 3. Child templates - parent template needs them
       build_shared_resources_templates
-      # 4. Finally parent template
-      build_parent_template # must be called at the end
     end
 
-    def build_minimal_template
-      Jets::Cfn::Builders::ParentBuilder.new(@options).build(parent=true)
+    def build_full_parent_template
+      Parent.new(@options.merge(stack_type: :full)).build
     end
 
     def build_api_gateway_templates
-      Jets::Cfn::Builders::ApiGatewayBuilder.new(@options).build
-      Jets::Cfn::Builders::ApiDeploymentBuilder.new(@options).build
+      Api::Gateway.new(@options).build
+      Api::Resources.build_pages(@options)
+      Api::Methods.build_pages(@options)
+      Api::Deployment.new(@options).build
+      Api::Mapping.new(@options).build
     end
 
     def build_authorizer_templates
       authorizer_files.each do |path|
-        Jets::Cfn::Builders::AuthorizerBuilder.new(path).build
+        Authorizer.new(path).build
       end
     end
 
+    def build_one_lambda_for_all_controllers
+      return if Jets.config.mode == "job"
+      return unless Jets.one_lambda_for_all_controllers?
+      OneController.new(@options).build
+    end
+
     def build_app_child_templates
       app_files.each do |path|
         build_child_template(path)
@@ -75,7 +67,7 @@ module Jets::Commands
 
     def build_shared_resources_templates
       Jets::Stack.subclasses.each do |subclass|
-        Jets::Cfn::Builders::SharedBuilder.new(subclass).build
+        Shared.new(subclass).build
       end
     end
 
@@ -85,32 +77,34 @@ module Jets::Commands
       return if authorizer?(path) # AuthorizerBuilder is built earlier
 
       md = path.match(%r{app/(.*?)/}) # extract: controller, job or function
-      process_class = md[1].classify
-      builder_class = "Jets::Cfn::Builders::#{process_class}Builder".constantize
+      app_class = md[1].classify
+
+      if app_class == "Controller" && Jets.one_lambda_for_all_controllers? # app/controllers
+        return
+      end
+
+      builder_class = "Jets::Cfn::Builder::#{app_class}".constantize
 
-      # Examples:
-      #   Jets::Cfn::Builders::ControllerBuilder.new(PostsController)
-      #   Jets::Cfn::Builders::JobBuilder.new(EasyJob)
-      #   Jets::Cfn::Builders::RuleBuilder.new(CheckRule)
-      #   Jets::Cfn::Builders::FunctionBuilder.new(Hello)
-      #   Jets::Cfn::Builders::FunctionBuilder.new(HelloFunction)
       app_class = Jets::Klass.from_path(path)
       if Jets.poly_only? && app_class == Jets::PreheatJob
         return # No prewarm when there's only poly functions
       end
 
-      builder = builder_class.new(app_class)
-      builder.build
+      # Builder class fully qualified name:
+      #   Controller => Jets::Cfn::Builder::Controller
+      # Examples:
+      #   Controller.new(PostsController).build
+      #   Job.new(EasyJob).build
+      #   Rule.new(CheckRule).build
+      #   Function.new(Hello).build
+      #   Function.new(HelloFunction).build
+      builder_class.new(app_class).build
     end
 
     def authorizer?(path)
       path.include?("app/authorizers")
     end
 
-    def build_parent_template
-      Jets::Cfn::Builders::ParentBuilder.new(@options).build(parent=true)
-    end
-
     def clean_templates
       FileUtils.rm_rf("#{Jets.build_root}/templates")
     end
@@ -142,7 +136,6 @@ module Jets::Commands
           relative_path = path.sub("#{Jets.root}/", '') # rid of the Jets.root at beginning
           paths << relative_path
         end
-        paths += internal_app_files
         paths
       end
 
@@ -200,7 +193,7 @@ module Jets::Commands
       def app_has_ruby?
         has_ruby = app_files.detect do |path|
           app_class = Jets::Klass.from_path(path)  # IE: PostsController, Jets::PublicController
-          langs = app_class.tasks.map(&:lang)
+          langs = app_class.definitions.map(&:lang)
           langs.include?(:ruby) && app_class != Jets::PreheatJob
         end
         !!has_ruby
@@ -219,27 +212,6 @@ module Jets::Commands
         has_ruby
       end
 
-      # Add internal Jets controllers if they are being used
-      # TODO: Interesting, this eventually just used to generate handlers and controllers only.
-      # Maybe rename to make that clear.
-      # The copying of other internal files like views is done in builders/code_builder.rb copy_internal_jets_code
-      def internal_app_files
-        paths = []
-        internal = File.expand_path("../internal", __dir__)
-
-        controllers = "#{internal}/app/controllers/jets"
-        paths << "#{controllers}/public_controller.rb" if router_has?("Jets::PublicController")
-        paths << "#{controllers}/rack_controller.rb" if router_has?("Jets::RackController")
-        paths << "#{controllers}/mailers_controller.rb" if router_has?("Jets::MailersController")
-        paths << "#{controllers}/mount_controller.rb" if router_has?("Jets::MountController")
-
-        if Jets.config.prewarm.enable
-          paths << "#{internal}/app/jobs/jets/preheat_job.rb"
-        end
-
-        paths
-      end
-
       def router_has?(controller)
         Jets::Router.has_controller?(controller)
       end

data/lib/jets/cfn/deployment.rb

@@ -0,0 +1,45 @@
+module Jets::Cfn
+  class Deployment
+    extend Memoist
+    include Jets::AwsServices
+    include Jets::Command::AwsHelpers
+    include Jets::Command::ApiHelpers
+
+    def initialize(options={})
+      @options = options
+      @stack_name = options[:stack_name] # stack name or stack id (deleted)
+      @rollback_version = options[:rollback_version]
+    end
+
+    def create
+      Jets.boot # needed since Jets is lazy loaded
+      return if Jets.config.pro.disable
+      return unless Jets::Api.token
+      stack = find_stack(@stack_name)
+      return unless stack
+
+      record_deployment(stack)
+    end
+
+    def record_deployment(stack)
+      deploy_user = ENV['JETS_DEPLOY_USER'] || ENV['USER']
+      resp = Jets::Api::Release.create(
+        stack_arn: stack.stack_id,
+        stack_status: stack.stack_status,
+        message: message,
+        deploy_user: deploy_user,
+      )
+      check_for_error_message!(resp)
+      puts "Release version: #{resp["version"]}" if resp["version"]
+      resp
+    rescue Jets::Api::RequestError => e
+      puts "WARNING: Unable to create release. #{e.class}: #{e.message}"
+    end
+
+    def message
+      return @options[:message][0..255] if @options[:message]
+      # else default message
+      @rollback_version ? "Rollback to #{@rollback_version}" : "Deploy"
+    end
+  end
+end

data/lib/jets/cfn/download.rb

@@ -0,0 +1,39 @@
+module Jets::Cfn
+  class Download
+    include Jets::AwsServices
+
+    def download_templates(version)
+      bucket = s3_resource.bucket(bucket_name)
+      unless bucket.exists?
+        puts "ERROR: The bucket #{bucket_name} does not exist.".color(:red)
+        exit 1
+      end
+
+      # Cleanup templates folder
+      FileUtils.rm_rf(Jets::Names.templates_folder)
+      FileUtils.mkdir_p(Jets::Names.templates_folder)
+
+      key_path = "jets/cfn-templates/versions/#{version}"
+      objects = bucket.objects(prefix: key_path)
+      if objects.count > 0
+        objects.each do |object|
+          file_name = "#{Jets::Names.templates_folder}/#{object.key.split('/').last}"
+          object.get(response_target: file_name)
+          puts "Downloaded #{file_name} from s3://#{bucket_name}/#{object.key}" if ENV['JETS_DEBUG']
+        end
+      else
+        puts "ERROR: Cannot rollback to this version because the CloudFormation templates are not available.".color(:red)
+        puts <<~EOL
+          This can happen the app was deployed before Jets Pro features were enabled,
+          or if the stack was delete and redeployed. Deleted stacks history are not
+          rollbackable because their original s3 bucket is deleted.
+        EOL
+        exit 1
+      end
+    end
+
+    def bucket_name
+      Jets.s3_bucket
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# Params are an attempt to centralize the logic for building parameters.
+# Params are built at two different times:
+# 1. Cfn::Builders::Api::Methods.build_pages
+#      => Api::Pages::Methods => api-methods-1.yml nested stack
+#    Only uses keys.
+# 2. Cfn::Builders::Parent
+#      => Resource::Nested::Api::Methods => parent.yml logical id ApiMethods1
+#    Uses both keys and values.
+module Jets::Cfn::Params::Api
+  class Base
+    extend Memoist
+
+    def initialize(options={})
+      @options = options
+      @template = load_template # current paged template_path
+      @params = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def params
+      build # interface method
+      @params
+    end
+    memoize :params
+
+    # Nice to be able to use template or template_path so the common Template.load_file
+    # is centralized.
+    def load_template
+      if @options[:template]
+        # At Cfn::Builders::Api::Methods build time, template is in memory
+        @options[:template]
+      else
+        # At Resource::Nested::Api::Methods build time, template is on disk
+        Jets::Cfn::Template.load_file(@options[:template_path])
+      end
+    end
+
+    def build; end # noop by default
+  end
+end

data/lib/jets/cfn/params/api/cors.rb

@@ -0,0 +1,10 @@
+module Jets::Cfn::Params::Api
+  class Cors < Base
+    # interface method
+    def build
+      resources = Resources.new(@options).params
+      methods = Methods.new(@options).params
+      @params = resources.merge(methods)
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Jets::Cfn::Params::Api
+  class Methods < Base
+    # interface method
+    def build
+      @params.merge!(RestApi: "!GetAtt ApiGateway.Outputs.RestApi") # common
+      @template[:Resources].each do |logical_id, resource|
+        create_params_from_resource(resource)
+      end
+    end
+
+    def create_params_from_resource(resource)
+      case resource[:Type]
+      when "AWS::ApiGateway::Method"
+        # function name
+        create_function_name_param(resource)
+        # authorizer id
+        create_authorizer_param(resource)
+        # resource id
+        resource_id = resource[:Properties][:ResourceId].sub("!Ref ", "")
+        @params.merge!(resource_id => api_method_stack_value(resource_id))
+      when "AWS::Lambda::Permission"
+        # function name
+        function_name = resource[:Properties][:FunctionName].sub("!Ref ", "")
+        @params.merge!(function_name => controller_stack_value(function_name))
+      end
+    end
+
+    def create_authorizer_param(resource)
+      authorizer_id_ref = resource[:Properties][:AuthorizerId]
+      return unless authorizer_id_ref
+      authorizer_id = authorizer_id_ref.sub("!Ref ", "")
+      @params.merge!(authorizer_id => api_authorizer_stack_value(authorizer_id))
+    end
+
+    # IE: !GetAtt MainAuthorizer.Outputs.MainAuthorizerProtectAuthorizer
+    def api_authorizer_stack_value(authorizer_id)
+      stack = authorizer_id.sub(/(.*?)Authorizer.*Authorizer$/, '\1') # IE: Main
+      stack += "Authorizer" # IE: MainAuthorizer
+      "!GetAtt #{stack}.Outputs.#{authorizer_id}"
+    end
+
+    def create_function_name_param(resource)
+      # Type can be: AWS_PROXY or MOCK (cors)
+      return unless resource[:Properties][:Integration][:Type] == "AWS_PROXY"
+      uri = resource[:Properties][:Integration][:Uri]
+      md = uri.match(%r|functions/\${(.*)}/invocations|)
+      function_name = md[1]
+      @params.merge!(function_name => controller_stack_value(function_name))
+    end
+
+    # function_name: UpControllerIndexLambdaFunction
+    def controller_stack_value(function_name)
+      controller = function_name.sub(/Controller.*/, "Controller")
+      # IE: !GetAtt UpController.Outputs.UpControllerIndexLambdaFunction
+      "!GetAtt #{controller}.Outputs.#{function_name}"
+    end
+
+    def api_method_stack_value(resource_id)
+      # IE: !GetAtt ApiResources1.Outputs.UpApiResource
+      api_stack = if resource_id == "RootResourceId"
+            "ApiGateway"
+          else
+            Jets::Cfn::Params::Api::Resources.stack_logical_id(resource_id)
+          end
+      "!GetAtt #{api_stack}.Outputs.#{resource_id}"
+    end
+  end
+end
+