jets 5.0.14 → 6.0.0.beta1

data/lib/jets/core.rb

@@ -1,221 +1,66 @@
 module Jets::Core
   extend Memoist
 
-  mattr_accessor :cache
-
-  delegate :aws, :autoloaders, :config, to: :application
-
-  @application = @app_class = nil
-
-  attr_writer :application
-  attr_accessor :app_class
-  def application
-    @application ||= (app_class.instance if app_class)
-  end
-
-  def backtrace_cleaner
-    @backtrace_cleaner ||= Jets::BacktraceCleaner.new
-  end
-
-  # The Configuration instance used to configure the Rails environment
-  def configuration
-    application.config
-  end
-
   def root
-    root = ENV['JETS_ROOT'].to_s
-    root = Dir.pwd if root == ''
+    root = ENV["JETS_ROOT"].to_s
+    root = Dir.pwd if root == ""
     Pathname.new(root)
   end
+  memoize :root
 
   def env
-    env = ENV['JETS_ENV'] || 'development'
-    ENV['RAILS_ENV'] = ENV['RACK_ENV'] = env
+    env = ENV["JETS_ENV"] || "dev"
     ActiveSupport::StringInquirer.new(env)
   end
   memoize :env
 
-  @@extra_warning_shown = false
   def extra
-    # Keep for backwards compatibility
-    unless ENV['JETS_ENV_EXTRA'].blank?
-      puts "DEPRECATION WARNING: JETS_ENV_EXTRA is deprecated. Use JETS_EXTRA instead.".color(:yellow) unless @@extra_warning_shown
-      @@extra_warning_shown = true
-      extra = ENV['JETS_ENV_EXTRA']
-    end
-    extra = ENV['JETS_EXTRA'] unless ENV['JETS_EXTRA'].blank?
-    extra
+    ENV["JETS_EXTRA"] unless ENV["JETS_EXTRA"].blank?
   end
 
-  def project_name
-    path = "config/project_name"
-    if ENV['JETS_PROJECT_NAME'] && !ENV['JETS_PROJECT_NAME'].blank?
-      ENV['JETS_PROJECT_NAME']
-    elsif File.exist?(path)
-      IO.read(path).strip
-    elsif parsed_project_name
-      parsed_project_name
-    else
-      Dir.pwd.split("/").last # conventionally infer app name from current directory
-    end
+  def project
+    Config::Project.instance
   end
 
-  def project_namespace
-    [project_name, short_env, extra].compact.join('-').gsub('_','-')
+  def bootstrap
+    Config::Bootstrap.instance
   end
 
-  def table_namespace
-    [project_name, short_env].compact.join('-')
+  def shim
+    Jets::Shim
   end
 
-  ENV_MAP = {
-    development: 'dev',
-    production: 'prod',
-    staging: 'stag',
-  }
-  def short_env
-    ENV_MAP[Jets.env.to_sym] || Jets.env
+  # Load project and app config files
+  def boot
+    Jets::Core::Booter.boot!
   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.
-  #
-  # Keep for backwards compatibility
-  def parsed_project_name
-    lines = IO.readlines("#{Jets.root}/config/application.rb")
-    project_name_line = lines.find { |l| l =~ /config\.project_name.*=/ && l !~ /^\s+#/ }
-    if project_name_line
-      parsed = project_name_line.gsub(/.*=/,'').strip
-      # The +? makes it non-greedy
-      # See: https://ruby-doc.org/core-2.5.1/Regexp.html#class-Regexp-label-Repetition
-      md = parsed.match(/['"](.+?)['"]/)
-      md ? md[1] : raise("Unable to parse project name from config/application.rb: #{project_name_line}")
-    end
+  # delegate :aws, :autoloaders, :config, to: :application
+  def aws
+    Jets::AwsServices::AwsInfo.new
   end
-  memoize :parsed_project_name
+  memoize :aws
 
-  # Load all application base classes and project classes
-  def boot
-    Jets::Booter.boot!
+  # Frameworks can set Jets.logger to use their own logger.
+  cattr_accessor :logger
+  def logger
+    @logger ||= Jets.bootstrap.config.logger
   end
 
   def build_root
-    "/tmp/jets/#{Jets.project_name}".freeze
+    root = ENV["JETS_BUILD_ROOT"] || "/tmp/jets"
+    "#{root}/#{Jets.project.namespace}".freeze
   end
   memoize :build_root
 
-  def logger
-    @logger
-  end
-
-  def logger=(logger)
-    @logger = logger
+  def s3_bucket
+    Jets::Cfn::Resource::S3::JetsBucket.name
   end
 
   def deprecator # :nodoc:
     @deprecator ||= ActiveSupport::Deprecation.new
   end
 
-  def webpacker?
-    Gem.loaded_specs.keys.any?{|k| k.start_with?("webpacker")}
-  end
-  memoize :webpacker?
-
-  def version
-    Jets::VERSION
-  end
-
-  # NOTE: In development this will always be 1 because the app gets reloaded.
-  # On AWS Lambda, this will be ever increasing until the container gets replaced.
-  @@call_count = 0
-  def increase_call_count
-    @@call_count += 1
-  end
-
-  def call_count
-    @@call_count
-  end
-
-  @@prewarm_count = 0
-  def increase_prewarm_count
-    @@prewarm_count += 1
-  end
-
-  def prewarm_count
-    @@prewarm_count
-  end
-
-  def poly_only?
-    return true if ENV['JETS_POLY_ONLY'] # bypass to allow rapid development of handlers
-    Jets::Cfn::Builder.poly_only?
-  end
-
-  def custom_domain?
-    Jets.config.domain.hosted_zone_name
-  end
-
-  def s3_events?
-    !Jets::Job::Base._s3_events.empty?
-  end
-
-  def process(event, context, handler)
-    if event['_prewarm']
-      Jets.increase_prewarm_count
-      Jets.logger.info("Prewarm request")
-      {prewarmed_at: Time.now.to_s}
-    else
-      Jets::Processors::MainProcessor.new(event, context, handler).run
-    end
-  end
-
-  def once
-    boot
-    override_lambda_ruby_runtime
-    # require "jets/overrides/puma" # leaving around as a comment in case needed in the future
-    tmp_load!
-  end
-
-  def tmp_load!
-    Jets::TmpLoader.load!
-  end
-
-  def override_lambda_ruby_runtime
-    require "jets/overrides/lambda"
-  end
-
-  def ruby_folder
-    RUBY_VERSION.split('.')[0..1].join('.') + '.0'
-  end
-
-  # used to configure internal lambda functions
-  # current ruby runtime that user is running
-  # IE: ruby2.5 ruby2.7
-  def ruby_runtime
-    version = RUBY_VERSION.split('.')[0..1].join('.')
-    "ruby#{version}"
-  end
-
-  def one_lambda_per_controller?
-    Jets.config.cfn.build.controllers == "one_lambda_per_controller"
-  end
-
-  def one_lambda_for_all_controllers?
-    Jets.config.cfn.build.controllers == "one_lambda_for_all_controllers"
-  end
-
-  def gem_layer?
-    !Jets.poly_only? || Jets.one_lambda_for_all_controllers?
-  end
-
-  # Do not memoize here. The JetsBucket.name does it's own special memoization.
-  def s3_bucket
-    Jets::Cfn::Resource::S3::JetsBucket.name
-  end
-
   def report_exception(exception)
     # See Jets::ExceptionReporting decorate_exception_with_exception_reported!
     if exception.respond_to?(:with_exception_reported?) && exception.with_exception_reported?
@@ -240,25 +85,4 @@ module Jets::Core
     application && application.executor.error_reporter
     # ActiveSupport.error_reporter
   end
-
-  # Returns a Pathname object of the public folder of the current
-  # \Jets project, otherwise it returns +nil+ if there is no project:
-  #
-  #   Jets.public_path
-  #     # => #<Pathname:/Users/someuser/some/path/project/public>
-  def public_path
-    application && Pathname.new(application.paths["public"].first)
-  end
-
-  def autoloaders
-    application.autoloaders
-  end
-
-  # It's useful to eager load and find out any error within the jets code immediately.
-  # Leaving in place because think the layer of protection is good.
-  # Eager load outside of a jets project can error. IE: `jets -h`
-  # Eager load inside a jets project is fine.
-  def eager_load_gem?
-    File.exist?("config/application.rb") || ENV['JETS_TEST'] || defined?(ENGINE_ROOT) # jets project
-  end
 end

data/lib/jets/core_ext/bundler.rb

@@ -1,7 +1,9 @@
 # Bundler 2.0 does yet not have with_unbundled_env
-# Bundler 2.1 deprecates with_unbundled_env for with_unbundled_env
+# Bundler 2.1 deprecates with_clean_env for with_unbundled_env
 
 require "bundler"
-def Bundler.with_unbundled_env(&block)
-  with_clean_env(&block)
-end unless Bundler.respond_to?(:with_unbundled_env)
+unless Bundler.respond_to?(:with_unbundled_env)
+  def Bundler.with_unbundled_env(&block)
+    with_clean_env(&block)
+  end
+end

data/lib/jets/core_ext.rb

@@ -1,4 +1,3 @@
 require "jets/core_ext/bundler"
 require "jets/core_ext/file"
 require "jets/core_ext/symbol"
-# Do not require jets/core_ext/kernel because it is a special case

data/lib/jets/dotenv/convention.rb

@@ -0,0 +1,86 @@
+class Jets::Dotenv
+  class Convention
+    extend Memoist
+    delegate :config, to: "Jets.project"
+    delegate :env, to: Jets
+
+    # ssm leaf name is the name of the leaf in the SSM parameter store.
+    # It can come from the key or the value.
+    #
+    #   DATABASE_URL=SSM        => DATABASE_URL
+    #   DATABASE_URL=SSM:DB_URL => DB_URL
+    #
+    #
+    # Full SSM name. Example:
+    #
+    #   /project/dev/DATABASE_URL
+    #   /project/dev/DB_URL
+    #
+    def ssm_name(ssm_leaf_name)
+      if config.dotenv.ssm.convention_resolver
+        config.dotenv.ssm.convention_resolver.call(ssm_leaf_name)
+      else
+        "#{self.class.ssm_path}#{ssm_leaf_name}"
+      end
+    end
+
+    class << self
+      extend Memoist
+      delegate :config, to: "Jets.project"
+      delegate :env, to: Jets
+
+      def ssm_path
+        project = config.dotenv.ssm.project_name || Jets.project.name
+        # consider long_env config in the ssm_name only
+        ssm_env = config.dotenv.ssm.long_env_name ? resolved_long_env : resolved_env
+
+        "/#{project}/#{ssm_env}/"
+      end
+
+      # Does not use the envs.fallbakc and envs.unique settings.
+      def jets_env_path
+        project = config.dotenv.ssm.project_name || Jets.project.name
+        ssm_env = config.dotenv.ssm.long_env_name ? (long_env_map[Jets.env.to_sym] || Jets.env) : Jets.env
+
+        "/#{project}/#{ssm_env}/"
+      end
+
+      def ssm_env
+        config.dotenv.ssm.long_env_helper ? resolved_long_env : resolved_env
+      end
+
+      def resolved_env
+        if unique_env?(env)
+          env # IE: dev or prod
+        else
+          config.dotenv.ssm.envs.fallback # IE: dev
+        end
+      end
+
+      def unique_env?(env)
+        config.dotenv.ssm.envs.unique.nil? ||
+          config.dotenv.ssm.envs.unique == :all ||
+          config.dotenv.ssm.envs.unique.include?(env)
+      end
+
+      def resolved_long_env
+        short_env = resolved_env
+        long_env_map[short_env.to_sym] || short_env
+      end
+
+      # Jets 5.0 legacy
+      def long_env
+        short_env = Jets.env.to_s
+        long_env_map[short_env.to_sym] || short_env
+      end
+
+      def long_env_map
+        {
+          dev: "development",
+          prod: "production",
+          stag: "staging"
+        }
+      end
+    end
+  end
+end

data/lib/jets/dotenv/ssm.rb

@@ -1,67 +1,90 @@
-require 'aws-sdk-ssm'
-
 class Jets::Dotenv
   class Ssm
-    SSM_VARIABLE_REGEXP = /^ssm:(.*)/i
+    include Jets::AwsServices
+    include Jets::Util::Logging
 
-    def initialize(variables={})
+    def initialize(variables)
       @variables = variables
       @missing = []
     end
 
     def interpolate!
-      interpolated_variables = @variables.map do |key, value|
-        if value[SSM_VARIABLE_REGEXP]
-          value = fetch_ssm_value(key, $1)
-        elsif value == "SSM"
-          value = fetch_ssm_value(key, "SSM")
-        end
-
-        [key, value]
+      interpolated_vars = merged_variables.map do |key, value|
+        var = Var.new(key, value)
+        @missing << var if var.ssm_missing?
+        var
       end
 
-      interpolated_variables.each do |key, value|
-        ENV[key] = value
+      interpolated_vars.each do |var|
+        ENV[var.name] = var.value
       end
 
       if @missing.empty?
-        interpolated_variables.to_h.sort_by { |k,_| k }.to_h # success
+        interpolated_vars.map { |var| [var.name, var.value] }.sort.to_h # success
       else
         message = "Error loading .env variables. No matching SSM parameters found for:\n".color(:red)
-        message += @missing.map do |k,v,n|
-          value = v == "SSM" ? v : "ssm:#{v}"
-          "  #{k}=#{value} # ssm name: #{n}"
+        message += @missing.map do |var|
+          "    #{var.name}=#{var.raw_value} # ssm name: #{var.ssm_name}"
         end.join("\n")
         abort message
       end
     end
 
-    def fetch_ssm_value(key, value)
-      return "fake-ssm-value" if ENV['JETS_NO_INTERNET']
+    # Merges the variables from the dotenv files with the conventional ssm variables
+    # inferred by path, IE: /demo/dev/
+    # User defined config/jets/env files values win over inferred ssm variables.
+    def merged_variables
+      if Jets.project.dotenv.ssm.autoload.enable
+        ssm_vars = get_ssm_parameters_path(Convention.ssm_path) # IE: /demo/dev/
+        if Convention.jets_env_path != Convention.ssm_path
+          jets_env_vars = get_ssm_parameters_path(Convention.jets_env_path) # IE: /demo/sbx/
+          ssm_vars = ssm_vars.merge(jets_env_vars)
+        end
+
+        # skip list
+        ssm_vars = ssm_vars.delete_if { |k, v| skip_list?(k) }
 
-      name = ssm_name(key, value)
-      response = ssm.get_parameter(name: name, with_decryption: true)
-      response.parameter.value
-    rescue Aws::SSM::Errors::ParameterNotFound
-      @missing << [key, value, name]
-      ''
-    rescue Aws::SSM::Errors::ValidationException
-      puts "ERROR: Invalid SSM parameter name: #{name.inspect}".color(:red)
-      raise
+        # optimization: no need to get vars with SSM values since they are already in ssm_vars
+        vars = @variables.dup.delete_if { |k, v| v == "SSM" && ssm_vars.key?(k) }
+        ssm_vars.merge(vars)
+      else
+        @variables
+      end
     end
 
-    def ssm_name(key, value)
-      if value == "SSM"
-        "/#{Jets.project_name}/#{Jets.env}/#{key}"
-      else
-        value.start_with?("/") ?
-          value :
-          "/#{Jets.project_name}/#{Jets.env}/#{value}"
+    def skip_list?(key)
+      key = key.to_s
+      a = Jets.project.dotenv.ssm.autoload
+      skip_list = a.default_skip + a.skip
+      skip_list.detect do |i|
+        if i.is_a?(Regexp)
+          key.match(i)
+        else
+          key == i
+        end
       end
     end
 
-    def ssm
-      @ssm ||= Aws::SSM::Client.new
+    def get_ssm_parameters_path(path)
+      if ARGV.include?("dotenv") && ARGV.include?("list")
+        warn "# Autoloading SSM parameters within path #{path}"
+      end
+      parameters = {}
+      next_token = nil
+
+      loop do
+        resp = ssm.get_parameters_by_path(path: path, with_decryption: true, next_token: next_token)
+
+        resp.parameters.each do |param|
+          key = param.name.sub(path, "")
+          parameters[key] = param.value
+        end
+
+        next_token = resp.next_token
+        break unless next_token
+      end
+
+      parameters
     end
   end
 end

data/lib/jets/dotenv/var.rb

@@ -0,0 +1,60 @@
+class Jets::Dotenv
+  class Var
+    extend Memoist
+    include Jets::AwsServices
+    include Jets::Util::Logging
+
+    attr_reader :raw_key, :raw_value
+    def initialize(raw_key, raw_value)
+      @raw_key, @raw_value = raw_key, raw_value
+    end
+
+    def name
+      @raw_key
+    end
+
+    def value
+      ssm? ? ssm_value : @raw_value
+    end
+    memoize :value
+
+    SSM_VARIABLE_REGEXP = /^SSM:(.*)/i
+    def ssm_name
+      if @raw_value == "SSM"
+        # "/#{Jets.project.name}/#{Jets.env}/#{@raw_key}"
+        Convention.new.ssm_name(@raw_key)
+      else
+        value = @raw_value.sub(/SSM:/i, "")
+        if value.start_with?("/")
+          value
+        else
+          # "/#{Jets.project.name}/#{Jets.env}/#{value}"
+          Convention.new.ssm_name(value)
+        end
+      end
+    end
+
+    def ssm_value
+      return "fake-ssm-value" if ENV["JETS_NO_INTERNET"]
+
+      name = ssm_name
+      resp = ssm.get_parameter(name: name, with_decryption: true)
+      resp.parameter.value
+    rescue Aws::SSM::Errors::ParameterNotFound
+      @ssm_missing = true
+      nil
+    rescue Aws::SSM::Errors::ValidationException
+      puts "ERROR: Invalid SSM parameter name: #{name.inspect}".color(:red)
+      raise
+    end
+
+    def ssm_missing?
+      value # trigger memoization
+      !!@ssm_missing
+    end
+
+    def ssm?
+      @raw_value&.start_with?("SSM")
+    end
+  end
+end

data/lib/jets/dotenv.rb

@@ -1,54 +1,59 @@
 require "dotenv"
 
-class Jets::Dotenv
-  def self.load!(remote = false)
-    new(remote).load!
-  end
-
-  def initialize(remote = false)
-    @remote = ENV["JETS_ENV_REMOTE"] || remote
-  end
-
-  # @@vars cache to prevent multiple calls to Ssm
-  # Tricky note: The cache also prevents the second call to Dotenv.load from
-  # returning {} vars. Dotenv 3.0 will not return the vars if it has already been loaded
-  # in the ENV. We want this side-effect due to the new way Dotenv 3.0 works.
-  @@vars = nil
-  def load!
-    return @@vars if @@vars
-    return if on_aws? # this prevents ssm calls if used in dotenv files
-    vars = ::Dotenv.load(*dotenv_files)
-    @@vars = Ssm.new(vars).interpolate!
-  end
-
-  def on_aws?
-    return true if ENV["ON_AWS"]
-    !!ENV["_HANDLER"] # https://docs.aws.amazon.com/lambda/latest/dg/lambda-environment-variables.html
-  end
-
-  # dotenv files with the following precedence:
-  #
-  # - .env.development.jets_extra (highest)
-  # - .env.development.remote (2nd highest, only if JETS_ENV_REMOTE=1)
-  # - .env.development.local (unless JETS_ENV_REMOTE=1)
-  # - .env.development
-  # - .env.local - This file is loaded for all environments _except_ `test` or unless JETS_ENV_REMOTE=1
-  # - .env - The original (lowest)
-  #
-  def dotenv_files
-    files = []
-
-    files << files << root.join(".env.#{Jets.env}.#{Jets.extra}") if Jets.extra
-    files << root.join(".env.#{Jets.env}.remote") if @remote
-    files << root.join(".env.#{Jets.env}.local") unless @remote
-    files << root.join(".env.#{Jets.env}")
-    files << root.join(".env.local") unless Jets.env.test? || @remote
-    files << root.join(".env")
-
-    files.compact.map(&:to_s)
-  end
-
-  def root
-    Jets.root || Pathname.new(ENV["JETS_ROOT"] || Dir.pwd)
+module Jets
+  class Dotenv
+    include Jets::AwsServices
+    include Jets::Util::Logging
+
+    def load!
+      return unless load?
+      variables = ::Dotenv.load(*dotenv_files)
+      Ssm.new(variables).interpolate!
+    end
+
+    def parse
+      return {} unless load?
+      variables = ::Dotenv.parse(*dotenv_files)
+      Ssm.new(variables).interpolate!
+    end
+
+    def load?
+      enabled = ENV["JETS_DOTENV"] != "0" # allow to disable with JETS_DOTENV=0
+      # Prevent ssm calls when on AWS Lambda but will call if on AWS CodeBuild
+      on_aws = (ENV["ON_AWS"] || ENV["_HANDLER"]) && !ENV["CODEBUILD_CI"]
+      enabled && !on_aws
+    end
+
+    # dotenv files with the following precedence:
+    #
+    # - config/jets/env/.env.dev.extra (highest)
+    # - config/jets/env/.env.dev
+    # - config/jets/env/.env - The original (lowest)
+    #
+    def dotenv_files
+      files = []
+
+      files << ".env.#{Jets.env}.#{Jets.extra}" if Jets.extra
+      files << ".env.#{Jets.env}"
+      files << ".env"
+
+      files.map! { |f| Jets.root.join("config/jets/env", f) }.compact
+      files.map(&:to_s)
+    end
+
+    class << self
+      extend Memoist
+      @@load = nil
+      def load!
+        @@load ||= new.load!
+      end
+      memoize :load!
+
+      @@parse = nil
+      def parse
+        @@parse ||= new.parse
+      end
+      memoize :parse
+    end
   end
 end