jets.benforeva 3.0.17.pre.mount.pre.fix

data/lib/jets/application/defaults.rb

@@ -0,0 +1,200 @@
+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/application.rb

@@ -0,0 +1,240 @@
+require "singleton"
+require "rack"
+
+class Jets::Application
+  include Singleton
+  extend Memoist
+  include Jets::Middleware
+  include Defaults
+
+  def configure(&block)
+    instance_eval(&block) if block
+  end
+
+  def setup!
+    load_default_config
+    setup_autoload_paths
+    setup_ignore_paths
+    main_loader_setup
+  end
+
+  def configs!
+    load_environments_config
+    load_db_config
+    set_iam_policy # relies on dependent values, must be called afterwards
+    set_time_zone
+    normalize_env_vars!
+  end
+
+  # After the mimimal template gets build, we need to reload it for the full stack
+  # creation. This allows us to reference IAM policies configs that depend on the
+  # creation of the s3 bucket.
+  def reload_configs!
+    # Tricky: reset only the things that depends on the minimal stack
+    @config.iam_policy = nil
+    configs!
+  end
+
+  def finish!
+    deprecated_configs_message
+    load_inflections
+    load_routes
+
+    Jets::Controller::Rendering::RackRenderer.setup! # Sets up ActionView etc
+    # Load libraries at the end to trigger onload so we can defined options in any order.
+    # Only action_mailer library have been used properly this way so far.
+    require 'action_mailer'
+  end
+
+  def load_inflections
+    Jets::Inflections.load!
+  end
+
+  def config
+    @config ||= ActiveSupport::OrderedOptions.new # dont use memoize since we reset @config later
+  end
+
+  # Double evaling config/application.rb causes subtle issues:
+  #   * double loading of shared resources: Jets::Stack.subclasses will have the same
+  #   class twice when config is called when declaring a function
+  #   * forces us to rescue all exceptions, which is a big hammer
+  #
+  # Lets parse for the project name instead for now.
+  #
+  def parse_project_name
+    return ENV['JETS_PROJECT_NAME'] if ENV['JETS_PROJECT_NAME'] # override
+
+    lines = IO.readlines("#{Jets.root}/config/application.rb")
+    project_name_line = lines.find { |l| l =~ /config\.project_name.*=/ && l !~ /^\s+#/ }
+    project_name_line.gsub(/.*=/,'').strip.gsub(/["']/,'') # project_name
+  end
+
+  def load_default_config
+    @config = default_config # sets Jets.config.project_name by calling parse_project_name
+    set_computed_configs! # things like project_namespace that need project_name
+    Jets::Dotenv.load! # needs Jets.config.project_name when using ssm in dotenv files
+    Jets.config.project_name = parse_project_name # Must set again because JETS_PROJECT_NAME is possible
+    load_config_application # this overwrites Jets.config.project_name
+  end
+
+  def load_config_application
+    app_config = "#{Jets.root}/config/application.rb"
+    load app_config # use load instead of require so reload_configs! works
+  end
+
+  def load_environments_config
+    env_file = "#{Jets.root}/config/environments/#{Jets.env}.rb"
+    if File.exist?(env_file)
+      code = IO.read(env_file)
+      instance_eval(code, env_file)
+    end
+  end
+
+  def deprecated_configs_message
+    unless config.ruby.lazy_load.nil?
+      puts "Detected config.ruby.lazy_load = #{config.ruby.lazy_load.inspect}".color(:yellow)
+      puts "Deprecated: config.ruby.lazy_load".color(:yellow)
+      puts "Gems are now bundled with with Lambda Layer and there's no need to lazy load them."
+      puts "Please remove the config in your config/application.rb or config/environments files."
+      puts "You can have Jets automatically do this by running:"
+      puts "  jets upgrade"
+    end
+  end
+
+  def main_loader
+    Jets::Autoloaders.main
+  end
+
+  def setup_autoload_paths
+    autoload_paths = default_autoload_paths + config.autoload_paths
+    autoload_paths.each do |path|
+      next unless File.exist?(path)
+      main_loader.push_dir(path)
+    end
+  end
+
+  # Allow use to add config.ignore_paths just in case there's some case Jets hasn't considered
+  def setup_ignore_paths
+    ignore_paths = default_ignore_paths + config.ignore_paths
+    ignore_paths.each do |path|
+      main_loader.ignore("#{Jets.root}/#{path}")
+    end
+  end
+
+  def main_loader_setup
+    main_loader.enable_reloading if Jets.env.development?
+    main_loader.setup # only respected on the first call
+  end
+
+  def each_app_autoload_path(expression)
+    Dir.glob(expression).each do |p|
+      p.sub!('./','')
+      yield(p) unless exclude_autoload_path?(p)
+    end
+  end
+
+  def exclude_autoload_path?(path)
+    path =~ %r{app/javascript} ||
+    path =~ %r{app/views} ||
+    path =~ %r{/functions} # app and shared
+  end
+
+  def internal_autoload_paths
+    internal = File.expand_path("../internal", __FILE__)
+    paths = %w[
+      app/controllers
+      app/helpers
+      app/jobs
+      app/models
+    ]
+    paths.map { |path| "#{internal}/#{path}" }
+  end
+
+  # Use the shorter name in stack names, but use the full name when it
+  # comes to checking for the env.
+  #
+  # Example:
+  #
+  #   Jets.env: 'development'
+  #   Jets.config.project_namespace: 'demo-dev'
+  ENV_MAP = {
+    development: 'dev',
+    production: 'prod',
+    staging: 'stag',
+  }
+  def set_computed_configs!
+    # env_extra can be also be set with JETS_ENV_EXTRA.
+    # JETS_ENV_EXTRA higher precedence than config.env_extra
+    config.env_extra = ENV['JETS_ENV_EXTRA'] if ENV['JETS_ENV_EXTRA']
+    # IE: With env_extra: project-dev-1
+    #     Without env_extra: project-dev
+    config.short_env = ENV_MAP[Jets.env.to_sym] || Jets.env
+    # table_namespace does not have the env_extra, more common case desired.
+    config.table_namespace = [config.project_name, config.short_env].compact.join('-')
+
+    config.project_namespace = Jets.project_namespace
+  end
+
+  def set_iam_policy
+    config.iam_policy ||= []
+    config.default_iam_policy ||= self.class.default_iam_policy
+    config.iam_policy = config.default_iam_policy | config.iam_policy
+    config.managed_policy_definitions ||= [] # default empty
+  end
+
+  def set_time_zone
+    Time.zone_default = Time.find_zone!(config.time_zone)
+  end
+
+  # It is pretty easy to attempt to set environment variables without
+  # the correct AWS Environment.Variables path struture.
+  # Auto-fix it for convenience.
+  def normalize_env_vars!
+    environment = config.function.environment
+    if environment and !environment.to_h.key?(:variables)
+      config.function.environment = {
+        variables: environment.to_h
+      }
+    end
+  end
+
+  def load_db_config(database_yml="#{Jets.root}/config/database.yml")
+    config.database = {}
+
+    Jets::Dotenv.load!
+    if File.exist?(database_yml)
+      require "active_record/database_configurations" # lazy require
+      text = Jets::Erb.result(database_yml)
+      db_configs = YAML.load(text)
+      configurations = ActiveRecord::DatabaseConfigurations.new(db_configs)
+      config.database = configurations
+    end
+  end
+
+  # Naming it routes because config/routes.rb requires
+  #
+  #   Jets.application.routes.draw do
+  #
+  # for scaffolding to work.
+  def routes
+    @router ||= Jets::Router.new
+  end
+
+  def load_routes(refresh: false)
+    @router = nil if refresh # clear_routes
+
+    routes_file = "#{Jets.root}/config/routes.rb"
+    return unless File.exist?(routes_file)
+    if refresh
+      load routes_file # always evaluate
+    else
+      require routes_file # evaluate once
+    end
+  end
+
+  def aws
+    Jets::AwsInfo.new
+  end
+  memoize :aws
+
+end

data/lib/jets/authorizer/base.rb

@@ -0,0 +1,36 @@
+# Authorizer public methods get turned into Lambda functions.
+#
+# Jets::Authorizer::Base < Jets::Lambda::Functions
+# Both Jets::Authorizer::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Authorizer::Dsl overrides some of the Jets::Lambda::Functions behavior.
+module Jets::Authorizer
+  class Base < Jets::Lambda::Functions
+    include Dsl
+    include Helpers::IamHelper
+
+    class << self
+      def process(event, context, meth)
+        authorizer = new(event, context, meth)
+        authorizer.send(meth)
+      end
+
+      # Parameter: authorizer: Example: "main#protect"
+      #
+      # Determines authorization_type based on whether the authorizer is a Lambda or Cognito authorizer.
+      #
+      # Returns custom or cognito_user_pools
+      def authorization_type(authorizer)
+        class_name, meth = authorizer.split('#')
+        klass = "#{class_name}_authorizer".camelize.constantize
+        meth = meth.to_sym
+
+        # If there's a lambda function associated with the authorizer then it's a custom authorizer
+        # Otherwise it's a cognito authorizer.
+        #
+        # Returns: Valid values: none, aws_iam, custom, cognito_user_pools, aws_cross_account_iam
+        methods = klass.public_instance_methods(false)
+        methods.include?(meth) ? :custom : :cognito_user_pools
+      end
+    end
+  end
+end

data/lib/jets/authorizer/dsl.rb

@@ -0,0 +1,69 @@
+require 'active_support'
+require 'active_support/core_ext/class'
+
+# Jets::Authorizer::Base < Jets::Lambda::Functions
+# Both Jets::Authorizer::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Authorizer::Dsl overrides some of the Jets::Lambda::Functions behavior.
+#
+# Implements:
+#
+#   default_associated_resource_definition
+#
+module Jets::Authorizer
+  module Dsl
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def authorizer(props={})
+        if props[:type].to_s.upcase == "COGNITO_USER_POOLS"
+          cognito_authorizer(props)
+        else
+          lambda_authorizer(props)
+        end
+      end
+
+      def lambda_authorizer(props={})
+        with_fresh_properties(multiple_resources: false) do
+          r = Jets::Resource::ApiGateway::Authorizer.new(props)
+          resource(r.definition) # add associated resource immediately
+        end
+      end
+
+      # Creates a task but registers it to cognito_authorizers instead of all_tasks because there is no Lambda
+      # function associated with the cognito authorizer.
+      def cognito_authorizer(props={})
+        resources = [props]
+        # Authorizer name can have dashes, but "method" name should be underscored for correct logical id.
+        meth = props[:name].gsub('-','_')
+        resource = Jets::Resource::ApiGateway::Authorizer.new(props)
+
+        # Mimic task to grab base_replacements, namely namespace.
+        # Do not actually use the task to create a Lambda function for cognito authorizer.
+        # Only using the task for base_replacements.
+        task = Jets::Lambda::Task.new(self.name, meth,
+                 resources: resources,
+                 replacements: {}) # No need for need additional replacements. Baseline replacements suffice
+        all_cognito_authorizers[name] = { definition: resource.definition, replacements: task.replacements }
+        clear_properties
+      end
+
+      def all_cognito_authorizers
+        @all_cognito_authorizers ||= ActiveSupport::OrderedHash.new
+      end
+
+      def cognito_authorizers
+        all_cognito_authorizers.values
+      end
+
+      def build?
+        !tasks.empty? || !all_cognito_authorizers.empty?
+      end
+    end
+
+    included do
+      class << self
+        include Jets::AwsServices
+      end
+    end
+  end
+end

data/lib/jets/authorizer/helpers/iam_helper.rb

@@ -0,0 +1,47 @@
+module Jets::Authorizer::Helpers
+  module IamHelper
+  private
+    # Structure: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-lambda-authorizer-output.html
+    # Example:
+    #
+    #     {
+    #       "principalId" => "yyyyyyyy", // The principal user identification associated with the token sent by the client.
+    #       "policyDocument" => {},
+    #       "context" => {},
+    #       "usageIdentifierKey" => "{api-key}"
+    #     }
+    #
+    def build_policy(*args)
+      if args.first.is_a?(Hash) # generalized form
+        props = args.first
+      else # build_policy(resource, principal, context, usage_identifier_key) form
+        resource, principal_id, context, usage_identifier_key = args
+        props = {
+          principal_id: principal_id || "default_user",
+          policy_document: {
+            version: "2012-10-17",
+            statement: [
+              action: "execute-api:Invoke",
+              effect: "Allow",
+              resource: resource || "*",
+            ],
+          },
+        }
+        props[:context] = context if context
+        props[:usage_identifier_key] = usage_identifier_key if usage_identifier_key
+      end
+
+      props.transform_keys! { |k| pascalize(k) } # Only top-level keys are pascalized
+      # policyDocument is camelized, everything else is left alone
+      props["policyDocument"] = Jets::Camelizer.transform(props["policyDocument"])
+      props
+    end
+
+    def pascalize(value)
+      new_value = value.to_s.camelize
+      first_char = new_value[0..0].downcase
+      new_value[0] = first_char
+      new_value
+    end
+  end
+end

data/lib/jets/autoloaders.rb

@@ -0,0 +1,112 @@
+require "jets/bundle"
+Jets::Bundle.setup
+require "zeitwerk"
+
+module Jets
+  module Commands ; end
+
+  module Autoloaders
+    class OnceInflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = {
+          cli: "CLI",
+          io: "IO",
+          version: "VERSION"
+        }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      extend Memoist
+
+      def log!
+        main.log!
+        once.log!
+        cli.log!
+      end
+
+      def main
+        Zeitwerk::Loader.new.tap do |loader|
+          loader.tag = "jets.main"
+          # loader.inflector = Inflector.new # TODO: allow custom app inflector
+          # The main loader is configured later on in Jets::Application#setup_autoload_paths
+          # because it needs access to Jets.root and Jets.config settings
+        end
+      end
+      memoize :main
+
+      def once
+        Zeitwerk::Loader.new.tap do |loader|
+          loader.tag = "jets.once"
+          loader.inflector = OnceInflector.new
+
+          loader.push_dir("#{__dir__}/..")
+          internal_app_paths.each do |path|
+            loader.push_dir("#{__dir__}/#{path}")
+            # Cannot eager load internal app classes because need the app first for classes like ApplicationHelper
+            loader.do_not_eager_load("#{__dir__}/#{path}")
+          end
+
+          do_not_eager_load_paths.each do |path|
+            loader.do_not_eager_load("#{__dir__}/#{path}")
+          end
+
+          ignore_paths.each do |path|
+            loader.ignore("#{__dir__}/#{path}")
+          end
+        end
+      end
+      memoize :once
+
+      def cli
+        Zeitwerk::Loader.new.tap do |loader|
+          loader.tag = "jets.cli"
+          loader.inflector = OnceInflector.new
+
+          loader.push_dir("#{__dir__}/commands", namespace: Jets::Commands)
+          loader.ignore("#{__dir__}/commands/templates*")
+        end
+      end
+      memoize :cli
+
+    private
+      def internal_app_paths
+        %w[
+          internal/app/controllers
+          internal/app/helpers
+          internal/app/jobs
+          internal/turbines
+        ]
+      end
+
+      # Do eager load but allow autoloading. Specs related files make sense here.
+      def do_not_eager_load_paths
+        %w[
+          cli
+          spec_helpers
+          spec_helpers.rb
+          generator
+        ]
+      end
+
+      # These files will not be eager loaded and also will not follow the autoloading convention.
+      # They are generally explictly required.
+      def ignore_paths
+        # eager loading builders/rackup_wrappers - will cause the program to exit
+        %w[
+          builders/rackup_wrappers
+          builders/reconfigure_rails
+          builders/templates
+          commands
+          controller/middleware/webpacker_setup.rb
+          core_ext
+          internal
+          overrides
+          turbo/project
+        ]
+      end
+    end
+  end
+end
+