jets 3.1.0 → 5.0.10

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,11 +132,12 @@ module Jets::Controller::Rack
     end
 
     def query_string
-      qs_params = @event["queryStringParameters"] || {} # always set with API Gateway but when testing node shim might not be
-      hash = Jets::Mega::HashConverter.encode(qs_params)
-      hash.to_query
+      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

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

@@ -0,0 +1,67 @@
+module Jets::Controller::Response::Compat
+  module Response
+    extend ActiveSupport::Concern
+
+    included do
+      # Must come before include ActionDispatch::Http::Cache::Response
+      # Aliasing these off because AD::Http::Cache::Response defines them.
+      alias :_cache_control :cache_control
+      alias :_cache_control= :cache_control=
+    end
+
+    class_methods do
+      cattr_accessor :default_charset, default: "utf-8"
+    end
+
+    ContentTypeHeader = Struct.new :mime_type, :charset
+    NullContentTypeHeader = ContentTypeHeader.new nil, nil
+
+    CONTENT_TYPE = "Content-Type"
+    CONTENT_TYPE_PARSER = /
+      \A
+      (?<mime_type>[^;\s]+\s*(?:;\s*(?:(?!charset)[^;\s])+)*)?
+      (?:;\s*charset=(?<quote>"?)(?<charset>[^;\s]+)\k<quote>)?
+    /x # :nodoc:
+
+    def parse_content_type(content_type)
+      if content_type && match = CONTENT_TYPE_PARSER.match(content_type)
+        ContentTypeHeader.new(match[:mime_type], match[:charset])
+      else
+        NullContentTypeHeader
+      end
+    end
+
+    # Small internal convenience method to get the parsed version of the current
+    # content type header.
+    def parsed_content_type_header
+      parse_content_type(get_header("Content-Type"))
+    end
+
+    def set_content_type(content_type, charset)
+      type = content_type || ""
+      type = "#{type}; charset=#{charset.to_s.downcase}" if charset
+      set_header CONTENT_TYPE, type
+    end
+
+    # Sets the HTTP character set. In case of +nil+ parameter
+    # it sets the charset to +default_charset+.
+    #
+    #   response.charset = 'utf-16' # => 'utf-16'
+    #   response.charset = nil      # => 'utf-8'
+    def charset=(charset)
+      content_type = parsed_content_type_header.mime_type
+      if false == charset
+        set_content_type content_type, nil
+      else
+        set_content_type content_type, charset || self.class.default_charset
+      end
+    end
+
+    # The charset of the response. HTML wants to know the encoding of the
+    # content you're giving them, so we need to send that along.
+    def charset
+      header_info = parsed_content_type_header
+      header_info.charset || self.class.default_charset
+    end
+  end
+end

data/lib/jets/controller/response.rb

@@ -1,21 +1,96 @@
+require 'action_dispatch/http/cache'
+require 'action_dispatch/http/filter_redirect'
+require 'monitor'
 require 'rack/response'
+require 'rack/utils'
 
-class Jets::Controller
+module Jets::Controller
   # The response object. See Rack::Response and Rack::Response::Helpers for
   # more info:
   # http://rubydoc.info/github/rack/rack/master/Rack/Response
   # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
   class Response < ::Rack::Response
-    DROP_BODY_RESPONSES = [204, 304]
+    include Compat::Response
+
+    include ActionDispatch::Http::FilterRedirect
+    include ActionDispatch::Http::Cache::Response
+    include MonitorMixin
+
+    attr_accessor :request
+
     def initialize(*)
       super
-      # headers['Content-Type'] ||= 'text/html'
+      prepare_cache_control!
+    end
+
+    # What Rack::Response#initialize does.
+    def body=(body)
+      if body.nil?
+        @body = []
+        @buffered = true
+        @length = 0
+      elsif body.respond_to?(:to_str)
+        @body = [body]
+        @buffered = true
+        @length = body.to_str.bytesize
+      else
+        @body = body
+        @buffered = false
+        @length = 0
+      end
+      @body
+    end
+
+    # Sets the HTTP status code.
+    def status=(status)
+      @status = Rack::Utils.status_code(status)
+    end
+
+    def to_a
+      commit!
+      rack_response status, headers.to_hash
+    end
+
+    def committed?; synchronize { @committed }; end
+    # sending? and send? are for compatibility but not used for Jets
+    def sending?;   synchronize { @sending };   end
+    def sent?;      synchronize { @sent };      end
+
+    def commit!
+      synchronize do
+        before_committed
+        @committed = true
+      end
     end
 
-    # TODO: unsure if we should even have these methods.  We dont really use them.
-    def body=(value)
-      value = value.body while Rack::Response === value
-      @body = String === value ? [value.to_str] : value
+    def before_committed
+      assign_default_content_type_and_charset!
+      merge_and_normalize_cache_control!(@cache_control)
+      handle_conditional_get!
+      handle_no_content!
+    end
+
+    def assign_default_content_type_and_charset!
+      return if media_type
+
+      ct = parsed_content_type_header
+      set_content_type(ct.mime_type || Mime[:html].to_s,
+                       ct.charset || self.class.default_charset)
+    end
+
+    def handle_no_content!
+      if NO_CONTENT_CODES.include?(@status)
+        headers.delete "Content-Length"
+      end
+    end
+
+    NO_CONTENT_CODES = [100, 101, 102, 103, 204, 205, 304]
+    def rack_response(status, header)
+      if NO_CONTENT_CODES.include?(status)
+        [status, header, []]
+      else
+        [status, header, body]
+      end
     end
 
     def each
@@ -44,7 +119,14 @@ class Jets::Controller
       [status.to_i, headers, result]
     end
 
-    private
+    # The response code of the request.
+    alias response_code status
+
+    def media_type
+      headers["Content-Type"]
+    end
+
+  private
 
     def calculate_content_length?
       headers["Content-Type"] and not headers["Content-Length"] and Array === body
@@ -54,6 +136,7 @@ class Jets::Controller
       status.to_i / 100 == 1 or drop_body?
     end
 
+    DROP_BODY_RESPONSES = [204, 304]
     def drop_body?
       DROP_BODY_RESPONSES.include?(status.to_i)
     end