jets 4.0.17 → 5.0.0.beta1

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,17 +1,38 @@
 # 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,
@@ -25,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,19 +101,21 @@ class Jets::Controller::Middleware::Local
     end
 
     def query_string_parameters
-      @env['QUERY_STRING']&.split('&')&.each_with_object({}) do |parameter, hash|
-        key, value = parameter.split('=')
-        hash[key] = value
-      end || {}
+      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
+    # 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

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

@@ -1,8 +1,9 @@
 require 'kramdown'
 
 # Handles mimicing of API Gateway to Lambda function call locally
+# Logic in the opposite direction: Jets::Controller::Handler::Apigw#rack_vars
 module Jets::Controller::Middleware
-  class Local
+  class Mimic
     extend Memoist
 
     def initialize(app)
@@ -10,21 +11,30 @@ module Jets::Controller::Middleware
     end
 
     def call(env)
-      route = RouteMatcher.new(env).find_route
-      unless route
-        return [404, {'Content-Type' => 'text/html'}, not_found(env)]
-      end
+      matcher = Jets::Router::Matcher.new
+      route = matcher.find_by_env(env) # simpler version does not check constraints
+      return not_found(env) unless route
+
+      # Make instance available so we dont not have to pass it around.
+      # Also important to assign to instance variables so values are memoized in variables
+      # So the mimic logic work because @env.merge! does not happened
+      # until end. We do not want apigw.controller to create a new controller instance
+      # with a different object_id
+      apigw = Apigw.new(route, env) # takes rack env and converts to API Gateway event structure
+      @controller = apigw.controller
+      @meth = apigw.meth
+      @event = apigw.event
+      @context = apigw.context
 
-      mimic = MimicAwsCall.new(route, env)
-      # Make @controller and @meth instance available so we dont not have to pass it around.
-      @controller, @meth, @event = mimic.controller, mimic.meth, mimic.event
+      route = matcher.find_by_request(@controller.request) # need request object to check constraints
+      return not_found(env) unless route
 
       if route.to == 'jets/rack#process' # megamode
         # Bypass the Jets middlewares since it could interfere with the Rack
         # application's middleware stack.
         #
-        # Rails sends back a transfer-encoding=chunked. Curling Rails directly works,
-        # but passing the Rails response back through this middleware results in errors.
+        # Jets sends back a transfer-encoding=chunked. Curling Jets directly works,
+        # but passing the Jets response back through this middleware results in errors.
         # Disable chunking responses by deleting the transfer-encoding response header.
         # Would like to understand why this happens this better, if someone can explain please let me know.
         status, headers, body = @controller.dispatch! # jets/rack_controller
@@ -36,21 +46,30 @@ module Jets::Controller::Middleware
       elsif polymorphic_function?
         run_polymophic_function
       else # Normal Jets request
-        mimic_aws_lambda!(env, mimic.vars) unless on_aws?(env)
-        @app.call(env)
+        unless on_aws?(env)
+          # Only set these variables when running locally and not on AWS.
+          # On AWS, these are set by the Jets::Controller::Handler::Apigw#rack_vars
+          env.merge!(
+            'jets.controller' => @controller, # mimic controller instance
+            'jets.context'    => @context,    # mimic context
+            'jets.event'      => @event,      # mimic event
+            'jets.meth'       => @meth,
+          )
+        end
+        @app.call(env) # goes to all middleware all the way to Jets::Controller::Middleware::Main
       end
     end
 
     # Never hit when calling polymorphic function on AWS Lambda. Can only get called with the local server.
     def polymorphic_function?
       return false if ENV['_HANDLER'] # slight speed improvement on Lambda
-      polymorphic_function.task.lang != :ruby
+      polymorphic_function.definition.lang != :ruby
     end
 
     def polymorphic_function
-      # Abusing PolyFun to run polymorphic code, should call LambdaExecutor directly
+      # Abusing Poly to run polymorphic code, should call LambdaExecutor directly
       # after reworking LambdaExecutor so it has a better interface.
-      Jets::PolyFun.new(@controller.class, @meth)
+      Jets::Poly.new(@controller.class, @meth)
     end
     memoize :polymorphic_function
 
@@ -62,13 +81,8 @@ module Jets::Controller::Middleware
       [status, headers, body] # triplet
     end
 
-    # Modifies env the in the same way real call from AWS lambda would modify env
-    def mimic_aws_lambda!(env, vars)
-      env.merge!(vars)
-      env
-    end
-
     def on_aws?(env)
+      return true if ENV['ON_AWS']
       return false if Jets.env.test? # usually with test we're passing in full API Gateway fixtures with the HTTP_X_AMZN_TRACE_ID
       return false if ENV['JETS_ELB'] # If we're using an ELB and Jets is inside a container running jets server, we don't want to pretend we're on AWS.
       on_cloud9 = !!(env['HTTP_HOST'] =~ /cloud9\..*\.amazonaws\.com/)
@@ -85,36 +99,7 @@ module Jets::Controller::Middleware
     end
 
     def not_found(env)
-      message = routes_error_message(env)
-      body = <<~HTML
-        <!DOCTYPE html>
-        <html>
-            <head>
-                <meta charset="utf-8">
-                <title>Route not found</title>
-            </head>
-            <body>
-              #{message}
-            </body>
-        </html>
-      HTML
-      StringIO.new(body)
-    end
-
-    # Show pretty route table for user to help with debugging in non-production mode
-    def routes_table
-      routes = Jets::Router.routes
-
-      return "Your routes table is empty." if routes.empty?
-
-      text = "Verb | Path | Controller#action\n"
-      text << "--- | --- | ---\n"
-      routes.each do |route|
-        text << "#{route.method} | #{route.path} | #{route.to}\n"
-      end
-      html = Kramdown::Document.new(text).to_html
-      puts html
-      html
+      raise Jets::Controller::RoutingError, "No route matches #{env['PATH_INFO'].inspect}"
     end
   end
 end

data/lib/jets/controller/rack_adapter/action.rb

@@ -0,0 +1,35 @@
+module Jets::Controller::RackAdapter
+  module Action
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def action(name)
+        lambda do |env|
+          route = find_first_route_for_action(name)
+          env['PATH_INFO'] = route_path(route)
+          controller = new({}, {}, name, env)
+          controller.dispatch! # does not go through middleware stack
+        end
+      end
+
+      # Find first route to be used for PATH_INFO.
+      # This allows engine_delegate to work properly.
+      def find_first_route_for_action(name)
+        Jets::Router.routes.find do |r|
+          route_controller_path, route_action_name = r.to.split('#')
+          route_controller_path == controller_path && route_action_name == name.to_s
+        end
+      end
+
+      def route_path(route)
+        if route
+          path = route.path
+          path = "/#{path}" unless path.starts_with?('/')
+        else
+          path = "/#{controller_path}##{name} (action proc)"
+        end
+        path
+      end
+    end
+  end
+end