jsonapi-rails 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6c912f8bf18b7cb9aae401d121380b0d48e897d8
-  data.tar.gz: ca83afd750f861b825c11e2f5b44de19532e252b
+SHA256:
+  metadata.gz: 0c800b64bcd00613a30227d1ce18ad5a26e1cd28979fde5a64c055aa471864f9
+  data.tar.gz: 99fecc3f76f087018335941f017c7e04b5e95a9de4da4b21c5e7fd03302355cb
 SHA512:
-  metadata.gz: 604a2e70580bfb24d1abe48a11fa6748128e05906ab324b13125addc6da362d36c2fd8371c6d14c06ddb5c13edf4bdd227a8474a2a21f90fb5256201f4c7c5eb
-  data.tar.gz: 5441fb97181fb8cae74f7bfd99de4107cf4ef5a2b8bf766bbadba2dcacac4059639b0ac2344aa267a4def895c9cd247656eb22f36c1e1522843f00068da071bf
+  metadata.gz: 23a5535c16e86c274045d93dcdccfe86731247b96afb432c1945a0bd3043e497ac8df0e8bd69d2436d19e5a54d3b7867586827bf0ab804a4f4c27dbfb4e287e0
+  data.tar.gz: 1cc3c9b6305fe6829fb44caa19716a429ea51a0210a080c64c1668d7e5e1aa9d29ae645ac2adc69a4b92329b6d0bd7d875ea4bf2563941b8f6561ba8458fd920

data/README.md

@@ -4,8 +4,8 @@ Rails integration for [jsonapi-rb](http://jsonapi-rb.org).
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/jsonapi-rails.svg)](https://badge.fury.io/rb/jsonapi-rails)
-[![Build Status](https://secure.travis-ci.org/jsonapi-rb/jsonapi-rails.svg?branch=master)](http://travis-ci.org/jsonapi-rb/jsonapi-rails?branch=master)
-[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/jsonapi-rb/Lobby)
+[![Build Status](https://github.com/jsonapi-rb/jsonapi-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/jsonapi-rb/jsonapi-rails/actions/workflows/ci.yml/badge.svg)
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.svg)](https://gitter.im/jsonapi-rb/Lobby)
 
 ## Resources
 

data/lib/generators/jsonapi/initializer/templates/initializer.rb

@@ -21,12 +21,57 @@ JSONAPI::Rails.configure do |config|
   #   version: '1.0'
   # }
   #
+  # # Set default cache.
+  # # A lambda/proc that will be eval'd in the controller context.
+  # config.jsonapi_cache = ->() { nil }
+  #
+  # # Uncomment the following to enable fragment caching. Make sure you
+  # #   invalidate cache keys accordingly.
+  # config.jsonapi_cache = lambda {
+  #   Rails.cache
+  # }
+  #
   # # Set default exposures.
   # # A lambda/proc that will be eval'd in the controller context.
   # config.jsonapi_expose = lambda {
   #   { url_helpers: ::Rails.application.routes.url_helpers }
   # }
   #
+  # # Set default fields.
+  # # A lambda/proc that will be eval'd in the controller context.
+  # config.jsonapi_fields = ->() { nil }
+  #
+  # # Uncomment the following to have it default to the `fields` query
+  # #   parameter.
+  # config.jsonapi_fields = lambda {
+  #   fields_param = params.to_unsafe_hash.fetch(:fields, {})
+  #   Hash[fields_param.map { |k, v| [k.to_sym, v.split(',').map!(&:to_sym)] }]
+  # }
+  #
+  # # Set default include.
+  # # A lambda/proc that will be eval'd in the controller context.
+  # config.jsonapi_include = ->() { nil }
+  #
+  # # Uncomment the following to have it default to the `include` query
+  # #   parameter.
+  # config.jsonapi_include = lambda {
+  #   params[:include]
+  # }
+  #
+  # # Set default links.
+  # # A lambda/proc that will be eval'd in the controller context.
+  # config.jsonapi_links = ->() { {} }
+  #
+  # # Set default meta.
+  # # A lambda/proc that will be eval'd in the controller context.
+  # config.jsonapi_meta = ->() { nil }
+  #
   # # Set a default pagination scheme.
-  # config.jsonapi_pagination = ->(_) { nil }
+  # config.jsonapi_pagination = ->(_) { {} }
+  #
+  # # Set a logger.
+  # config.logger = Logger.new(STDOUT)
+  #
+  # # Uncomment the following to disable logging.
+  # config.logger = Logger.new('/dev/null')
 end

data/lib/generators/jsonapi/serializable/serializable_generator.rb

@@ -6,20 +6,35 @@ module Jsonapi
     # TODO(beauby): Implement versioning.
 
     def copy_serializable_file
+      fail "#{class_name} model not found." unless model_exists?
+
       template 'serializable.rb.erb',
                File.join('app/serializable', class_path,
-                         "serializable_#{file_name}.rb")
+                         "#{serializable_file_name}.rb")
     end
 
     private
 
+    def model_exists?
+      Rails.application.eager_load!
+      models = ApplicationRecord.descendants.map(&:name)
+      !!models.find { |model_name| model_name == class_name }
+    end
+
+    def serializable_file_name
+      "serializable_#{file_name}"
+    end
+
+    def serializable_class_name
+      (class_path + [serializable_file_name]).map!(&:camelize).join("::")
+    end
+
     def model_klass
-      # TODO(beauby): Ensure the model class exists.
       class_name.safe_constantize
     end
 
     def type
-      model_klass.name.underscore.pluralize
+      model_klass.model_name.plural
     end
 
     def attr_names

data/lib/generators/jsonapi/serializable/templates/serializable.rb.erb

@@ -1,5 +1,5 @@
 <% module_namespacing do -%>
-class Serializable<%= class_name %> < JSONAPI::Serializable::Resource
+class <%= serializable_class_name %> < JSONAPI::Serializable::Resource
   type '<%= type %>'
 <% attr_names.each do |attr| -%>
   attribute :<%= attr %>

data/lib/jsonapi/rails/configuration.rb

@@ -4,42 +4,64 @@ require 'jsonapi/rails/serializable_error_hash'
 module JSONAPI
   module Rails
     class Configuration < ActiveSupport::InheritableOptions; end
-    DEFAULT_JSONAPI_CLASS = Hash.new do |h, k|
-      names = k.to_s.split('::')
-      klass = names.pop
-      h[k] = [*names, "Serializable#{klass}"].join('::').safe_constantize
-    end.freeze
-
-    DEFAULT_JSONAPI_ERRORS_CLASS = DEFAULT_JSONAPI_CLASS.dup.merge!(
-      'ActiveModel::Errors'.to_sym =>
+
+    # @private
+    module Configurable
+      DEFAULT_JSONAPI_CLASS = Hash.new do |h, k|
+        names = k.to_s.split('::')
+        klass = names.pop
+        h[k] = [*names, "Serializable#{klass}"].join('::').safe_constantize
+      end.freeze
+
+      DEFAULT_JSONAPI_ERRORS_CLASS = DEFAULT_JSONAPI_CLASS.dup.merge!(
+        'ActiveModel::Errors'.to_sym =>
         JSONAPI::Rails::SerializableActiveModelErrors,
-      'Hash'.to_sym => JSONAPI::Rails::SerializableErrorHash
-    ).freeze
+        'Hash'.to_sym => JSONAPI::Rails::SerializableErrorHash
+      ).freeze
 
-    DEFAULT_JSONAPI_OBJECT = {
-      version: '1.0'
-    }.freeze
+      DEFAULT_JSONAPI_OBJECT = {
+        version: '1.0'
+      }.freeze
 
-    DEFAULT_JSONAPI_EXPOSE = lambda {
-      { url_helpers: ::Rails.application.routes.url_helpers }
-    }.freeze
+      DEFAULT_JSONAPI_CACHE = ->() { nil }
 
-    DEFAULT_JSONAPI_PAGINATION = ->(_) { nil }
+      DEFAULT_JSONAPI_EXPOSE = lambda {
+        { url_helpers: ::Rails.application.routes.url_helpers }
+      }
 
-    DEFAULT_CONFIG = {
-      jsonapi_class: DEFAULT_JSONAPI_CLASS,
-      jsonapi_errors_class: DEFAULT_JSONAPI_ERRORS_CLASS,
-      jsonapi_object: DEFAULT_JSONAPI_OBJECT,
-      jsonapi_expose: DEFAULT_JSONAPI_EXPOSE,
-      jsonapi_pagination: DEFAULT_JSONAPI_PAGINATION
-    }.freeze
+      DEFAULT_JSONAPI_FIELDS = ->() { nil }
 
-    def self.configure
-      yield config
-    end
+      DEFAULT_JSONAPI_INCLUDE = ->() { nil }
+
+      DEFAULT_JSONAPI_LINKS = ->() { {} }
+
+      DEFAULT_JSONAPI_META = ->() { nil }
+
+      DEFAULT_JSONAPI_PAGINATION = ->(_) { {} }
+
+      DEFAULT_LOGGER = Logger.new(STDERR)
+
+      DEFAULT_CONFIG = {
+        jsonapi_class: DEFAULT_JSONAPI_CLASS,
+        jsonapi_errors_class: DEFAULT_JSONAPI_ERRORS_CLASS,
+        jsonapi_cache:   DEFAULT_JSONAPI_CACHE,
+        jsonapi_expose:  DEFAULT_JSONAPI_EXPOSE,
+        jsonapi_fields:  DEFAULT_JSONAPI_FIELDS,
+        jsonapi_include: DEFAULT_JSONAPI_INCLUDE,
+        jsonapi_links:   DEFAULT_JSONAPI_LINKS,
+        jsonapi_meta:    DEFAULT_JSONAPI_META,
+        jsonapi_object:  DEFAULT_JSONAPI_OBJECT,
+        jsonapi_pagination: DEFAULT_JSONAPI_PAGINATION,
+        logger: DEFAULT_LOGGER
+      }.freeze
+
+      def configure
+        yield config
+      end
 
-    def self.config
-      @config ||= JSONAPI::Rails::Configuration.new(DEFAULT_CONFIG)
+      def config
+        @config ||= JSONAPI::Rails::Configuration.new(DEFAULT_CONFIG)
+      end
     end
   end
 end

data/lib/jsonapi/rails/controller/deserialization.rb

@@ -0,0 +1,84 @@
+require 'jsonapi/parser'
+require 'jsonapi/rails/deserializable_resource'
+
+module JSONAPI
+  module Rails
+    module Controller
+      # Controller class and instance methods for deserialization of incoming
+      #   JSON API payloads.
+      module Deserialization
+        extend ActiveSupport::Concern
+
+        JSONAPI_POINTERS_KEY = 'jsonapi-rails.jsonapi_pointers'.freeze
+
+        class_methods do
+          # Declare a deserializable resource.
+          #
+          # @param key [Symbol] The key under which the deserialized hash will be
+          #   available within the `params` hash.
+          # @param options [Hash]
+          # @option class [Class] A custom deserializer class. Optional.
+          # @option only List of actions for which deserialization should happen.
+          #   Optional.
+          # @option except List of actions for which deserialization should not
+          #   happen. Optional.
+          # @yieldreturn Optional block for in-line definition of custom
+          #   deserializers.
+          #
+          # @example
+          #   class ArticlesController < ActionController::Base
+          #     deserializable_resource :article, only: [:create, :update]
+          #
+          #     def create
+          #       article = Article.new(params[:article])
+          #
+          #       if article.save
+          #         render jsonapi: article
+          #       else
+          #         render jsonapi_errors: article.errors
+          #       end
+          #     end
+          #
+          #     # ...
+          #   end
+          #
+          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          def deserializable_resource(key, options = {}, &block)
+            options = options.dup
+            klass = options.delete(:class) ||
+                    Class.new(JSONAPI::Rails::DeserializableResource, &block)
+
+            before_action(options) do |controller|
+              hash = controller.params.to_unsafe_hash
+                .with_indifferent_access[:_jsonapi]
+              if hash.nil?
+                JSONAPI::Rails.logger.warn do
+                  "Unable to deserialize #{key} because no JSON API payload was" \
+                  " found. (#{controller.controller_name}##{params[:action]})"
+                end
+                next
+              end
+
+              ActiveSupport::Notifications
+                .instrument('parse.jsonapi-rails',
+                            key: key, payload: hash, class: klass) do
+                JSONAPI::Parser::Resource.parse!(hash)
+                resource = klass.new(hash[:data])
+                controller.request.env[JSONAPI_POINTERS_KEY] =
+                  resource.reverse_mapping
+                controller.params[key.to_sym] = resource.to_hash
+              end
+            end
+          end
+          # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+        end
+
+        # JSON pointers for deserialized fields.
+        # @return [Hash{Symbol=>String}]
+        def jsonapi_pointers
+          request.env[JSONAPI_POINTERS_KEY] || {}
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/rails/controller/hooks.rb

@@ -0,0 +1,75 @@
+require 'jsonapi/rails/configuration'
+
+module JSONAPI
+  module Rails
+    module Controller
+      extend ActiveSupport::Concern
+
+      # Hooks for customizing rendering default options at controller-level.
+      module Hooks
+        # Hook for serializable class mapping (for resources).
+        # Overridden by the `class` renderer option.
+        # @return [Hash{Symbol=>Class}]
+        def jsonapi_class
+          JSONAPI::Rails.config[:jsonapi_class].dup
+        end
+
+        # Hook for serializable class mapping (for errors).
+        # Overridden by the `class` renderer option.
+        # @return [Hash{Symbol=>Class}]
+        def jsonapi_errors_class
+          JSONAPI::Rails.config[:jsonapi_errors_class].dup
+        end
+
+        # Hook for the jsonapi object.
+        # Overridden by the `jsonapi_object` renderer option.
+        # @return [Hash,nil]
+        def jsonapi_object
+          JSONAPI::Rails.config[:jsonapi_object]
+        end
+
+        # Hook for default exposures.
+        # @return [Hash]
+        def jsonapi_expose
+          instance_exec(&JSONAPI::Rails.config[:jsonapi_expose])
+        end
+
+        # Hook for default cache.
+        # @return [#fetch_multi]
+        def jsonapi_cache
+          instance_exec(&JSONAPI::Rails.config[:jsonapi_cache])
+        end
+
+        # Hook for default fields.
+        # @return [Hash{Symbol=>Array<Symbol>},nil]
+        def jsonapi_fields
+          instance_exec(&JSONAPI::Rails.config[:jsonapi_fields])
+        end
+
+        # Hook for default includes.
+        # @return [IncludeDirective]
+        def jsonapi_include
+          instance_exec(&JSONAPI::Rails.config[:jsonapi_include])
+        end
+
+        # Hook for default links.
+        # @return [Hash]
+        def jsonapi_links
+          instance_exec(&JSONAPI::Rails.config[:jsonapi_links])
+        end
+
+        # Hook for default meta.
+        # @return [Hash,nil]
+        def jsonapi_meta
+          instance_exec(&JSONAPI::Rails.config[:jsonapi_meta])
+        end
+
+        # Hook for pagination scheme.
+        # @return [Hash]
+        def jsonapi_pagination(resources)
+          instance_exec(resources, &JSONAPI::Rails.config[:jsonapi_pagination])
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/rails/controller.rb

@@ -1,126 +1,13 @@
-require 'jsonapi/deserializable'
-require 'jsonapi/parser'
-require 'jsonapi/rails/configuration'
+require 'jsonapi/rails/controller/deserialization'
+require 'jsonapi/rails/controller/hooks'
 
 module JSONAPI
   module Rails
-    module Deserializable
-      # @private
-      class Resource < JSONAPI::Deserializable::Resource
-        id
-        type
-        attributes
-        has_one do |_rel, id, type, key|
-          type = type.to_s.singularize.camelize
-          { "#{key}_id".to_sym => id, "#{key}_type".to_sym => type }
-        end
-        has_many do |_rel, ids, types, key|
-          key   = key.to_s.singularize
-          types = types.map { |t| t.to_s.singularize.camelize }
-          { "#{key}_ids".to_sym => ids, "#{key}_types".to_sym => types }
-        end
-      end
-    end
-
     # ActionController methods and hooks for JSON API deserialization and
     #   rendering.
     module Controller
-      extend ActiveSupport::Concern
-
-      JSONAPI_POINTERS_KEY = 'jsonapi-rails.jsonapi_pointers'.freeze
-
-      class_methods do
-        # Declare a deserializable resource.
-        #
-        # @param key [Symbol] The key under which the deserialized hash will be
-        #   available within the `params` hash.
-        # @param options [Hash]
-        # @option class [Class] A custom deserializer class. Optional.
-        # @option only List of actions for which deserialization should happen.
-        #   Optional.
-        # @option except List of actions for which deserialization should not
-        #   happen. Optional.
-        # @yieldreturn Optional block for in-line definition of custom
-        #   deserializers.
-        #
-        # @example
-        #   class ArticlesController < ActionController::Base
-        #     deserializable_resource :article, only: [:create, :update]
-        #
-        #     def create
-        #       article = Article.new(params[:article])
-        #
-        #       if article.save
-        #         render jsonapi: article
-        #       else
-        #         render jsonapi_errors: article.errors
-        #       end
-        #     end
-        #
-        #     # ...
-        #   end
-        #
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        def deserializable_resource(key, options = {}, &block)
-          options = options.dup
-          klass = options.delete(:class) ||
-                  Class.new(JSONAPI::Rails::Deserializable::Resource, &block)
-
-          before_action(options) do |controller|
-            # TODO(lucas): Fail with helpful error message if _jsonapi not
-            #   present.
-            hash = controller.params[:_jsonapi].to_unsafe_hash
-            ActiveSupport::Notifications
-              .instrument('parse.jsonapi', payload: hash, class: klass) do
-              JSONAPI::Parser::Resource.parse!(hash)
-              resource = klass.new(hash[:data])
-              controller.request.env[JSONAPI_POINTERS_KEY] =
-                resource.reverse_mapping
-              controller.params[key.to_sym] = resource.to_hash
-            end
-          end
-        end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-      end
-
-      # Hook for serializable class mapping (for resources).
-      # Overridden by the `class` renderer option.
-      # @return [Hash{Symbol=>Class}]
-      def jsonapi_class
-        JSONAPI::Rails.config[:jsonapi_class].dup
-      end
-
-      # Hook for serializable class mapping (for errors).
-      # Overridden by the `class` renderer option.
-      # @return [Hash{Symbol=>Class}]
-      def jsonapi_errors_class
-        JSONAPI::Rails.config[:jsonapi_errors_class].dup
-      end
-
-      # Hook for the jsonapi object.
-      # Overridden by the `jsonapi_object` renderer option.
-      # @return [Hash]
-      def jsonapi_object
-        JSONAPI::Rails.config[:jsonapi_object]
-      end
-
-      # Hook for default exposures.
-      # @return [Hash]
-      def jsonapi_expose
-        instance_exec(&JSONAPI::Rails.config[:jsonapi_expose])
-      end
-
-      # Hook for pagination scheme.
-      # @return [Hash]
-      def jsonapi_pagination(resources)
-        instance_exec(resources, &JSONAPI::Rails.config[:jsonapi_pagination])
-      end
-
-      # JSON pointers for deserialized fields.
-      # @return [Hash{Symbol=>String}]
-      def jsonapi_pointers
-        request.env[JSONAPI_POINTERS_KEY] || {}
-      end
+      include Deserialization
+      include Hooks
     end
   end
 end

data/lib/jsonapi/rails/deserializable_resource.rb

@@ -0,0 +1,21 @@
+require 'jsonapi/deserializable/resource'
+
+module JSONAPI
+  module Rails
+    # Customized deserializable resource class to match ActiveRecord's API.
+    class DeserializableResource < JSONAPI::Deserializable::Resource
+      id
+      type
+      attributes
+      has_one do |_rel, id, type, key|
+        type = type.to_s.singularize.camelize
+        { "#{key}_id".to_sym => id, "#{key}_type".to_sym => type }
+      end
+      has_many do |_rel, ids, types, key|
+        key   = key.to_s.singularize
+        types = types.map { |t| t.to_s.singularize.camelize }
+        { "#{key}_ids".to_sym => ids, "#{key}_types".to_sym => types }
+      end
+    end
+  end
+end

data/lib/jsonapi/rails/filter_media_type.rb

@@ -0,0 +1,39 @@
+require 'rack/media_type'
+
+module JSONAPI
+  module Rails
+    class FilterMediaType
+      JSONAPI_MEDIA_TYPE = 'application/vnd.api+json'.freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return [415, {}, []] unless valid_content_type?(env['CONTENT_TYPE'])
+        return [406, {}, []] unless valid_accept?(env['HTTP_ACCEPT'])
+
+        @app.call(env)
+      end
+
+      private
+
+      def valid_content_type?(content_type)
+        Rack::MediaType.type(content_type) != JSONAPI_MEDIA_TYPE ||
+          content_type == JSONAPI_MEDIA_TYPE
+      end
+
+      def valid_accept?(accept)
+        return true if accept.nil?
+
+        jsonapi_media_types =
+          accept.split(',')
+                .map(&:strip)
+                .select { |m| Rack::MediaType.type(m) == JSONAPI_MEDIA_TYPE }
+
+        jsonapi_media_types.empty? ||
+          jsonapi_media_types.any? { |m| Rack::MediaType.params(m) == {} }
+      end
+    end
+  end
+end

data/lib/jsonapi/rails/log_subscriber.rb

@@ -0,0 +1,25 @@
+module JSONAPI
+  module Rails
+    # @private
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def render(event)
+        info do
+          "Completed JSON API rendering (#{event.duration.round(2)}ms)"
+        end
+      end
+
+      def parse(event)
+        info do
+          "Completed JSON API deserializing of #{event.payload[:key]}" \
+          " (#{event.duration.round(2)})"
+        end
+      end
+
+      def logger
+        JSONAPI::Rails.logger
+      end
+    end
+  end
+end
+
+JSONAPI::Rails::LogSubscriber.attach_to :'jsonapi-rails'

data/lib/jsonapi/rails/logging.rb

@@ -0,0 +1,10 @@
+module JSONAPI
+  module Rails
+    # @private
+    module Logging
+      def logger
+        config[:logger]
+      end
+    end
+  end
+end

data/lib/jsonapi/rails/railtie.rb

@@ -1,7 +1,7 @@
 require 'rails/railtie'
-require 'action_controller'
-require 'active_support'
 
+require 'jsonapi/rails/filter_media_type'
+require 'jsonapi/rails/log_subscriber'
 require 'jsonapi/rails/renderer'
 
 module JSONAPI
@@ -20,7 +20,7 @@ module JSONAPI
         jsonapi_errors: ErrorsRenderer.new
       }.freeze
 
-      initializer 'jsonapi-rails.init' do
+      initializer 'jsonapi-rails.init' do |app|
         register_mime_type
         register_parameter_parser
         register_renderers
@@ -28,6 +28,8 @@ module JSONAPI
           require 'jsonapi/rails/controller'
           include ::JSONAPI::Rails::Controller
         end
+
+        app.middleware.use FilterMediaType
       end
 
       private
@@ -50,12 +52,78 @@ module JSONAPI
           RENDERERS.each do |name, renderer|
             ::ActionController::Renderers.add(name) do |resources, options|
               # Renderer proc is evaluated in the controller context.
-              self.content_type ||= Mime[:jsonapi]
+              headers['Content-Type'] = Mime[:jsonapi].to_s
+
+              ActiveSupport::Notifications.instrument(
+                'render.jsonapi-rails',
+                resources: resources,
+                options: options
+              ) do
+                # Depending on whether or not a valid cache object is present
+                # in the options, the #render call below will return two
+                # slightly different kinds of hash.
+                #
+                # Both hashes have broadly the following structure, where r is
+                # some representation of a JSON::API resource:
+                #
+                # {
+                #   data: [ r1, r2, r3 ],
+                #   meta: { count: 12345 },
+                #   jsonapi: { version: "1.0" }
+                # }
+                #
+                # For non-cached calls to this method, the `data` field in the
+                # return value will contain an array of Ruby hashes.
+                #
+                # For cached calls, the `data` field will contain an array of
+                # JSON strings corresponding to the same data. This happens
+                # because jsonapi-renderer caches both the JSON serialization
+                # step as well as the assembly of the relevant attributes into
+                # a JSON::API-compliant structure. Those JSON strings are
+                # created via calls to `to_json`. They are then wrapped in
+                # CachedResourcesProcessor::JSONString. This defines a
+                # `to_json` method which simply returns self, ie - it attempts
+                # to ensure that any further `to_json` calls result in no
+                # changes.
+                #
+                # That isn't what happens in a Rails context, however. Below,
+                # the last step is to convert the entire output hash of the
+                # renderer into a JSON string to send to the client. If we
+                # call `to_json` on the cached output, the already-made JSON
+                # strings in the `data` field will be converted again,
+                # resulting in malformed data reaching the client. This happens
+                # because the ActiveSupport `to_json` takes precedent, meaning
+                # the "no-op" `to_json` definition on JSONString never gets
+                # executed.
+                #
+                # We can get around this by using JSON.generate instead, which
+                # will use the `to_json` defined on JSONString rather than the
+                # ActiveSupport one.
+                #
+                # However, we can't use JSON.generate on the non-cached output.
+                # Doing so means that its `data` field contents are converted
+                # with a non-ActiveSupport `to_json`. This means cached and
+                # non-cached responses have subtle differences in how their
+                # resources are serialized. For example:
+                #
+                # x = Time.new(2021,1,1)
+                #
+                # x.to_json
+                # => "\"2021-01-01T00:00:00.000+00:00\""
+                #
+                # JSON.generate x
+                # => "\"2021-01-01 00:00:00 +0000\""
+                #
+                # The different outputs mean we need to take different
+                # approaches when converting the entire payload into JSON,
+                # hence the check below.
+                jsonapi_hash = renderer.render(resources, options, self)
 
-              ActiveSupport::Notifications.instrument('render.jsonapi',
-                                                      resources: resources,
-                                                      options: options) do
-                renderer.render(resources, options, self).to_json
+                if jsonapi_hash[:data]&.first&.class == JSONAPI::Renderer::CachedResourcesProcessor::JSONString
+                  JSON.generate jsonapi_hash
+                else
+                  jsonapi_hash.to_json
+                end
               end
             end
           end

data/lib/jsonapi/rails/renderer.rb

@@ -18,17 +18,24 @@ module JSONAPI
 
       private
 
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def default_options(options, controller, resources)
         options.dup.tap do |opts|
           opts[:class] ||= controller.jsonapi_class
-          if (pagination_links = controller.jsonapi_pagination(resources))
-            opts[:links] = (opts[:links] || {}).merge(pagination_links)
-          end
-          opts[:expose]  = controller.jsonapi_expose.merge(opts[:expose] || {})
+          opts[:cache] ||= controller.jsonapi_cache
+          opts[:links] =
+            controller.jsonapi_links
+                      .merge!(controller.jsonapi_pagination(resources))
+                      .merge!(opts[:links] || {})
+          opts[:expose] = controller.jsonapi_expose.merge!(opts[:expose] || {})
+          opts[:fields] ||= controller.jsonapi_fields
+          opts[:include] ||= controller.jsonapi_include
           opts[:jsonapi] = opts.delete(:jsonapi_object) ||
                            controller.jsonapi_object
+          opts[:meta] ||= controller.jsonapi_meta
         end
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
     end
 
     # @private
@@ -52,6 +59,7 @@ module JSONAPI
       def default_options(options, controller)
         options.dup.tap do |opts|
           opts[:class] ||= controller.jsonapi_errors_class
+          opts[:links] = controller.jsonapi_links.merge!(opts[:links] || {})
           opts[:expose] =
             controller.jsonapi_expose
                       .merge(opts[:expose] || {})

data/lib/jsonapi/rails/serializable_active_model_errors.rb

@@ -25,7 +25,7 @@ module JSONAPI
       end
 
       def as_jsonapi
-        @errors.keys.flat_map do |key|
+        error_keys.flat_map do |key|
           @errors.full_messages_for(key).map do |message|
             SerializableActiveModelError.new(field: key, message: message,
                                              pointer: @reverse_mapping[key])
@@ -33,6 +33,12 @@ module JSONAPI
           end
         end
       end
+
+      private
+
+      def error_keys
+        @errors.respond_to?(:attribute_names) ? @errors.attribute_names : @errors.keys
+      end
     end
   end
 end

data/lib/jsonapi/rails.rb

@@ -1,4 +1,13 @@
 require 'jsonapi/deserializable'
 require 'jsonapi/serializable'
-require 'jsonapi/rails/configuration'
 require 'jsonapi/rails/railtie'
+
+module JSONAPI
+  module Rails
+    require 'jsonapi/rails/configuration'
+    require 'jsonapi/rails/logging'
+
+    extend Configurable
+    extend Logging
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Lucas Hosseini
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-09-11 00:00:00.000000000 Z
+date: 2022-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-rb
@@ -42,14 +42,14 @@ dependencies:
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
@@ -58,26 +58,26 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '11.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '11.3'
 - !ruby/object:Gem::Dependency
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: with_model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -125,6 +139,12 @@ files:
 - lib/jsonapi/rails.rb
 - lib/jsonapi/rails/configuration.rb
 - lib/jsonapi/rails/controller.rb
+- lib/jsonapi/rails/controller/deserialization.rb
+- lib/jsonapi/rails/controller/hooks.rb
+- lib/jsonapi/rails/deserializable_resource.rb
+- lib/jsonapi/rails/filter_media_type.rb
+- lib/jsonapi/rails/log_subscriber.rb
+- lib/jsonapi/rails/logging.rb
 - lib/jsonapi/rails/railtie.rb
 - lib/jsonapi/rails/renderer.rb
 - lib/jsonapi/rails/serializable_active_model_errors.rb
@@ -133,7 +153,7 @@ homepage: https://github.com/jsonapi-rb/jsonapi-rails
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -148,9 +168,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: jsonapi-rb integrations for Rails.
 test_files: []