jets 3.1.0 → 5.0.0

data/.python-version

@@ -1 +0,0 @@
-3.8.6

data/.ruby-version

@@ -1 +0,0 @@
-2.7.5

data/bin/release

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-# Wrapper release script so we don't forget to add submodules.
-# Should still update the CHANGELOG.md and version.rb before running this script.
-
-git submodule init
-git submodule update
-bundle update
-rake release

data/lib/jets/application/defaults.rb

@@ -1,200 +0,0 @@
-class Jets::Application
-  module Defaults
-    extend ActiveSupport::Concern
-
-    included do
-      def self.default_iam_policy
-        project_namespace = Jets.project_namespace
-        logs = {
-          action: ["logs:*"],
-          effect: "Allow",
-          resource: "arn:aws:logs:#{Jets.aws.region}:#{Jets.aws.account}:log-group:/aws/lambda/#{project_namespace}-*",
-        }
-        s3_readonly = {
-          action: ["s3:Get*", "s3:List*", "s3:HeadBucket"],
-          effect: "Allow",
-          resource: "arn:aws:s3:::#{Jets.aws.s3_bucket}*",
-        }
-        policies = [logs, s3_readonly]
-
-        cloudformation = {
-          action: ["cloudformation:DescribeStacks", "cloudformation:DescribeStackResources"],
-          effect: "Allow",
-          resource: "arn:aws:cloudformation:#{Jets.aws.region}:#{Jets.aws.account}:stack/#{project_namespace}*",
-        }
-        policies << cloudformation
-
-        if Jets.config.function.vpc_config
-          vpc = {
-            action: %w[
-              ec2:CreateNetworkInterface
-              ec2:DeleteNetworkInterface
-              ec2:DescribeNetworkInterfaces
-              ec2:DescribeVpcs
-              ec2:DescribeSubnets
-              ec2:DescribeSecurityGroups
-            ],
-            effect: "Allow",
-            resource: "*",
-          }
-          policies << vpc
-        end
-
-        policies
-      end
-    end
-
-    def default_config
-      config = ActiveSupport::OrderedOptions.new
-      config.project_name = parse_project_name # must set early because other configs requires this
-      config.cors = false
-      config.autoload_paths = [] # allows for customization
-      config.ignore_paths = [] # allows for customization
-      config.logger = Jets::Logger.new($stderr)
-      config.time_zone = "UTC"
-
-      # function properties defaults
-      config.function = ActiveSupport::OrderedOptions.new
-      config.function.timeout = 30
-      # default memory setting based on:
-      # https://medium.com/epsagon/how-to-make-lambda-faster-memory-performance-benchmark-be6ebc41f0fc
-      config.function.memory_size = 1536
-
-      config.prewarm = ActiveSupport::OrderedOptions.new
-      config.prewarm.enable = true
-      config.prewarm.rate = '30 minutes'
-      config.prewarm.concurrency = 2
-      config.prewarm.public_ratio = 3
-      config.prewarm.rack_ratio = 5
-
-      config.gems = ActiveSupport::OrderedOptions.new
-      config.gems.clean = false
-      config.gems.disable = false
-      config.gems.source = "https://api.serverlessgems.com/api/v1"
-
-      config.inflections = ActiveSupport::OrderedOptions.new
-      config.inflections.irregular = {}
-
-      config.assets = ActiveSupport::OrderedOptions.new
-      config.assets.folders = %w[assets images packs]
-      config.assets.base_url = nil # IE: https://cloudfront.com/my/base/path
-      config.assets.max_age = 3600
-      config.assets.cache_control = nil # IE: public, max-age=3600 , max_age is a shorter way to set cache_control.
-
-      config.ruby = ActiveSupport::OrderedOptions.new
-
-      config.middleware = Jets::Middleware::Configurator.new
-
-      config.session = ActiveSupport::OrderedOptions.new
-      config.session.store = Rack::Session::Cookie # note when accessing it use session[:store] since .store is an OrderedOptions method
-      config.session.options = {}
-
-      config.api = ActiveSupport::OrderedOptions.new
-      config.api.api_key_required = false # Turn off API key required
-      config.api.authorization_type = "NONE"
-      config.api.auto_replace = nil # https://github.com/boltops-tools/jets/issues/391
-      config.api.binary_media_types = ['multipart/form-data']
-      config.api.cors_authorization_type = nil # nil so ApiGateway::Cors#cors_authorization_type handles
-      config.api.endpoint_policy = nil # required when endpoint_type is EDGE
-      config.api.endpoint_type = 'EDGE' # PRIVATE, EDGE, REGIONAL
-
-      config.api.authorizers = ActiveSupport::OrderedOptions.new
-      config.api.authorizers.default_token_source = "Auth" # method.request.header.Auth
-
-      config.domain = ActiveSupport::OrderedOptions.new
-      # config.domain.name = "#{Jets.project_namespace}.coolapp.com" # Default is nil
-      # config.domain.cert_arn = "..."
-      config.domain.endpoint_type = "REGIONAL" # EDGE or REGIONAL. Default to EDGE because CloudFormation update is faster
-      config.domain.route53 = true # controls whether or not to create the managed route53 record.
-        # Useful to disable this when user wants to manage the route themself like pointing
-        # it to CloudFront for blue-green deployments instead.
-
-      # Custom user lambda layers
-      config.lambda = ActiveSupport::OrderedOptions.new
-      config.lambda.layers = []
-
-      # Only used for Jets Afterburner, Mega Mode currently. This is a fallback default
-      # encoding.  Usually, the Rails response will return a content-type header and
-      # the encoding in there is used when possible. Example Content-Type header:
-      #   Content-Type    text/html; charset=utf-8
-      config.encoding = ActiveSupport::OrderedOptions.new
-      config.encoding.default = "utf-8"
-
-      config.s3_event = ActiveSupport::OrderedOptions.new
-      # These notification_configuration properties correspond to the ruby aws-sdk
-      #   s3.put_bucket_notification_configuration
-      # in jets/s3_bucket_config.rb, not the CloudFormation Bucket properties. The CloudFormation
-      # bucket properties have a similiar structure but is slightly different so it can be confusing.
-      #
-      #   Ruby aws-sdk S3 Docs: https://amzn.to/2N7m5Lr
-      config.s3_event.configure_bucket = true
-      config.s3_event.notification_configuration = {
-        topic_configurations: [
-          {
-            events: ["s3:ObjectCreated:*"],
-            topic_arn: "!Ref SnsTopic", # must use this logical id
-          },
-        ],
-      }
-
-      # So tried to defined this in the jets/mailer.rb Turbine only but jets new requires it
-      # config.action_mailer = ActiveSupport::OrderedOptions.new
-
-      config.helpers = ActiveSupport::OrderedOptions.new
-      config.helpers.host = nil # nil by default. Other examples: https://myurl.com:8888
-
-      config.controllers = ActiveSupport::OrderedOptions.new
-      config.controllers.default_protect_from_forgery = nil
-      config.controllers.filtered_parameters = []
-
-      config.app = ActiveSupport::OrderedOptions.new
-      config.app.domain = nil
-
-      config.deploy = ActiveSupport::OrderedOptions.new
-      config.deploy.stagger = ActiveSupport::OrderedOptions.new
-      config.deploy.stagger.enabled = false
-      config.deploy.stagger.batch_size = 10
-
-      config.hot_reload = Jets.env.development?
-
-      config.ruby = ActiveSupport::OrderedOptions.new
-      config.ruby.check = true
-
-      config
-    end
-
-    # Essentially folders under app folder will be the default_autoload_paths. Example:
-    #   app/controllers
-    #   app/helpers
-    #   app/jobs
-    #   app/models
-    #   app/rules
-    #   app/shared/resources
-    #
-    # Also include:
-    #   app/models/concerns
-    #   app/controllers/concerns
-    def default_autoload_paths
-      paths = []
-      each_app_autoload_path("#{Jets.root}/app/*") do |path|
-        paths << path
-      end
-      # Handle concerns folders
-      each_app_autoload_path("#{Jets.root}/app/**/concerns") do |path|
-        paths << path
-      end
-
-      paths << "#{Jets.root}/app/shared/resources"
-      paths << "#{Jets.root}/app/shared/extensions"
-
-      paths
-    end
-
-    def default_ignore_paths
-      %w[
-        app/functions
-        app/shared/functions
-      ]
-    end
-  end
-end

data/lib/jets/builders/reconfigure_rails/config/initializers/jets.rb

@@ -1,16 +0,0 @@
-JetsRails.stage = ENV['JETS_STAGE'] || 'dev' # for jets-rails StageMiddleware
-
-# config/s3_base_url.txt is generated as part of jets build process
-s3_base_url = IO.read("#{Rails.root}/config/s3_base_url.txt").strip rescue "s3_base_url_placeholder"
-asset_host = "#{s3_base_url}/rack/public"
-Rails.application.config.action_controller.asset_host = asset_host
-Rails.application.config.public_file_server.enabled = true
-
-<% unless @api_mode -%>
-# Rails.application.config.assets.quiet = false
-Rails.application.config.assets.debug = false
-Rails.application.config.assets.compile = false
-<% end -%>
-
-# Looks better without colorizatiion in CloudWatch logs
-Rails.application.config.colorize_logging = false

data/lib/jets/builders/reconfigure_rails.rb

@@ -1,114 +0,0 @@
-# TODO: Move logic into plugin instead
-module Jets::Builders
-  class ReconfigureRails
-    def initialize(full_app_root)
-      # IE: @app_root: /tmp/jets/demo/stage/code/rack
-      @app_root = full_app_root
-    end
-
-    # Only support Rails right now. Maybe move into plugin when adding support
-    # to more frameworks. Or maybe better to just abstract but maintain in Jets.
-    def run
-      return unless rails?
-
-      puts "Mega Mode: Reconfiguring Rails app."
-      copy_initializer
-      update_gemfile
-      update_development_environment
-      set_favicon
-    end
-
-    def copy_initializer
-      templates = File.expand_path("./reconfigure_rails", File.dirname(__FILE__))
-      relative_path = "config/initializers/jets.rb"
-      src = "#{templates}/#{relative_path}"
-      result = Jets::Erb.result(src, api_mode: rails_api?)
-      dest = "#{@app_root}/#{relative_path}"
-      FileUtils.mkdir_p(File.dirname(dest))
-      IO.write(dest, result)
-    end
-
-    def api_mode?
-    end
-
-    def update_gemfile
-      gemfile = "#{@app_root}/Gemfile"
-      lines = IO.readlines(gemfile)
-      lines = add_jets_rails_gem(lines)
-      lines = comment_out_ruby_declaration(lines)
-      write_content(gemfile, lines)
-    end
-
-    def add_jets_rails_gem(lines)
-      return lines if lines.detect { |l| l =~ /jets-rails/ }
-      lines << "\n"
-      lines << %Q|gem "jets-rails"\n|
-      lines
-    end
-
-    # Jets packages up and uses only one version of ruby and different declarations
-    # of ruby can cause issues.
-    def comment_out_ruby_declaration(lines)
-      lines.map do |l|
-        l =~ /^(ruby[ (].*)/ ? "# #{$1} # commented out by jets" : l
-      end
-    end
-
-    def update_development_environment
-      env_file = "#{@app_root}/config/environments/development.rb"
-      lines = IO.readlines(env_file)
-      new_lines = lines.map do |line|
-        if line =~ /(config\.file_watcher.*)/
-          "  # #{$1} # commented out by jets\n"
-        else
-          line
-        end
-      end
-      write_content(env_file, new_lines)
-    end
-
-    # Evaluate the application layout and see if has a custom favicon defined yet.
-    # If not insert one and rewrite the application layout.
-    #
-    # This avoids serving binary assets from API gateway, instead serve it from s3 directly.
-    def set_favicon
-      app_layout = "#{@app_root}/app/views/layouts/application.html.erb"
-      return  unless File.exist?(app_layout)
-
-      favicon = '<link rel="shortcut icon" href="<%= asset_path("/favicon.ico") %>">'
-
-      lines = IO.readlines(app_layout)
-      has_favicon = !!lines.find { |l| l.include?(favicon) }
-      return if has_favicon
-
-      content = IO.read(app_layout)
-      content = content.sub('</head>', "\n    #{favicon}\n  </head>")
-
-      IO.write(app_layout, content)
-    end
-
-    # lines is an Array
-    def write_content(path, lines)
-      content = lines.join + "\n"
-      IO.write(path, content)
-    end
-
-    # Rudimentary rails detection
-    # Duplicated in builders/code_builders.rb
-    def rails?
-      config_ru = "#{@app_root}/config.ru"
-      return false unless File.exist?(config_ru)
-      !IO.readlines(config_ru).grep(/Rails.application/).empty?
-    end
-
-    # Rudimentary rails api detection
-    # Duplicated in builders/code_builders.rb
-    # Another way of checking is loading a rails console and checking Rails.application.config.api_only
-    # Using this way for simplicity.
-    def rails_api?
-      config_app = "#{@app_root}/config/application.rb"
-      return false unless File.exist?(config_app)
-      !IO.readlines(config_app).grep(/config.api_only.*=.*true/).empty?
-    end
-  end
-end

data/lib/jets/cfn/builders/api_gateway_builder.rb

@@ -1,123 +0,0 @@
-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
-    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
-    def template_path
-      Jets::Naming.api_gateway_template_path
-    end
-
-    # do not bother writing a template if routes are empty
-    def write
-      super unless Jets::Router.routes.empty?
-    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
-      add_resource(rest_api)
-      add_outputs(rest_api.outputs)
-
-      deployment = Jets::Resource::ApiGateway::Deployment.new
-      outputs = deployment.outputs(true)
-      add_output("RestApiUrl", Value: outputs["RestApiUrl"])
-    end
-
-    def add_custom_domain
-      return unless Jets.custom_domain?
-      add_domain_name
-      add_route53_dns if Jets.config.domain.route53
-    end
-
-    def add_domain_name
-      add_outputs(create_domain_name)
-    end
-
-    def add_route53_dns
-      dns = Jets::Resource::Route53::RecordSet.new
-      if !existing_domain_name?(dns.domain_name) or existing_dns_record_on_stack? 
-        add_resource(dns)
-        add_outputs(dns.outputs)
-      end
-    end
-
-    def create_domain_name()
-      resource = Jets::Resource::ApiGateway::DomainName.new
-      
-      return {
-        "DomainName" => resource.domain_name
-      } if (existing_domain_name?(resource) and !existing_domain_name_on_stack?)
-      
-      add_resource(resource)
-      return resource.outputs
-    end
-
-    def existing_domain_name?(resource)
-      apigateway.get_domain_name({
-        domain_name: resource.domain_name
-      })
-      return true
-    rescue
-      return false
-    end
-    memoize :existing_domain_name?
-
-    def existing_domain_name_on_stack?
-      cfn.describe_stack_resource({
-        stack_name: api_gateway_physical_resource_id,
-        logical_resource_id: "DomainName"
-      })
-      return true
-    rescue
-      return false
-    end
-
-    def existing_dns_record_on_stack?
-      cfn.describe_stack_resource({
-        stack_name: api_gateway_physical_resource_id,
-        logical_resource_id: "DnsRecord"
-      })
-      return true
-    rescue
-      return false
-    end
-
-    def api_gateway_physical_resource_id
-      cfn.describe_stack_resource({
-        stack_name: Jets::Naming.parent_stack_name,
-        logical_resource_id: "ApiGateway"
-      })
-      .stack_resource_detail
-      .physical_resource_id
-    rescue
-      return 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.
-      all_paths = Jets::Router.all_paths.reject { |p| p == '' }
-      all_paths.each_slice(PAGE_LIMIT).each_with_index do |paths, i|
-        ApiResourcesBuilder.new(@options, paths, i+1).build
-      end
-    end
-  end
-end

data/lib/jets/cfn/builders/api_resources_builder.rb

@@ -1,44 +0,0 @@
-module Jets::Cfn::Builders
-  class ApiResourcesBuilder
-    include Interface
-    include Jets::AwsServices
-
-    def initialize(options={}, paths=[], page)
-      @options, @paths, @page = options, paths, page
-      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
-    end
-
-    # compose is an interface method
-    def compose
-      add_rest_api_parameter
-      add_gateway_routes
-    end
-
-    # template_path is an interface method
-    def template_path
-      Jets::Naming.api_resources_template_path(@page)
-    end
-
-    def add_rest_api_parameter
-      add_parameter("RestApi", Description: "RestApi")
-    end
-
-    def add_gateway_routes
-      @paths.each do |path|
-        homepage = path == ''
-        next if homepage # handled by RootResourceId output already
-
-        resource = Jets::Resource::ApiGateway::Resource.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
-
-    def part_of_template?(parent_path)
-      @template["Resources"].key?(parent_path)
-    end
-  end
-end

data/lib/jets/cfn/builders/base_child_builder.rb

@@ -1,69 +0,0 @@
-# Implements:
-#
-#   * template_path
-#
-# FYI
-#
-#   * compose implemented by the classes that include this
-module Jets::Cfn::Builders
-  class BaseChildBuilder
-    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
-
-    # template_path is an interface method for Interface module
-    def template_path
-      Jets::Naming.app_template_path(@app_class)
-    end
-
-    def add_common_parameters
-      common_parameters = Jets::Resource::ChildStack::CommonParameters.common_parameters
-      common_parameters.each do |k,_|
-        add_parameter(k, Description: k.to_s)
-      end
-
-      depends_on_params.each do |output_key, output_value|
-        desc = output_value.gsub("!GetAtt ", "") # desc doesnt allow !GetAtt
-        add_parameter(output_key, Description: desc)
-      end
-    end
-
-    def depends_on_params
-      return {} unless @app_class.depends_on
-      depends = Jets::Stack::Depends.new(@app_class.depends_on)
-      depends.params
-    end
-
-    def add_functions
-      add_class_iam_policy
-      @app_class.tasks.each do |task|
-        add_function(task)
-        add_function_iam_policy(task)
-      end
-    end
-
-    def add_function(task)
-      resource = Jets::Resource::Lambda::Function.new(task)
-      add_resource(resource)
-    end
-
-    def add_class_iam_policy
-      return unless @app_class.build_class_iam?
-
-      resource = Jets::Resource::Iam::ClassRole.new(@app_class)
-      add_resource(resource)
-    end
-
-    def add_function_iam_policy(task)
-      return unless task.build_function_iam?
-
-      resource = Jets::Resource::Iam::FunctionRole.new(task)
-      add_resource(resource)
-    end
-  end
-end

data/lib/jets/cfn/builders/controller_builder.rb

@@ -1,50 +0,0 @@
-# Implements:
-#
-#   compose
-#   template_path
-#
-module Jets::Cfn::Builders
-  class ControllerBuilder < BaseChildBuilder
-    # compose is an interface method for Interface module
-    def compose
-      add_common_parameters
-      add_api_gateway_parameters
-      add_functions
-      add_routes
-      add_resources
-    end
-
-    def add_api_gateway_parameters
-      return if Jets::Router.routes.empty?
-
-      add_parameter("RestApi", Description: "RestApi")
-      scoped_routes.each do |route|
-        resource = Jets::Resource::ApiGateway::Resource.new(route.path)
-        add_parameter(resource.logical_id, description: resource.desc)
-        if route.authorizer
-          add_parameter(route.authorizer_id, description: route.authorizer_metadata)
-        end
-      end
-
-      if @app_class.authorizer
-        add_parameter(@app_class.authorizer_id, description: @app_class.authorizer_metadata)
-      end
-    end
-
-    def add_routes
-      scoped_routes.each_with_index do |route, i|
-        method = Jets::Resource::ApiGateway::Method.new(route)
-        add_resource(method)
-        add_resource(method.permission)
-        add_resource(method.cors) if Jets.config.cors
-      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
-  end
-end

data/lib/jets/cfn/builders/function_builder.rb

@@ -1,14 +0,0 @@
-# Implements:
-#
-#   compose
-#   template_path
-#
-module Jets::Cfn::Builders
-  class FunctionBuilder < BaseChildBuilder
-    # compose is an interface method for Interface module
-    def compose
-      add_common_parameters
-      add_functions
-    end
-  end
-end