jets 4.0.10 → 5.0.0.beta1

data/lib/jets/authorizer/base.rb

@@ -7,6 +7,7 @@ module Jets::Authorizer
   class Base < Jets::Lambda::Functions
     include Dsl
     include Helpers::IamHelper
+    prepend Jets::ExceptionReporting::Process
 
     class << self
       def process(event, context, meth)

data/lib/jets/authorizer/dsl.rb

@@ -14,8 +14,11 @@ module Jets::Authorizer
     extend ActiveSupport::Concern
 
     class_methods do
+      include Jets::Util::Camelize
+
       def authorizer(props={})
-        if props[:type].to_s.upcase == "COGNITO_USER_POOLS"
+        camelize(props)
+        if props[:Type].to_s.upcase == "COGNITO_USER_POOLS"
           cognito_authorizer(props)
         else
           lambda_authorizer(props)
@@ -24,26 +27,27 @@ module Jets::Authorizer
 
       def lambda_authorizer(props={})
         with_fresh_properties(multiple_resources: false) do
-          r = Jets::Resource::ApiGateway::Authorizer.new(props)
+          r = Jets::Cfn::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
+      # Creates a definition 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={})
+        camelize(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)
+        meth = props[:Name].gsub('-','_')
+        resource = Jets::Cfn::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,
+        # Mimic definition to grab base_replacements, namely namespace.
+        # Do not actually use the definition to create a Lambda function for cognito authorizer.
+        # Only using the definition for base_replacements.
+        definition = Jets::Lambda::Definition.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 }
+        all_cognito_authorizers[name] = { definition: resource.definition, replacements: definition.replacements }
         clear_properties
       end
 
@@ -56,7 +60,7 @@ module Jets::Authorizer
       end
 
       def build?
-        !tasks.empty? || !all_cognito_authorizers.empty?
+        !definitions.empty? || !all_cognito_authorizers.empty?
       end
     end
 

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

@@ -1,6 +1,8 @@
 module Jets::Authorizer::Helpers
   module IamHelper
-  private
+    include Jets::Util::Camelize
+
+    private
     # Structure: https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-lambda-authorizer-output.html
     # Example:
     #
@@ -17,23 +19,23 @@ module Jets::Authorizer::Helpers
       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 || "*",
+          principalId: principal_id || "default_user",
+          policyDocument: {
+            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
+        props[:usageIdentifierKey] = 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[:policyDocument] = camelize(props[:policyDocument])
       props
     end
 
@@ -41,7 +43,7 @@ module Jets::Authorizer::Helpers
       new_value = value.to_s.camelize
       first_char = new_value[0..0].downcase
       new_value[0] = first_char
-      new_value
+      new_value.to_sym
     end
   end
 end

data/lib/jets/autoloaders/gem.rb

@@ -0,0 +1,70 @@
+require "zeitwerk"
+
+module Jets
+  class Autoloaders
+    class GemInflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = {
+          cli: "CLI",
+          io: "IO",
+          version: "VERSION"
+        }
+        map[basename.to_sym] || super
+      end
+    end
+
+    # for jets gem itself
+    class Gem
+      def autoloader
+        loader = Zeitwerk::Loader.new
+        loader.tag = "jets.gem"
+        loader.inflector = GemInflector.new
+        loader.push_dir(lib)
+        loader.do_not_eager_load(do_not_eager_load)
+        loader.ignore(ignore_paths) # loader.ignore requires full dir or path
+        # loader.log!
+        loader
+      end
+
+      def lib
+        File.expand_path("#{__dir__}/../..") # jets/lib
+      end
+
+      # For jets/info.rb see Jets::Info property Middleware for why we do not eager load.
+      def do_not_eager_load
+        paths = %w[
+          jets/info.rb
+          jets/spec_helpers
+          jets/spec_helpers.rb
+          jets/commands
+          jets/commands.rb
+          jets/generators
+          jets/generators.rb
+        ]
+        paths.map { |path| "#{lib}/#{path}" } # do_not_eager_load requires full dir or path
+      end
+
+      def ignore_paths
+        # commands
+        paths = %w[
+          jets/application/dummy_config.rb
+          jets/application/dummy_erb_compiler.rb
+          jets/builders/rackup_wrappers
+          jets/builders/templates
+          jets/commands/templates
+          jets/controller/middleware/webpacker_setup.rb
+          jets/core_ext
+          jets/core_ext.rb
+          jets/generator
+          jets/overrides
+          jets/ruby_version_check.rb
+          jets/cli.rb
+          jets/commands.rb
+          jets/generators/jets/app/ignore
+          jets/tasks.rb
+        ]
+        paths.map { |path| "#{lib}/#{path}" }
+      end
+    end
+  end
+end

data/lib/jets/autoloaders/inflector.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Jets
+  class Autoloaders
+    module Inflector # :nodoc:
+      # Concurrent::Map is not needed. This is a private class, and overrides
+      # must be defined while the application boots.
+      @overrides = {}
+
+      def self.camelize(basename, _abspath)
+        @overrides[basename] || basename.camelize
+      end
+
+      def self.inflect(overrides)
+        @overrides.merge!(overrides)
+      end
+    end
+  end
+end

data/lib/jets/autoloaders.rb

@@ -3,113 +3,50 @@ 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
+  class Autoloaders
+    require_relative "autoloaders/inflector"
+
+    include Enumerable
+
+    attr_reader :main, :once
+
+    def initialize
+      # This `require` delays loading the library on purpose.
+      #
+      # In Rails 7.0.0, railties/lib/rails.rb loaded Zeitwerk as a side-effect,
+      # but a couple of edge cases related to Bundler and Bootsnap showed up.
+      # They had to do with order of decoration of `Kernel#require`, something
+      # the three of them do.
+      #
+      # Delaying this `require` up to this point is a convenient trade-off.
+      require "zeitwerk"
+
+      @main = Zeitwerk::Loader.new
+      @main.tag = "jets.main"
+      @main.inflector = Inflector
+
+      @once = Zeitwerk::Loader.new
+      @once.tag = "jets.once"
+      @once.inflector = Inflector
     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
-
-          internal_turbine_path = "#{__dir__}/internal/turbines"
-          loader.push_dir(internal_turbine_path)
-
-          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
+    def each
+      yield main
+      yield once
+    end
 
-    private
-      def internal_app_paths
-        %w[
-          internal/app/controllers
-          internal/app/helpers
-          internal/app/jobs
-          internal/turbines
-        ]
-      end
+    def logger=(logger)
+      each { |loader| loader.logger = logger }
+    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
+    def log!
+      each(&:log!)
+    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
+    def self.for_gem
+      Gem.new.autoloader
     end
   end
 end
 
+require_relative "autoloaders/gem"

data/lib/jets/aws_services/stack_status.rb

@@ -55,7 +55,7 @@ module Jets::AwsServices
     end
 
     # Lookup output value.
-    # Used in Jets::Resource::ApiGateway::RestApi::* andJets::Commands::Url
+    # Used in Jets::Cfn::Resource::ApiGateway::RestApi::* andJets::Commands::Url
     def lookup(outputs, key)
       out = outputs.find { |o| o.output_key == key }
       out&.output_value

data/lib/jets/backtrace_cleaner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "active_support/backtrace_cleaner"
+require "active_support/core_ext/string/access"
+
+module Jets
+  class BacktraceCleaner < ActiveSupport::BacktraceCleaner
+    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/
+    RENDER_TEMPLATE_PATTERN = /:in `.*_\w+_{2,3}\d+_\d+'/
+
+    def initialize
+      super
+      @root = "#{Jets.root}/"
+      add_filter do |line|
+        line.start_with?(@root) ? line.from(@root.size) : line
+      end
+      add_filter do |line|
+        if RENDER_TEMPLATE_PATTERN.match?(line)
+          line.sub(RENDER_TEMPLATE_PATTERN, "")
+        else
+          line
+        end
+      end
+      add_silencer { |line| !APP_DIRS_PATTERN.match?(line) }
+    end
+  end
+end

data/lib/jets/booter.rb

@@ -1,133 +1,35 @@
-require "jets/core_ext/kernel" # Hack prevents Rails const from being defined
+require "jets/core_ext/kernel" # Hack prevents Jets const from being defined
 
 class Jets::Booter
   class << self
     @booted = false
     def boot!
       return if @booted
-
       confirm_jets_project!
-      Jets::Bundle.require
-
-      Jets.application.setup!
-      check_ruby_version!
-
-      # Turbines are loaded after setup_autoload_paths in Jets.application.setup!  Some Turbine options are defined
-      # in the project so setup must happen before internal Turbines are loaded.
-      load_internal_turbines
-
-      run_turbines(:initializers)
-      # Load configs after Turbine initializers so Turbines can defined some config options and they are available in
-      # user's project environment configs.
-      Jets.application.configs!
-      app_initializers
-      run_turbines(:after_initializers)
-      Jets.application.finish!
 
-      setup_db # establish db connections in Lambda Execution Context.
-      # The eager load calls connects_to in models and establish those connections in Lambda Execution Context also.
-      internal_finisher
-      eager_load
-
-      # TODO: Figure out how to build middleware during Jets.boot without breaking jets new and webpacker:install
-      # build_middleware_stack
+      # Registration phase
+      Jets::Bundle.require    # engine config and register initializers
+      load_internal_engine    # internal engine initializers
+      require_application!    # override with user customizations
 
+      # Run phase
+      Jets.application.initialize!
       @booted = true
     end
 
-    # Runs right before eager_load
-    def internal_finisher
-      load_shared_extensions
-    end
-
-    # Shared extensions are added near the end because they require the Jets app load paths to first.
-    # We eager load the extensions and then use the loaded modules to extend Jets::Stack directly.
-    # Originally used an included hook but thats too early before app/shared/extensions is in the load_path.
-    def load_shared_extensions
-      base_path = "#{Jets.root}/app/shared/extensions"
-      Dir.glob("#{base_path}/**/*.rb").each do |path|
-        next unless File.file?(path)
+    def require_application!
+      require ENGINE_PATH if defined?(ENGINE_PATH)
 
-        class_name = path.sub("#{base_path}/", '').sub(/\.rb/,'').camelize
-        mod = class_name.constantize # autoload
-        Jets::Stack.extend(mod)
-      end
-    end
-
-    def eager_load
-      preload_extensions
-      Jets::Autoloaders.main.eager_load # Eager load project code. Rather have user find out early than later on AWS Lambda.
-    end
-
-    def preload_extensions
-      base_path = "#{Jets.root}/app/extensions"
-      Dir.glob("#{base_path}/**/*.rb").each do |path|
-        next unless File.file?(path)
-
-        class_name = path.sub("#{base_path}/", '').sub(/\.rb/,'').camelize
-        klass = class_name.constantize # autoload
-        Jets::Lambda::Functions.extend(klass)
-      end
-    end
-
-    # Using ActiveRecord outside of Rails, so we need to set up the db connection ourself.
-    #
-    # Only connects to database for ActiveRecord and when config/database.yml exists.
-    # Dynomite handles connecting to the clients lazily.
-    def setup_db
-      return unless File.exist?("#{Jets.root}/config/database.yml")
-
-      db_configs = Jets.application.config.database
-      # DatabaseTasks.database_configuration for db:create db:migrate tasks
-      # Documented in DatabaseTasks that this is the right way to set it when
-      # using ActiveRecord rake tasks outside of Rails.
-      ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs
-
-      if db_configs.configs_for(env_name: Jets.env).blank?
-        abort("ERROR: config/database.yml exists but no environment section configured for #{Jets.env}")
-      end
-      ActiveRecord::Base.configurations = db_configs
-      connect_db
-    end
-
-    # Eager connect to database, so connections are established in the Lambda Execution Context and get reused.
-    # Interestingly, the connections info is stored in the shared state but the connection doesnt show up on
-    # `show processlist` until after a query. Have confirmed that the connection is reused and the connection count stays
-    # the same.
-    def connect_db
-      if ActiveRecord::Base.legacy_connection_handling
-        primary_hash_config = ActiveRecord::Base.configurations.configs_for(env_name: Jets.env).find { |hash_config|
-          hash_config.name == "primary"
-        }
-
-        primary_config = primary_hash_config.configuration_hash # configuration_hash is a normal Ruby Hash
-
-        ActiveRecord::Base.establish_connection(primary_config)
+      if defined?(APP_PATH)
+        check_old_jets_code!
+        require APP_PATH
       else
-        configs = ActiveRecord::Base.configurations.configs_for(env_name: Jets.env, include_replicas: true)
-
-        databases = { }
-        databases[:writing] = :primary if configs.any? { |config| config.name == "primary" }
-        databases[:reading] = :primary_replica if configs.any? { |config| config.name == "primary_replica" }
-
-        ActiveRecord::Base.connects_to database: databases
+        require "#{Jets.root}/config/application"
       end
     end
 
-    def load_internal_turbines
-      Jets::Autoloaders.once.on_setup do
-        Jets::Mailer # only one right now
-      end
-    end
-
-    # All Turbines
-    def turbine_initializers
-      Jets::Turbine.subclasses.each do |subclass|
-        initializers = subclass.initializers || []
-        initializers.each do |label, block|
-          block.call(Jets.application)
-        end
-      end
+    def load_internal_engine
+      require File.expand_path("../../engines/internal/lib/internal/engine.rb", __dir__)
     end
 
     # All Turbines
@@ -137,30 +39,27 @@ class Jets::Booter
       end
     end
 
-    # run_turbines(:initializers)
-    # run_turbines(:after_initializers)
-    def run_turbines(name)
-      Jets::Turbine.subclasses.each do |subclass|
-        hooks = subclass.send(name) || []
-        hooks.each do |label, block|
-          block.call(Jets.application)
-        end
-      end
-    end
-
-    # Builds and memoize stack so it only gets built on bootup
-    def build_middleware_stack
-      Jets.application.build_stack
-    end
-
     # Cannot call this for the jets new
+    # We check that within a jets project again as Jets.boot
+    # Also checked in the jets/cli.rb more generally
     def confirm_jets_project!
+      return if defined?(ENGINE_PATH)
       unless File.exist?("#{Jets.root}/config/application.rb")
         puts "It does not look like you are running this command within a jets project.  Please confirm that you are in a jets project and try again.".color(:red)
         exit 1
       end
     end
 
+    def check_old_jets_code!
+      application_rb = "#{Jets.root}/config/application.rb"
+      return unless File.exist?(application_rb)
+      return if File.read(application_rb).include?(' < Jets::Application')
+      puts "ERROR: Based on config/application.rb, it looks like your app code was written with an older version of Jets.".color(:red)
+      puts "Please install and run the jets-upgrade command to upgrade your project."
+      puts "  jets-upgrade go".color(:green)
+      exit 1
+    end
+
     def message
       "Jets booting up in #{Jets.env.color(:green)} mode!"
     end
@@ -171,55 +70,9 @@ class Jets::Booter
         puts 'The config.ru file is missing Jets.boot.  Please add Jets.boot after require "jets"'.color(:red)
         puts "This was changed as made in Jets v1.1.0."
         puts "To have Jets update the config.fu file for you, you can run:\n\n"
-        puts "  jets upgrade"
+        puts "    jets-upgrade"
         exit 1
       end
     end
-
-    def check_ruby_version!
-      return if ENV['JETS_RUBY_CHECK'] == '0'
-      return if !Jets.config.ruby.check
-      return if ruby_version_supported?
-
-      puts <<~EOL.color(:red)
-        You are using Ruby #{RUBY_VERSION}
-        AWS Lambda does not support this version.
-        Please use one of the supported Ruby versions: #{supported_ruby_versions.join(' ')}
-      EOL
-
-      puts <<~EOL
-        If you would like to skip this check, you can set: JETS_RUBY_CHECK=0 or configure
-
-        config/application.rb
-
-            Jets.application.configure do
-              config.ruby.check = false
-            end
-
-        Or if you want to allow additional Ruby versions, then configure:
-
-        config/application.rb
-
-            Jets.application.configure do
-              config.ruby.supported_versions = ["2.5", "2.7", "3.2"]
-            end
-
-        Note: If AWS Lambda does not officially support the Ruby version,
-        you'll need to also provide the Ruby Custom Runtime Layer.
-        Related Docs: https://rubyonjets.com/docs/extras/custom-runtime/
-      EOL
-      exit 1
-    end
-
-    def ruby_version_supported?
-      md = RUBY_VERSION.match(/(\d+)\.(\d+)\.\d+/)
-      major, minor = md[1], md[2]
-      detected_ruby = [major, minor].join('.')
-      supported_ruby_versions.include?(detected_ruby)
-    end
-
-    def supported_ruby_versions
-      Jets.config.ruby.supported_versions
-    end
   end
 end