jets 4.0.8 → 5.0.0.beta1

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

data/lib/jets/controller/{rack → rack_adapter}/env.rb

@@ -1,9 +1,9 @@
 require 'rack'
 require 'base64'
 
-# Takes an ApiGateway event and converts it to an Rack env that can be used for
-# rack.call(env).
-module Jets::Controller::Rack
+# Only called by AWS Lambda
+# Takes an ApiGateway event and converts it to an Rack env that can be used for rack middleware
+module Jets::Controller::RackAdapter
   class Env
     def initialize(event, context, options={})
       @event, @context, @options = event, context, options
@@ -15,11 +15,15 @@ module Jets::Controller::Rack
       options = add_http_headers(options)
       path = path_with_base_path || @event['path'] || '/' # always set by API Gateway but might not be when testing shim, so setting it to make testing easier
 
+      # In case of non-ascii characters, CGI.escape will escape them
+      # IE: get '/ほげ'
+      # This just because MockRequest.env_for uses URI.parse which does not
+      # escape non-ascii characters and throws an error
+      unescaped_path = path
+      path = path.chars.map { |char| char.ascii_only? ? char : CGI.escape(char) }.join
       env = Rack::MockRequest.env_for(path, options)
-      if @options[:adapter]
-        env['adapter.event'] = @event
-        env['adapter.context'] = @context
-      end
+      env['PATH_INFO'] = unescaped_path
+      # env['QUERY_STRING'] = query_string
       env
     end
 
@@ -45,15 +49,15 @@ module Jets::Controller::Rack
         'CONTENT_TYPE' => content_type,
         'QUERY_STRING' => query_string,
         'REMOTE_ADDR' => headers['X-Forwarded-For'],
-        'REMOTE_HOST' => headers['Host'],
+        'REMOTE_HOST' => headers_host,
         'REQUEST_METHOD' => @event['httpMethod'] || 'GET', # useful to default to GET when testing with Lambda console
         'REQUEST_PATH' => @event['path'],
         'REQUEST_URI' => request_uri,
         'SCRIPT_NAME' => "",
-        'SERVER_NAME' => headers['Host'],
+        'SERVER_NAME' => headers_host,
         'SERVER_PORT' => headers['X-Forwarded-Port'],
         'SERVER_PROTOCOL' => "HTTP/1.1",  # unsure if this should be set
-        'SERVER_SOFTWARE' => "WEBrick/1.3.1 (Ruby/2.2.2/2015-04-13)",
+        'SERVER_SOFTWARE' => headers['User-Agent'],
       }
 
       map['CONTENT_LENGTH'] = content_length if content_length
@@ -63,10 +67,18 @@ module Jets::Controller::Rack
       options.merge(map)
     end
 
+    # Generally should use content_type method instead of headers['Content-Type'] because
+    # headers['Content-Type'] is not normally available for Rails.
+    #
+    # Jets makes it available and normalizes the casing by grabbing it from APIGW event['headers']
+    # APIGW is inconsistent about the casing.
+    # In POST request it's content-type and in GET request it's Content-Type
+    #
+    #   Rack (local) uses Content-Type and APIGW (remote) uses content-type
+    #   Rack::MethodOverride relys on content-type to detect content type properly.
+    #
     def content_type
-      # Rack (local) uses Content-Type and APIGW (remote) uses content-type
-      # Rack::MethodOverride relys on content-type to detect content type properly.
-      headers['Content-Type'] || headers['content-type'] || Jets::Controller::DEFAULT_CONTENT_TYPE
+      headers['Content-Type'] || headers['content-type']
     end
 
     def content_length
@@ -89,15 +101,23 @@ module Jets::Controller::Rack
         # content-type => HTTP_CONTENT_TYPE
         key = k.gsub('-','_').upcase
         key = "HTTP_#{key}"
-        options[key] = v
+        if k == "Host"
+          options[key] = headers_host
+        else
+          options[key] = v
+        end
       end
       options
     end
 
+    def headers_host
+      Jets.config.app.domain || headers['Host']
+    end
+
     def request_uri
       # IE: "http://localhost:8888/posts/tung/edit?foo=bar"
       proto = headers['X-Forwarded-Proto']
-      host = headers['Host']
+      host = headers_host
       port = headers['X-Forwarded-Port']
 
       # Add port if needed
@@ -112,17 +132,12 @@ module Jets::Controller::Rack
     end
 
     def query_string
-      qs_params = @event["multiValueQueryStringParameters"] || {} # always set with API Gateway but when testing node shim might not be
-
-      array = qs_params.each_with_object([]) do |(key, value), arr|
-        arr << value.map do |v|
-          v.to_query(key)
-        end
-      end
-
-      array.join("&")
+      query = @event["queryStringParameters"] || @event["multiValueQueryStringParameters"] || {} # always set with API Gateway but when testing node shim might not be
+      Rack::Utils.build_nested_query(query)
+      # query.map { |k,v| "#{k}=#{v}" }.join('&')
     end
 
+    # request headers
     def headers
       @event['headers'] || {}
     end

data/lib/jets/controller/request/compat/params.rb

@@ -0,0 +1,144 @@
+require "action_dispatch/request/utils"
+require "rack"
+
+module Jets::Controller::Request::Compat
+  # Provides these 3 methods to make it Rails compatible:
+  #
+  #   request_parameters
+  #   query_parameters
+  #   path_parameters
+  #
+  module Params
+    extend Memoist
+
+    delegate :normalize_encode_params, to: ActionDispatch::Request::Utils
+    def set_binary_encoding(params)
+      controller = path_parameters[:controller]
+      action = path_parameters[:action]
+      ActionDispatch::Request::Utils.set_binary_encoding(self, params, controller, action)
+    end
+
+    # Merge all the parameters together for convenience.
+    # Users still have access via events.
+    #
+    # Precedence:
+    #   1. path parameters have highest precdence
+    #   2. query string parameters
+    #   3. body parameters
+    def parameters(include_path_params: true, include_body_params: true)
+      params = {}
+      params = params.deep_merge(request_parameters) if include_body_params
+      params = params.deep_merge(unescape_recursively(query_parameters)) # always
+      params = params.deep_merge(path_parameters) if include_path_params
+      params = set_binary_encoding(params)
+      params = normalize_encode_params(params)
+      params
+    end
+    memoize :parameters
+    alias params parameters
+
+    def path_parameters
+      path_params = event["pathParameters"] || {}
+      path_params.merge!(path_parameters_defaults)
+      path_params = path_params.map { |k, path| [k, CGI.unescape(path.to_s)] }.to_h
+    end
+
+    def path_parameters_defaults
+      route = Jets::Router::Matcher.new.find_by_request(self)
+      if route
+        controller = route.controller_name.delete_suffix("Controller").underscore
+        {
+          controller: controller,
+          action: route.action_name,
+        }.merge(route.resolved_defaults)
+      else
+        {}
+      end
+    end
+
+    # Based on ActionDispatch::Request#GET https://bit.ly/48hvDwe
+    # Override Rack's GET method to support indifferent access.
+    def GET
+      fetch_header("action_dispatch.request.query_parameters") do |k|
+        params = event["queryStringParameters"] || {}
+        set_binary_encoding(params)
+        set_header k, normalize_encode_params(params)
+      end
+    end
+    alias query_parameters GET
+
+    # Based on ActionDispatch::Request#POST https://bit.ly/48fxh1A
+    # Override Rack's POST method to support indifferent access.
+    def POST
+      fetch_header("action_dispatch.request.request_parameters") do
+        params = get_request_parameters
+        self.request_parameters = normalize_encode_params(params)
+      end
+    end
+    alias request_parameters POST
+
+    def request_parameters=(params)
+      raise if params.nil?
+      set_header("action_dispatch.request.request_parameters", params)
+    end
+
+    def get_request_parameters
+      body = event['isBase64Encoded'] ? base64_decode(event["body"]) : event["body"]
+      return {} if body.nil?
+
+      parsed_json = parse_json(body)
+      return parsed_json if parsed_json
+
+      if content_type.to_s.include?("application/x-www-form-urlencoded")
+        return ::Rack::Utils.parse_nested_query(body)
+      elsif content_type.to_s.include?("multipart/form-data")
+        return parse_multipart(body)
+      end
+
+      {} # fallback to empty Hash
+    end
+    memoize :get_request_parameters
+
+    # jets specific
+    def request_method_from_hidden_method_field
+      get_request_parameters["_method"].to_s.upcase if get_request_parameters["_method"]
+    end
+
+  private
+
+    def parse_multipart(body)
+      boundary = ::Rack::Multipart::Parser.parse_boundary(content_type)
+      options = multipart_options(body, boundary)
+      env = ::Rack::MockRequest.env_for("/", options)
+      ::Rack::Multipart.parse_multipart(env) # params Hash
+    end
+
+    def multipart_options(data, boundary = "AaB03x")
+      type = %(multipart/form-data; boundary=#{boundary})
+      length = data.bytesize
+
+      { "CONTENT_TYPE" => type,
+        "CONTENT_LENGTH" => length.to_s,
+        :input => StringIO.new(data) }
+    end
+
+    def parse_json(text)
+      JSON.parse(text)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def base64_decode(body)
+      return nil if body.nil?
+      Base64.decode64(body)
+    end
+
+    def unescape_recursively(obj)
+      case obj
+      when Hash then obj.map { |k, v| [k, unescape_recursively(v)] }.to_h
+      when Array then obj.map { |v| unescape_recursively(v) }
+      else CGI.unescape(obj.to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Jets::Controller::Request::Compat
+  # Based on ActionDispatch::Request class
+  module Request
+    extend Memoist
+
+    ENV_METHODS = %w[ AUTH_TYPE GATEWAY_INTERFACE
+      PATH_TRANSLATED REMOTE_HOST
+      REMOTE_IDENT REMOTE_USER REMOTE_ADDR
+      SERVER_NAME SERVER_PROTOCOL
+      ORIGINAL_SCRIPT_NAME
+
+      HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
+      HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_FROM
+      HTTP_NEGOTIATE HTTP_PRAGMA HTTP_CLIENT_IP
+      HTTP_X_FORWARDED_FOR HTTP_ORIGIN HTTP_VERSION
+      HTTP_X_CSRF_TOKEN HTTP_X_REQUEST_ID HTTP_X_FORWARDED_HOST
+      ].freeze
+
+    ENV_METHODS.each do |env|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        # frozen_string_literal: true
+        def #{env.delete_prefix("HTTP_").downcase}  # def accept_charset
+          get_header "#{env}"                       #   get_header "HTTP_ACCEPT_CHARSET"
+        end                                         # end
+      METHOD
+    end
+
+    LOCALHOST   = Regexp.union [/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, /^::1$/, /^0:0:0:0:0:0:0:1(%.*)?$/]
+
+    def session
+      key = ActionDispatch::Request::Session::ENV_SESSION_KEY
+      session = env[key]
+      if session.nil? # controller dispatch! does not go through middleware
+        # mock session that is disabled
+        session = ActionDispatch::Request::Session.new(nil, self, enabled: false)
+      end
+      session
+    end
+
+    def session=(session) # :nodoc:
+      ActionDispatch::Request::Session.set self, session
+    end
+
+    def session_options=(options)
+      ActionDispatch::Request::Session::Options.set self, options
+    end
+
+    def reset_session
+      session.destroy
+    end
+
+    def headers
+      top_level_headers.merge(http_headers)
+    end
+
+    def http_headers
+      Hash[*env.select {|k,v| k.start_with? 'HTTP_'}
+        .collect {|k,v| [k.sub(/^HTTP_/, ''), v]}
+        .collect {|k,v| [k.split('_').collect(&:capitalize).join('-'), v]}
+        .sort
+        .flatten]
+    end
+
+    # These are not part of a Rails headers but believe
+    # they make sense to add as it feel like expected behavior.
+    def top_level_headers
+      hash = {
+        "Host" => env["HTTP_HOST"],
+        "Content-Type" => env["CONTENT_TYPE"],
+        "Content-Length" => env["CONTENT_LENGTH"],
+      }
+      hash.delete_if { |k, v| v.nil? }
+      hash
+    end
+
+    # Returns the lowercase name of the HTTP server software.
+    def server_software
+      (get_header("SERVER_SOFTWARE") && /^([a-zA-Z]+)/ =~ get_header("SERVER_SOFTWARE")) ? $1.downcase : nil
+    end
+
+    # Returns the authorization header regardless of whether it was specified directly or through one of the
+    # proxy alternatives.
+    def authorization
+      get_header("HTTP_AUTHORIZATION")   ||
+      get_header("X-HTTP_AUTHORIZATION") ||
+      get_header("X_HTTP_AUTHORIZATION") ||
+      get_header("REDIRECT_X_HTTP_AUTHORIZATION")
+    end
+
+    # True if the request came from localhost, 127.0.0.1, or ::1.
+    def local?
+      LOCALHOST.match?(remote_addr) && LOCALHOST.match?(remote_ip)
+    end
+
+    def controller_class_for(name)
+      controller_param = name.underscore
+      const_name = controller_param.camelize << "Controller"
+      const_name.constantize
+    end
+
+    def request_method_symbol
+      request_method.downcase.to_sym
+    end
+    alias method_symbol request_method_symbol
+
+    # Returns the IP address of client as a +String+,
+    # usually set by the RemoteIp middleware.
+    def remote_ip
+      @remote_ip ||= (get_header("action_dispatch.remote_ip") || ip).to_s
+    end
+
+    def remote_ip=(remote_ip)
+      @remote_ip = nil
+      set_header "action_dispatch.remote_ip", remote_ip
+    end
+
+    # Needed when action_view.preload_links_header = true
+    # Rails 6.1 defaults
+    def send_early_hints(links)
+      return unless env["rack.early_hints"]
+
+      env["rack.early_hints"].call(links)
+    end
+  end
+end

data/lib/jets/controller/request.rb

@@ -1,29 +1,46 @@
 require 'rack/request'
 
-class Jets::Controller
-  class Request < ::Rack::Request
-    def initialize(event, context)
-      @event, @context = event, context
-      super(env)
+module Jets::Controller
+  class Request
+    include Rack::Request::Helpers
+    include Compat::Request
+    include Compat::Params
+
+    include ActionDispatch::Flash::RequestMethods
+    include ActionDispatch::Http::Cache::Request
+    include ActionDispatch::Http::MimeNegotiation
+    include ActionDispatch::Http::FilterParameters # parameter_filter and filtered_parameters
+    include ActionDispatch::Http::URL
+    include ActionDispatch::RequestCookieMethods
+    include ActionDispatch::ContentSecurityPolicy::Request
+    include ActionDispatch::PermissionsPolicy::Request
+    include Rack::Request::Env
+
+    # since jets delegates parameter_filter from controller to request
+    public :parameter_filter
+
+    attr_reader :event, :env
+    attr_accessor :routes
+    def initialize(rack_env: nil, event: nil)
+      @rack_env = rack_env
+      @event = event
+      @env = normalize_env
+      super(@env) # Rack::Env module => super()
     end
 
-    def env
-      @env ||= Jets::Controller::Rack::Env.new(@event, @context).convert # convert to Rack env
+    def normalize_env
+      if @rack_env # already rack env
+        @rack_env # rack_env is from Controller.action => lambda { |env| .. }
+      else
+        Jets::Controller::RackAdapter::Env.new(@event, {}).convert # convert to Rack env
+      end
     end
 
-    # When request hits the middleware Controller::Rack::Middleware::Main endpoint
-    # We set the it with the updated env since it could had been mutated down the
-    # middleware stack.
+    # When request hits the middleware Controller::RackAdapter::Middleware::Main endpoint
+    # We updated env since it could had been mutated down the middleware stack
+    # from Mimic to Main.
     def set_env!(env)
       @env = env
     end
-
-    # API Gateway is inconsistent about how it cases it keys.
-    # Sometimes it is "x-requested-with" vs "X-Requested-With"
-    # Normalize it with downcase.
-    def headers
-      headers = @event["headers"] || {}
-      headers.transform_keys { |key| key.downcase }
-    end
   end
 end