jets 3.1.0 → 5.0.10

data/lib/jets/controller/base.rb

@@ -1,195 +1,117 @@
+require "action_controller"
+require "action_controller/log_subscriber"
+require "active_support/concern"
+require "active_support/callbacks"
+require "abstract_controller/callbacks"
 require "json"
 require "rack/utils" # Rack::Utils.parse_nested_query
 
 # Controller public methods get turned into Lambda functions.
-class Jets::Controller
-  class Base < Jets::Lambda::Functions
-    include ActiveSupport::Rescuable
-    include Authorization
-    include Callbacks
-    include Cookies
-    include ForgeryProtection
-    include Jets::Router::Helpers
-    include Layout
-    include Params
-    include Rendering
-
-    delegate :headers, to: :request
-    delegate :set_header, to: :response
-    attr_reader :request, :response
-    attr_accessor :session
-    def initialize(event, context={}, meth)
-      super
-      @request = Request.new(event, context)
-      @response = Response.new
-    end
-
-    # Overrides Base.process
-    def self.process(event, context={}, meth)
-      controller = new(event, context, meth)
-      # Using send because process! is private method in Jets::RackController so
-      # it doesnt create a lambda function.  It's doesnt matter what scope process!
-      # is in Controller::Base because Jets lambda functions inheritance doesnt
-      # include methods in Controller::Base.
-      # TODO: Can process! be a protected method to avoid this?
-      controller.send(:process!)
-    end
-
-    # One key difference between process! vs dispatch!
-    #
-    #    process! - takes the request through the middleware stack
-    #    dispatch! - does not
-    #
-    # Most of the time, you want process! instead of dispatch!
-    #
-    def process!
-      adapter = Jets::Controller::Rack::Adapter.new(event, context)
-      adapter.rack_vars(
-        'jets.controller' => self,
-        'lambda.context' => context,
-        'lambda.event' => event,
-        'lambda.meth' => meth,
-      )
-
-      # adapter.process calls
-      #
-      #     Jets.application.call(env)
-      #
-      # and that goes through the middleware stacks. The last middleware stack is Jets::Controller::Middleware::Main
-      #
-      #     class Jets::Controller::Middleware::Main
-      #       def call!
-      #         setup
-      #         @controller.dispatch! # Returns triplet
-      #       end
-      #     end
-      #
-      adapter.process # Returns API Gateway hash structure
-    end
-
-    # One key difference between process! vs dispatch!
-    #
-    #    process! - takes the request through the middleware stack
-    #    dispatch! - does not
-    #
-    # dispatch! is useful for megamode or mounted applications
-    #
-    def dispatch!
-      method_override!
-
-      t1 = Time.now
-      log_start
-
-      begin
-        if run_before_actions(break_if: -> { @rendered })
-          send(@meth)
-          action_completed = true
-        else
-          Jets.logger.info "Filter chain halted as #{@last_callback_name} rendered or redirected"
-        end
-
-        triplet = ensure_render
-        run_after_actions if action_completed
-      rescue Exception => exception
-        rescue_with_handler(exception) || raise
-        triplet = ensure_render
-      end
-
-      took = Time.now - t1
-      status = triplet[0]
-      log_finish(status: status, took: took)
-      triplet # status, headers, body
-    end
-
-    # Override @meth when POST with _method=delete
-    # By the time processing reaches dispatch which calls method_override!
-    # The Rack::MethodOverride middleware has overriden env['REQUEST_METHOD'] with DELETE
-    # and set env['rack.methodoverride.original_method']
-    def method_override!
-      env = request.env
-      if env['rack.methodoverride.original_method'] && env['REQUEST_METHOD'] == 'DELETE'
-        @original_meth = @meth
-        @meth = "delete"
-      end
-    end
-
-    def processing_log
-      processing = "Processing #{self.class.name}##{@meth}"
-      processing << " (original method #{@original_meth})" if @original_meth
-      processing
-    end
-
-    # Documented interface method, careful not to rename
-    def log_start
-      # JSON.dump makes logging look pretty in CloudWatch logs because it keeps it on 1 line
-      ip = request.ip
-      Jets.logger.info "Started #{@event['httpMethod']} \"#{@event['path']}\" for #{ip} at #{Time.now}"
-      Jets.logger.info processing_log
-      Jets.logger.info "  Event: #{event_log}"
-      Jets.logger.info "  Parameters: #{JSON.dump(filtered_parameters.to_h)}"
-    end
-
-    # Documented interface method, careful not to rename
-    def log_finish(options={})
-      status, took = options[:status], options[:took]
-      Jets.logger.info "Completed Status Code #{status} in #{took}s"
-    end
-
-    def event_log
-      display_event = @event.dup
+module Jets::Controller
+  DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8"
 
-      if @event['isBase64Encoded']
-        display_event['body'] = '[BASE64_ENCODED]'
-      else
-        display_event['body'] = parameter_filter.filter_json(display_event['body'])
-      end
+  class RoutingError < StandardError; end
 
-      display_event["queryStringParameters"] = parameter_filter.filter(display_event['queryStringParameters'])
-      display_event["pathParameters"] = parameter_filter.filter(display_event['pathParameters'])
-      json_dump(display_event)
+  class Base < Jets::Lambda::Functions
+    # Make Jets controller "compatible" with Rails
+    # Note: Rolling include into a single Compat module causes naming conflicts with ActionController and AbstractController.
+    # So we include each module individually. It's clearer this way anyway.
+    include Compat::AbstractController::Base
+    include Compat::ActionController::Metal
+    include Compat::RouteSet
+    include Compat::Caching
+    include Compat::Future
+
+    # Order matters due to use of super and the module included chain.
+    include AbstractController::Rendering    # at top to normalize render options asap
+    include AbstractController::Translation
+    include AbstractController::AssetPaths
+
+    include ActionController::Helpers
+    include Jets::Router::Helpers::NamedRoutes
+
+    include ActionController::UrlFor      # includes ActionDispatch::Routing::UrlFor
+    include ActionController::Redirecting
+    include ActionView::Layouts           # includes ActionView::Rendering
+    include ActionController::Rendering
+    include ActionController::Renderers::All # for use_renderers :json, :js, :xml
+    include ActionController::ConditionalGet
+    include ActionController::EtagWithTemplateDigest
+    include ActionController::EtagWithFlash
+    include ActionController::Caching
+    include ActionController::MimeResponds
+    include ActionController::ImplicitRender # includes BasicImplicitRender action_controller/metal/basic_implicit_render.rb
+    include ActionController::StrongParameters
+    include ActionController::ParameterEncoding
+    include ActionController::Cookies
+    include ActionController::Flash
+    include ActionController::FormBuilder
+    include ActionController::RequestForgeryProtection
+    include ActionController::ContentSecurityPolicy
+    include ActionController::PermissionsPolicy
+    # include ActionController::Streaming       # not supported
+    # include ActionController::DataStreaming   # not supported
+    include ActionController::HttpAuthentication::Basic::ControllerMethods
+    include ActionController::HttpAuthentication::Digest::ControllerMethods
+    include ActionController::HttpAuthentication::Token::ControllerMethods
+    # include ActionController::DefaultHeaders  # not needed
+    include ActionController::Logging           # log_at: ability to change log level
+
+    # More Jets overrides and customizations
+    include Handler               # Lambda Handler process! method. Runs on AWS only.
+    include RackAdapter::Action   # action rack method
+
+    # Before callbacks should also be executed as early as possible, so
+    # also include them at the bottom.
+    include AbstractController::Callbacks
+
+    # Must near bottom because decorating Rails behavior
+    include Decorate::Authorization         # APIGW Authorizers
+    include Decorate::UrlFor                # add_apigw_stage
+    include Decorate::Redirecting           # add_apigw_stage
+    include Decorate::Logging
+
+    # Append rescue at the bottom to wrap as much as possible.
+    include ActionController::Rescue
+
+    # Add instrumentations hooks at the bottom, to ensure they instrument
+    # all the methods properly.
+    include ActionController::Instrumentation # TODO: figure why notifications dont work
+
+    # Params wrapper should come before instrumentation so they are
+    # properly showed in logs
+    include ActionController::ParamsWrapper
+
+    def initialize(event, context, meth, rack_env)
+      # Passing in rack env so the same rack env (same object id) is used.
+      # This is important for:
+      #  1. Constraints lambda procs
+      #  2. Controller.action rack methods
+      @event = event
+      @context = context
+      @meth = meth
+      @rack_env = rack_env
+      @_request = Jets::Controller::Request.new(event: event, rack_env: @rack_env)
+      # Note: Rails sets request.route in the Rails::Engine#build_request instead.
+      # The Jets request class is built slightly differently, so set it here.
+      # The request.routes method is need to that url_helpers work in generally.
+      # It's just how Rails ActionView implements url_helpers.
+      @_request.routes = self.class._routes
+      @_response = Jets::Controller::Response.new
+      @_response.request = @request
+      # Jets::Controller::Base#initialize interface is different than ActionController::Controller::Base.
+      # The super call goes to ActionController modules that can decorate and call super again.
+      # At the end of the module chain is Jets::Controller::Compat::ActionController::Metal#initialize
+      # which goes back to the original Jets::Lambda::Functions#initialize(event, context, meth) interface.
+      super() # ActionController::Base#initialize() interface
     end
 
-    # Handles binary data safely
-    def json_dump(data)
-      JSON.dump(data)
-    rescue Encoding::UndefinedConversionError
-      data['body'] = '[BINARY]'
-      JSON.dump(data)
-    end
+    abstract!
 
-    def controller_paths
-      paths = []
-      klass = self.class
-      while klass != Jets::Controller::Base
-        paths << klass.controller_path
-        klass = klass.superclass
-      end
-      paths
-    end
-
-    def controller_name
-      self.class.to_s.underscore
-    end
+    use_renderers :json, :js, :xml
+  end
 
-    def action_name
-      @meth
-    end
+  # See Jets::Controller::Compat::ActionController::Metal dispatch! method
 
-    class_attribute :internal_controller
-    class << self
-      def internal(value=nil)
-        if !value.nil?
-          self.internal_controller = value
-        else
-          self.internal_controller
-        end
-      end
-
-      def helper_method(*meths)
-        meths.each do |meth|
-          Jets::Router::Helpers.define_helper_method(meth)
-        end
-      end
-    end
-  end
+  ActiveSupport.run_load_hooks(:jets_controller, Base)
 end

data/lib/jets/controller/compat/abstract_controller/base.rb

@@ -0,0 +1,126 @@
+require "abstract_controller/error"
+require "active_support/configurable"
+require "active_support/descendants_tracker"
+require "active_support/core_ext/module/anonymous"
+require "active_support/core_ext/module/attr_internal"
+
+module Jets::Controller::Compat::AbstractController
+  module Base
+    extend ActiveSupport::Concern
+    include ActiveSupport::Configurable
+
+    delegate :action_methods,
+             :controller_name,
+             :controller_path,
+             to: :class
+    class_methods do
+      # A list of method names that should be considered actions. This
+      # includes all public instance methods on a controller, less
+      # any internal methods (see internal_methods), adding back in
+      # any methods that are internal, but still exist on the class
+      # itself.
+      #
+      # ==== Returns
+      # * <tt>Set</tt> - A set of all methods that should be considered actions.
+      def action_methods
+        @action_methods ||= begin
+          # All public instance methods of this class, including ancestors
+          methods = (public_instance_methods(true) -
+            # Except for public instance methods of Base and its ancestors
+            internal_methods +
+            # Be sure to include shadowed public instance methods of this class
+            public_instance_methods(false))
+
+          methods.map!(&:to_s)
+
+          methods.to_set
+        end
+      end
+
+        # A list of all internal methods for a controller. This finds the first
+      # abstract superclass of a controller, and gets a list of all public
+      # instance methods on that abstract class. Public instance methods of
+      # a controller would normally be considered action methods, so methods
+      # declared on abstract classes are being removed.
+      # (ActionController::Metal and ActionController::Base are defined as abstract)
+      def internal_methods
+        controller = self
+
+        controller = controller.superclass until controller.abstract?
+        controller.public_instance_methods(true)
+      end
+
+      def controller_name
+        @controller_name ||= name.demodulize.delete_suffix("Controller").underscore
+      end
+
+      def controller_path
+        @controller_path ||= name.delete_suffix("Controller").underscore
+      end
+
+      # Returns true if the given controller is capable of rendering
+      # a path. A subclass of +AbstractController::Base+
+      # may return false. An Email controller for example does not
+      # support paths, only full URLs.
+      def supports_path?
+        true
+      end
+    end
+
+    ##
+    # Returns the body of the HTTP response sent by the controller.
+    attr_internal :response_body
+
+    ##
+    # Returns the name of the action this controller is processing.
+    def action_name
+      @meth
+    end
+
+    def available_action?(action_name)
+      self.class.action_methods.include?(action_name.to_s)
+    end
+
+    # Tests if a response body is set. Used to determine if the
+    # +process_action+ callback needs to be terminated in
+    # AbstractController::Callbacks.
+    def performed?
+      if response_body.respond_to?(:each)
+        !response_body.compact.empty? # [""] is considered true
+      else # nil
+        !response_body.nil?
+      end
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
+
+  private
+    # Returns true if the name can be considered an action because
+    # it has a method defined in the controller.
+    #
+    # ==== Parameters
+    # * <tt>name</tt> - The name of an action to be tested
+    def action_method?(name)
+      self.class.action_methods.include?(name)
+    end
+
+    # Call the action. Override this in a subclass to modify the
+    # behavior around processing an action. This, and not #process,
+    # is the intended way to override action dispatching.
+    #
+    # Notice that the first argument is the method to be dispatched
+    # which is *not* necessarily the same as the action name.
+    def process_action
+      send_action(action_name) # to BasicImplicitRender#send_action => super (posts#index) or default_render
+    end
+
+    # Actually call the method associated with the action. Override
+    # this method if you wish to change how action methods are called,
+    # not to add additional behavior around it. For example, you would
+    # override #send_action if you want to inject arguments into the
+    # method.
+    alias send_action send
+  end
+end

data/lib/jets/controller/compat/action_controller/metal.rb

@@ -0,0 +1,99 @@
+module Jets::Controller::Compat::ActionController
+  module Metal
+    extend ActiveSupport::Concern
+
+    delegate :commit_flash,
+             :filtered_parameters,
+             :parameter_filter,
+             :params,
+             :reset_session,
+             :session,
+             :session=,
+             :_routes,
+             to: :request
+    delegate :content_type,
+             :content_type=,
+             :get_header,
+             :headers,
+             :location,
+             :location=,
+             :media_type,
+             :response_code,
+             :set_header,
+             :status,
+             :status=,
+             :to_a,
+             to: :response
+    attr_internal :request, :response
+
+    alias :response_code :status # :nodoc:
+
+    # End of the module include chain.
+    # Go back from the ActionController::Base#initialize() interface
+    # to the original Jets::Lambda::Functions#initialize(event, context, meth) interface
+    def initialize
+      super(@event, @context, @meth)
+    end
+
+    # One key difference between process! vs dispatch!
+    #
+    #    process! - takes the request through the middleware stack
+    #    dispatch! - does not
+    #
+    # dispatch! is useful for megamode or mounted applications
+    #
+    def dispatch!
+      # extend Jets.application.routes.url_helpers
+      # extend Blorgh::Engine.routes.url_helpers
+
+      # ActionView::Base.send :include, Jets.application.routes.url_helpers
+      # ActionView::Base.send :include, Blorgh::Engine.routes.url_helpers
+      # extend Jets.application.routes.mounted_helpers
+
+      method_override!
+      process_action
+      commit_flash
+      response.to_a
+    end
+
+    # Override @meth when POST with _method=delete
+    # By the time processing reaches dispatch which calls method_override!
+    # The Rack::MethodOverride middleware has overriden env['REQUEST_METHOD'] with DELETE
+    # and set env['rack.methodoverride.original_method']
+    def method_override!
+      env = request.env
+      if env['rack.methodoverride.original_method'] && env['REQUEST_METHOD'] == 'DELETE'
+        @original_meth = @meth
+        @meth = "destroy"
+      end
+    end
+
+    # Not using rack.response.body directly because its value is wrapped in an Array, IE: [body]
+    # and ActionController components check response_body assuming it can be nil or a String.
+    # So we assign the String at the controller.response_body level and [body] at the
+    # the Response#body= level.
+    def response_body=(body)
+      body = [body] unless body.nil? || body.respond_to?(:each)
+      return unless body
+      response.body = body
+      super
+    end
+
+    # Unsure how Rails defines this but this is the Rails behavior according to the Kingsman/Devise port
+    def response=(triplet)
+      if triplet.is_a?(Array)
+        status, headers, body = triplet
+        self.status = status
+        self.headers.merge!(headers)
+        self.response_body = body
+      else
+        self.response_body = triplet # string
+      end
+    end
+
+    # Tests if render or redirect has already happened.
+    def performed?
+      response_body || response.committed?
+    end
+  end
+end

data/lib/jets/controller/compat/caching.rb

@@ -0,0 +1,13 @@
+module Jets::Controller::Compat
+  # Got most from AbstractController::Caching and ActionController::Caching
+  module Caching
+    extend ActiveSupport::Concern
+
+    delegate :perform_caching, to: :class
+    class_methods do
+      def perform_caching
+        Jets.config.controller.perform_caching
+      end
+    end
+  end
+end

data/lib/jets/controller/compat/future.rb

@@ -0,0 +1,13 @@
+module Jets::Controller::Compat
+  module Future
+    # raise_on_missing_callback_actions will be called in Rails 7.1
+    def raise_on_missing_callback_actions
+      puts <<~EOL
+        raise_on_missing_callback_actions called, Jets defaults to true so
+        when we upgrade to Rails 7.1 components it'll trigger and will
+        fix any issues. Also will need to make it configurable.
+      EOL
+      true
+    end
+  end
+end

data/lib/jets/controller/compat/route_set.rb

@@ -0,0 +1,47 @@
+module Jets::Controller::Compat
+  module RouteSet
+    # Override behavior from ActionDispatch::Routing::UrlFor
+    #
+    # When Jets include ActionDispatch::Routing::UrlFor is in the Jets::Controller::Base class
+    # It sets @_routes = nil
+    #
+    # We need to set @_routes to the Jets::Controller::Request routes object
+    # to provide a Jets custom routes object that's compatiable the Rails routes object.
+    #
+    # Why does @_routes have to be set?
+    #
+    # How this works is a bit hard to follow. Here's the current trace with actionpack 7.0.8
+    #
+    # Here's where controller render goes from controller-land to view-land.
+    #
+    #     action_controller/metal/rendering.rb:158:in `render_to_body'
+    #     action_view/rendering.rb:114:in `render_to_body'
+    #
+    # In action_view/rendering.rb render_to_body => _render_template is called and
+    # a view_context is created.
+    #
+    #     def view_context
+    #       view_context_class.new(lookup_context, view_assigns, self)
+    #     end
+    #
+    # self is the <PostsController>. The controller instance is the _routes is used.
+    # The view_context_class is somehow a wrapped anonymous class that has the
+    # ActionView::Base#initialize method.
+    #
+    # Usage:
+    #
+    #     module Jets::Controller
+    #       class Base < Jets::Lambda::Functions
+    #         ...
+    #         include Compat::RouteSet::ControllerPrepend
+    #         ...
+    #         include ActionController::UrlFor # includes ActionDispatch::Routing::UrlFor
+    #         ...
+    #         include Compat::RouteSet::ControllerAppend
+    #
+    def initialize(*)
+      @_routes = self.class._routes # set by inherited hook in JetsTurbines::RoutesHelpers.with
+      super
+    end
+  end
+end

data/lib/jets/controller/decorate/apigw_stage.rb

@@ -0,0 +1,39 @@
+module Jets::Controller::Decorate
+  module ApigwStage
+    def add_apigw_stage(url)
+      return url unless add_apigw_stage?
+      stage_name = ENV['JETS_APIGW_STAGE'] || Jets::Cfn::Resource::ApiGateway::Deployment.stage_name
+      uri = URI.parse(url)
+      path = uri.path
+      original_ends_with_slash = path.ends_with?('/')
+      path = "/#{path}" unless path.starts_with?('/')
+      segments = path.split('/')
+      # unless to prevent stage name being added twice if url_for is called twice on the same string
+      segments.insert(1, stage_name) unless segments[1] == stage_name
+      new_path = segments.join('/') # modified path
+      new_path = "#{new_path}/" if !new_path.ends_with?('/') && original_ends_with_slash
+      uri.path = new_path
+      uri.to_s
+    end
+
+    def add_apigw_stage?
+      return true if ENV['JETS_APIGW_STAGE']
+      return false if ENV['JETS_TEST']
+      return false unless request # nil for `importmap json` cli and actionmailer
+
+      # Using request.host which might be different than event['headers']['Host'] when config.app.domain is set.
+      # This means that visiting the APIGW domain name directly will not prepend the stage name
+      # to the helper method urls.  This is ok since the APIGW domain name is not used in production.
+      # It's a compromise since we cannot pass the CloudFront host to APIGW.
+      # Rather have the CloudFront user-friendly domain name work than APIGW domain name.
+      # Examples:
+      #   https://djvojd3em5.execute-api.us-west-2.amazonaws.com/dev/
+      #   https://friendly.domain.com/
+      host = request.host
+      on_cloud9 = !!(host =~ /cloud9\..*\.amazonaws\.com/)
+      return false if on_cloud9
+
+      host.include?('amazonaws.com')
+    end
+  end
+end

data/lib/jets/controller/{authorization.rb → decorate/authorization.rb}

@@ -1,4 +1,4 @@
-class Jets::Controller
+module Jets::Controller::Decorate
   module Authorization
     extend ActiveSupport::Concern