shark-on-lambda 0.0.0 → 0.6.7

data/lib/shark_on_lambda/api_gateway/jsonapi_parameters.rb

@@ -0,0 +1,68 @@
+# 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

@@ -0,0 +1,105 @@
+# 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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,69 @@
+# 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.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

@@ -0,0 +1,148 @@
+# 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

@@ -0,0 +1,82 @@
+# 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