jets 1.0.18 → 1.1.0

data/lib/jets/controller/redirection.rb

@@ -19,7 +19,7 @@ class Jets::Controller
 
       redirect_url = ensure_protocol(redirect_url)
 
-      aws_proxy = Renderers::AwsProxyRenderer.new(self,
+      aws_proxy = Renderers::RackRenderer.new(self,
         status: options[:status] || 302,
         headers: { "Location" => redirect_url },
         body: "",

data/lib/jets/controller/renderers.rb

@@ -1,5 +1,5 @@
 module Jets::Controller::Renderers
-  autoload :AwsProxyRenderer, "jets/controller/renderers/aws_proxy_renderer"
   autoload :BaseRenderer, "jets/controller/renderers/base_renderer"
+  autoload :RackRenderer, "jets/controller/renderers/rack_renderer"
   autoload :TemplateRenderer, "jets/controller/renderers/template_renderer"
 end

data/lib/jets/controller/renderers/base_renderer.rb

@@ -8,9 +8,5 @@ module Jets::Controller::Renderers
       @controller = controller
       @options = options
     end
-
-    def render_aws_proxy(options)
-      AwsProxyRenderer.new(@controller, options).render
-    end
   end
 end

data/lib/jets/controller/renderers/{aws_proxy_renderer.rb → rack_renderer.rb}

@@ -2,17 +2,10 @@ require "rack/utils"
 
 # Special renderer.  All the other renderers lead here
 module Jets::Controller::Renderers
-  class AwsProxyRenderer < BaseRenderer
-    # Transform the structure to AWS_PROXY compatiable structure
-    # http://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
+  class RackRenderer < BaseRenderer
     # Example response:
     #
-    #   {
-    #     "statusCode" => status,
-    #     "headers" => headers,
-    #     "body" => body,
-    #     "isBase64Encoded" => base64,
-    #   }
+    #   [200, {"my-header" = > "value" }, "my body" ]
     def render
       # we do some normalization here
       status = map_status_code(@options[:status]) || 200
@@ -22,16 +15,11 @@ module Jets::Controller::Renderers
 
       headers = @options[:headers] || {}
       headers = cors_headers.merge(headers)
-      headers["Content-Type"] ||= @options[:content_type] || "text/html; charset=utf-8"
-
-      # Compatiable Lambda Proxy response Hash.
-      # Additional extra keys results in compatiability. Explictly assign keys.
-      {
-        "statusCode" => status,
-        "headers" => headers,
-        "body" => body,
-        "isBase64Encoded" => base64,
-      }
+      headers["Content-Type"] ||= @options[:content_type] || Jets::Controller::DEFAULT_CONTENT_TYPE
+      # x-jets-base64 to convert this Rack triplet to a API Gateway hash structure later
+      headers["x-jets-base64"] = base64 ? "true" : "false"
+      body = StringIO.new(body)
+      [status, headers, body] # triplet
     end
 
     # maps:

data/lib/jets/controller/renderers/template_renderer.rb

@@ -16,7 +16,7 @@ module Jets::Controller::Renderers
       body = renderer.render(render_options)
       @options[:body] = body # important to set as it was originally nil
 
-      render_aws_proxy(@options)
+      RackRenderer.new(@controller, @options).render
     end
 
     # Example: posts/index

data/lib/jets/controller/request.rb

@@ -1,42 +1,21 @@
-# Somewhat based off of: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/request.rb
+require 'rack/request'
+
 class Jets::Controller
-  class Request
-    def initialize(event)
-      @event = event
+  class Request < ::Rack::Request
+    def initialize(event, context)
+      @event, @context = event, context
+      super(env)
     end
 
-    # lambda integration proxy headers
-    HEADER_METHODS = %w[
-      Accept
-      Accept-Encoding
-      Accept-Language
-      cache-control
-      CloudFront-Forwarded-Proto
-      CloudFront-Is-Desktop-Viewer
-      CloudFront-Is-Mobile-Viewer
-      CloudFront-Is-SmartTV-Viewer
-      CloudFront-Is-Tablet-Viewer
-      CloudFront-Viewer-Country
-      content-type
-      Host
-      origin
-      Referer
-      upgrade-insecure-requests
-      User-Agent
-      Via
-      X-Amz-Cf-Id
-      X-Amzn-Trace-Id
-      X-Forwarded-For
-      X-Forwarded-Port
-      X-Forwarded-Proto
-    ].freeze
+    def env
+      @env ||= Jets::Controller::Rack::Env.new(@event, @context).convert # convert to Rack env
+    end
 
-    HEADER_METHODS.each do |meth|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{meth.downcase.underscore}       # def content_type
-          headers["#{meth.downcase}"].freeze  #   headers["content-type"]
-        end                                   # end
-      METHOD
+    # 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.
+    def set_env!(env)
+      @env = env
     end
 
     # API Gateway is inconsistent about how it cases it keys.
@@ -46,14 +25,5 @@ class Jets::Controller
       headers = @event["headers"] || {}
       headers.transform_keys { |key| key.downcase }
     end
-
-    def xhr?
-      headers["x-requested-with"] == "XMLHttpRequest"
-    end
-
-    def path
-      @event["path"]
-    end
-
   end
 end

data/lib/jets/controller/response.rb

@@ -1,13 +1,61 @@
+require 'rack/response'
+
 class Jets::Controller
-  class Response
-    attr_reader :headers
-    def initialize(event)
-      @event = event
-      @headers = {}
+  # 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]
+    def initialize(*)
+      super
+      # headers['Content-Type'] ||= 'text/html'
+    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
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      result = body
+
+      if drop_content_info?
+        headers.delete "Content-Length"
+        headers.delete "Content-Type"
+      end
+
+      if drop_body?
+        close
+        result = []
+      end
+
+      if calculate_content_length?
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers["Content-Length"] = body.inject(0) { |l, p| l + p.bytesize }.to_s
+      end
+
+      [status.to_i, headers, result]
+    end
+
+    private
+
+    def calculate_content_length?
+      headers["Content-Type"] and not headers["Content-Length"] and Array === body
+    end
+
+    def drop_content_info?
+      status.to_i / 100 == 1 or drop_body?
     end
 
-    def set_header(k,v)
-      @headers[k] = v
+    def drop_body?
+      DROP_BODY_RESPONSES.include?(status.to_i)
     end
   end
 end

data/lib/jets/internal/app/controllers/jets/rack_controller.rb

@@ -4,12 +4,22 @@ class Jets::RackController < Jets::Controller::Base
 
   # Megamode
   def process
-    resp = rack_request
+    resp = mega_request
     render(resp)
   end
 
 private
-  def rack_request
-    Jets::Rack::Request.new(event, self).process
+  # Override process! so it doesnt go through middleware adapter and hits
+  # process logic directly. This handles the case for AWS Lambda.
+  # For local server, we adjust the Middleware::Local logic.
+  def process!
+    status, headers, body = dispatch!
+    # Use the adapter only to convert the Rack triplet to a API Gateway hash structure
+    adapter = Jets::Controller::Rack::Adapter.new(event, context, meth)
+    adapter.convert_to_api_gateway(status, headers, body)
+  end
+
+  def mega_request
+    Jets::Mega::Request.new(event, self).proxy
   end
 end

data/lib/jets/mega.rb

@@ -0,0 +1,7 @@
+module Jets
+  module Mega
+    autoload :Request, 'jets/mega/request'
+    autoload :Server, 'jets/mega/server'
+    autoload :HashConverter, 'jets/mega/hash_converter'
+  end
+end

data/lib/jets/{rack → mega}/hash_converter.rb

@@ -1,5 +1,5 @@
 # Thanks https://mensfeld.pl/2012/01/converting-nested-hash-into-http-url-params-hash-version-in-ruby/
-module Jets::Rack
+module Jets::Mega
   module HashConverter
     def self.encode(value, key = nil, out_hash = {})
       case value

data/lib/jets/{rack → mega}/request.rb

@@ -1,18 +1,21 @@
 require 'net/http'
+require 'rack'
 
-module Jets::Rack
+module Jets::Mega
   class Request
     def initialize(event, controller)
       @event = event
       @controller = controller # Jets::Controller instance
     end
 
-    def process
+    def proxy
       http_method = @event['httpMethod'] # GET, POST, PUT, DELETE, etc
       params = @controller.params(raw: true, path_parameters: false)
 
       uri = URI("http://localhost:9292#{@controller.request.path}") # local rack server
       http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 60
+      http.read_timeout = 60
 
       # Rails sets _method=patch or _method=put as workaround
       # Falls back to GET when testing in lambda console
@@ -20,7 +23,7 @@ module Jets::Rack
       http_class.capitalize!
 
       request_class = "Net::HTTP::#{http_class}".constantize # IE: Net::HTTP::Get
-      request = request_class.new(@controller.request.path)
+      request = request_class.new(uri.path)
       if %w[Post Patch Put].include?(http_class)
         params = HashConverter.encode(params)
         request.set_form_data(params)
@@ -28,8 +31,18 @@ module Jets::Rack
 
       request = set_headers!(request)
 
-      # TODO: handle binary
+      # Setup body
+      env = Jets::Controller::Rack::Env.new(@event, {}).convert # convert to Rack env
+      source_request = Rack::Request.new(env)
+      if source_request.body.respond_to?(:read)
+        request.body = source_request.body.read
+        request.content_length = source_request.content_length.to_i
+        source_request.body.rewind
+      end
+
       response = http.request(request)
+
+      # TODO: handle binary
       {
         status: response.code.to_i,
         headers: response.each_header.to_h,

data/lib/jets/middleware.rb

@@ -0,0 +1,38 @@
+module Jets
+  module Middleware
+    extend Memoist
+
+    autoload :Configurator, 'jets/middleware/configurator'
+    autoload :DefaultStack, 'jets/middleware/default_stack'
+    autoload :Layer, 'jets/middleware/layer'
+    autoload :Stack, 'jets/middleware/stack'
+
+    def call(env)
+      stack = middlewares.build(endpoint)
+      stack.call(env)
+    end
+
+    # Final middleware in the stack
+    def endpoint
+      Jets::Controller::Middleware::Main
+    end
+
+    # Called in Jets::Booter to build middleware stack only once during bootup
+    def build_stack
+      middlewares
+    end
+
+    def middlewares
+      config_middleware.merge_into(default_stack) # returns Jets::Middleware::Stack
+    end
+    memoize :middlewares
+
+    def default_stack
+      Jets::Middleware::DefaultStack.new(Jets.config, Jets.application).build_stack # returns Jets::Middleware::Stack
+    end
+
+    def config_middleware
+      Jets.config.middleware # returns Jets::Middleware::Configurator
+    end
+  end
+end

data/lib/jets/middleware/configurator.rb

@@ -0,0 +1,84 @@
+# Based on Rails MiddlewareStackProxy
+#
+# Configurator is a proxy for the Jets middleware stack that allows
+# you to configure middlewares in your application. It works basically as a
+# command recorder, saving each command to be applied after initialization
+# over the default middleware stack, so you can add, swap, or remove any
+# middleware in Jets.
+#
+# You can add your own middlewares by using the +config.middleware.use+ method:
+#
+#     config.middleware.use Magical::Unicorns
+#
+# This will put the <tt>Magical::Unicorns</tt> middleware on the end of the stack.
+# You can use +insert_before+ if you wish to add a middleware before another:
+#
+#     config.middleware.insert_before Rack::Head, Magical::Unicorns
+#
+# There's also +insert_after+ which will insert a middleware after another:
+#
+#     config.middleware.insert_after Rack::Head, Magical::Unicorns
+#
+# Middlewares can also be completely swapped out and replaced with others:
+#
+#     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
+#
+# And finally they can also be removed from the stack completely:
+#
+#     config.middleware.delete ActionDispatch::Flash
+#
+module Jets::Middleware
+  class Configurator
+    def initialize(operations = [], delete_operations = [])
+      @operations = operations
+      @delete_operations = delete_operations
+    end
+
+    def insert_before(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    alias :insert :insert_before
+
+    def insert_after(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def swap(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def use(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def delete(*args, &block)
+      @delete_operations << [__method__, args, block]
+    end
+
+    def unshift(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def merge_into(other) #:nodoc:
+      (@operations + @delete_operations).each do |operation, args, block|
+        other.send(operation, *args, &block)
+      end
+
+      other
+    end
+
+    def +(other) # :nodoc:
+      Configurator.new(@operations + other.operations, @delete_operations + other.delete_operations)
+    end
+
+    protected
+      def operations
+        @operations
+      end
+
+      def delete_operations
+        @delete_operations
+      end
+  end
+end

data/lib/jets/middleware/default_stack.rb

@@ -0,0 +1,44 @@
+module Jets::Middleware
+  class DefaultStack
+    attr_reader :config, :app
+    def initialize(app, config)
+      @app = app
+      @config = config
+    end
+
+    def build_stack
+      Stack.new do |middleware|
+        middleware.use Jets::Controller::Middleware::Local # mimics AWS Lambda for local server only
+        middleware.use Rack::Runtime
+        middleware.use Rack::MethodOverride
+        middleware.use session_store, session_options # use session_store, session_options
+        middleware.use Rack::Head
+        middleware.use Rack::ConditionalGet
+        middleware.use Rack::ETag
+        use_webpacker(middleware)
+      end
+    end
+
+  private
+    # Written as method to easily not include webpacker for case when either
+    # webpacker not installed at all or disabled upon `jets deploy`.
+    def use_webpacker(middleware)
+      return unless Jets.webpacker? # checks for local development if webpacker installed
+      # Different check for middleware because we need webpacker helpers for url helpers.
+      # But we dont want to actually serve via webpacker middleware when running on AWS.
+      # By this time the url helpers are serving assets out of s3.
+      return if File.exist?("#{Jets.root}config/disable-webpacker-middleware.txt") # created as part of `jets deploy`
+      require "jets/controller/middleware/webpacker_setup"
+      middleware.use Webpacker::DevServerProxy
+    end
+
+    def session_store
+      Jets.config.session[:store] # do not use dot notation. session.store is a method on ActiveSupport::OrderedOptions.new
+    end
+
+    def session_options
+      defaults = { secret: ENV['SECRET_KEY_BASE'] }
+      defaults.merge(Jets.config.session.options)
+    end
+  end
+end