shark-on-lambda 0.6.10 → 1.0.0.rc1

data/lib/shark_on_lambda/jsonapi_parameters.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  class JsonapiParameters
+    def initialize(params = {})
+      @class = default_serializer_classes
+      @fields = HashWithIndifferentAccess.new
+      @include = []
+
+      parse_params(params) if params.present?
+    end
+
+    def classes(serializer_classes = {})
+      @class = default_serializer_classes.merge(serializer_classes)
+    end
+
+    def fields(serialized_fields = {})
+      @fields = serialized_fields.with_indifferent_access
+    end
+
+    def includes(*includes_list)
+      @include = includes_list
+    end
+
+    def to_h
+      {
+        class: @class,
+        fields: @fields,
+        include: @include
+      }
+    end
+    alias to_hash to_h
+
+    protected
+
+    def default_serializer_classes
+      HashWithIndifferentAccess.new do |hash, key|
+        serializer_service = Inferrers::SerializerInferrer.new(key)
+        serializer_class = serializer_service.serializer_class
+        hash[key] = serializer_class
+      end
+    end
+
+    def parse_fields_params(fields_params)
+      return if fields_params.blank?
+
+      serialized_fields = fields_params.transform_values do |fields_param|
+        fields = fields_param.split(',')
+        fields.map!(&:strip)
+        fields.map!(&:to_sym)
+      end
+      fields(serialized_fields)
+    end
+
+    def parse_include_params(include_params)
+      include_params = JSONAPI::IncludeDirective.new(include_params)
+      include_params = include_params.to_hash
+      includes(include_params.with_indifferent_access)
+    end
+
+    def parse_params(params)
+      parse_fields_params(params[:fields])
+      parse_include_params(params[:include])
+    end
+  end
+end

data/lib/shark_on_lambda/jsonapi_renderer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  class JsonapiRenderer
+    def initialize(renderer: nil)
+      @renderer = renderer || JSONAPI::Serializable::Renderer.new
+    end
+
+    def render(object, options = {})
+      object = transform_active_model_errors(object)
+
+      unless renderable?(object, options)
+        return handle_unrenderable_objects(object, options)
+      end
+
+      if error?(object)
+        render_errors(object, options).to_json
+      else
+        render_success(object, options).to_json
+      end
+    end
+
+    protected
+
+    attr_reader :renderer
+
+    def active_model_error?(error)
+      return false unless defined?(::ActiveModel::Errors)
+
+      error.is_a?(::ActiveModel::Errors)
+    end
+
+    def attribute_name(attribute)
+      File.basename(attribute_path(attribute))
+    end
+
+    def attribute_path(attribute)
+      attribute.to_s.tr('.', '/').gsub(/\[(\d+)\]/, '/\1')
+    end
+
+    def error?(object)
+      if object.respond_to?(:to_ary)
+        object.to_ary.any? { |item| item.is_a?(StandardError) }
+      else
+        object.is_a?(StandardError)
+      end
+    end
+
+    def handle_unrenderable_objects(object, options)
+      objects_without_serializer = unrenderable_objects(object, options)
+      classes_without_serializer = objects_without_serializer.map(&:class)
+      classes_without_serializer.uniq!
+      errors = classes_without_serializer.map do |item|
+        Errors[500].new("Could not find serializer for: #{item.name}.")
+      end
+
+      render_errors(errors, options)
+    end
+
+    def render_errors(error, options)
+      renderer.render_errors(Array(error), options)
+    end
+
+    def render_success(object, options)
+      return { data: {} } if object.nil?
+
+      renderer.render(object, options)
+    end
+
+    def renderable?(object, options)
+      return true if object.nil?
+
+      serializers = serializer_classes(options)
+
+      if object.respond_to?(:to_ary)
+        object.to_ary.all? { |item| serializers[item.class.name].present? }
+      else
+        serializers[object.class.name].present?
+      end
+    end
+
+    def serializer_classes(options)
+      return @serializer_classes if defined?(@serializer_classes)
+
+      @serializer_classes = HashWithIndifferentAccess.new do |hash, key|
+        serializer_inferrer = Inferrers::SerializerInferrer.new(key)
+        serializer_class = serializer_inferrer.serializer_class
+        hash[key] = serializer_class
+      end
+      @serializer_classes.merge!(options[:class])
+    end
+
+    def transform_active_model_errors(errors)
+      return errors unless active_model_error?(errors)
+
+      result = errors.messages.map do |attribute, attribute_errors|
+        attribute_errors.map do |attribute_error|
+          error_message = "`#{attribute_name(attribute)}' #{attribute_error}"
+          Errors[422].new(error_message).tap do |error|
+            error.pointer = "/data/attributes/#{attribute_path(attribute)}"
+          end
+        end
+      end
+      result.flatten! || result
+    end
+
+    def unrenderable_objects(object, options)
+      if object.respond_to?(:to_ary)
+        object.to_ary.reject { |item| renderable?(item, options) }
+      else
+        renderable?(object, options) ? [] : [object]
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/middleware/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Middleware
+    class Base
+      attr_reader :app
+
+      def initialize(app = nil)
+        @app = app
+      end
+
+      def call(env)
+        dup.send('_call', env)
+      end
+
+      private
+
+      def _call(_env)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/middleware/jsonapi_rescuer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Middleware
+    class JsonapiRescuer < Rescuer
+      private
+
+      def error_object(status, message)
+        {
+          status: status.to_s,
+          title: Rack::Utils::HTTP_STATUS_CODES[status],
+          detail: message
+        }
+      end
+
+      def error_response(status, headers, message)
+        body = {
+          errors: [
+            error_object(status, message)
+          ]
+        }.to_json
+
+        response_body = Rack::BodyProxy.new([body]) do
+          message.close if message.respond_to?(:close)
+        end
+
+        [status, headers, response_body]
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/middleware/rescuer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Middleware
+    class Rescuer < Base
+      private
+
+      def _call(env)
+        app.call(env)
+      rescue Errors::Base => e
+        rescue_shark_error(e)
+      rescue StandardError => e
+        rescue_standard_error(e)
+      end
+
+      def error_response(status, headers, message)
+        response_body = Rack::BodyProxy.new([message]) do
+          message.close if message.respond_to?(:close)
+        end
+
+        [status, headers, response_body]
+      end
+
+      def rescue_shark_error(error)
+        status = error.status || 500
+        error_response(status, {}, error.message)
+      end
+
+      def rescue_standard_error(error)
+        SharkOnLambda.logger.error(error.message)
+        SharkOnLambda.logger.error(error.backtrace.join("\n"))
+        Honeybadger.notify(error) if defined?(Honeybadger)
+
+        error_response(500, {}, error.message)
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/query.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  # The `multiValueQueryStringParameters` object from the API Gateway event
+  # keeps _all_ values in an array, regardless of the actual size of the array
+  # and regardless of the "intent" of the query string parameter.
+  #
+  # In order to normalise this behaviour, we treat the query strings
+  #
+  #   `key=value1&key=value2`
+  #
+  # and
+  #
+  #   `key[]=value1&key[]=value2`
+  #
+  # the same. Both are to be serialised to the query string
+  #
+  #   `key[]=value1&key[]=value2`
+  #
+  # However, the query strings
+  #
+  #   `key=value`
+  #
+  # and
+  #
+  #   `key[]=value`
+  #
+  # are _not_ to be treated the same.
+  class Query
+    def initialize(data = {})
+      @params = HashWithIndifferentAccess.new.merge(data)
+    end
+
+    def add(key, values)
+      if key.to_s.end_with?('[]')
+        actual_key = key[0..-3]
+        add_list(actual_key, values)
+      else
+        values.each { |value| add_item(key, value) }
+      end
+    end
+
+    def to_h
+      @params
+    end
+
+    def to_s
+      Rack::Utils.build_nested_query(to_h)
+    end
+
+    private
+
+    def add_item(key, value)
+      if @params[key].nil?
+        @params[key] = value
+      else
+        @params[key] = Array(@params[key])
+        @params[key] << value
+      end
+    end
+
+    def add_list(key, value)
+      @params[key] ||= []
+      @params[key].concat(value)
+    end
+  end
+end

data/lib/shark_on_lambda/rack_adapters/api_gateway.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module RackAdapters
+    class ApiGateway
+      attr_reader :context, :event
+
+      def initialize(context:, event:)
+        @context = context
+        @event = event.deep_stringify_keys
+      end
+
+      def build_response(status, headers, body)
+        body_content = ''
+        body.each { |line| body_content += line.to_s }
+        response = {
+          'statusCode' => status,
+          'headers' => headers,
+          'body' => body_content
+        }
+        response['isBase64Encoded'] = false if elb?
+        response
+      end
+
+      def env
+        default_env.merge(env_request_metadata)
+                   .merge(env_headers)
+                   .merge(env_params)
+                   .merge(env_body)
+      end
+
+      private
+
+      def default_env
+        {
+          'SCRIPT_NAME' => '',
+          'rack.version' => Rack::VERSION,
+          'rack.errors' => $stderr,
+          'rack.multithread' => true,
+          'rack.multiprocess' => true,
+          'rack.run_once' => false
+        }
+      end
+
+      def elb?
+        return false if event['requestContext'].nil?
+
+        event['requestContext'].key?('elb')
+      end
+
+      def env_body
+        result = event['body'] || ''
+        result = Base64.decode64(result) if event['isBase64Encoded']
+
+        {
+          'rack.input' => StringIO.new(result).set_encoding(Encoding::BINARY)
+        }
+      end
+
+      def env_headers
+        result = {}
+        http_headers.each_pair do |header, value|
+          key = key_for_header(header)
+          result[key] = value.to_s
+        end
+        result
+      end
+
+      def env_params
+        {
+          'QUERY_STRING' => query_string,
+          'shark.path_parameters' => event['pathParameters']
+        }
+      end
+
+      def env_request_metadata
+        {
+          'REQUEST_METHOD' => event['httpMethod'],
+          'PATH_INFO' => path_info,
+          'SERVER_NAME' => server_name,
+          'SERVER_PORT' => server_port.to_s,
+          'rack.url_scheme' => url_scheme
+        }
+      end
+
+      def http_headers
+        event['headers'] || {}
+      end
+
+      def key_for_header(header)
+        key = header.upcase.tr('-', '_')
+        case key
+        when 'CONTENT_LENGTH', 'CONTENT_TYPE' then key
+        else "HTTP_#{key}"
+        end
+      end
+
+      def path_info
+        event['path'] || ''
+      end
+
+      def query_string
+        return @query_string if defined?(@query_string)
+
+        query = Query.new
+        event['multiValueQueryStringParameters']&.each_pair do |key, value|
+          query.add(key, value)
+        end
+        @query_string = query.to_s
+      end
+
+      def server_name
+        http_headers['Host'] || 'localhost'
+      end
+
+      def server_port
+        http_headers['X-Forwarded-Port'] || 443
+      end
+
+      def url_scheme
+        http_headers['CloudFront-Forwarded-Proto'] ||
+          http_headers['X-Forwarded-Proto'] ||
+          'https'
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/request.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  class Request < ActionDispatch::Request
+    def path_parameters
+      super.merge(env['shark.path_parameters'] || {})
+    end
+  end
+end

data/lib/shark_on_lambda/response.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  class Response < ActionDispatch::Response
+  end
+end

data/lib/shark_on_lambda/rspec/env_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module RSpec
+    class EnvBuilder
+      attr_reader :action, :controller, :headers, :method, :params
+
+      def initialize(options = {})
+        @method = options.fetch(:method).to_s.upcase
+        @controller = options.fetch(:controller)
+        @action = options.fetch(:action)
+
+        @headers = (options[:headers] || {}).deep_stringify_keys
+        @params = options[:params]
+
+        initialize_env
+        add_headers
+        add_request_body
+      end
+
+      def build
+        env.deep_stringify_keys
+      end
+
+      private
+
+      attr_reader :env
+
+      def add_header(name, value)
+        name = name.upcase.tr('-', '_')
+        key = case name
+              when 'CONTENT_LENGTH', 'CONTENT_TYPE' then name
+              else "HTTP_#{name}"
+              end
+        @env[key] = value.to_s
+      end
+
+      def add_headers
+        headers.each_pair { |name, value| add_header(name, value) }
+      end
+
+      def add_request_body
+        return if %w[GET HEAD OPTIONS].include?(env['REQUEST_METHOD'])
+        return unless params.is_a?(Hash)
+
+        body = params.to_json
+
+        env['rack.input'] = StringIO.new(body).set_encoding(Encoding::BINARY)
+        env['CONTENT_TYPE'] = 'application/json'
+        env['CONTENT_LENGTH'] = body.bytesize.to_s
+      end
+
+      def initialize_env
+        @env = Rack::MockRequest.env_for(
+          'https://localhost:9292',
+          method: method,
+          params: params,
+          'shark.controller' => controller,
+          'shark.action' => action
+        )
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/rspec/helpers.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module RSpec
+    module Helpers
+      def delete(controller_method, options = {})
+        make_request('DELETE', controller_method, options)
+      end
+
+      def get(controller_method, options = {})
+        make_request('GET', controller_method, options)
+      end
+
+      def patch(controller_method, options = {})
+        make_request('PATCH', controller_method, options)
+      end
+
+      def post(controller_method, options = {})
+        make_request('POST', controller_method, options)
+      end
+
+      def put(controller_method, options = {})
+        make_request('PUT', controller_method, options)
+      end
+
+      def response
+        if @response.nil?
+          raise 'You must make a request before you can request a response.'
+        end
+
+        @response
+      end
+
+      private
+
+      def build_env(method, action, options = {})
+        env_builder = EnvBuilder.new(
+          method: method,
+          controller: controller_name,
+          action: action,
+          headers: options[:headers],
+          params: options[:params]
+        )
+        env_builder.build
+      end
+
+      def controller?
+        controller_name.present?
+      end
+
+      def controller_name
+        self.class.ancestors.find do |klass|
+          klass.name.end_with?('Controller')
+        end&.description
+      end
+
+      def dispatch_request(env, skip_middleware: false)
+        return SharkOnLambda.application.call(env) unless skip_middleware
+
+        controller_class = env['shark.controller'].constantize
+        action = env['shark.action']
+
+        request = Request.new(env)
+        response = Response.new
+        controller_class.dispatch(action, request, response)
+        response.prepare!
+      end
+
+      def make_request(method, action, options = {})
+        raise ArgumentError, 'Cannot find controller name.' unless controller?
+
+        options = options.with_indifferent_access
+        env = build_env(method, action, options)
+
+        status, headers, body = dispatch_request(
+          env,
+          skip_middleware: options[:skip_middleware]
+        )
+        errors = env['rack.errors']
+        @response = Rack::MockResponse.new(status, headers, body, errors)
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/rspec/jsonapi_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module RSpec
+    module JsonapiHelpers
+      include Helpers
+
+      def jsonapi_attributes
+        jsonapi_data[:attributes] || {}
+      end
+
+      def jsonapi_data
+        parsed_body[:data] || {}
+      end
+
+      def jsonapi_errors
+        parsed_body[:errors] || []
+      end
+
+      private
+
+      def parsed_body
+        @parsed_body ||= JSON.parse(response.body).with_indifferent_access
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SharkOnLambda
-  VERSION = '0.6.10'
+  VERSION = '1.0.0.rc1'
 end