jsonapi-resources 0.10.0.beta1 → 0.10.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1da47a9966931af4ff9a5bab22e41097bf9075bf
-  data.tar.gz: 7ed9248ebb089d4c3f76b03d9e1eb47c8810be75
+  metadata.gz: f0435c60c6dca20674f60da2681d58407de97f96
+  data.tar.gz: 9bad26baa66aaf9a6c5d3aa9f7e3797229826b67
 SHA512:
-  metadata.gz: 7f8a2a940460ca620cf2495856523c2cab00e72ee169ecc9c7bb84cb3499d96e4fe9a39b39f439b116bef24417e766cd93f8b2bf2be98e397cfe4994806abcc8
-  data.tar.gz: c54161c677a2b7dcf1db569bf1c05685ce8d5b84349157f7ab6f3b927c0a357322b57f762b2feeb8225ca8f9e04aeb63aa8313467d77e1f0e1d7d44616ff3357
+  metadata.gz: 97daeb8e0a39bac96c4c840e86fedd7a576a1877537a855c20b21ea29d3b29001fcf2c3e4b8e8f7ce3fbf544d84a6a54bd7742fd7a7c49f4a18579d1cc639645
+  data.tar.gz: 10983a6d90cd6e83b63a65e8a9fae0a1fc010b9dae266d1365ee11c8494e89bce1f32f18dce2151b4d2b3657d3cb41202d2556464e3d0ba651f933158c40e225

data/lib/jsonapi-resources.rb

@@ -30,3 +30,5 @@ require 'jsonapi/resource_identity'
 require 'jsonapi/resource_fragment'
 require 'jsonapi/resource_id_tree'
 require 'jsonapi/resource_set'
+require 'jsonapi/path'
+require 'jsonapi/path_segment'

data/lib/jsonapi/active_relation_resource_finder.rb

@@ -1,3 +1,5 @@
+require 'jsonapi/active_relation_resource_finder/adapters/join_left_active_record_adapter'
+
 module JSONAPI
   module ActiveRelationResourceFinder
     def self.included(base)
@@ -15,7 +17,21 @@ module JSONAPI
       #
       # @return [Array<Resource>] the Resource instances matching the filters, sorting and pagination rules.
       def find(filters, options = {})
-        records = find_records(filters, options)
+        sort_criteria = options.fetch(:sort_criteria) { [] }
+
+        join_tree = JoinTree.new(resource_klass: self,
+                                 options: options,
+                                 filters: filters,
+                                 sort_criteria: sort_criteria)
+
+        paginator = options[:paginator]
+
+        records = find_records(records: records(options),
+                               filters: filters,
+                               join_tree: join_tree,
+                               paginator: paginator,
+                               options: options)
+
         resources_for(records, options[:context])
       end
 
@@ -26,7 +42,16 @@ module JSONAPI
       #
       # @return [Integer] the count
       def count(filters, options = {})
-        count_records(filter_records(records(options), filters, options))
+        join_tree = JoinTree.new(resource_klass: self,
+                                 options: options,
+                                 filters: filters)
+
+        records = find_records(records: records(options),
+                               filters: filters,
+                               join_tree: join_tree,
+                               options: options)
+
+        count_records(records)
       end
 
       # Returns the single Resource identified by `key`
@@ -49,6 +74,7 @@ module JSONAPI
 
       # Finds Resource fragments using the `filters`. Pagination and sort options are used when provided.
       # Retrieving the ResourceIdentities and attributes does not instantiate a model instance.
+      # Note: This is incompatible with Polymorphic resources (which are going to come from two separate tables)
       #
       # @param filters [Hash] the filters hash
       # @option options [Hash] :context The context of the request, set in the controller
@@ -61,27 +87,76 @@ module JSONAPI
       #    the ResourceInstances matching the filters, sorting, and pagination rules along with any request
       #    additional_field values
       def find_fragments(filters, options = {})
-        records = find_records(filters, options)
+        include_directives = options[:include_directives] ? options[:include_directives].include_directives : {}
+        resource_klass = self
+        linkage_relationships = to_one_relationships_for_linkage(include_directives[:include_related])
 
-        table_name = _model_class.table_name
-        pluck_fields = [Arel.sql("#{concat_table_field(table_name, _primary_key)} AS #{table_name}_#{_primary_key}")]
+        sort_criteria = options.fetch(:sort_criteria) { [] }
+
+        join_tree = JoinTree.new(resource_klass: resource_klass,
+                                 source_relationship: nil,
+                                 relationships: linkage_relationships,
+                                 sort_criteria: sort_criteria,
+                                 filters: filters,
+                                 options: options)
+
+        paginator = options[:paginator]
+
+        records = find_records(records: records(options),
+                               filters: filters,
+                               sort_criteria: sort_criteria,
+                               paginator: paginator,
+                               join_tree: join_tree,
+                               options: options)
+
+        joins = join_tree.joins
+
+        # This alias is going to be resolve down to the model's table name and will not actually be an alias
+        resource_table_alias = joins[''][:alias]
+
+        pluck_fields = [Arel.sql("#{concat_table_field(resource_table_alias, resource_klass._primary_key)} AS #{resource_table_alias}_#{resource_klass._primary_key}")]
 
         cache_field = attribute_to_model_field(:_cache_field) if options[:cache]
         if cache_field
-          pluck_fields << Arel.sql("#{concat_table_field(table_name, cache_field[:name])} AS #{table_name}_#{cache_field[:name]}")
+          pluck_fields << Arel.sql("#{concat_table_field(resource_table_alias, cache_field[:name])} AS #{resource_table_alias}_#{cache_field[:name]}")
+        end
+
+        linkage_fields = []
+
+        linkage_relationships.each do |name|
+          linkage_relationship = resource_klass._relationship(name)
+
+          if linkage_relationship.polymorphic? && linkage_relationship.belongs_to?
+            linkage_relationship.resource_types.each do |resource_type|
+              klass = resource_klass_for(resource_type)
+              linkage_fields << {relationship_name: name, resource_klass: klass}
+
+              linkage_table_alias = joins["#{linkage_relationship.name.to_s}##{resource_type}"][:alias]
+              primary_key = klass._primary_key
+              pluck_fields << Arel.sql("#{concat_table_field(linkage_table_alias, primary_key)} AS #{linkage_table_alias}_#{primary_key}")
+            end
+          else
+            klass = linkage_relationship.resource_klass
+            linkage_fields << {relationship_name: name, resource_klass: klass}
+
+            linkage_table_alias = joins[name.to_s][:alias]
+            primary_key = klass._primary_key
+            pluck_fields << Arel.sql("#{concat_table_field(linkage_table_alias, primary_key)} AS #{linkage_table_alias}_#{primary_key}")
+          end
         end
 
         model_fields = {}
         attributes = options[:attributes]
         attributes.try(:each) do |attribute|
-          model_field = attribute_to_model_field(attribute)
+          model_field = resource_klass.attribute_to_model_field(attribute)
           model_fields[attribute] = model_field
-          pluck_fields << Arel.sql("#{concat_table_field(table_name, model_field[:name])} AS #{table_name}_#{model_field[:name]}")
+          pluck_fields << Arel.sql("#{concat_table_field(resource_table_alias, model_field[:name])} AS #{resource_table_alias}_#{model_field[:name]}")
         end
 
         fragments = {}
-        records.pluck(*pluck_fields).collect do |row|
-          rid = JSONAPI::ResourceIdentity.new(self, pluck_fields.length == 1 ? row : row[0])
+        rows = records.pluck(*pluck_fields)
+        rows.collect do |row|
+          rid = JSONAPI::ResourceIdentity.new(resource_klass, pluck_fields.length == 1 ? row : row[0])
 
           fragments[rid] ||= JSONAPI::ResourceFragment.new(rid)
           attributes_offset = 1
@@ -91,6 +166,16 @@ module JSONAPI
             attributes_offset+= 1
           end
 
+          linkage_fields.each do |linkage_field_details|
+            fragments[rid].initialize_related(linkage_field_details[:relationship_name])
+            related_id = row[attributes_offset]
+            if related_id
+              related_rid = JSONAPI::ResourceIdentity.new(linkage_field_details[:resource_klass], related_id)
+              fragments[rid].add_related_identity(linkage_field_details[:relationship_name], related_rid)
+            end
+            attributes_offset+= 1
+          end
+
           model_fields.each_with_index do |k, idx|
             fragments[rid].attributes[k[0]]= cast_to_attribute_type(row[idx + attributes_offset], k[1][:type])
           end
@@ -113,17 +198,17 @@ module JSONAPI
       def find_related_fragments(source_rids, relationship_name, options = {})
         relationship = _relationship(relationship_name)
 
-        if relationship.polymorphic? && relationship.foreign_key_on == :self
+        if relationship.polymorphic? # && relationship.foreign_key_on == :self
           find_related_polymorphic_fragments(source_rids, relationship, options, false)
         else
           find_related_monomorphic_fragments(source_rids, relationship, options, false)
         end
       end
 
-      def find_included_fragments(source_rids, relationship_name, options = {})
+      def find_included_fragments(source_rids, relationship_name, options)
         relationship = _relationship(relationship_name)
 
-        if relationship.polymorphic? && relationship.foreign_key_on == :self
+        if relationship.polymorphic? # && relationship.foreign_key_on == :self
           find_related_polymorphic_fragments(source_rids, relationship, options, true)
         else
           find_related_monomorphic_fragments(source_rids, relationship, options, true)
@@ -138,207 +223,221 @@ module JSONAPI
       #
       # @return [Integer] the count
       def count_related(source_rid, relationship_name, options = {})
-        opts = options.dup
-
         relationship = _relationship(relationship_name)
         related_klass = relationship.resource_klass
 
-        context = opts[:context]
-
-        primary_key_field = "#{_table_name}.#{_primary_key}"
-
-        records = records(context: context).where(primary_key_field => source_rid.id)
-
-        # join in related to the source records
-        records, related_alias = get_join_alias(records) { |records| records.joins(relationship.relation_name(opts)) }
+        filters = options.fetch(:filters, {})
 
-        join_tree = JoinTree.new(resource_klass: related_klass,
+        # Joins in this case are related to the related_klass
+        join_tree = JoinTree.new(resource_klass: self,
                                  source_relationship: relationship,
                                  filters: filters,
-                                 options: opts)
+                                 options: options)
 
-        records, joins = apply_joins(records, join_tree, opts)
+        records = find_records(records: records(options),
+                               resource_klass: related_klass,
+                               primary_keys: source_rid.id,
+                               join_tree: join_tree,
+                               filters: filters,
+                               options: options)
 
-        # Options for filtering
-        opts[:joins] = joins
-        opts[:related_alias] = related_alias
+        joins = join_tree.joins
+        related_alias = joins[''][:alias]
 
-        filters = opts.fetch(:filters, {})
-        records = related_klass.filter_records(records, filters,  opts)
+        records = records.select(Arel.sql("#{concat_table_field(related_alias, related_klass._primary_key)}"))
 
-        records.count(:all)
+        count_records(records)
       end
 
-      def parse_relationship_path(path)
-        relationships = []
-        relationship_names = []
-        field = nil
-
-        current_path = path
-        current_resource_klass = self
-        loop do
-          parts = current_path.to_s.partition('.')
-          relationship = current_resource_klass._relationship(parts[0])
-          if relationship
-            relationships << relationship
-            relationship_names << relationship.name
-          else
-            if parts[2].blank?
-              field = parts[0]
-              break
-            else
-              # :nocov:
-              warn "Unknown relationship #{parts[0]}"
-              # :nocov:
-            end
-          end
+      def records(_options = {})
+        _model_class.distinct.all
+      end
 
-          current_resource_klass = relationship.resource_klass
+      protected
 
-          if parts[2].include?('.')
-            current_path = parts[2]
-          else
-            relationship = current_resource_klass._relationship(parts[2])
-            if relationship
-              relationships << relationship
-              relationship_names << relationship.name
-            else
-              field = parts[2]
-            end
-            break
+      def to_one_relationships_for_linkage(include_related)
+        include_related ||= {}
+        relationships = []
+        _relationships.each do |name, relationship|
+          if relationship.is_a?(JSONAPI::Relationship::ToOne) && !include_related.has_key?(name) && relationship.include_optional_linkage_data?
+            relationships << name
           end
         end
-
-        return relationships, relationship_names.join('.'), field
+        relationships
       end
 
-      protected
-
       def find_record_by_key(key, options = {})
-        records = find_records({ _primary_key => key }, options.except(:paginator, :sort_criteria))
-        record = records.first
+        record = find_records(records: records(options), primary_keys: key, options: options).first
         fail JSONAPI::Exceptions::RecordNotFound.new(key) if record.nil?
         record
       end
 
       def find_records_by_keys(keys, options = {})
-        records(options).where({ _primary_key => keys })
+        find_records(records: records(options), primary_keys: keys, options: options)
       end
 
       def find_related_monomorphic_fragments(source_rids, relationship, options, connect_source_identity)
-        opts = options.dup
-
+        filters = options.fetch(:filters, {})
         source_ids = source_rids.collect {|rid| rid.id}
 
-        context = opts[:context]
-
-        related_klass = relationship.resource_klass
-
-        primary_key_field = "#{_table_name}.#{_primary_key}"
-
-        records = records(context: context).where(primary_key_field => source_ids)
-
-        # join in related to the source records
-        records, related_alias = get_join_alias(records) { |records| records.joins(relationship.relation_name(opts)) }
+        include_directives = options[:include_directives] ? options[:include_directives].include_directives : {}
+        resource_klass = relationship.resource_klass
+        linkage_relationships = resource_klass.to_one_relationships_for_linkage(include_directives[:include_related])
 
         sort_criteria = []
-        opts[:sort_criteria].try(:each) do |sort|
-          field = sort[:field].to_s == 'id' ? related_klass._primary_key : sort[:field]
+        options[:sort_criteria].try(:each) do |sort|
+          field = sort[:field].to_s == 'id' ? resource_klass._primary_key : sort[:field]
           sort_criteria << { field: field, direction: sort[:direction] }
         end
 
-        paginator = opts[:paginator]
-
-        filters = opts.fetch(:filters, {})
-
-        # Joins in this case are related to the related_klass
-        join_tree = JoinTree.new(resource_klass: related_klass,
+        join_tree = JoinTree.new(resource_klass: self,
                                  source_relationship: relationship,
-                                 filters: filters,
+                                 relationships: linkage_relationships,
                                  sort_criteria: sort_criteria,
-                                 options: opts)
+                                 filters: filters,
+                                 options: options)
 
-        records, joins = apply_joins(records, join_tree, opts)
+        paginator = options[:paginator] if source_rids.count == 1
 
-        # Options for filtering
-        opts[:joins] = joins
-        opts[:related_alias] = related_alias
+        records = find_records(records: records(options),
+                               resource_klass: resource_klass,
+                               sort_criteria: sort_criteria,
+                               primary_keys: source_ids,
+                               paginator: paginator,
+                               filters: filters,
+                               join_tree: join_tree,
+                               options: options)
 
-        records = related_klass.filter_records(records, filters,  opts)
+        joins = join_tree.joins
+        resource_table_alias = joins[''][:alias]
 
-        order_options = related_klass.construct_order_options(sort_criteria)
+        pluck_fields = [
+            Arel.sql("#{_table_name}.#{_primary_key} AS source_id"),
+            Arel.sql("#{concat_table_field(resource_table_alias, resource_klass._primary_key)} AS #{resource_table_alias}_#{resource_klass._primary_key}")
+        ]
 
-        # ToDO: Remove count check. Currently pagination isn't working with multiple source_rids (i.e. it only works
-        # for show relationships, not related includes).
-        if paginator && source_rids.count == 1
-          records = related_klass.apply_pagination(records, paginator, order_options)
+        cache_field = resource_klass.attribute_to_model_field(:_cache_field) if options[:cache]
+        if cache_field
+          pluck_fields << Arel.sql("#{concat_table_field(resource_table_alias, cache_field[:name])} AS #{resource_table_alias}_#{cache_field[:name]}")
         end
 
-        records = sort_records(records, order_options, opts)
+        linkage_fields = []
 
-        pluck_fields = [
-            Arel.sql(primary_key_field),
-            Arel.sql("#{concat_table_field(related_alias, related_klass._primary_key)} AS #{related_alias}_#{related_klass._primary_key}")
-        ]
+        linkage_relationships.each do |name|
+          linkage_relationship = resource_klass._relationship(name)
 
-        cache_field = related_klass.attribute_to_model_field(:_cache_field) if opts[:cache]
-        if cache_field
-          pluck_fields << Arel.sql("#{concat_table_field(related_alias, cache_field[:name])} AS #{related_alias}_#{cache_field[:name]}")
+          if linkage_relationship.polymorphic? && linkage_relationship.belongs_to?
+            linkage_relationship.resource_types.each do |resource_type|
+              klass = resource_klass_for(resource_type)
+              linkage_fields << {relationship_name: name, resource_klass: klass}
+
+              linkage_table_alias = joins["#{linkage_relationship.name.to_s}##{resource_type}"][:alias]
+              primary_key = klass._primary_key
+              pluck_fields << Arel.sql("#{concat_table_field(linkage_table_alias, primary_key)} AS #{linkage_table_alias}_#{primary_key}")
+            end
+          else
+            klass = linkage_relationship.resource_klass
+            linkage_fields << {relationship_name: name, resource_klass: klass}
+
+            linkage_table_alias = joins[name.to_s][:alias]
+            primary_key = klass._primary_key
+            pluck_fields << Arel.sql("#{concat_table_field(linkage_table_alias, primary_key)} AS #{linkage_table_alias}_#{primary_key}")
+          end
         end
 
         model_fields = {}
-        attributes = opts[:attributes]
+        attributes = options[:attributes]
         attributes.try(:each) do |attribute|
-          model_field = related_klass.attribute_to_model_field(attribute)
+          model_field = resource_klass.attribute_to_model_field(attribute)
           model_fields[attribute] = model_field
-          pluck_fields << Arel.sql("#{concat_table_field(related_alias, model_field[:name])} AS #{related_alias}_#{model_field[:name]}")
+          pluck_fields << Arel.sql("#{concat_table_field(resource_table_alias, model_field[:name])} AS #{resource_table_alias}_#{model_field[:name]}")
         end
 
+        fragments = {}
         rows = records.pluck(*pluck_fields)
-
-        related_fragments = {}
-
         rows.each do |row|
-          unless row[1].nil?
-            rid = JSONAPI::ResourceIdentity.new(related_klass, row[1])
+          rid = JSONAPI::ResourceIdentity.new(resource_klass, row[1])
 
-            related_fragments[rid] ||= JSONAPI::ResourceFragment.new(rid)
+          fragments[rid] ||= JSONAPI::ResourceFragment.new(rid)
 
-            attributes_offset = 2
+          attributes_offset = 2
 
-            if cache_field
-              related_fragments[rid].cache = cast_to_attribute_type(row[attributes_offset], cache_field[:type])
-              attributes_offset+= 1
-            end
+          if cache_field
+            fragments[rid].cache = cast_to_attribute_type(row[attributes_offset], cache_field[:type])
+            attributes_offset+= 1
+          end
 
-            model_fields.each_with_index do |k, idx|
-              related_fragments[rid].attributes[k[0]] = cast_to_attribute_type(row[idx + attributes_offset], k[1][:type])
-            end
+          model_fields.each_with_index do |k, idx|
+            fragments[rid].add_attribute(k[0], cast_to_attribute_type(row[idx + attributes_offset], k[1][:type]))
+            attributes_offset+= 1
+          end
 
-            source_rid = JSONAPI::ResourceIdentity.new(self, row[0])
+          source_rid = JSONAPI::ResourceIdentity.new(self, row[0])
 
-            related_fragments[rid].add_related_from(source_rid)
+          fragments[rid].add_related_from(source_rid)
 
-            if connect_source_identity
-              related_relationship = related_klass._relationships[relationship.inverse_relationship]
-              if related_relationship
-                related_fragments[rid].add_related_identity(related_relationship.name, source_rid)
-              end
+          linkage_fields.each do |linkage_field|
+            fragments[rid].initialize_related(linkage_field[:relationship_name])
+            related_id = row[attributes_offset]
+            if related_id
+              related_rid = JSONAPI::ResourceIdentity.new(linkage_field[:resource_klass], related_id)
+              fragments[rid].add_related_identity(linkage_field[:relationship_name], related_rid)
+            end
+            attributes_offset+= 1
+          end
+
+          if connect_source_identity
+            related_relationship = resource_klass._relationships[relationship.inverse_relationship]
+            if related_relationship
+              fragments[rid].add_related_identity(related_relationship.name, source_rid)
             end
           end
         end
 
-        related_fragments
+        fragments
       end
 
       # Gets resource identities where the related resource is polymorphic and the resource type and id
       # are stored on the primary resources. Cache fields will always be on the related resources.
       def find_related_polymorphic_fragments(source_rids, relationship, options, connect_source_identity)
+        filters = options.fetch(:filters, {})
         source_ids = source_rids.collect {|rid| rid.id}
 
-        context = options[:context]
+        resource_klass = relationship.resource_klass
+        include_directives = options[:include_directives] ? options[:include_directives].include_directives : {}
+
+        linkage_relationships = []
+
+        resource_types = relationship.resource_types
+
+        resource_types.each do |resource_type|
+          related_resource_klass = resource_klass_for(resource_type)
+          relationships = related_resource_klass.to_one_relationships_for_linkage(include_directives[:include_related])
+          relationships.each do |r|
+            linkage_relationships << "##{resource_type}.#{r}"
+          end
+        end
+
+        join_tree = JoinTree.new(resource_klass: self,
+                                 source_relationship: relationship,
+                                 relationships: linkage_relationships,
+                                 filters: filters,
+                                 options: options)
+
+        paginator = options[:paginator] if source_rids.count == 1
 
-        records = records(context: context)
+        # Note: We will sort by the source table. Without using unions we can't sort on a polymorphic relationship
+        # in any manner that makes sense
+        records = find_records(records: records(options),
+                               resource_klass: resource_klass,
+                               sort_primary: true,
+                               primary_keys: source_ids,
+                               paginator: paginator,
+                               filters: filters,
+                               join_tree: join_tree,
+                               options: options)
+
+        joins = join_tree.joins
 
         primary_key = concat_table_field(_table_name, _primary_key)
         related_key = concat_table_field(_table_name, relationship.foreign_key)
@@ -350,62 +449,85 @@ module JSONAPI
             Arel.sql("#{related_type} AS #{_table_name}_#{relationship.polymorphic_type}")
         ]
 
-        relations = relationship.polymorphic_relations
-
         # Get the additional fields from each relation. There's a limitation that the fields must exist in each relation
 
         relation_positions = {}
-        relation_index = 3
+        relation_index = pluck_fields.length
 
         attributes = options.fetch(:attributes, [])
 
-        if relations.nil? || relations.length == 0
+        # Add resource specific fields
+        if resource_types.nil? || resource_types.length == 0
           # :nocov:
-          warn "No relations found for polymorphic relationship."
+          warn "No resource types found for polymorphic relationship."
           # :nocov:
         else
-          relations.try(:each) do |relation|
-            related_klass = resource_klass_for(relation.to_s)
+          resource_types.try(:each) do |type|
+            related_klass = resource_klass_for(type.to_s)
 
             cache_field = related_klass.attribute_to_model_field(:_cache_field) if options[:cache]
 
-            # We only need to join the relations if we are getting additional fields
-            if cache_field || attributes.length > 0
-              records, table_alias = get_join_alias(records) { |records| records.left_joins(relation.to_sym) }
-
-              if cache_field
-                pluck_fields << concat_table_field(table_alias, cache_field[:name])
-              end
-
-              model_fields = {}
-              attributes.try(:each) do |attribute|
-                model_field = related_klass.attribute_to_model_field(attribute)
-                model_fields[attribute] = model_field
-              end
+            table_alias = joins["##{type}"][:alias]
 
-              model_fields.each do |_k, v|
-                pluck_fields << concat_table_field(table_alias, v[:name])
-              end
+            cache_offset = relation_index
+            if cache_field
+              pluck_fields << Arel.sql("#{concat_table_field(table_alias, cache_field[:name])} AS cache_#{type}_#{cache_field[:name]}")
+              relation_index+= 1
+            end
 
+            model_fields = {}
+            field_offset = relation_index
+            attributes.try(:each) do |attribute|
+              model_field = related_klass.attribute_to_model_field(attribute)
+              model_fields[attribute] = model_field
+              pluck_fields << Arel.sql("#{concat_table_field(table_alias, model_field[:name])} AS #{table_alias}_#{model_field[:name]}")
+              relation_index+= 1
             end
 
-            related = related_klass._model_class.name
-            relation_positions[related] = { relation_klass: related_klass,
-                                            cache_field: cache_field,
-                                            model_fields: model_fields,
-                                            field_offset: relation_index}
+            model_offset = relation_index
+            model_fields.each do |_k, v|
+              pluck_fields << Arel.sql("#{concat_table_field(table_alias, v[:name])}")
+              relation_index+= 1
+            end
 
-            relation_index+= 1 if cache_field
-            relation_index+= attributes.length if attributes.length > 0
+            relation_positions[type] = {relation_klass: related_klass,
+                                        cache_field: cache_field,
+                                        cache_offset: cache_offset,
+                                        model_fields: model_fields,
+                                        model_offset: model_offset,
+                                        field_offset: field_offset}
           end
         end
 
-        primary_resource_filters = options[:filters]
-        primary_resource_filters ||= {}
+        # Add to_one linkage fields
+        linkage_fields = []
+        linkage_offset = relation_index
 
-        primary_resource_filters[_primary_key] = source_ids
+        linkage_relationships.each do |linkage_relationship_path|
+          path = JSONAPI::Path.new(resource_klass: self,
+                                   path_string: "#{relationship.name}#{linkage_relationship_path}",
+                                   ensure_default_field: false)
 
-        records = apply_filters(records, primary_resource_filters, options)
+          linkage_relationship = path.segments[-1].relationship
+
+          if linkage_relationship.polymorphic? && linkage_relationship.belongs_to?
+            linkage_relationship.resource_types.each do |resource_type|
+              klass = resource_klass_for(resource_type)
+              linkage_fields << {relationship: linkage_relationship, resource_klass: klass}
+
+              linkage_table_alias = joins[linkage_relationship_path][:alias]
+              primary_key = klass._primary_key
+              pluck_fields << Arel.sql("#{concat_table_field(linkage_table_alias, primary_key)} AS #{linkage_table_alias}_#{primary_key}")
+            end
+          else
+            klass = linkage_relationship.resource_klass
+            linkage_fields << {relationship: linkage_relationship, resource_klass: klass}
+
+            linkage_table_alias = joins[linkage_relationship_path.to_s][:alias]
+            primary_key = klass._primary_key
+            pluck_fields << Arel.sql("#{concat_table_field(linkage_table_alias, primary_key)} AS #{linkage_table_alias}_#{primary_key}")
+          end
+        end
 
         rows = records.pluck(*pluck_fields)
 
@@ -428,21 +550,29 @@ module JSONAPI
               end
             end
 
-            relation_position = relation_positions[row[2]]
+            relation_position = relation_positions[row[2].downcase.pluralize]
             model_fields = relation_position[:model_fields]
             cache_field = relation_position[:cache_field]
+            cache_offset = relation_position[:cache_offset]
             field_offset = relation_position[:field_offset]
 
-            attributes_offset = 0
-
             if cache_field
-              related_fragments[rid].cache = cast_to_attribute_type(row[field_offset], cache_field[:type])
-              attributes_offset+= 1
+              related_fragments[rid].cache = cast_to_attribute_type(row[cache_offset], cache_field[:type])
             end
 
             if attributes.length > 0
               model_fields.each_with_index do |k, idx|
-                related_fragments[rid].add_attribute(k[0], cast_to_attribute_type(row[idx + field_offset + attributes_offset], k[1][:type]))
+                related_fragments[rid].add_attribute(k[0], cast_to_attribute_type(row[idx + field_offset], k[1][:type]))
+              end
+            end
+
+            linkage_fields.each_with_index do |linkage_field_details, idx|
+              relationship = linkage_field_details[:relationship]
+              related_fragments[rid].initialize_related(relationship.name)
+              related_id = row[linkage_offset + idx]
+              if related_id
+                related_rid = JSONAPI::ResourceIdentity.new(linkage_field_details[:resource_klass], related_id)
+                related_fragments[rid].add_related_identity(relationship.name, related_rid)
               end
             end
           end
@@ -451,28 +581,41 @@ module JSONAPI
         related_fragments
       end
 
-      def find_records(filters, options = {})
-        opts = options.dup
-
-        sort_criteria = opts.fetch(:sort_criteria) { [] }
+      def find_records(records:,
+                       join_tree: JoinTree.new(resource_klass: self),
+                       resource_klass: self,
+                       filters: nil,
+                       primary_keys: nil,
+                       sort_criteria: nil,
+                       sort_primary: nil,
+                       paginator: nil,
+                       options: {})
 
-        join_tree = JoinTree.new(resource_klass: self,
-                                 filters: filters,
-                                 sort_criteria: sort_criteria,
-                                 options: opts)
+        opts = options.dup
+        records = resource_klass.apply_joins(records, join_tree, opts)
 
-        records, joins = apply_joins(records(opts), join_tree, opts)
+        if primary_keys
+          records = records.where(_primary_key => primary_keys)
+        end
 
-        opts[:joins] = joins
+        opts[:joins] = join_tree.joins
 
-        records = filter_records(records, filters, opts)
+        if filters
+          records = resource_klass.filter_records(records, filters, opts)
+        end
 
-        order_options = construct_order_options(sort_criteria)
-        records = sort_records(records, order_options, opts)
+        if sort_primary
+          records = records.order(_primary_key => :asc)
+        else
+          order_options = resource_klass.construct_order_options(sort_criteria)
+          records = resource_klass.sort_records(records, order_options, opts)
+        end
 
-        records = apply_pagination(records, opts[:paginator], order_options)
+        if paginator
+          records = resource_klass.apply_pagination(records, paginator, order_options)
+        end
 
-        records.distinct
+        records
       end
 
       def get_join_alias(records, &block)
@@ -507,20 +650,20 @@ module JSONAPI
       end
 
       def apply_joins(records, join_tree, _options)
-        joins = join_tree.get_joins
+        joins = join_tree.joins
 
-        joins.each do |key, join_details|
-          case join_details[:join_type]
+        joins.each_value do |join|
+          case join[:join_type]
           when :inner
-            records, join_alias = get_join_alias(records) { |records| records.joins(join_details[:relation_join_hash]) }
+            records, join_alias = get_join_alias(records) { |records| records.joins(join[:relation_join_hash]) }
+            join[:alias] = join_alias
           when :left
-            records, join_alias = get_join_alias(records) { |records| records.left_joins(join_details[:relation_join_hash]) }
+            records, join_alias = get_join_alias(records) { |records| records.joins_left(join[:relation_join_hash]) }
+            join[:alias] = join_alias
           end
-
-          joins[key][:alias] = join_alias
         end
 
-        return records, joins
+        return records
       end
 
       def apply_pagination(records, paginator, order_options)
@@ -544,21 +687,41 @@ module JSONAPI
         strategy = _allowed_sort.fetch(field.to_sym, {})[:apply]
 
         if strategy
-          call_method_or_proc(strategy, records, direction, context)
+          records = call_method_or_proc(strategy, records, direction, context)
         else
           joins = options[:joins] || {}
 
-          records.order("#{get_aliased_field(field, joins, options[:related_alias])} #{direction}")
+          records = records.order("#{get_aliased_field(field, joins)} #{direction}")
         end
+        records
       end
 
       # Assumes ActiveRecord's counting. Override if you need a different counting method
       def count_records(records)
-        records.count(:all)
+        if Rails::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MINOR >= 1
+          records.count(:all)
+        else
+          records.count
+        end
       end
 
       def filter_records(records, filters, options)
-        apply_filters(records, filters, options)
+        if _polymorphic
+          _polymorphic_resource_klasses.each do |klass|
+            records = klass.apply_filters(records, filters, options)
+          end
+        else
+          records = apply_filters(records, filters, options)
+        end
+        records
+      end
+
+      def construct_order_options(sort_params)
+        if _polymorphic
+          warn "Sorting is not supported on polymorphic relationships"
+        else
+          super(sort_params)
+        end
       end
 
       def sort_records(records, order_options, options)
@@ -595,31 +758,22 @@ module JSONAPI
         records
       end
 
-      def get_aliased_field(path_with_field, joins, related_alias)
-        relationships, relationship_path, field = parse_relationship_path(path_with_field)
-        relationship = relationships.last
-
-        resource_klass = relationship ? relationship.resource_klass : self
+      def get_aliased_field(path_with_field, joins)
+        path = JSONAPI::Path.new(resource_klass: self, path_string: path_with_field)
 
-        if field.empty?
-          field_name = resource_klass._primary_key
-        else
-          field_name = resource_klass._attribute_delegated_name(field)
-        end
+        relationship = path.segments[-2]
+        field = path.segments[-1]
+        relationship_path = path.relationship_path_string
 
         if relationship
           join_name = relationship_path
-
           join = joins.try(:[], join_name)
-
           table_alias = join.try(:[], :alias)
-        else
-          table_alias = related_alias
         end
 
-        table_alias ||= resource_klass._table_name
+        table_alias ||= joins[''][:alias]
 
-        concat_table_field(table_alias, field_name)
+        concat_table_field(table_alias, field.delegated_field_name)
       end
 
       def apply_filter(records, filter, value, options = {})
@@ -629,8 +783,7 @@ module JSONAPI
           records = call_method_or_proc(strategy, records, value, options)
         else
           joins = options[:joins] || {}
-          related_alias = options[:related_alias]
-          records = records.where(get_aliased_field(filter, joins, related_alias) => value)
+          records = records.where(get_aliased_field(filter, joins) => value)
         end
 
         records