Allow ActiveRecordRetrieval to support getting related resources through the inverse or primary resources

Author: lgebhardt

lib/jsonapi-resources.rb

@@ -41,8 +41,8 @@
 require 'jsonapi/callbacks'
 require 'jsonapi/link_builder'
 require 'jsonapi/active_relation/adapters/join_left_active_record_adapter'
-require 'jsonapi/active_relation/join_manager'
-require 'jsonapi/active_relation/join_manager_v10'
+require 'jsonapi/active_relation/join_manager_through_inverse'
+require 'jsonapi/active_relation/join_manager_through_primary'
 require 'jsonapi/resource_identity'
 require 'jsonapi/resource_fragment'
 require 'jsonapi/resource_tree'

lib/jsonapi/active_relation/join_manager.rb renamed to lib/jsonapi/active_relation/join_manager_through_inverse.rb

@@ -5,7 +5,7 @@ module ActiveRelation
 
   # Stores relationship paths starting from the resource_klass, consolidating duplicate paths from
   # relationships, filters and sorts. When joins are made the table aliases are tracked in join_details
-  class JoinManager
+  class JoinManagerThroughInverse
       attr_reader :resource_klass,
                   :source_relationship,
                   :resource_join_tree,

lib/jsonapi/active_relation/join_manager_v10.rb renamed to lib/jsonapi/active_relation/join_manager_through_primary.rb

@@ -5,7 +5,7 @@ module ActiveRelation
 
     # Stores relationship paths starting from the resource_klass, consolidating duplicate paths from
     # relationships, filters and sorts. When joins are made the table aliases are tracked in join_details
-    class JoinManagerV10
+    class JoinManagerThroughPrimary
       attr_reader :resource_klass,
                   :source_relationship,
                   :resource_join_tree,

lib/jsonapi/active_relation_retrieval.rb

@@ -15,6 +15,10 @@ def records_for(relation_name)
     end
 
     module ClassMethods
+      def default_find_related_through(polymorphic = false)
+        polymorphic ? :model : :model
+      end
+
       # Finds Resources using the `filters`. Pagination and sort options are used when provided
       #
       # @param filters [Hash] the filters hash
@@ -103,9 +107,9 @@ def find_fragments(filters, options)
         sort_criteria = options.fetch(:sort_criteria) { [] }
         order_options = construct_order_options(sort_criteria)
 
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: self,
-                                                       filters: filters,
-                                                       sort_criteria: sort_criteria)
+        join_manager = ActiveRelation::JoinManagerThroughInverse.new(resource_klass: self,
+                                                                     filters: filters,
+                                                                     sort_criteria: sort_criteria)
 
         options[:_relation_helper_options] = {
           context: context,

lib/jsonapi/active_relation_retrieval_v09.rb

@@ -9,6 +9,10 @@ def find_related_ids(relationship, options)
     end
 
     module ClassMethods
+      def default_find_related_through(polymorphic = false)
+        polymorphic ? :primary : :primary
+      end
+
       # Finds Resources using the `filters`. Pagination and sort options are used when provided
       #
       # @param filters [Hash] the filters hash
@@ -20,9 +24,9 @@ module ClassMethods
       def find(filters, options)
         sort_criteria = options.fetch(:sort_criteria) { [] }
 
-        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
-                                                       filters: filters,
-                                                       sort_criteria: sort_criteria)
+        join_manager = ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: self,
+                                                                     filters: filters,
+                                                                     sort_criteria: sort_criteria)
 
         paginator = options[:paginator]
 
@@ -42,8 +46,8 @@ def find(filters, options)
       #
       # @return [Integer] the count
       def count(filters, options)
-        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
-                                                       filters: filters)
+        join_manager = ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: self,
+                                                                     filters: filters)
 
         records = apply_request_settings_to_records(records: records(options),
                                filters: filters,
@@ -103,11 +107,11 @@ def find_fragments(filters, options)
 
         sort_criteria = options.fetch(:sort_criteria) { [] }
 
-        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: resource_klass,
-                                                       source_relationship: nil,
-                                                       relationships: linkage_relationships.collect(&:name),
-                                                       sort_criteria: sort_criteria,
-                                                       filters: filters)
+        join_manager = ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: resource_klass,
+                                                                     source_relationship: nil,
+                                                                     relationships: linkage_relationships.collect(&:name),
+                                                                     sort_criteria: sort_criteria,
+                                                                     filters: filters)
 
         paginator = options[:paginator]
 
@@ -234,9 +238,9 @@ def count_related(source_resource, relationship, options)
         filters = options.fetch(:filters, {})
 
         # Joins in this case are related to the related_klass
-        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
-                                                       source_relationship: relationship,
-                                                       filters: filters)
+        join_manager = ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: self,
+                                                                     source_relationship: relationship,
+                                                                     filters: filters)
 
         records = apply_request_settings_to_records(records: records(options),
                                resource_klass: related_klass,
@@ -377,11 +381,11 @@ def find_related_monomorphic_fragments(source_fragments, relationship, options,
           sort_criteria << { field: field, direction: sort[:direction] }
         end
 
-        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
-                                                       source_relationship: relationship,
-                                                       relationships: linkage_relationships.collect(&:name),
-                                                       sort_criteria: sort_criteria,
-                                                       filters: filters)
+        join_manager = ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: self,
+                                                                     source_relationship: relationship,
+                                                                     relationships: linkage_relationships.collect(&:name),
+                                                                     sort_criteria: sort_criteria,
+                                                                     filters: filters)
 
         paginator = options[:paginator]
 
@@ -495,10 +499,10 @@ def find_related_polymorphic_fragments(source_fragments, relationship, options,
           end
         end
 
-        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
-                                                       source_relationship: relationship,
-                                                       relationships: linkage_relationship_paths,
-                                                       filters: filters)
+        join_manager = ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: self,
+                                                                     source_relationship: relationship,
+                                                                     relationships: linkage_relationship_paths,
+                                                                     filters: filters)
 
         paginator = options[:paginator]
 
@@ -630,7 +634,7 @@ def find_related_polymorphic_fragments(source_fragments, relationship, options,
       end
 
       def apply_request_settings_to_records(records:,
-                                            join_manager: ActiveRelation::JoinManagerV10.new(resource_klass: self),
+                                            join_manager: ActiveRelation::JoinManagerThroughPrimary.new(resource_klass: self),
                                             resource_klass: self,
                                             filters: {},
                                             primary_keys: nil,

lib/jsonapi/active_relation_retrieval_v10.rb

@@ -44,6 +44,8 @@ class Configuration
                 :default_exclude_links,
                 :default_resource_retrieval_strategy,
                 :use_related_resource_records_for_joins,
+                :default_find_related_through,
+                :default_find_related_through_polymorphic,
                 :related_identities_set
 
     def initialize
@@ -172,13 +174,32 @@ def initialize
       # per resource (or base resource) using the class method `load_resource_retrieval_strategy`.
       #
       # Available strategies:
-      # 'JSONAPI::ActiveRelationRetrieval'
-      # 'JSONAPI::ActiveRelationRetrievalV09'
-      # 'JSONAPI::ActiveRelationRetrievalV10'
+      # 'JSONAPI::ActiveRelationRetrieval' - A configurable retrieval strategy
+      # 'JSONAPI::ActiveRelationRetrievalV09' - Retrieves resources using the v0.9.x approach. This uses rails'
+      # `includes` method to retrieve related models. This requires overriding the `records_for` method on the resource
+      # to control filtering of included resources.
+      # 'JSONAPI::ActiveRelationRetrievalV10' - Retrieves resources using the v0.10.x approach
+      # Custom - Specify the a custom retrieval strategy module name as a string
       # :none
       # :self
       self.default_resource_retrieval_strategy = 'JSONAPI::ActiveRelationRetrieval'
 
+      # For 'JSONAPI::ActiveRelationRetrieval' we can refine how related resources are retrieved with options for
+      # monomorphic and polymorphic relationships. The default is :inverse for both.
+      # :inverse - use the inverse relationship on the related resource. This joins the related resource to the
+      # primary resource table. To use this a relationship to the primary resource must be defined on the related
+      # resource.
+      # :primary - use the primary resource joined with the related resources table. This results in a two phased
+      # querying approach. The first phase gets the ids and cache fields. The second phase gets any cache misses
+      # from the related resource. In the second phase permissions are not applied since they were already applied in
+      # the first phase. This behavior is consistent with JR v0.10.x, with the exception that when caching is disabled
+      # the retrieval of the primary resources does not need to be done in two phases.
+      # TODO: Currently this results in `records_for_populate` not being called. We should see if we can fix this by
+      #       merging in `records_for_populate`.
+
+      self.default_find_related_through = :inverse
+      self.default_find_related_through_polymorphic = :inverse
+
       # 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.
@@ -344,6 +365,10 @@ def allow_include=(allow_include)
 
     attr_writer :use_related_resource_records_for_joins
 
+    attr_writer :default_find_related_through
+
+    attr_writer :default_find_related_through_polymorphic
+
     attr_writer :related_identities_set
   end
 

lib/jsonapi/configuration.rb

@@ -2,14 +2,25 @@
 
 module JSONAPI
   class Relationship
-    attr_reader :acts_as_set, :foreign_key, :options, :name,
-                :class_name, :polymorphic, :always_include_optional_linkage_data, :exclude_linkage_data,
-                :parent_resource, :eager_load_on_include, :custom_methods,
-                :inverse_relationship, :allow_include, :hidden, :use_related_resource_records_for_joins
-
-    attr_writer :allow_include
-
-    attr_accessor :_routed, :_warned_missing_route
+    attr_reader :acts_as_set,
+                :foreign_key,
+                :options,
+                :name,
+                :class_name,
+                :polymorphic,
+                :always_include_optional_linkage_data,
+                :exclude_linkage_data,
+                :parent_resource,
+                :eager_load_on_include,
+                :custom_methods,
+                :inverse_relationship,
+                :hidden,
+                :use_related_resource_records_for_joins,
+                :find_related_through
+
+    attr_accessor :allow_include,
+                  :_routed,
+                  :_warned_missing_route
 
     def initialize(name, options = {})
       @name = name.to_s
@@ -42,6 +53,9 @@ def initialize(name, options = {})
       @allow_include = options[:allow_include]
       @class_name = nil
 
+      find_related_through = options.fetch(:find_related_through, parent_resource_klass&.default_find_related_through)
+      @find_related_through = find_related_through&.to_sym
+
       @inverse_relationship = options[:inverse_relationship]&.to_sym
 
       @_routed = false
@@ -86,6 +100,10 @@ def inverse_relationship
       @inverse_relationship
     end
 
+    def inverse_relationship_klass
+      @inverse_relationship_klass ||= resource_klass._relationship(inverse_relationship)
+    end
+
     def self.polymorphic_types(name)
       ::JSONAPI::Utils::PolymorphicTypesLookup.polymorphic_types(name)
     end