jsonapi-resources 0.10.6 → 0.11.0.beta2

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'csv'
 
 module JSONAPI
@@ -13,7 +15,7 @@ module JSONAPI
                                               :transaction
     end
 
-    attr_reader :response_document
+    attr_reader :response_document, :jsonapi_request
 
     def index
       process_request
@@ -76,48 +78,54 @@ module JSONAPI
     end
 
     def process_request
-      @response_document = create_response_document
-
-      unless verify_content_type_header && verify_accept_header
-        render_response_document
-        return
+      begin
+        setup_response_document
+        verify_content_type_header
+        verify_accept_header
+        parse_request
+        execute_request
+      rescue => e
+        handle_exceptions(e)
       end
+      render_response_document
+    end
 
-      request_parser = JSONAPI::RequestParser.new(
-          params,
-          context: context,
-          key_formatter: key_formatter,
-          server_error_callbacks: (self.class.server_error_callbacks || []))
-
-      transactional = request_parser.transactional?
+    def setup_response_document
+      @response_document = create_response_document
+    end
 
-      begin
-        process_operations(transactional) do
-          run_callbacks :process_operations do
-            request_parser.each(response_document) do |op|
-              op.options[:serializer] = resource_serializer_klass.new(
-                  op.resource_klass,
-                  include_directives: op.options[:include_directives],
-                  fields: op.options[:fields],
-                  base_url: base_url,
-                  key_formatter: key_formatter,
-                  route_formatter: route_formatter,
-                  serialization_options: serialization_options,
-                  controller: self
-              )
-              op.options[:cache_serializer_output] = !JSONAPI.configuration.resource_cache.nil?
-
-              process_operation(op)
-            end
-          end
-          if response_document.has_errors?
-            raise ActiveRecord::Rollback
+    def parse_request
+      @jsonapi_request = JSONAPI::Request.new(
+        params,
+        context: context,
+        key_formatter: key_formatter,
+        server_error_callbacks: (self.class.server_error_callbacks || []))
+      fail JSONAPI::Exceptions::Errors.new(@jsonapi_request.errors) if @jsonapi_request.errors.any?
+    end
+
+    def execute_request
+      process_operations(jsonapi_request.transactional?) do
+        run_callbacks :process_operations do
+          jsonapi_request.operations.each do |op|
+            op.options[:serializer] = resource_serializer_klass.new(
+              op.resource_klass,
+              include_directives: op.options[:include_directives],
+              fields: op.options[:fields],
+              base_url: base_url,
+              key_formatter: key_formatter,
+              route_formatter: route_formatter,
+              serialization_options: serialization_options,
+              controller: self
+            )
+            op.options[:cache_serializer_output] = !JSONAPI.configuration.resource_cache.nil?
+
+            process_operation(op)
           end
         end
-      rescue => e
-        handle_exceptions(e)
+        if response_document.has_errors?
+          raise ActiveRecord::Rollback
+        end
       end
-      render_response_document
     end
 
     def process_operations(transactional)
@@ -161,24 +169,16 @@ module JSONAPI
 
     def verify_content_type_header
       if ['create', 'create_relationship', 'update_relationship', 'update'].include?(params[:action])
-        unless request.content_type == JSONAPI::MEDIA_TYPE
-          fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
+        unless request.media_type == JSONAPI::MEDIA_TYPE
+          fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.media_type)
         end
       end
-      true
-    rescue => e
-      handle_exceptions(e)
-      false
     end
 
     def verify_accept_header
       unless valid_accept_media_type?
         fail JSONAPI::Exceptions::NotAcceptableError.new(request.accept)
       end
-      true
-    rescue => e
-      handle_exceptions(e)
-      false
     end
 
     def valid_accept_media_type?
@@ -273,7 +273,7 @@ module JSONAPI
         when ActionController::ParameterMissing
           errors = JSONAPI::Exceptions::ParameterMissing.new(e.param).errors
         else
-          if JSONAPI.configuration.exception_class_whitelisted?(e)
+          if JSONAPI.configuration.exception_class_allowed?(e)
             raise e
           else
             if self.class.server_error_callbacks
@@ -308,7 +308,7 @@ module JSONAPI
     # caught that is not a JSONAPI::Exceptions::Error
     # Useful for additional logging or notification configuration that
     # would normally depend on rails catching and rendering an exception.
-    # Ignores whitelist exceptions from config
+    # Ignores allowlist exceptions from config
 
     module ClassMethods
 

data/lib/jsonapi/cached_response_fragment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class CachedResponseFragment
 
@@ -51,8 +53,8 @@ module JSONAPI
       @fetchable_fields = Set.new(fetchable_fields)
 
       # Relationships left uncompiled because we'll often want to insert included ids on retrieval
-      # Remove the data since that should not be cached
-      @relationships = relationships&.transform_values {|v| v.delete_if {|k, _v| k == 'data'} }
+      @relationships = relationships
+
       @links_json = CompiledJson.of(links_json)
       @attributes_json = CompiledJson.of(attributes_json)
       @meta_json = CompiledJson.of(meta_json)

data/lib/jsonapi/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/callbacks'
 
 module JSONAPI

data/lib/jsonapi/compiled_json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class CompiledJson
     def self.compile(h)

data/lib/jsonapi/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'jsonapi/formatter'
 require 'jsonapi/processor'
 require 'concurrent'
@@ -28,8 +30,8 @@ module JSONAPI
                 :allow_transactions,
                 :include_backtraces_in_errors,
                 :include_application_backtraces_in_errors,
-                :exception_class_whitelist,
-                :whitelist_all_exceptions,
+                :exception_class_allowlist,
+                :allow_all_exceptions,
                 :always_include_to_one_linkage_data,
                 :always_include_to_many_linkage_data,
                 :cache_formatters,
@@ -40,6 +42,7 @@ module JSONAPI
                 :resource_cache_digest_function,
                 :resource_cache_usage_report_function,
                 :default_exclude_links,
+                :default_resource_retrieval_strategy,
                 :use_related_resource_records_for_joins
 
     def initialize
@@ -96,12 +99,12 @@ module JSONAPI
       # raise a Pundit::NotAuthorizedError at some point during operations
       # processing. If you want to use Rails' `rescue_from` macro to
       # catch this error and render a 403 status code, you should add
-      # the `Pundit::NotAuthorizedError` to the `exception_class_whitelist`.
-      self.exception_class_whitelist = []
+      # the `Pundit::NotAuthorizedError` to the `exception_class_allowlist`.
+      self.exception_class_allowlist = []
 
-      # If enabled, will override configuration option `exception_class_whitelist`
-      # and whitelist all exceptions.
-      self.whitelist_all_exceptions = false
+      # If enabled, will override configuration option `exception_class_allowlist`
+      # and allow all exceptions.
+      self.allow_all_exceptions = false
 
       # Resource Linkage
       # Controls the serialization of resource linkage for non compound documents
@@ -160,9 +163,24 @@ module JSONAPI
       # specific default links to exclude, which may be `:self` and `:related`.
       self.default_exclude_links = :none
 
-      # Use a related resource's `records` when performing joins. This setting allows included resources to account for
-      # permission scopes. It can be overridden explicitly per relationship. Furthermore, specifying a `relation_name`
-      # on a relationship will cause this setting to be ignored.
+      # Global configuration for resource retrieval strategy used by the Resource class.
+      # Selecting a default_resource_retrieval_strategy will affect all resources that derive from
+      # Resource. The default value is 'JSONAPI::ActiveRelationRetrieval'.
+      #
+      # To use multiple retrieval strategies in an app set this to :none and set a custom retrieval strategy
+      # per resource (or base resource) using the class method `load_resource_retrieval_strategy`.
+      #
+      # Available strategies:
+      # 'JSONAPI::ActiveRelationRetrieval'
+      # 'JSONAPI::ActiveRelationRetrievalV09'
+      # 'JSONAPI::ActiveRelationRetrievalV10'
+      # :none
+      # :self
+      self.default_resource_retrieval_strategy = 'JSONAPI::ActiveRelationRetrieval'
+
+      # For 'JSONAPI::ActiveRelationRetrievalV10': use a related resource's `records` when performing joins.
+      # This setting allows included resources to account for permission scopes. It can be overridden explicitly per
+      # relationship. Furthermore, specifying a `relation_name` on a relationship will cause this setting to be ignored.
       self.use_related_resource_records_for_joins = true
     end
 
@@ -225,9 +243,9 @@ module JSONAPI
       return formatter
     end
 
-    def exception_class_whitelisted?(e)
-      @whitelist_all_exceptions ||
-        @exception_class_whitelist.flatten.any? { |k| e.class.ancestors.map(&:to_s).include?(k.to_s) }
+    def exception_class_allowed?(e)
+      @allow_all_exceptions ||
+        @exception_class_allowlist.flatten.any? { |k| e.class.ancestors.map(&:to_s).include?(k.to_s) }
     end
 
     def default_processor_klass=(default_processor_klass)
@@ -276,9 +294,9 @@ module JSONAPI
 
     attr_writer :include_application_backtraces_in_errors
 
-    attr_writer :exception_class_whitelist
+    attr_writer :exception_class_allowlist
 
-    attr_writer :whitelist_all_exceptions
+    attr_writer :allow_all_exceptions
 
     attr_writer :always_include_to_one_linkage_data
 
@@ -306,6 +324,8 @@ module JSONAPI
 
     attr_writer :default_exclude_links
 
+    attr_writer :default_resource_retrieval_strategy
+
     attr_writer :use_related_resource_records_for_joins
   end
 

data/lib/jsonapi/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Error
     attr_accessor :title, :detail, :id, :href, :code, :source, :links, :status, :meta

data/lib/jsonapi/error_codes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   VALIDATION_ERROR = '100'
   INVALID_RESOURCE = '101'

data/lib/jsonapi/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Exceptions
     class Error < RuntimeError

data/lib/jsonapi/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Formatter
     class << self

data/lib/jsonapi/include_directives.rb

@@ -1,24 +1,35 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class IncludeDirectives
     # Construct an IncludeDirectives Hash from an array of dot separated include strings.
     # For example ['posts.comments.tags']
     # will transform into =>
     # {
-    #   posts: {
-    #     include_related: {
-    #       comments:{
-    #         include_related: {
-    #           tags: {
-    #             include_related: {}
-    #           }
+    #   include_related: {
+    #     posts: {
+    #       include: true,
+    #       include_related: {
+    #         comments: {
+    #           include: true,
+    #           include_related: {
+    #             tags: {
+    #               include: true,
+    #               include_related: {},
+    #               include_in_join: true
+    #             }
+    #           },
+    #           include_in_join: true
     #         }
-    #       }
+    #       },
+    #       include_in_join: true
     #     }
     #   }
     # }
 
-    def initialize(resource_klass, includes_array)
+    def initialize(resource_klass, includes_array, force_eager_load: false)
       @resource_klass = resource_klass
+      @force_eager_load = force_eager_load
       @include_directives_hash = { include_related: {} }
       includes_array.each do |include|
         parse_include(include)
@@ -29,21 +40,68 @@ module JSONAPI
       @include_directives_hash
     end
 
-    private
+    def [](name)
+      @include_directives_hash[name]
+    end
 
-    def parse_include(include)
-      path = JSONAPI::Path.new(resource_klass: @resource_klass,
-                               path_string: include,
-                               ensure_default_field: false,
-                               parse_fields: false)
+    def model_includes
+      get_includes(@include_directives_hash)
+    end
 
+    private
+
+    def get_related(current_path)
       current = @include_directives_hash
+      current_resource_klass = @resource_klass
+      current_path.split('.').each do |fragment|
+        fragment = fragment.to_sym
+
+        if current_resource_klass
+          current_relationship = current_resource_klass._relationship(fragment)
+          current_resource_klass = current_relationship.try(:resource_klass)
+        else
+          raise JSONAPI::Exceptions::InvalidInclude.new(current_resource_klass, current_path)
+        end
+
+        include_in_join = @force_eager_load || !current_relationship || current_relationship.eager_load_on_include
+
+        current[:include_related][fragment] ||= { include: false, include_related: {}, include_in_join: include_in_join }
+        current = current[:include_related][fragment]
+      end
+      current
+    end
+
+    def get_includes(directive, only_joined_includes = true)
+      ir = directive[:include_related]
+      ir = ir.select { |_k,v| v[:include_in_join] } if only_joined_includes
+
+      ir.map do |name, sub_directive|
+        sub = get_includes(sub_directive, only_joined_includes)
+        sub.any? ? { name => sub } : name
+      end
+    end
+
+    def parse_include(include)
+      parts = include.split('.')
+      local_path = ''
 
-      path.segments.each do |segment|
-        relationship_name = segment.relationship.name.to_sym
+      parts.each do |name|
+        local_path += local_path.length > 0 ? ".#{name}" : name
+        related = get_related(local_path)
+        related[:include] = true
+      end
+    end
 
-        current[:include_related][relationship_name] ||= { include_related: {} }
-        current = current[:include_related][relationship_name]
+    def delve_paths(obj)
+      case obj
+        when Array
+          obj.map{|elem| delve_paths(elem)}.flatten(1)
+        when Hash
+          obj.map{|k,v| [[k]] + delve_paths(v).map{|path| [k] + path } }.flatten(1)
+        when Symbol, String
+          [[obj]]
+        else
+          raise "delve_paths cannot descend into #{obj.class.name}"
       end
 
     rescue JSONAPI::Exceptions::InvalidRelationship => _e

data/lib/jsonapi/link_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class LinkBuilder
     attr_reader :base_url,

data/lib/jsonapi/mime_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module JSONAPI
@@ -7,16 +9,10 @@ module JSONAPI
     def self.install
       Mime::Type.register JSONAPI::MEDIA_TYPE, :api_json
 
-      # :nocov:
-      if Rails::VERSION::MAJOR >= 5
-        parsers = ActionDispatch::Request.parameter_parsers.merge(
-          Mime::Type.lookup(JSONAPI::MEDIA_TYPE).symbol => parser
-        )
-        ActionDispatch::Request.parameter_parsers = parsers
-      else
-        ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime::Type.lookup(JSONAPI::MEDIA_TYPE)] = parser
-      end
-      # :nocov:
+      parsers = ActionDispatch::Request.parameter_parsers.merge(
+        Mime::Type.lookup(JSONAPI::MEDIA_TYPE).symbol => parser
+      )
+      ActionDispatch::Request.parameter_parsers = parsers
     end
 
     def self.parser

data/lib/jsonapi/naive_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
 
   # Cache which memoizes the given block.

data/lib/jsonapi/operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Operation
     attr_reader :resource_klass, :operation_type, :options

data/lib/jsonapi/operation_result.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class OperationResult
     attr_accessor :code

data/lib/jsonapi/paginator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Paginator
     def initialize(_params)

data/lib/jsonapi/path.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Path
     attr_reader :segments, :resource_klass

data/lib/jsonapi/path_segment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class PathSegment
     def self.parse(source_resource_klass:, segment_string:, parse_fields: true)
@@ -30,7 +32,7 @@ module JSONAPI
       end
 
       def eql?(other)
-        other.is_a?(JSONAPI::PathSegment::Relationship) && relationship == other.relationship && resource_klass == other.resource_klass
+        other.is_a?(self.class) && relationship == other.relationship && resource_klass == other.resource_klass
       end
 
       def hash
@@ -59,7 +61,7 @@ module JSONAPI
       end
 
       def eql?(other)
-        other.is_a?(JSONAPI::PathSegment::Field) && field_name == other.field_name && resource_klass == other.resource_klass
+        other.is_a?(self.class) && field_name == other.field_name && resource_klass == other.resource_klass
       end
 
       def delegated_field_name