infinum_json_api_setup 0.0.3

data/lib/infinum_json_api_setup/json_api/content_negotiation.rb

@@ -0,0 +1,29 @@
+module InfinumJsonApiSetup
+  module JsonApi
+    module ContentNegotiation
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :validate_jsonapi_request
+      end
+
+      def validate_jsonapi_request
+        if !acceptable?
+          head :not_acceptable
+        elsif !valid_content_type?
+          head :unsupported_media_type
+        end
+      end
+
+      def valid_content_type?
+        return true if request.body.size.zero?
+
+        request.content_type == Mime.fetch(:json_api)
+      end
+
+      def acceptable?
+        request.accept&.split(',')&.include?(Mime.fetch(:json_api))
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/json_api/error_handling.rb

@@ -0,0 +1,49 @@
+module InfinumJsonApiSetup
+  module JsonApi
+    module ErrorHandling
+      extend ActiveSupport::Concern
+
+      included do # rubocop:disable Metrics/BlockLength
+        rescue_from ActionController::ParameterMissing do |e|
+          message = e.to_s.split("\n").first
+          render_error(InfinumJsonApiSetup::Error::BadRequest.new(message: message))
+        end
+
+        rescue_from ActiveRecord::RecordNotFound do
+          render_error(InfinumJsonApiSetup::Error::RecordNotFound.new)
+        end
+
+        if defined?(Pundit)
+          rescue_from Pundit::NotAuthorizedError do
+            render_error(InfinumJsonApiSetup::Error::Forbidden.new)
+          end
+        end
+
+        if defined?(Jsonapi::QueryBuilder)
+          rescue_from Jsonapi::QueryBuilder::Mixins::Sort::UnpermittedSortParameters do |e|
+            Bugsnag.notify(e)
+            render_error(InfinumJsonApiSetup::Error::BadRequest.new(message: e.to_s))
+          end
+        end
+
+        # we don't want to expose internal details to API consumer
+        rescue_from PG::Error do |e|
+          Bugsnag.notify(e)
+          render_error(InfinumJsonApiSetup::Error::InternalServerError.new)
+        end
+
+        rescue_from I18n::InvalidLocale do |e|
+          render_error(InfinumJsonApiSetup::Error::BadRequest.new(message: e.to_s))
+        end
+
+        rescue_from ActionDispatch::Http::Parameters::ParseError do |e|
+          render_error(InfinumJsonApiSetup::Error::BadRequest.new(message: e.to_s))
+        end
+      end
+
+      def render_error(error)
+        render json_api: error, status: error.http_status
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/json_api/error_serializer.rb

@@ -0,0 +1,72 @@
+module InfinumJsonApiSetup
+  module JsonApi
+    class ErrorSerializer
+      # @return [Object]
+      attr_reader :error
+
+      # @return [String]
+      delegate :details, to: :error
+
+      # @param [Object]
+      def initialize(error)
+        @error = error
+      end
+
+      # @param [String]
+      def serialized_json
+        ActiveSupport::JSON.encode(serializable_hash)
+      end
+
+      # @param [Hash]
+      def serializable_hash
+        {}.tap do |hash|
+          hash[:errors] =
+            error.details.is_a?(Array) ? serialize_error_array : serialize_error_message
+        end
+      end
+
+      private
+
+      def serialize_error_array
+        details.map do |attribute, message|
+          {
+            status: error.http_status.to_s.humanize(capitalize: false),
+            code: error.code,
+            title: I18n.t("json_api.errors.#{error.http_status}.title"),
+            detail: message,
+            source: serialize_source(attribute)
+          }
+        end
+      end
+
+      def serialize_source(attribute)
+        # examples:
+        #   'attribute_name'.match(/(?:(.+)\.)?([^.]+\z)/).to_a
+        #   # => ["attribute_name", nil, "attribute_name"]
+        #   'relationship.attribute_name'.match(/(?:(.+)\.)?([^.]+\z)/).to_a
+        #   # => ["relationship.attribute_name", "relationship", "attribute_name"]
+        parameter, relationship, attribute = attribute.match(/(?:(.+)\.)?([^.]+\z)/).to_a
+
+        {}.tap do |hash|
+          hash[:parameter] = parameter
+          hash[:pointer] = if relationship
+                             "data/attributes/#{relationship}_attributes/#{attribute}"
+                           else
+                             "data/attributes/#{attribute}"
+                           end
+        end
+      end
+
+      def serialize_error_message
+        [
+          {
+            status: error.http_status.to_s.humanize(capitalize: false),
+            code: error.code,
+            title: I18n.t("json_api.errors.#{error.http_status}.title"),
+            detail: details
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/json_api/request_parsing.rb

@@ -0,0 +1,17 @@
+module InfinumJsonApiSetup
+  module JsonApi
+    module RequestParsing
+      def relationship_children_ids(type)
+        data_params.filter_map do |p|
+          next if p[:type] != type
+
+          p[:id].to_i
+        end.uniq
+      end
+
+      def data_params
+        params.to_unsafe_hash[:data]
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/json_api/responder.rb

@@ -0,0 +1,31 @@
+module InfinumJsonApiSetup
+  module JsonApi
+    class Responder < ActionController::Responder
+      def to_json_api
+        if !get? && has_errors?
+          display_errors
+        else
+          display_resource
+        end
+      end
+
+      private
+
+      def display_resource
+        if get? || patch? || put?
+          display resource
+        elsif post?
+          display resource, status: :created
+        elsif delete?
+          head :no_content
+        else
+          raise 'respond_with should be used only for standard REST CRUD actions'
+        end
+      end
+
+      def json_api_resource_errors
+        InfinumJsonApiSetup::Error::UnprocessableEntity.new(object: resource)
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/json_api/serializer_options.rb

@@ -0,0 +1,76 @@
+module InfinumJsonApiSetup
+  module JsonApi
+    class SerializerOptions
+      # @param [Hash] opts
+      # @option opts [Hash] :params
+      # @option opts [Object] :pagination_details
+      def initialize(params:, pagination_details:)
+        @params = params
+        @pagination_details = pagination_details
+      end
+
+      # @return [Hash]
+      def build
+        {
+          meta: meta,
+          links: links,
+          fields: fields,
+          include: include
+        }.compact
+      end
+
+      private
+
+      attr_reader :params
+      attr_reader :pagination_details
+
+      def meta
+        return {} unless pagination_details
+
+        {
+          current_page: pagination_details.page,
+          total_pages: pagination_details.pages,
+          total_count: pagination_details.count,
+          padding: pagination_details.vars.fetch(:outset).to_i,
+          page_size: pagination_details.vars.fetch(:items).to_i,
+          max_page_size: Pagy::VARS[:max_items]
+        }
+      end
+
+      def links
+        return {} unless pagination_details
+
+        {
+          self: build_link(pagination_details.page),
+          first: build_link(1),
+          last: build_link(pagination_details.last),
+          prev: build_link(pagination_details.prev),
+          next: build_link(pagination_details.next)
+        }.compact
+      end
+
+      def build_link(page)
+        return unless page
+
+        link_params = params.deep_dup
+        link_params[:page] = {
+          number: page,
+          size: pagination_details.vars.fetch(:items),
+          padding: pagination_details.vars.fetch(:outset)
+        }.compact
+
+        Rails.application.routes.url_helpers.url_for(link_params)
+      end
+
+      def fields
+        return nil unless params[:fields]
+
+        params[:fields].transform_values { |fields| fields.split(',') }
+      end
+
+      def include
+        params[:include]&.split(',')
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rails.rb

@@ -0,0 +1,28 @@
+Mime::Type.register('application/vnd.api+json', :json_api)
+
+ActionDispatch::Request.parameter_parsers[:json_api] = lambda do |body|
+  ActiveSupport::JSON.decode(body)
+end
+
+ActiveSupport.on_load(:action_controller) do
+  ActionController::Renderers.add(:json_api) do |resources, opts|
+    # Renderer proc is evaluated in the controller context.
+    self.content_type ||= Mime[:json_api]
+
+    ActiveSupport::Notifications.instrument('render.json_api', resources: resources, opts: opts) do
+      if resources.is_a?(InfinumJsonApiSetup::Error::Base)
+        break InfinumJsonApiSetup::JsonApi::ErrorSerializer.new(resources).serialized_json
+      end
+      break if opts[:status] == 204
+
+      serializer = opts.delete(:serializer) do
+        "#{controller_path.classify.pluralize}::Serializer".constantize
+      end
+      options = InfinumJsonApiSetup::JsonApi::SerializerOptions.new(
+        params: params.to_unsafe_h, pagination_details: opts[:pagination_details]
+      ).build
+
+      serializer.new(resources, options.merge(opts)).serializable_hash.to_json
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/helpers/request_helper.rb

@@ -0,0 +1,80 @@
+module InfinumJsonApiSetup
+  module Rspec
+    module Helpers
+      module RequestHelper
+        def default_headers
+          {
+            'content-type' => 'application/vnd.api+json',
+            'accept' => 'application/vnd.api+json'
+          }
+        end
+
+        def json_api_relationships_request_body(relationships)
+          json_api_relationship_data(relationships).to_json
+        end
+
+        def json_api_request_body(type:, attributes: {}, relationships: {}, included: [], **options)
+          {}.tap do |body|
+            body[:data] = _data_params(type, attributes, relationships, **options)
+            body[:included] = _included_params(included).presence
+          end.merge(options).compact.to_json
+        end
+
+        def _data_params(type, attributes, relationships, **options)
+          attributes = attributes.with_indifferent_access
+
+          {
+            type: type,
+            id: attributes.delete(:id).to_s,
+            attributes: attributes.presence,
+            relationships: _relationships_params(relationships).presence
+          }.merge(options).compact
+        end
+
+        def _included_params(resources)
+          resources.reject do |resource|
+            resource[:attributes].blank? && resource[:relationships].blank?
+          end
+        end
+
+        def _relationships_params(relationships)
+          relationships.transform_values do |relationship|
+            json_api_relationship_data(relationship)
+          end
+        end
+
+        def json_api_relationship_data(relationship)
+          {
+            data: case relationship
+                  when Array then relationship.map { |rel| rel.slice(:id, :type) }
+                  when Hash then relationship.slice(:id, :type)
+                  when NilClass then nil
+                  else raise ArgumentError 'relationship must be either an array or hash'
+                  end
+          }
+        end
+
+        def json_api_relationship(resource, type: nil)
+          if resource.is_a?(Array)
+            type = type.presence || _detect_resource_type(resource.first)
+            resource.map { |item| json_api_relationship_hash(item.id, type) }
+          else
+            type = type.presence || _detect_resource_type(resource)
+            json_api_relationship_hash(resource.id, type)
+          end
+        end
+
+        def json_api_relationship_hash(id, type)
+          {
+            id: id.to_s,
+            type: type
+          }
+        end
+
+        def _detect_resource_type(resource)
+          resource.class.name.parameterize.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/helpers/response_helper.rb

@@ -0,0 +1,56 @@
+module InfinumJsonApiSetup
+  module Rspec
+    module Helpers
+      module ResponseHelper
+        def json_response
+          JSON.parse(response.body, symbolize_names: true)
+        end
+
+        def response_item
+          raise 'json response is not an item' if json_response[:data].is_a?(Array)
+
+          OpenStruct.new(json_response[:data][:attributes])
+        end
+
+        def response_collection
+          raise 'json response is not a collection' unless json_response[:data].is_a?(Array)
+
+          json_response[:data].map do |item|
+            OpenStruct.new(id: item[:id], type: item[:type], **item[:attributes])
+          end
+        end
+
+        def response_relationships(response_type: :item)
+          case response_type
+          when :item then json_response.dig(:data, :relationships)
+          when :collection then json_response[:data].pluck(:relationships)
+          else raise ArgumentError ':response_type must be one of [:item, :collection]'
+          end
+        end
+
+        def response_meta
+          json_response[:meta]
+        end
+
+        def response_included
+          json_response[:included].map do |item|
+            OpenStruct.new(id: item[:id], type: item[:type], **item[:attributes])
+          end
+        end
+
+        def response_included_relationship(name)
+          data = response_relationships.fetch(name)[:data]
+
+          return if data.nil?
+
+          relationship_id, relationship_type =
+            response_relationships.fetch(name)[:data].values_at(:id, :type)
+
+          response_included.find do |object|
+            object.id == relationship_id && object.type == relationship_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/have_empty_data.rb

@@ -0,0 +1,32 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::HaveEmptyData]
+      def have_empty_data # rubocop:disable Naming/PredicateName
+        HaveEmptyData.new
+      end
+
+      class HaveEmptyData < JsonBodyMatcher
+        def initialize
+          super(Matchers::Util::BodyParser.new('data'))
+        end
+
+        private
+
+        attr_reader :data
+
+        def body_matches?
+          data.empty?
+        end
+
+        def match_failure_message
+          "Expected response data(#{data}) to be empty, but isn't"
+        end
+
+        def process_parsing_result(data)
+          @data = data
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/have_error_pointer.rb

@@ -0,0 +1,37 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @param [String] pointer
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::HaveErrorPointer]
+      def have_error_pointer(pointer) # rubocop:disable Naming/PredicateName
+        HaveErrorPointer.new(pointer)
+      end
+
+      class HaveErrorPointer < JsonBodyMatcher
+        # @param [String] pointer
+        def initialize(pointer)
+          super(Matchers::Util::BodyParser.new('errors'))
+
+          @pointer = pointer
+        end
+
+        private
+
+        attr_reader :pointer
+        attr_reader :errors
+
+        def body_matches?
+          errors.any? { |error| error.dig('source', 'pointer') == pointer }
+        end
+
+        def match_failure_message
+          "Expected error pointers to include '#{pointer}', but didn't"
+        end
+
+        def process_parsing_result(result)
+          @errors = result
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/have_resource_count_of.rb

@@ -0,0 +1,37 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @param [Integer] expected_count
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::HaveResourceCountOf]
+      def have_resource_count_of(expected_count) # rubocop:disable Naming/PredicateName
+        HaveResourceCountOf.new(expected_count)
+      end
+
+      class HaveResourceCountOf < JsonBodyMatcher
+        # @param [Integer] expected_count
+        def initialize(expected_count)
+          super(Matchers::Util::BodyParser.new('data'))
+
+          @expected_count = expected_count
+        end
+
+        private
+
+        attr_reader :data
+        attr_reader :expected_count
+
+        def body_matches?
+          data.length == expected_count
+        end
+
+        def match_failure_message
+          "Expected response data to have #{expected_count} items, but had #{data.length}"
+        end
+
+        def process_parsing_result(data)
+          @data = data
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/include_all_resource_ids.rb

@@ -0,0 +1,51 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @param [Array<Integer>] required_ids
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::IncludeAllResourceIds]
+      def include_all_resource_ids(required_ids)
+        IncludeAllResourceIds.new(required_ids)
+      end
+
+      class IncludeAllResourceIds < JsonBodyMatcher
+        # @param [Array<Integer>] required_ids
+        def initialize(required_ids)
+          super(Matchers::Util::BodyParser.new('data'))
+
+          @required_ids = process_required_ids(required_ids)
+        end
+
+        private
+
+        attr_reader :actual_ids
+        attr_reader :required_ids
+
+        def body_matches?
+          actual_ids == required_ids
+        end
+
+        def match_failure_message
+          "Expected response ID's(#{actual_ids}) to match #{required_ids}"
+        end
+
+        def process_parsing_result(data)
+          @actual_ids = process_actual_ids(
+            data.map { |item| process_actual_id(item['id']) }
+          )
+        end
+
+        def process_required_ids(ids)
+          ids.sort
+        end
+
+        def process_actual_id(value)
+          value.to_i
+        end
+
+        def process_actual_ids(ids)
+          ids.sort
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/include_all_resource_ids_sorted.rb

@@ -0,0 +1,21 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @param [Array<Integer>] required_ids
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::IncludeAllResourceIdsSorted]
+      def include_all_resource_ids_sorted(required_ids)
+        IncludeAllResourceIdsSorted.new(required_ids)
+      end
+
+      class IncludeAllResourceIdsSorted < IncludeAllResourceIds
+        def process_required_ids(ids)
+          ids
+        end
+
+        def process_actual_ids(ids)
+          ids
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/include_all_resource_string_ids.rb

@@ -0,0 +1,17 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @param [Array<Integer>] required_ids
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::IncludeAllResourceStringIds]
+      def include_all_resource_string_ids(required_ids)
+        IncludeAllResourceStringIds.new(required_ids)
+      end
+
+      class IncludeAllResourceStringIds < IncludeAllResourceIds
+        def process_actual_id(id)
+          id
+        end
+      end
+    end
+  end
+end

data/lib/infinum_json_api_setup/rspec/matchers/include_error_detail.rb

@@ -0,0 +1,37 @@
+module InfinumJsonApiSetup
+  module RSpec
+    module Matchers
+      # @param [String] error_detail
+      # @return [InfinumJsonApiSetup::Rspec::Matchers::IncludeErrorDetail]
+      def include_error_detail(error_detail)
+        IncludeErrorDetail.new(error_detail)
+      end
+
+      class IncludeErrorDetail < JsonBodyMatcher
+        # @param [String] error_detail
+        def initialize(error_detail)
+          super(Matchers::Util::BodyParser.new('errors'))
+
+          @error_detail = error_detail
+        end
+
+        private
+
+        attr_reader :error_detail
+        attr_reader :errors
+
+        def body_matches?
+          errors.any? { |error| error['detail'].include?(error_detail) }
+        end
+
+        def match_failure_message
+          "Expected error details to include '#{error_detail}', but didn't"
+        end
+
+        def process_parsing_result(result)
+          @errors = result
+        end
+      end
+    end
+  end
+end