shark-on-lambda 0.6.10 → 1.0.0.rc1

data/lib/shark_on_lambda/api_gateway/jsonapi_controller.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    class JsonapiController < BaseController
-      # TODO: Evaluate if deserialisation should happen in here, happen
-      #       somewhere else in SharkOnLambda, or if it should be something
-      #       the user has to take care of entirely.
-      #
-      # class << self
-      #   attr_writer :deserializer_class
-      #
-      #   def deserializer_class
-      #     return @deserializer_class if defined?(@deserializer_class)
-      #
-      #     name_inferrer = Inferrers::NameInferrer.from_controller_name(name)
-      #     @deserializer_class = name_inferrer.deserializer.safe_constantize
-      #   end
-      # end
-      #
-      # def payload
-      #   if request.raw_post.blank?
-      #     raise Errors[400], "The request body can't be empty."
-      #   end
-      #
-      #   deserialize(request.request_parameters[:data])
-      # end
-
-      def redirect_to(url, options = {})
-        status = options[:status] || 307
-        validate_url!(url)
-        validate_redirection_status!(status)
-
-        uri = URI.parse(url)
-        response.set_header('Location', uri.to_s)
-        render(nil, status: status)
-      end
-
-      def render(object, options = {})
-        status = options.delete(:status) || 200
-        renderer_options = jsonapi_params.to_h.merge(options)
-
-        body = serialize(object, renderer_options)
-        update_response(status: status, body: body)
-
-        respond!
-      end
-
-      protected
-
-      # def deserialize(data)
-      #   deserializer_class = self.class.deserializer_class
-      #   if deserializer_class.nil?
-      #     raise Errors[500], 'Could not find a deserializer class.'
-      #   end
-      #
-      #   deserializer = deserializer_class.new(data)
-      #   deserializer.to_h
-      # end
-
-      def jsonapi_params
-        @jsonapi_params ||= JsonapiParameters.new(params)
-      end
-
-      def jsonapi_renderer
-        @jsonapi_renderer ||= JsonapiRenderer.new
-      end
-
-      def serialize(object, options = {})
-        return { data: {} }.to_json if object.nil?
-
-        jsonapi_hash = jsonapi_renderer.render(object, options)
-        jsonapi_hash.to_json
-      end
-    end
-  end
-end

data/lib/shark_on_lambda/api_gateway/jsonapi_parameters.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    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
-end

data/lib/shark_on_lambda/api_gateway/jsonapi_renderer.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    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)
-        else
-          render_success(object, options)
-        end
-      end
-
-      protected
-
-      attr_reader :renderer
-
-      def active_model_error?(error)
-        return false unless defined?(::ActiveModel::Errors)
-
-        error.is_a?(::ActiveModel::Errors)
-      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)
-        renderer.render(object, options)
-      end
-
-      def renderable?(object, options)
-        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}' #{attribute_error}"
-            Errors[422].new(error_message).tap do |error|
-              error.pointer = "/data/attributes/#{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
-end

data/lib/shark_on_lambda/api_gateway/parameters.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    class Parameters
-      extend ::Forwardable
-
-      def initialize(request)
-        @params = ::HashWithIndifferentAccess.new
-        @params = @params.merge(request.request_parameters)
-        @params = @params.merge(request.query_parameters)
-        @params = @params.merge(request.path_parameters)
-      end
-
-      def_instance_delegators :@params, :[], :as_json
-    end
-  end
-end

data/lib/shark_on_lambda/api_gateway/query.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    # 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
-        @params = HashWithIndifferentAccess.new
-      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
-end

data/lib/shark_on_lambda/api_gateway/request.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    class Request
-      attr_reader :event, :context
-
-      LOCALHOST = Regexp.union([/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/,
-                                /^::1$/,
-                                /^0:0:0:0:0:0:0:1(%.*)?$/]).freeze
-
-      def initialize(event:, context:)
-        @event = event
-        @context = context
-        @headers = Headers.new
-
-        event['headers']&.each { |key, value| @headers[key] = value }
-      end
-
-      def authorization
-        @headers['authorization'] || @headers['x-authorization']
-      end
-
-      def body
-        StringIO.new(raw_post)
-      end
-
-      def content_length
-        raw_post.present? ? raw_post.bytesize : 0
-      end
-
-      def form_data?
-        raw_post.present?
-      end
-
-      # This method does not necessarily return the full path the client sent
-      # for the request: AWS API Gateway does not provide such an attribute.
-      # We therefore put together the query string using the
-      # event['multiValueQueryStringParameters'] property and return a path
-      # that is for almost all purposes equivalent to the client's request path.
-      # But keep in mind it is NOT the same!
-      def fullpath
-        return @fullpath if defined?(@fullpath)
-
-        uri = URI.parse(event['requestContext']['path'])
-        uri.query = query_string if query_string.present?
-        @fullpath = uri.to_s
-      end
-      alias original_fullpath fullpath
-
-      def headers
-        @headers.to_h
-      end
-
-      def ip
-        event['requestContext']['identity']['sourceIp']
-      end
-      alias remote_ip ip
-
-      def key?(key)
-        @headers.key?(key)
-      end
-
-      def local?
-        (LOCALHOST =~ remote_ip).present?
-      end
-
-      def media_type
-        @headers['content-type']
-      end
-
-      def method
-        event['httpMethod']
-      end
-      alias request_method method
-
-      def method_symbol
-        return nil if method.blank?
-
-        method.downcase.to_sym
-      end
-      alias request_method_symbol method_symbol
-
-      def original_url
-        hostname = event['requestContext']['domainName']
-        URI.join("https://#{hostname}", original_fullpath).to_s
-      end
-
-      def path_parameters
-        return @path_parameters if defined?(@path_parameters)
-
-        @path_parameters = HashWithIndifferentAccess.new
-        @path_parameters = @path_parameters.merge(event['pathParameters'] || {})
-      end
-
-      def query_parameters
-        return @query_parameters if defined?(@query_parameters)
-
-        # We have to jump through the Rack::Utils hoops here, because the event
-        # object from the AWS Gateway deserialises the query string in a "wrong"
-        # way, so we need to put it back together and deserialise it with
-        # Rack::Utils.parse_nested_query.
-        data = Rack::Utils.parse_nested_query(query_string)
-        @query_parameters = HashWithIndifferentAccess.new
-        @query_parameters = @query_parameters.merge(data)
-      end
-      alias GET query_parameters
-
-      def raw_post
-        return @raw_post if defined?(@raw_post)
-
-        @raw_post = event['body']
-        @raw_post = Base64.decode64(@raw_post) if event['isBase64Encoded']
-        @raw_post
-      end
-
-      def request_parameters
-        return @request_parameters if defined?(@request_parameters)
-        return {} if raw_post.blank?
-
-        data = JSON.parse(raw_post)
-        @request_parameters = HashWithIndifferentAccess.new.merge(data)
-      rescue JSON::ParserError => e
-        raise Errors[400], e.message
-      rescue StandardError
-        raise Errors[400], 'The request body must be empty or a JSON object.'
-      end
-      alias POST request_parameters
-
-      def xml_http_request?
-        (headers['x-requested-with'] =~ /XMLHttpRequest/i).present?
-      end
-      alias xhr? xml_http_request?
-
-      protected
-
-      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
-    end
-  end
-end

data/lib/shark_on_lambda/api_gateway/response.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    class Response
-      attr_accessor :body, :charset, :content_type
-      attr_reader :headers
-      attr_writer :status
-
-      STATUS_WITH_NO_ENTITY_BODY = ((100..199).to_a + [204, 304]).freeze
-
-      def self.default_charset
-        'utf-8'
-      end
-
-      def self.default_content_type
-        'application/vnd.api+json'
-      end
-
-      def initialize(headers: nil)
-        @body = nil
-        @charset = self.class.default_charset
-        @content_type = self.class.default_content_type
-        @headers = headers || Headers.new
-        @headers['content-type'] = self.class.default_content_type
-        @status = 200
-      end
-
-      def delete_header(key)
-        @headers.delete(key)
-      end
-
-      def get_header(key)
-        @headers[key]
-      end
-
-      # rubocop:disable Naming/PredicateName
-      def has_header?(key)
-        @headers.key?(key)
-      end
-      # rubocop:enable Naming/PredicateName
-
-      def message
-        ::Rack::Utils::HTTP_STATUS_CODES[response_code]
-      end
-      alias status_message message
-
-      def response_code
-        @status
-      end
-
-      def set_header(key, value)
-        @headers[key] = value
-      end
-
-      def to_h
-        {
-          statusCode: response_status_code,
-          headers: headers.to_h,
-          body: response_body
-        }
-      end
-
-      protected
-
-      def response_status_code
-        return response_code.to_i if response_body.present?
-        return 204 if (200..299).cover?(response_code.to_i)
-        return 304 if (300..399).cover?(response_code.to_i)
-
-        response_code.to_i
-      end
-
-      def response_body
-        return if STATUS_WITH_NO_ENTITY_BODY.include?(response_code)
-        return if body.blank?
-
-        body.is_a?(String) ? body : body.to_json
-      end
-    end
-  end
-end

data/lib/shark_on_lambda/api_gateway/serializers/base_error_serializer.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module ApiGateway
-    module Errors
-      class BaseSerializer < ::JSONAPI::Serializable::Error
-        id { @object.id }
-        status { @object.status }
-        code { @object.code }
-        title { @object.title }
-        detail { @object.detail }
-        meta { @object.meta }
-        source do
-          pointer @object.pointer if @object.pointer.present?
-          parameter @object.parameter if @object.parameter.present?
-        end
-      end
-    end
-  end
-end

data/lib/shark_on_lambda/concerns/filter_actions.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module Concerns
-    module FilterActions
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def after_action(symbol, only: [], except: [])
-          @after_actions ||= []
-          @after_actions << {
-            symbol: symbol,
-            only: Array(only),
-            except: Array(except)
-          }
-        end
-
-        def after_actions
-          collect_from_ancestors(:after_actions) + Array(@after_actions)
-        end
-
-        def before_action(symbol, only: [], except: [])
-          @before_actions ||= []
-          @before_actions << {
-            symbol: symbol,
-            only: Array(only),
-            except: Array(except)
-          }
-        end
-
-        def before_actions
-          collect_from_ancestors(:before_actions) + Array(@before_actions)
-        end
-
-        private
-
-        def collect_from_ancestors(method)
-          ancestors_without_self = ancestors[1..-1]
-          return [] if ancestors_without_self.empty?
-
-          ancestors_without_self.map! { |ancestor| ancestor.try(method) }
-          ancestors_without_self.compact!
-          ancestors_without_self.reduce([], &:+)
-        end
-      end
-
-      def call_with_filter_actions(method, *args)
-        run_before_actions(method)
-        result = send(method, *args)
-        run_after_actions(method)
-        result
-      end
-
-      protected
-
-      def after_actions
-        self.class.after_actions
-      end
-
-      def before_actions
-        self.class.before_actions
-      end
-
-      def run_actions(method, actions)
-        actions.each do |action|
-          next if skip_filter_action?(method, action)
-
-          send(action[:symbol])
-        end
-      end
-
-      def run_after_actions(method)
-        run_actions(method, after_actions)
-      end
-
-      def run_before_actions(method)
-        run_actions(method, before_actions)
-      end
-
-      def skip_filter_action?(method, filter_action)
-        only = filter_action[:only]
-        except = filter_action[:except]
-
-        return true if only.any? && !only.include?(method)
-        return true if except.any? && except.include?(method)
-
-        false
-      end
-    end
-  end
-end