jsonapi.rb 1.6.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc1e0239230a7a14a008b6344be8857fccd4db574af564a9b49342842fcc316d
-  data.tar.gz: 16615a0a1e0bd8b6f0a84ae9f2adcc16005a16b6413577b3ee945fddb6ce90c5
+  metadata.gz: d531366279855044f83d35f4526a72156c711895290ab4dbce73f1c7615f1079
+  data.tar.gz: 63bd2be61a78d79a64bc739cbb492ee75a9e2f90a95389d55f133a2565627abb
 SHA512:
-  metadata.gz: 2c65ee96100a9179205b0f8e220f4f42dc5cd0f03fb8c7c645cb1c70933f848e2e0fe11d600259f2001fe1a9d8760b821c4748009ee3451156e2b07a660df783
-  data.tar.gz: 26c49d61c04f3bc03eaee260137905886a421c31d6bb669c063eb4cca9bea15a77327a07e90eb63ede9bb4b0d5e4b153aa38eb6dd6167c2eeabf10a1d7fb8fd6
+  metadata.gz: e602d6c993cd0259ac0b81c57eca16aee525f53ed0e5b4ac8014a0cb500528d579541375ce7735f0f191f3f732af9178ebbfdf7d4615eb967cfb244d1796cd36
+  data.tar.gz: 46a957ded4247be1607f6a4d84246da42a44fe41c58c55e2a34a914e958a28731531bc5e8a3f0d0141f571e17dce19c9c1f6f58845fc3e7db874d763dfcaffbb

data/README.md

@@ -39,7 +39,7 @@ The available features include:
    [sparse fields](https://jsonapi.org/format/#fetching-sparse-fieldsets))
  * [filtering](https://jsonapi.org/format/#fetching-filtering) and
    [sorting](https://jsonapi.org/format/#fetching-sorting) of the data
-   (powered by Ransack)
+   (powered by Ransack, soft-dependency)
  * [pagination](https://jsonapi.org/format/#fetching-pagination) support
 
 ## But how?
@@ -49,6 +49,16 @@ and [Ransack](https://github.com/activerecord-hackery/ransack).
 
 Thanks to everyone who worked on these amazing projects!
 
+## Sponsors
+
+I'm grateful for the following companies for supporting this project!
+
+<p align="center">
+<a href="https://www.luneteyewear.com"><img src="https://user-images.githubusercontent.com/112147/136836142-2bfba96e-447f-4eb6-b137-2445aee81b37.png"/></a>
+<a href="https://www.startuplandia.io"><img src="https://user-images.githubusercontent.com/112147/136836147-93f8ab17-2465-4477-a7ab-e38255483c66.png"/></a>
+</p>
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -231,6 +241,8 @@ to filter and sort over a collection of records.
 The support is pretty extended and covers also relationships and composite
 matchers.
 
+Please add `ransack` to your `Gemfile` in order to benefit from this functionality!
+
 Here's an example:
 
 ```ruby
@@ -290,6 +302,7 @@ class MyController < ActionController::Base
       render jsonapi: paginated
     end
   end
+
 end
 ```
 
@@ -306,6 +319,17 @@ use the `jsonapi_pagination_meta` method:
   end
 
 ```
+
+If you want to change the default number of items per page or define a custom logic to handle page size, use the
+`jsonapi_page_size` method:
+
+```ruby
+  def jsonapi_page_size(pagination_params)
+    per_page = pagination_params[:size].to_f.to_i
+    per_page = 30 if per_page > 30 || per_page < 1
+    per_page
+  end
+```
 ### Deserialization
 
 `JSONAPI::Deserialization` provides a helper to transform a `JSONAPI` document

data/lib/jsonapi/active_model_error_serializer.rb

@@ -3,9 +3,6 @@ require 'jsonapi/error_serializer'
 module JSONAPI
   # [ActiveModel::Errors] serializer
   class ActiveModelErrorSerializer < ErrorSerializer
-    set_id :object_id
-    set_type :error
-
     attribute :status do
       '422'
     end

data/lib/jsonapi/error_serializer.rb

@@ -5,7 +5,6 @@ module JSONAPI
   class ErrorSerializer
     include JSONAPI::Serializer
 
-    set_id :object_id
     set_type :error
 
     # Object/Hash attribute helpers.
@@ -15,6 +14,12 @@ module JSONAPI
       end
     end
 
+    # Overwrite the ID extraction method, to skip validations
+    #
+    # @return [NilClass]
+    def self.id_from_record(_record, _params)
+    end
+
     # Remap the root key to `errors`
     #
     # @return [Hash]

data/lib/jsonapi/filtering.rb

@@ -1,5 +1,9 @@
-require 'ransack/predicate'
-require_relative 'patches'
+begin
+  require 'active_record'
+  require 'ransack'
+  require_relative 'patches'
+rescue LoadError
+end
 
 # Filtering and sorting support
 module JSONAPI

data/lib/jsonapi/pagination.rb

@@ -43,6 +43,8 @@ module JSONAPI
       original_url = request.base_url + request.path + '?'
 
       pagination.each do |page_name, number|
+        next if page_name == :records
+
         original_params[:page][:number] = number
         links[page_name] = original_url + CGI.unescape(
           original_params.to_query
@@ -63,7 +65,7 @@ module JSONAPI
       numbers = { current: page }
 
       if resources.respond_to?(:unscope)
-        total = resources.unscope(:limit, :offset, :order).count()
+        total = resources.unscope(:limit, :offset, :order).size
       else
         # Try to fetch the cached size first
         total = resources.instance_variable_get(:@original_size)
@@ -82,6 +84,10 @@ module JSONAPI
         numbers[:last] = last_page
       end
 
+      if total.present?
+        numbers[:records] = total
+      end
+
       numbers
     end
 
@@ -89,16 +95,30 @@ module JSONAPI
     #
     # @return [Array] with the offset, limit and the current page number
     def jsonapi_pagination_params
-      def_per_page = self.class.const_get(:JSONAPI_PAGE_SIZE).to_i
-
       pagination = params[:page].try(:slice, :number, :size) || {}
-      per_page = pagination[:size].to_f.to_i
-      per_page = def_per_page if per_page > def_per_page || per_page < 1
+      per_page = jsonapi_page_size(pagination)
       num = [1, pagination[:number].to_f.to_i].max
 
       [(num - 1) * per_page, per_page, num]
     end
 
+    # Retrieves the default page size
+    #
+    # @param per_page_param [Hash] opts the paginations params
+    # @option opts [String] :number the page number requested
+    # @option opts [String] :size the page size requested
+    #
+    # @return [Integer]
+    def jsonapi_page_size(pagination_params)
+      per_page = pagination_params[:size].to_f.to_i
+
+      return self.class
+              .const_get(:JSONAPI_PAGE_SIZE)
+              .to_i if per_page < 1
+
+      per_page
+    end
+
     # Fallback to Rack's parsed query string when Rails is not available
     #
     # @return [Hash]

data/lib/jsonapi/rails.rb

@@ -37,7 +37,7 @@ module JSONAPI
     # @return [NilClass]
     def self.add_errors_renderer!
       ActionController::Renderers.add(:jsonapi_errors) do |resource, options|
-        self.content_type ||= Mime[:jsonapi]
+        self.content_type = Mime[:jsonapi] if self.media_type.nil?
 
         many = JSONAPI::Rails.is_collection?(resource, options[:is_collection])
         resource = [resource] unless many
@@ -47,7 +47,7 @@ module JSONAPI
         ) unless resource.is_a?(ActiveModel::Errors)
 
         errors = []
-        model = resource.instance_variable_get('@base')
+        model = resource.instance_variable_get(:@base)
 
         if respond_to?(:jsonapi_serializer_class, true)
           model_serializer = jsonapi_serializer_class(model, false)
@@ -55,8 +55,18 @@ module JSONAPI
           model_serializer = JSONAPI::Rails.serializer_class(model, false)
         end
 
-        details = resource.messages
-        details = resource.details if resource.respond_to?(:details)
+        details = {}
+        if ::Rails.gem_version >= Gem::Version.new('6.1')
+          resource.each do |error|
+            attr = error.attribute
+            details[attr] ||= []
+            details[attr] << error.detail.merge(message: error.message)
+          end
+        elsif resource.respond_to?(:details)
+          details = resource.details
+        else
+          details = resource.messages
+        end
 
         details.each do |error_key, error_hashes|
           error_hashes.each do |error_hash|
@@ -80,7 +90,7 @@ module JSONAPI
     # @return [NilClass]
     def self.add_renderer!
       ActionController::Renderers.add(:jsonapi) do |resource, options|
-        self.content_type ||= Mime[:jsonapi]
+        self.content_type = Mime[:jsonapi] if self.media_type.nil?
 
         JSONAPI_METHODS_MAPPING.to_a[0..1].each do |opt, method_name|
           next unless respond_to?(method_name, true)
@@ -90,7 +100,7 @@ module JSONAPI
         # If it's an empty collection, return it directly.
         many = JSONAPI::Rails.is_collection?(resource, options[:is_collection])
         if many && !resource.any?
-          return options.slice(:meta, :links).merge(data: []).to_json
+          return options.slice(:meta, :links).compact.merge(data: []).to_json
         end
 
         JSONAPI_METHODS_MAPPING.to_a[2..-1].each do |opt, method_name|
@@ -111,15 +121,13 @@ module JSONAPI
 
     # Checks if an object is a collection
     #
-    # Stolen from [JSONAPI::Serializer], instance method.
+    # Basically forwards it to a [JSONAPI::Serializer] as there's no public API
     #
     # @param resource [Object] to check
     # @param force_is_collection [NilClass] flag to overwrite
     # @return [TrueClass] upon success
     def self.is_collection?(resource, force_is_collection = nil)
-      return force_is_collection unless force_is_collection.nil?
-
-      resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
+      JSONAPI::ErrorSerializer.is_collection?(resource, force_is_collection)
     end
 
     # Resolves resource serializer class

data/lib/jsonapi/version.rb

@@ -1,3 +1,3 @@
 module JSONAPI
-  VERSION = '1.6.0'
+  VERSION = '2.0.1'
 end

data/spec/deserialization_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+RSpec.describe JSONAPI::Deserialization do
+  let(:jsonapi_deserialize) { UsersController.new.method(:jsonapi_deserialize) }
+  let(:document) do
+    {
+      data: {
+        id: 1,
+        type: 'note',
+        attributes: {
+          title: 'Title 1',
+          date: '2015-12-20'
+        },
+        relationships: {
+          author: {
+            data: {
+              type: 'user',
+              id: 2
+            }
+          },
+          second_author: {
+            data: nil
+          },
+          notes: {
+            data: [
+              {
+                type: 'note',
+                id: 3
+              },
+              {
+                type: 'note',
+                id: 4
+              }
+            ]
+          }
+        }
+      }
+    }
+  end
+
+  describe '#jsonapi_deserialize' do
+    it do
+      expect(jsonapi_deserialize.call(document)).to eq(
+        'id' => 1,
+        'date' => '2015-12-20',
+        'title' => 'Title 1',
+        'author_id' => 2,
+        'second_author_id' => nil,
+        'note_ids' => [3, 4]
+      )
+    end
+
+    context 'with `only`' do
+      it do
+        expect(jsonapi_deserialize.call(document, only: :notes)).to eq(
+          'note_ids' => [3, 4]
+        )
+      end
+    end
+
+    context 'with `except`' do
+      it do
+        expect(
+          jsonapi_deserialize.call(document, except: [:date, :title])
+        ).to eq(
+          'id' => 1,
+          'author_id' => 2,
+          'second_author_id' => nil,
+          'note_ids' => [3, 4]
+        )
+      end
+    end
+
+    context 'with `polymorphic`' do
+      it do
+        expect(
+          jsonapi_deserialize.call(
+            document, only: :author, polymorphic: :author
+          )
+        ).to eq(
+          'author_id' => 2,
+          'author_type' => User.name
+        )
+      end
+    end
+  end
+end

data/spec/dummy.rb

@@ -0,0 +1,162 @@
+require 'securerandom'
+require 'rails/all'
+require 'ransack'
+require 'jsonapi'
+
+Rails.logger = Logger.new(STDOUT)
+Rails.logger.level = ENV['LOG_LEVEL'] || Logger::WARN
+
+JSONAPI::Rails.install!
+
+ActiveRecord::Base.logger = Rails.logger
+ActiveRecord::Base.establish_connection(
+  ENV['DATABASE_URL'] || 'sqlite3::memory:'
+)
+
+ActiveRecord::Schema.define do
+  create_table :users, force: true do |t|
+    t.string :first_name
+    t.string :last_name
+    t.timestamps
+  end
+
+  create_table :notes, force: true do |t|
+    t.string :title
+    t.integer :user_id
+    t.integer :quantity
+    t.timestamps
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :notes
+end
+
+class Note < ActiveRecord::Base
+  validates_format_of :title, without: /BAD_TITLE/
+  validates_numericality_of :quantity, less_than: 100, if: :quantity?
+  belongs_to :user, required: true
+end
+
+class CustomNoteSerializer
+  include JSONAPI::Serializer
+
+  set_type :note
+  belongs_to :user
+  attributes(:title, :quantity, :created_at, :updated_at)
+end
+
+class UserSerializer
+  include JSONAPI::Serializer
+
+  has_many :notes, serializer: CustomNoteSerializer
+  attributes(:last_name, :created_at, :updated_at)
+
+  attribute :first_name do |object, params|
+    if params[:first_name_upcase]
+      object.first_name.upcase
+    else
+      object.first_name
+    end
+  end
+end
+
+class Dummy < Rails::Application
+  secrets.secret_key_base = '_'
+  config.hosts << 'www.example.com' if config.respond_to?(:hosts)
+
+  routes.draw do
+    scope defaults: { format: :jsonapi } do
+      resources :users, only: [:index]
+      resources :notes, only: [:update]
+    end
+  end
+end
+
+class UsersController < ActionController::Base
+  include JSONAPI::Fetching
+  include JSONAPI::Filtering
+  include JSONAPI::Pagination
+  include JSONAPI::Deserialization
+
+  def index
+    allowed_fields = [
+      :first_name, :last_name, :created_at,
+      :notes_created_at, :notes_quantity
+    ]
+    options = { sort_with_expressions: true }
+
+    jsonapi_filter(User.all, allowed_fields, options) do |filtered|
+      result = filtered.result
+
+      if params[:sort].to_s.include?('notes_quantity')
+        render jsonapi: result.group('id').to_a
+        return
+      end
+
+      result = result.to_a if params[:as_list]
+
+      jsonapi_paginate(result) do |paginated|
+        render jsonapi: paginated
+      end
+    end
+  end
+
+  private
+  def jsonapi_meta(resources)
+    {
+      many: true,
+      pagination: jsonapi_pagination_meta(resources)
+    }
+  end
+
+  def jsonapi_serializer_params
+    {
+      first_name_upcase: params[:upcase]
+    }
+  end
+end
+
+class NotesController < ActionController::Base
+  include JSONAPI::Errors
+  include JSONAPI::Deserialization
+
+  def update
+    raise_error! if params[:id] == 'tada'
+
+    note = Note.find(params[:id])
+
+    if note.update(note_params)
+      render jsonapi: note
+    else
+      note.errors.add(:title, message: 'has typos') if note.errors.key?(:title)
+
+      render jsonapi_errors: note.errors, status: :unprocessable_entity
+    end
+  end
+
+  private
+  def render_jsonapi_internal_server_error(exception)
+    Rails.logger.error(exception)
+    super(exception)
+  end
+
+  def jsonapi_serializer_class(resource, is_collection)
+    JSONAPI::Rails.serializer_class(resource, is_collection)
+  rescue NameError
+    klass = resource.class
+    klass = resource.first.class if is_collection
+    "Custom#{klass.name}Serializer".constantize
+  end
+
+  def note_params
+    # Will trigger required attribute error handling
+    params.require(:data).require(:attributes).require(:title)
+
+    jsonapi_deserialize(params)
+  end
+
+  def jsonapi_meta(resources)
+    { single: true }
+  end
+end

data/spec/errors_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+RSpec.describe NotesController, type: :request do
+  describe 'PUT /notes/:id' do
+    let(:note) { create_note }
+    let(:note_id) { note.id }
+    let(:user) { note.user }
+    let(:user_id) { user.id }
+    let(:note_params) do
+      {
+        data: {
+          attributes: { title: FFaker::Company.name },
+          relationships: { user: { data: { id: user_id } } }
+        }
+      }
+    end
+    let(:params) { note_params }
+
+    before do
+      put(note_path(note_id), params: params.to_json, headers: jsonapi_headers)
+    end
+
+    it do
+      expect(response).to have_http_status(:ok)
+      expect(response_json['data']).to have_id(note.id.to_s)
+      expect(response_json['meta']).to eq('single' => true)
+    end
+
+    context 'with a missing parameter in the payload' do
+      let(:params) { {} }
+
+      it do
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('422')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+        expect(response_json['errors'][0]['source']).to eq('pointer' => '')
+        expect(response_json['errors'][0]['detail']).to be_nil
+      end
+    end
+
+    context 'with an invalid payload' do
+      let(:params) do
+        payload = note_params.dup
+        payload[:data][:relationships][:user][:data][:id] = nil
+        payload
+      end
+
+      it do
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('422')
+        expect(response_json['errors'][0]['code']).to include('blank')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+        expect(response_json['errors'][0]['source'])
+          .to eq('pointer' => '/data/relationships/user')
+        if Rails.gem_version >= Gem::Version.new('6.1')
+          expect(response_json['errors'][0]['detail'])
+            .to eq('User must exist')
+        else
+          expect(response_json['errors'][0]['detail'])
+            .to eq('User can\'t be blank')
+        end
+      end
+
+      context 'required by validations' do
+        let(:params) do
+          payload = note_params.dup
+          payload[:data][:attributes][:title] = 'BAD_TITLE'
+          payload[:data][:attributes][:quantity] = 100 + rand(10)
+          payload
+        end
+
+        it do
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(response_json['errors'].size).to eq(3)
+          expect(response_json['errors'][0]['status']).to eq('422')
+          expect(response_json['errors'][0]['code']).to include('invalid')
+          expect(response_json['errors'][0]['title'])
+            .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+          expect(response_json['errors'][0]['source'])
+              .to eq('pointer' => '/data/attributes/title')
+          expect(response_json['errors'][0]['detail'])
+            .to eq('Title is invalid')
+
+          expect(response_json['errors'][1]['status']).to eq('422')
+
+          if Rails::VERSION::MAJOR >= 5
+            expect(response_json['errors'][1]['code']).to eq('invalid')
+          else
+            expect(response_json['errors'][1]['code']).to eq('has_typos')
+          end
+
+          expect(response_json['errors'][1]['title'])
+            .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+          expect(response_json['errors'][1]['source'])
+            .to eq('pointer' => '/data/attributes/title')
+          expect(response_json['errors'][1]['detail'])
+            .to eq('Title has typos')
+
+          expect(response_json['errors'][2]['status']).to eq('422')
+
+          if Rails::VERSION::MAJOR >= 5
+            expect(response_json['errors'][2]['code']).to eq('less_than')
+          else
+            expect(response_json['errors'][2]['code'])
+              .to eq('must_be_less_than_100')
+          end
+
+          expect(response_json['errors'][2]['title'])
+            .to eq(Rack::Utils::HTTP_STATUS_CODES[422])
+          expect(response_json['errors'][2]['source'])
+            .to eq('pointer' => '/data/attributes/quantity')
+          expect(response_json['errors'][2]['detail'])
+            .to eq('Quantity must be less than 100')
+        end
+      end
+
+      context 'as a param attribute' do
+        let(:params) do
+          payload = note_params.dup
+          payload[:data][:attributes].delete(:title)
+          # To have any attribtues in the payload...
+          payload[:data][:attributes][:created_at] = nil
+          payload
+        end
+
+        it do
+          expect(response).to have_http_status(:unprocessable_entity)
+          expect(response_json['errors'][0]['source'])
+            .to eq('pointer' => '/data/attributes/title')
+        end
+      end
+    end
+
+    context 'with a bad note ID' do
+      let(:user_id) { nil }
+      let(:note_id) { rand(10) }
+
+      it do
+        expect(response).to have_http_status(:not_found)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('404')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[404])
+        expect(response_json['errors'][0]['source']).to be_nil
+        expect(response_json['errors'][0]['detail']).to be_nil
+      end
+    end
+
+    context 'with an exception' do
+      let(:user_id) { nil }
+      let(:note_id) { 'tada' }
+
+      it do
+        expect(response).to have_http_status(:internal_server_error)
+        expect(response_json['errors'].size).to eq(1)
+        expect(response_json['errors'][0]['status']).to eq('500')
+        expect(response_json['errors'][0]['title'])
+          .to eq(Rack::Utils::HTTP_STATUS_CODES[500])
+        expect(response_json['errors'][0]['source']).to be_nil
+        expect(response_json['errors'][0]['detail']).to be_nil
+      end
+    end
+  end
+end