simple_jsonapi_rails 1.0.0

data/lib/simple_jsonapi/rails/action_controller/jsonapi_helper.rb

@@ -0,0 +1,122 @@
+require 'simple_jsonapi/rails/action_controller/request_validator'
+
+module SimpleJsonapi
+  module Rails
+    module ActionController
+      class JsonapiHelper
+        attr_reader :controller, :pointers, :request_validator
+
+        delegate :params, :render, :request, :head, to: :controller, allow_nil: true
+
+        def initialize(controller)
+          @controller = controller
+          @pointers = {}
+          @request_validator = RequestValidator.new(request, params)
+        end
+
+        def include_params
+          params[:include].to_s.split(/,/).presence
+        end
+
+        def fields_params
+          (params[:fields] || {}).transform_values { |f| f.split(/,/) }
+        end
+
+        def filter_param(param_name)
+          (params[:filter] || {})[param_name]
+        end
+
+        def filter_param_list(param_name)
+          param_value = filter_param(param_name)
+          return nil unless param_value
+
+          param_value.split(/,/)
+        end
+
+        def sort_related_params
+          (params[:sort_related] || {}).transform_values { |f| f.split(/,/) }
+        end
+
+        # @param error [ActiveRecord::RecordNotFound]
+        def render_record_not_found(error)
+          render jsonapi_errors: error, status: :not_found
+        end
+
+        def render_model_errors(model)
+          errors = SimpleJsonapi::Errors::ActiveModelError.from_errors(model.errors, pointers)
+          render jsonapi_errors: errors, status: :unprocessable_entity
+        end
+
+        def render_bad_request(message)
+          error = SimpleJsonapi::Errors::BadRequest.new(detail: message)
+          render jsonapi_errors: [error], status: :bad_request
+        end
+
+        # private
+
+        # def url_helpers
+        #   ::Rails.application.routes.url_helpers
+        # end
+
+        def deserialize(jsonapi_data)
+          jsonapi_hash = case jsonapi_data
+          when String then JSON.parse(jsonapi_data).deep_symbolize_keys
+          when Hash then jsonapi_data.deep_symbolize_keys
+          else jsonapi_data
+          end
+
+          data = jsonapi_hash[:data]
+          return unless data
+
+          result = {}
+          pointers = {}
+
+          result[:type] = data[:type]
+          result[:id] = data[:id]
+          pointers[:type] = "/data/type"
+          pointers[:id] = "/data/id"
+
+          if data[:attributes].present?
+            data[:attributes].each do |name, value|
+              result[name] = value
+              pointers[name] = "/data/attributes/#{name}"
+            end
+          end
+
+          if data[:relationships].present?
+            data[:relationships].each do |name, value|
+              related_data = value[:data]
+
+              if related_data.is_a?(Array)
+                singular_name = name.to_s.singularize
+                result[:"#{singular_name}_types"] = related_data.pluck(:type)
+                result[:"#{singular_name}_ids"] = related_data.pluck(:id)
+                pointers[:"#{singular_name}_types"] = "/data/relationships/#{name}"
+                pointers[:"#{name}_ids"] = "/data/relationships/#{name}"
+              elsif related_data.is_a?(Hash)
+                result[:"#{name}_type"] = related_data[:type]
+                result[:"#{name}_id"] = related_data[:id]
+                pointers[:"#{name}_type"] = "/data/relationships/#{name}"
+                pointers[:"#{name}_id"] = "/data/relationships/#{name}"
+              end
+            end
+          end
+
+          @pointers = pointers
+          result
+        end
+
+        def validate_jsonapi_request_headers
+          return head :unsupported_media_type unless request_validator.valid_content_type_header?
+          head :not_acceptable unless request_validator.valid_accept_header?
+        end
+
+        def validate_jsonapi_request_body
+          unless request_validator.valid_request_body?
+            raise InvalidJsonStructureError, "Not a valid jsonapi request body"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/rails/action_controller/request_validator.rb

@@ -0,0 +1,40 @@
+module SimpleJsonapi
+  module Rails
+    module ActionController
+      class RequestValidator
+        attr_reader :request, :params
+
+        delegate :body, :content_type, :accept, :path, to: :request, prefix: true
+
+        def initialize(request, params)
+          @request = request
+          @params = params
+        end
+
+        def valid_content_type_header?
+          !request_has_body? || request_content_type == SimpleJsonapi::MIME_TYPE
+        end
+
+        def valid_accept_header?
+          request_accept.blank? || request_accept == SimpleJsonapi::MIME_TYPE
+        end
+
+        def valid_request_body?
+          return true unless request_has_body?
+
+          params["data"].present? && valid_relationship_body?
+        end
+
+        def valid_relationship_body?
+          request_path.exclude?("relationships") || params["data"]&.is_a?(Array)
+        end
+
+        private
+
+        def request_has_body?
+          request_body.size > 0
+        end
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/rails/action_controller.rb

@@ -0,0 +1,44 @@
+module SimpleJsonapi
+  module Rails
+    module ActionController
+      extend ActiveSupport::Concern
+
+      delegate :validate_jsonapi_request_headers, :validate_jsonapi_request_body, to: :jsonapi
+
+      included do
+        before_action :validate_jsonapi_request_headers
+        before_action :validate_jsonapi_request_body
+
+        rescue_from ActiveRecord::RecordNotFound do |err|
+          jsonapi.render_record_not_found(err)
+        end
+
+        rescue_from ActiveRecord::RecordInvalid do |err|
+          jsonapi.render_model_errors(err.record)
+        end
+
+        rescue_from ActiveRecord::RecordNotSaved do |err|
+          jsonapi.render_model_errors(err.model)
+        end
+
+        rescue_from InvalidJsonStructureError do |err|
+          jsonapi.render_bad_request(err.message)
+        end
+      end
+
+      class_methods do
+        def jsonapi_deserialize(param_key, options = {})
+          prepend_before_action(options) do
+            if request.raw_post.present?
+              params[param_key] = jsonapi.deserialize(request.request_parameters)
+            end
+          end
+        end
+      end
+
+      def jsonapi
+        @jsonapi ||= SimpleJsonapi::Rails::ActionController::JsonapiHelper.new(self)
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/rails/extensions/routing.rb

@@ -0,0 +1,57 @@
+module SimpleJsonapi
+  module Extensions
+    module Routing
+      ACTION_MAP = {
+        add: :create,
+        remove: :destroy,
+        replace: :update,
+      }.freeze
+
+      SUPPORTED_TO_MANY_ACTIONS = ACTION_MAP.keys.freeze
+
+      def jsonapi_to_one_relationship(member_name, association)
+        jsonapi_relationship([:replace], member_name, association)
+      end
+
+      def jsonapi_to_many_relationship(member_name, association, only: nil, except: nil)
+        jsonapi_relationship(to_many_actions_to_define(only, except), member_name, association)
+      end
+
+      private
+
+      def jsonapi_relationship(actions, member_name, association)
+        member do
+          scope as: member_name, module: member_name.to_s.pluralize do
+            namespace "relationships" do
+              actions.each do |action|
+                resource association, only: [ACTION_MAP[action]], action: action
+              end
+            end
+          end
+        end
+      end
+
+      def to_many_actions_to_define(only, except)
+        actions = if only
+                    Array(only)
+                  elsif except
+                    SUPPORTED_TO_MANY_ACTIONS - Array(except)
+                  else
+                    SUPPORTED_TO_MANY_ACTIONS
+                  end
+
+        ensure_actions_supported(actions)
+
+        actions
+      end
+
+      def ensure_actions_supported(actions)
+        if actions.any? { |action| SUPPORTED_TO_MANY_ACTIONS.exclude?(action) }
+          raise ArgumentError, "#jsonapi_to_many_relationship supports :add, :remove, and :replace actions"
+        end
+      end
+    end
+
+    ActionDispatch::Routing::Mapper.include(SimpleJsonapi::Extensions::Routing)
+  end
+end

data/lib/simple_jsonapi/rails/extensions.rb

@@ -0,0 +1,13 @@
+module SimpleJsonapi
+  module Rails
+    module RouteHelpers
+      private
+
+      def routes
+        ::Rails.application.routes.url_helpers
+      end
+    end
+
+    SimpleJsonapi::Serializer.include(RouteHelpers)
+  end
+end

data/lib/simple_jsonapi/rails/railtie.rb

@@ -0,0 +1,34 @@
+require 'rails/railtie'
+
+module SimpleJsonapi
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer 'simple_jsonapi_rails.initialize' do
+        Mime::Type.register(SimpleJsonapi::MIME_TYPE, :jsonapi)
+
+        ActiveSupport.on_load(:action_controller) do
+          ::ActionDispatch::Request.parameter_parsers[:jsonapi] = ->(raw_post) do
+            ActiveSupport::JSON.decode(raw_post)
+          end
+
+          # In the renderers, `self` is the controller
+
+          ::ActionController::Renderers.add(:jsonapi_resource) do |resource, options|
+            self.content_type ||= Mime[:jsonapi]
+            SimpleJsonapi.render_resource(resource, options).to_json
+          end
+
+          ::ActionController::Renderers.add(:jsonapi_resources) do |resources, options|
+            self.content_type ||= Mime[:jsonapi]
+            SimpleJsonapi.render_resources(resources, options).to_json
+          end
+
+          ::ActionController::Renderers.add(:jsonapi_errors) do |errors, options|
+            self.content_type ||= Mime[:jsonapi]
+            SimpleJsonapi.render_errors(errors, options).to_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/rails/test_helpers.rb

@@ -0,0 +1,20 @@
+# SimpleJsonapi::Rails::Railtie.initializers.each(&:run)
+
+# Work-around for rack-test/rack-test#200. Remove once that issue is resolved.
+module PatchRackTestDeleteRequests
+  def request(uri, env = {}, &block)
+    if env[:method] == :delete && env["HTTP_ACCEPT"] == SimpleJsonapi::MIME_TYPE && JSON.parse(env[:params]).present?
+      env[:input] = env[:params]
+    end
+
+    super(uri, env, &block)
+  end
+end
+
+Rack::Test::Session.prepend(PatchRackTestDeleteRequests)
+
+ActiveSupport.on_load(:action_controller) do
+  ActionDispatch::IntegrationTest.register_encoder :jsonapi,
+    param_encoder:   ->(params) { params.to_json },
+    response_parser: ->(body) { JSON.parse(body) }
+end

data/lib/simple_jsonapi/rails/version.rb

@@ -0,0 +1,5 @@
+module SimpleJsonapi
+  module Rails
+    VERSION = '1.0.0'.freeze
+  end
+end

data/lib/simple_jsonapi/rails.rb

@@ -0,0 +1,13 @@
+require 'active_support'
+
+require 'simple_jsonapi'
+
+require 'simple_jsonapi/rails/extensions'
+require 'simple_jsonapi/rails/extensions/routing'
+require 'simple_jsonapi/rails/action_controller'
+require 'simple_jsonapi/rails/action_controller/jsonapi_helper'
+require 'simple_jsonapi/rails/railtie'
+
+require 'simple_jsonapi/errors/active_record/record_not_found_serializer'
+require 'simple_jsonapi/errors/active_model_error'
+require 'simple_jsonapi/errors/active_model_error_serializer'

data/lib/simple_jsonapi_rails.rb

@@ -0,0 +1,4 @@
+require 'simple_jsonapi/rails'
+
+module SimpleJsonapi::Rails
+end

data/simple_jsonapi_rails.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'simple_jsonapi/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'simple_jsonapi_rails'
+  spec.version       = SimpleJsonapi::Rails::VERSION
+  spec.license       = "MIT"
+  spec.authors       = ['PatientsLikeMe']
+  spec.email         = ['engineers@patientslikeme.com']
+  spec.homepage      = 'https://www.patientslikeme.com'
+
+  spec.summary       = 'A library for integrating SimpleJsonapi into a Rails application.'
+  spec.description   = 'A library for integrating SimpleJsonapi into a Rails application.'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'simple_jsonapi'
+  spec.add_runtime_dependency 'rails', '>= 4.2', '< 6.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'listen'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'will_paginate'
+  spec.add_development_dependency 'yard'
+end

data/test/action_controller_test.rb

@@ -0,0 +1,299 @@
+require_relative 'test_helper'
+
+class ActionControllerTest < ActionDispatch::IntegrationTest
+  before do
+    @controller = OrdersController.new
+    @routes = Dummy::Application.routes
+  end
+
+  let(:order) { create_order }
+  let(:response_json) { response.parsed_body }
+
+  def create_order
+    Order.create!(customer_name: "Customer X", date: Date.today)
+  end
+
+  describe "ActionController" do
+    describe "basic get" do
+      it "gets a collection of resources without parameters" do
+        2.times { create_order }
+
+        get orders_url, as: :jsonapi
+        assert_equal %w[data], response_json.keys
+        assert_equal(%w[orders orders], response_json["data"].map { |o| o["type"] })
+      end
+
+      it "gets a single resource without parameters" do
+        get order_path(order), as: :jsonapi
+        assert_equal %w[data], response_json.keys
+        assert_equal "orders", response_json.dig("data", "type")
+        assert_equal order.id.to_s, response_json.dig("data", "id")
+      end
+    end
+
+    describe "include parameter" do
+      it "splits a comma-delimited value" do
+        get orders_url(include: "this,that"), as: :jsonapi
+        assert_equal %w[this that], @controller.jsonapi.include_params
+      end
+
+      it "defaults to nil" do
+        get orders_url, as: :jsonapi
+        assert_nil @controller.jsonapi.include_params
+      end
+    end
+
+    describe "fields parameter" do
+      it "splits comma-delimited values" do
+        input = {
+          orders: "customer_name",
+          line_items: "product_name,quantity",
+        }
+        expected_output = {
+          "orders" => %w[customer_name],
+          "line_items" => %w[product_name quantity],
+        }
+
+        get orders_url(fields: input), as: :jsonapi
+
+        assert_equal expected_output, @controller.jsonapi.fields_params.to_unsafe_h
+      end
+
+      it "defaults to an empty hash" do
+        get orders_url, as: :jsonapi
+        assert_equal({}, @controller.jsonapi.fields_params)
+      end
+    end
+
+    describe "filter_param" do
+      it "fetches the parameter value" do
+        get orders_url("filter[this]" => "that"), as: :jsonapi
+
+        assert_equal "that", @controller.jsonapi.filter_param(:this)
+      end
+    end
+
+    describe "filter_param_list" do
+      it "splits a comma-delimited string" do
+        get orders_url("filter[these]" => "that,those"), as: :jsonapi
+
+        assert_equal %w[that those], @controller.jsonapi.filter_param_list(:these)
+      end
+
+      it "returns a simple string as an array" do
+        get orders_url("filter[this]" => "that"), as: :jsonapi
+
+        assert_equal %w[that], @controller.jsonapi.filter_param_list(:this)
+      end
+    end
+
+    describe "sort_related parameter" do
+      it "splits comma-delimited values" do
+        input = {
+          orders: "customer_name",
+          line_items: "product_name,quantity",
+        }
+        expected_output = {
+          "orders" => %w[customer_name],
+          "line_items" => %w[product_name quantity],
+        }
+
+        get orders_url(sort_related: input), as: :jsonapi
+
+        assert_equal expected_output, @controller.jsonapi.sort_related_params.to_unsafe_h
+      end
+
+      it "defaults to an empty hash" do
+        get orders_url, as: :jsonapi
+        assert_equal({}, @controller.jsonapi.fields_params)
+      end
+    end
+
+    describe "jsonapi_deserialize" do
+      let(:request_json) { request_hash.to_json }
+      let(:request_hash) do
+        {
+          data: {
+            type: "orders",
+            id: "1",
+            attributes: {
+              customer_name: "Jose",
+              date: "2017-10-01",
+            },
+            relationships: {
+              customer: {
+                data: { type: "customers", id: "11" },
+              },
+              products: {
+                data: [
+                  { type: "products", id: "21" },
+                  { type: "widgets", id: "22" },
+                ],
+              },
+            },
+          },
+        }
+      end
+
+      let(:helper) { SimpleJsonapi::Rails::ActionController::JsonapiHelper.new(nil) }
+      let(:deserialized) { helper.deserialize(request_hash) }
+
+      it "parses the request body" do
+        post orders_url, params: request_hash, as: :jsonapi
+        assert_response :created
+        assert_instance_of ActionController::Parameters, @controller.params[:order]
+        assert_equal "orders", @controller.params.dig(:order, :type)
+        assert_equal "1", @controller.params.dig(:order, :id)
+      end
+
+      it "is a no-op if there's no request body" do
+        2.times { create_order }
+
+        get orders_url, as: :jsonapi
+        assert_response :ok
+        assert_nil @controller.params[:order]
+      end
+
+      it "moves the type and id to the object param" do
+        assert_equal "orders", deserialized[:type]
+        assert_equal "1", deserialized[:id]
+      end
+
+      it "moves the attributes to the object param" do
+        assert_equal "Jose", deserialized[:customer_name]
+        assert_equal "2017-10-01", deserialized[:date]
+      end
+
+      it "moves singular relationships to the object param" do
+        assert_equal "customers", deserialized[:customer_type]
+        assert_equal "11", deserialized[:customer_id]
+      end
+
+      it "moves collection relationships to the object param" do
+        assert_equal %w[products widgets], deserialized[:product_types]
+        assert_equal %w[21 22], deserialized[:product_ids]
+      end
+    end
+
+    describe "rendering errors" do
+      it "renders ActiveModel::Errors" do
+        post orders_url, params: {
+          data: {
+            type: "orders",
+            attributes: {
+              customer_name: "",
+              date: Date.today.iso8601,
+            },
+          },
+        }, as: :jsonapi
+
+        expected_output = {
+          errors: [{
+            status: "422",
+            code: "unprocessable_entity",
+            title: "Invalid customer_name",
+            detail: "Customer name can't be blank",
+            source: { pointer: "/data/attributes/customer_name" },
+          },],
+        }.deep_stringify_keys
+
+        assert_response :unprocessable_entity
+        assert_equal expected_output, response_json
+      end
+
+      it "renders ActiveRecord::RecordNotFound" do
+        get order_path(-1), as: :jsonapi
+
+        expected_output = {
+          errors: [{
+            status: "404",
+            code: "not_found",
+            title: "Not found",
+            detail: "Couldn't find Order with 'id'=-1",
+            source: { parameter: "id" },
+          },],
+        }.deep_stringify_keys
+
+        assert_response :not_found
+        assert_equal expected_output, response_json
+      end
+    end
+
+    describe "routing" do
+      it "generates correct relationship paths" do
+        assert_generates "/orders/1/relationships/items",
+                         controller: "orders/relationships/items",
+                         action: "add",
+                         id: 1
+
+        assert_generates "/orders/1/relationships/items",
+                         controller: "orders/relationships/items",
+                         action: "remove",
+                         id: 1
+
+        assert_generates "/orders/1/relationships/items",
+                         controller: "orders/relationships/items",
+                         action: "replace",
+                         id: 1
+      end
+
+      it "generates the correct path helpers" do
+        assert_equal "/orders/1/relationships/items", orders_relationships_items_path(1)
+      end
+    end
+
+    describe "request validation" do
+      let(:request_hash) do
+        {
+          data: {
+            type: "orders",
+            attributes: {
+              customer_name: "Jose",
+            },
+          },
+        }
+      end
+
+      let(:jsonapi_mime_type) do
+        SimpleJsonapi::MIME_TYPE
+      end
+
+      it "returns a 406 if there is an accept header that does not match the required mime-type" do
+        get order_path(order), headers: { "Accept" => "application/json" }
+
+        assert_response :not_acceptable
+      end
+
+      # NB: This doesn't quite test what happens if there is no accept header, since Rails not so helpfully adds in an
+      # Accept header if none is present.
+      it "does not require an accept header" do
+        get order_path(order), headers: { "Accept" => "" }
+
+        assert_response :ok
+      end
+
+      it "returns a 415 if there is a request body but not the proper Content Type header" do
+        headers = {
+          "Accept" => jsonapi_mime_type,
+          "Content-Type" => "application/json",
+        }
+
+        post orders_url, params: request_hash.to_json, headers: headers
+
+        assert_response :unsupported_media_type
+      end
+
+      it "returns a 400 if there is no data element" do
+        post orders_url, params: { hinkle: "finkle_dinkle_doo" }, as: :jsonapi
+
+        assert_response :bad_request
+      end
+
+      it "returns a 400 if the request is to a relationship and there is not a data array" do
+        post orders_relationships_items_url(1), params: { data: "array non est" }, as: :jsonapi
+
+        assert_response :bad_request
+      end
+    end
+  end
+end