jets 3.1.0 → 5.0.0

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
 

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

@@ -0,0 +1,90 @@
+module Jets::Controller::Decorate
+  module Logging
+    extend ActiveSupport::Concern
+
+    included do
+      # A little bit tricky. Jets::Controller::Base includes AbstractController::Logger
+      # via ActionController::Redirecting.
+      # AbstractController::Logger defines a config_accessor :logger
+      # This results in logger being nil.  We set it to logger here to correct it.
+      # Unsure why this does not happen with ActionController::Base though.
+      delegate :logger, to: Jets # fixes logger but Rails doesnt need this
+    end
+
+    def dispatch!
+      t1 = Time.now
+      log_start
+      triplet = super # Abstract#dispatch!
+      took = Time.now - t1
+      log_finish status: status, took: took
+      triplet
+    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
+      # Commented out Started because Jets::Rack::Logger middleware handles now
+      # ip = request.ip
+      # logger.info "Started (Jets) #{request.request_method} \"#{request.path}\" for #{ip} at #{Time.now}"
+
+      logger.info processing_log
+      logger.info "  Raw Event: #{@event}" if ENV['JETS_LOG_RAW_EVENT']
+      logger.info "  Event: #{event_log}" if log_event?
+      params = filtered_parameters.to_h.except('controller', 'action')
+      # JSON.dump makes logging look pretty in CloudWatch logs because it keeps it on 1 line
+      logger.info "  Parameters: #{JSON.dump(params)}" unless params.empty?
+    end
+
+    def log_event?
+      return false if ENV['JETS_LOG_EVENT'] == '0'
+      Jets.config.logging.event
+    end
+
+    # Documented interface method, careful not to rename
+    def log_finish(options={})
+      status, took = options[:status], options[:took]
+      logger.info "Completed Status Code #{status} in #{"%.3f" % took}s"
+    end
+
+    def event_log
+      event = @event.dup # clone to display event
+
+      if event['isBase64Encoded']
+        event['body'] = '[BASE64_ENCODED]'
+      else
+        event['body'] = filter_json_log(event['body'])
+      end
+
+      event["multiValueQueryStringParameters"] = parameter_filter.filter(event['multiValueQueryStringParameters']) if event['multiValueQueryStringParameters']
+      event["pathParameters"] = parameter_filter.filter(event['pathParameters']) if event['pathParameters']
+      event["queryStringParameters"] = parameter_filter.filter(event['queryStringParameters']) if event['queryStringParameters']
+      json_dump_log(event)
+    end
+
+    # Append _log to reduce chance of name collision with user defined methods
+    def filter_json_log(json_text)
+      return json_text if json_text.blank?
+
+      begin
+        hash_params = JSON.parse(json_text)
+        filtered_params = parameter_filter.filter(hash_params)
+        JSON.dump(filtered_params)
+      rescue JSON::ParserError
+        '[FILTERED]'
+      end
+    end
+
+    # Handles binary data safely
+    def json_dump_log(data)
+      JSON.dump(data)
+    rescue Encoding::UndefinedConversionError
+      data['body'] = '[BINARY]'
+      JSON.dump(data)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Jets::Controller::Decorate
+  module Redirecting
+    include ApigwStage
+
+    def _compute_redirect_to_location(request, options) # :nodoc:
+      adjust = options.respond_to?(:to_str) || options.is_a?(String)
+      options = add_apigw_stage(options) if adjust
+      super
+    end
+
+    def redirect_back(fallback_location: '/')
+      location = request.headers["Referer"] || fallback_location
+      redirect_to location
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Jets::Controller::Decorate
+  module UrlFor
+    include ApigwStage
+
+    def url_for(options = nil)
+      url = super
+      add_apigw_stage(url)
+    end
+  end
+end

data/lib/jets/controller/{rack/adapter.rb → handler/apigw.rb}

@@ -1,31 +1,49 @@
 require 'base64'
 
-module Jets::Controller::Rack
-  class Adapter
+# Also, logic in the opposite direction: Jets::Controller::Middleware::Mimic::Apigw
+# Only called by AWS Lambda before it runs through the middlewares.
+module Jets::Controller::Handler
+  class Apigw
     extend Memoist
 
-    # Returns back API Gateway response hash structure
-    def self.process(event, context)
-      adapter = new(event, context)
-      adapter.process
-    end
-
-    def initialize(event, context)
-      @event, @context = event, context
+    attr_reader :event, :context, :controller, :meth, :rack_env
+    def initialize(event, context, controller, meth, rack_env)
+      @event = event
+      @context = context
+      @controller = controller
+      @meth = meth
+      @rack_env = rack_env
     end
 
     # 1. Convert API Gateway event event to Rack env
     # 2. Process using full Rack middleware stack
     # 3. Convert back to API gateway response structure payload
-    def process
-      status, headers, body = Jets.application.call(env)
-      convert_to_api_gateway(status, headers, body)
-    end
-
-    def env
-      Env.new(@event, @context, adapter: true).convert # convert to Rack env
+    #
+    # Returns back API Gateway response hash structure
+    # Only called when running in AWS Lambda.
+    #
+    # Set the jets.* env variables so we have access to them in the middleware.
+    # The controller instance is called in the Main middleware.
+    # On AWS, will use original event and context.
+    # On local server, will use Middleware::Mimic event and context.
+    def process_through_middlewares
+      env = rack_env.merge(
+        'jets.controller' => @controller, # original controller instance from handler
+        'jets.context'    => @context,    # original AWS Lambda context
+        'jets.event'      => @event,      # original AWS Lambda event
+        'jets.meth'       => @meth,
+      )
+      status, headers, body = Jets.application.call(env) # goes through full middleware stack
+      # middleware can handle Array or BodyProxy, APIGW require Strings
+      case body
+      when Rack::Files::Iterator
+        str = File.read(body.path)
+      else
+        # join for Rack::BodyProxy or Array
+        str = body.join
+      end
+      convert_to_api_gateway(status, headers, str)
     end
-    memoize :env
 
     # Transform the structure to AWS_PROXY compatible structure
     # http://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
@@ -71,24 +89,5 @@ module Jets::Controller::Rack
       # Can set JETS_ELB=1 for local testing
       @event["requestContext"] && @event["requestContext"]["elb"] || ENV['JETS_ELB']
     end
-
-    # Called from Jets::Controller::Base.process. Example:
-    #
-    #   adapter.rack_vars(
-    #     'jets.controller' => self,
-    #     'lambda.context' => context,
-    #     'lambda.event' => event,
-    #     'lambda.meth' => meth,
-    #   )
-    #
-    # Passes a these special variables so we have access to them in the middleware.
-    # The controller instance is called in the Main middleware.
-    # The lambda.* info is used by the Rack::Local middleware to create a mimiced
-    # controller for the local server.
-    #
-    def rack_vars(vars)
-      env.merge!(vars)
-    end
-
   end
 end

data/lib/jets/controller/handler.rb

@@ -0,0 +1,41 @@
+module Jets::Controller
+  # Only called by AWS Lambda before it runs through the middlewares.
+  module Handler
+    extend ActiveSupport::Concern
+
+    # One key difference between process! vs dispatch!
+    #
+    #    process! - takes the request through the middleware stack
+    #    dispatch! - does not
+    #
+    # Generally, we want to use process! so it goes through the middleware stacks.
+    #
+    # The last middleware stack is Jets::Controller::Middleware::Main
+    # Which comes back to dispatch! in this same Controller Base class.
+    #
+    #     class Jets::Controller::Middleware::Main
+    #       def call!
+    #         setup
+    #         @controller.dispatch! # Returns triplet
+    #       end
+    #     end
+    #
+    def process!
+      apigw = Jets::Controller::Handler::Apigw.new(event, context, self, @meth, @rack_env)
+      apigw.process_through_middlewares # Returns API Gateway hash structure
+    end
+
+    class_methods do
+      def process(event, context={}, meth)
+        rack_env = Jets::Controller::RackAdapter::Env.new(event, context).convert # convert to Rack env
+        controller = new(event, context, meth, rack_env)
+        # Using send because process! was a private method in Jets::RackController (old) 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.
+        controller.send(:process!)
+      end
+    end
+  end
+end
+

data/lib/jets/controller/middleware/main.rb

@@ -1,6 +1,6 @@
 # All roads lead here
 #
-# 1. AWS Lambda: PostsController - Rack::Adapter - Jets.application.call
+# 1. AWS Lambda: PostsController - Handler::Apigw - Jets.application.call
 # 2. Local server:  config.ru - run Jet.application - Jets.application.call
 #
 # Then eventually:
@@ -9,22 +9,30 @@
 #
 module Jets::Controller::Middleware
   class Main
+    include Jets::ExceptionReporting
+
     def initialize(env)
       @env = env
-      @controller = env['jets.controller']
-      @event = env['lambda.event']
-      @context = env['lambda.context']
-      @meth = env['lambda.meth']
+      @controller = env['jets.controller'] # original controller instance from handler or mimic
+      @context = env['jets.context']  # original AWS Lambda event or mimic context
+      @event = env['jets.event']      # original AWS Lambda event or mimic event
+      @meth = env['jets.meth']
     end
 
     def call
-      ENV['JETS_HOST'] = jets_host # Dirty to use what's essentially a global variable but unsure how else to achieve
       dup.call!
     end
 
+    # With exception reporting here instead of Controller::Base#process so any
+    # exception in the middleware stack is caught.
+    # Also using with_exception_reporting instead of
+    # prepend Jets::ExceptionReporting::Process because the method is call!
+    # not process. The interface is different.
     def call!
-      setup
-      @controller.dispatch! # Returns triplet
+      with_exception_reporting do
+        setup
+        @controller.dispatch! # Returns triplet
+      end
     end
 
     # Common setup logical at this point of middleware processing right before

data/lib/jets/controller/middleware/{local/api_gateway.rb → mimic/apigw.rb}

@@ -1,21 +1,43 @@
 # Takes a Rack env and converts to ApiGateway event
-class Jets::Controller::Middleware::Local
-  class ApiGateway
+# This runs only locally, when not on AWS Lambda
+# Note: Logic in the opposite direction: Jets::Controller::Handler::Apigw#rack_vars
+class Jets::Controller::Middleware::Mimic
+  class Apigw
     extend Memoist
 
     def initialize(route, env)
       @route, @env = route, env
     end
 
+    # Actual controller instance
+    def controller
+      controller_class = @route.controller_name.constantize
+      meth = @route.action_name
+      # must keep the same env as @env, rack env, else constraint lambda proc request will be different
+      controller_class.new(event, context, meth, @env)
+    end
+    memoize :controller # for same object_id in case apigw.controller is called twice
+
+    def meth
+      @route.action_name
+    end
+    memoize :meth
+
+    def context
+      LambdaContext.new
+    end
+    memoize :context
+
     def event
-      resource = @route.path(:api_gateway) # posts/{id}/edit
+      resource = @route.path(:api_gateway) # /posts/{id}/edit
       path = @env['PATH_INFO'].sub('/','') # remove beginning slash
       {
-        "resource" => "/#{resource}", # "/posts/{id}/edit"
+        "resource" => resource, # "/posts/{id}/edit"
         "path" => @env['PATH_INFO'],  # /posts/tung/edit
         "httpMethod" => @env['REQUEST_METHOD'], # GET
         "headers" => request_headers,
         "queryStringParameters" => query_string_parameters,
+        "multiValueQueryStringParameters" => multi_value_query_string_parameters,
         "pathParameters" => @route.extract_parameters(path),
         "stageVariables" => nil,
         "requestContext" => {},
@@ -24,7 +46,9 @@ class Jets::Controller::Middleware::Local
       }
     end
     memoize :event
+    alias convert event
 
+    protected
     # Annoying. The headers part of the AWS Lambda proxy structure
     # does not consisently use the same casing scheme for the header keys.
     # Sometimes it looks like this:
@@ -78,7 +102,20 @@ class Jets::Controller::Middleware::Local
 
     def query_string_parameters
       Rack::Utils.parse_nested_query(@env['QUERY_STRING'])
+      # @env['QUERY_STRING']&.split('&')&.each_with_object({}) do |parameter, hash|
+      #   key, value = parameter.split('=')
+      #   hash[key] = value
+      # end || {}
     end
+    alias multi_value_query_string_parameters query_string_parameters
+
+    # def multi_value_query_string_parameters
+    #   @env['QUERY_STRING']&.split('&')&.each_with_object({}) do |parameter, hash|
+    #     key, value = parameter.split('=')
+    #     hash[key] = [] if hash[key].nil?
+    #     hash[key] << value
+    #   end || {}
+    # end
 
     # To get the post body:
     #   rack.input: #<StringIO:0x007f8ccf8db9a0>

data/lib/jets/controller/middleware/mimic/lambda_context.rb

@@ -0,0 +1,44 @@
+class Jets::Controller::Middleware::Mimic
+  # This class uses method_missing to mimic for all possible future methods
+  # that AWS Lambda might add to the context object.
+  #
+  # The current methods available on the Lambda Context object:
+  #   aws_request_id, invoked_function_arn, log_group_name,
+  #   log_stream_name, function_name, memory_limit_in_mb, function_version,
+  #   identity, client_context, deadline_ms
+  #
+  # Locally, example mimic values:
+  #
+  #   context.aws_request_id "mimic lambda context: aws_request_id"
+  #   context.invoked_function_arn "mimic lambda context: invoked_function_arn"
+  #   context.log_group_name "mimic lambda context: log_group_name"
+  #   context.log_stream_name "mimic lambda context: log_stream_name"
+  #   context.function_name "mimic lambda context: function_name"
+  #   context.memory_limit_in_mb "mimic lambda context: memory_limit_in_mb"
+  #   context.function_version "mimic lambda context: function_version"
+  #   context.identity "mimic lambda context: identity"
+  #   context.client_context "mimic lambda context: client_context"
+  #   context.deadline_ms "mimic lambda context: deadline_ms"
+  #
+  # On AWS, example real values:
+  #
+  #   context.aws_request_id "b8357b1d-15f2-4197-9c6b-d6873be5eaba"
+  #   context.invoked_function_arn "arn:aws:lambda:us-west-2:112233445566:function:demo-dev-controller"
+  #   context.log_group_name "/aws/lambda/demo-dev-controller"
+  #   context.log_stream_name "2023/09/10/[$LATEST]18323c481c674665b25496c329daa382"
+  #   context.function_name "demo-dev-controller"
+  #   context.memory_limit_in_mb "1536"
+  #   context.function_version "$LATEST"
+  #   context.identity nil
+  #   context.client_context nil
+  #   context.deadline_ms 1694353587386
+  #
+  class LambdaContext
+    def initialize(*)
+    end
+
+    def method_missing(method_name, *args)
+      "mimic lambda context: #{method_name}"
+    end
+  end
+end