jsonapi-resources 0.10.6 → 0.11.0.beta2

data/lib/jsonapi/{active_relation_resource.rb → active_relation_retrieval_v10.rb}

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module JSONAPI
-  class ActiveRelationResource < BasicResource
-    root_resource
+  module ActiveRelationRetrievalV10
+    def find_related_ids(relationship, options = {})
+      self.class.find_related_fragments(self, relationship, options).keys.collect { |rid| rid.id }
+    end
 
-    class << self
+    module ClassMethods
       # Finds Resources using the `filters`. Pagination and sort options are used when provided
       #
       # @param filters [Hash] the filters hash
@@ -14,7 +18,7 @@ module JSONAPI
       def find(filters, options = {})
         sort_criteria = options.fetch(:sort_criteria) { [] }
 
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: self,
+        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
                                                        filters: filters,
                                                        sort_criteria: sort_criteria)
 
@@ -36,7 +40,7 @@ module JSONAPI
       #
       # @return [Integer] the count
       def count(filters, options = {})
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: self,
+        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
                                                        filters: filters)
 
         records = apply_request_settings_to_records(records: records(options),
@@ -76,29 +80,30 @@ module JSONAPI
       end
 
       # 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
       # @option options [Hash] :sort_criteria The `sort criteria`
       # @option options [Hash] :include_directives The `include_directives`
-      # @option options [Hash] :attributes Additional fields to be retrieved.
       # @option options [Boolean] :cache Return the resources' cache field
       #
-      # @return [Hash{ResourceIdentity => {identity: => ResourceIdentity, cache: cache_field, attributes: => {name => value}}}]
+      # @return [Hash{ResourceIdentity => {identity: => ResourceIdentity, cache: cache_field}]
       #    the ResourceInstances matching the filters, sorting, and pagination rules along with any request
       #    additional_field values
       def find_fragments(filters, options = {})
-        include_directives = options[:include_directives] ? options[:include_directives].include_directives : {}
+        include_directives = options.fetch(:include_directives, {})
         resource_klass = self
+
+        fragments = {}
+
         linkage_relationships = to_one_relationships_for_linkage(include_directives[:include_related])
 
         sort_criteria = options.fetch(:sort_criteria) { [] }
 
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: resource_klass,
+        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: resource_klass,
                                                        source_relationship: nil,
-                                                       relationships: linkage_relationships,
+                                                       relationships: linkage_relationships.collect(&:name),
                                                        sort_criteria: sort_criteria,
                                                        filters: filters)
 
@@ -123,42 +128,41 @@ module JSONAPI
 
         linkage_fields = []
 
-        linkage_relationships.each do |name|
-          linkage_relationship = resource_klass._relationship(name)
+        linkage_relationships.each do |linkage_relationship|
+          linkage_relationship_name = linkage_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 = join_manager.join_details_by_polymorphic_relationship(linkage_relationship, resource_type)[:alias]
               primary_key = klass._primary_key
+
+              linkage_fields << {relationship_name: linkage_relationship_name,
+                                 resource_klass: klass,
+                                 field: sql_field_with_alias(linkage_table_alias, primary_key),
+                                 alias: alias_table_field(linkage_table_alias, primary_key)}
+
               pluck_fields << sql_field_with_alias(linkage_table_alias, primary_key)
             end
           else
             klass = linkage_relationship.resource_klass
-            linkage_fields << {relationship_name: name, resource_klass: klass}
-
             linkage_table_alias = join_manager.join_details_by_relationship(linkage_relationship)[:alias]
             primary_key = klass._primary_key
+
+            linkage_fields << {relationship_name: linkage_relationship_name,
+                               resource_klass: klass,
+                               field: sql_field_with_alias(linkage_table_alias, primary_key),
+                               alias: alias_table_field(linkage_table_alias, primary_key)}
+
             pluck_fields << sql_field_with_alias(linkage_table_alias, primary_key)
           end
         end
 
-        model_fields = {}
-        attributes = options[:attributes]
-        attributes.try(:each) do |attribute|
-          model_field = resource_klass.attribute_to_model_field(attribute)
-          model_fields[attribute] = model_field
-          pluck_fields << sql_field_with_alias(resource_table_alias, model_field[:name])
-        end
-
         sort_fields = options.dig(:_relation_helper_options, :sort_fields)
         sort_fields.try(:each) do |field|
           pluck_fields << Arel.sql(field)
         end
 
-        fragments = {}
         rows = records.pluck(*pluck_fields)
         rows.each do |row|
           rid = JSONAPI::ResourceIdentity.new(resource_klass, pluck_fields.length == 1 ? row : row[0])
@@ -180,10 +184,6 @@ module JSONAPI
             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
         end
 
         if JSONAPI.configuration.warn_on_performance_issues && (rows.length > fragments.length)
@@ -198,29 +198,24 @@ module JSONAPI
       # @param source_rids [Array<ResourceIdentity>] The resources to find related ResourcesIdentities for
       # @param relationship_name [String | Symbol] The name of the relationship
       # @option options [Hash] :context The context of the request, set in the controller
-      # @option options [Hash] :attributes Additional fields to be retrieved.
       # @option options [Boolean] :cache Return the resources' cache field
       #
-      # @return [Hash{ResourceIdentity => {identity: => ResourceIdentity, cache: cache_field, attributes: => {name => value}, related: {relationship_name: [] }}}]
+      # @return [Hash{ResourceIdentity => {identity: => ResourceIdentity, cache: cache_field, related: {relationship_name: [] }}}]
       #    the ResourceInstances matching the filters, sorting, and pagination rules along with any request
       #    additional_field values
-      def find_related_fragments(source_rids, relationship_name, options = {})
-        relationship = _relationship(relationship_name)
-
-        if relationship.polymorphic? # && relationship.foreign_key_on == :self
-          find_related_polymorphic_fragments(source_rids, relationship, options, false)
+      def find_related_fragments(source_fragment, relationship, options = {})
+        if relationship.polymorphic?
+          find_related_polymorphic_fragments([source_fragment], relationship, options, false)
         else
-          find_related_monomorphic_fragments(source_rids, relationship, options, false)
+          find_related_monomorphic_fragments([source_fragment], relationship, options, false)
         end
       end
 
-      def find_included_fragments(source_rids, relationship_name, options)
-        relationship = _relationship(relationship_name)
-
-        if relationship.polymorphic? # && relationship.foreign_key_on == :self
-          find_related_polymorphic_fragments(source_rids, relationship, options, true)
+      def find_included_fragments(source_fragments, relationship, options)
+        if relationship.polymorphic?
+          find_related_polymorphic_fragments(source_fragments, relationship, options, true)
         else
-          find_related_monomorphic_fragments(source_rids, relationship, options, true)
+          find_related_monomorphic_fragments(source_fragments, relationship, options, true)
         end
       end
 
@@ -231,20 +226,19 @@ module JSONAPI
       # @option options [Hash] :context The context of the request, set in the controller
       #
       # @return [Integer] the count
-      def count_related(source_rid, relationship_name, options = {})
-        relationship = _relationship(relationship_name)
+      def count_related(source_resource, relationship, options = {})
         related_klass = relationship.resource_klass
 
         filters = options.fetch(:filters, {})
 
         # Joins in this case are related to the related_klass
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: self,
+        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
                                                        source_relationship: relationship,
                                                        filters: filters)
 
         records = apply_request_settings_to_records(records: records(options),
                                resource_klass: related_klass,
-                               primary_keys: source_rid.id,
+                               primary_keys: source_resource.id,
                                join_manager: join_manager,
                                filters: filters,
                                options: options)
@@ -294,9 +288,7 @@ module JSONAPI
         records_base(options)
       end
 
-      # The `ActiveRecord::Relation` used for the finding related resources. Only resources that have been previously
-      # identified through the `records` method will be accessed and used as the basis to find related resources. Thus
-      # it should not be necessary to reapply permissions checks.
+      # The `ActiveRecord::Relation` used for the finding related resources.
       #
       # @option options [Hash] :context The context of the request, set in the controller
       #
@@ -357,18 +349,7 @@ module JSONAPI
         records.merge(relationship_records)
       end
 
-      protected
-
-      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
-        relationships
-      end
+      # protected
 
       def find_record_by_key(key, options = {})
         record = apply_request_settings_to_records(records: records(options), primary_keys: key, options: options).first
@@ -380,11 +361,11 @@ module JSONAPI
         apply_request_settings_to_records(records: records(options), primary_keys: keys, options: options)
       end
 
-      def find_related_monomorphic_fragments(source_rids, relationship, options, connect_source_identity)
+      def find_related_monomorphic_fragments(source_fragments, relationship, options, connect_source_identity)
         filters = options.fetch(:filters, {})
-        source_ids = source_rids.collect {|rid| rid.id}
+        source_ids = source_fragments.collect {|item| item.identity.id}
 
-        include_directives = options[:include_directives] ? options[:include_directives].include_directives : {}
+        include_directives = options.fetch(:include_directives, {})
         resource_klass = relationship.resource_klass
         linkage_relationships = resource_klass.to_one_relationships_for_linkage(include_directives[:include_related])
 
@@ -394,9 +375,9 @@ module JSONAPI
           sort_criteria << { field: field, direction: sort[:direction] }
         end
 
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: self,
+        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
                                                        source_relationship: relationship,
-                                                       relationships: linkage_relationships,
+                                                       relationships: linkage_relationships.collect(&:name),
                                                        sort_criteria: sort_criteria,
                                                        filters: filters)
 
@@ -425,13 +406,13 @@ module JSONAPI
 
         linkage_fields = []
 
-        linkage_relationships.each do |name|
-          linkage_relationship = resource_klass._relationship(name)
+        linkage_relationships.each do |linkage_relationship|
+          linkage_relationship_name = linkage_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_fields << {relationship_name: linkage_relationship_name, resource_klass: klass}
 
               linkage_table_alias = join_manager.join_details_by_polymorphic_relationship(linkage_relationship, resource_type)[:alias]
               primary_key = klass._primary_key
@@ -439,7 +420,7 @@ module JSONAPI
             end
           else
             klass = linkage_relationship.resource_klass
-            linkage_fields << {relationship_name: name, resource_klass: klass}
+            linkage_fields << {relationship_name: linkage_relationship_name, resource_klass: klass}
 
             linkage_table_alias = join_manager.join_details_by_relationship(linkage_relationship)[:alias]
             primary_key = klass._primary_key
@@ -447,14 +428,6 @@ module JSONAPI
           end
         end
 
-        model_fields = {}
-        attributes = options[:attributes]
-        attributes.try(:each) do |attribute|
-          model_field = resource_klass.attribute_to_model_field(attribute)
-          model_fields[attribute] = model_field
-          pluck_fields << sql_field_with_alias(resource_table_alias, model_field[:name])
-        end
-
         sort_fields = options.dig(:_relation_helper_options, :sort_fields)
         sort_fields.try(:each) do |field|
           pluck_fields << Arel.sql(field)
@@ -474,11 +447,6 @@ module JSONAPI
             attributes_offset+= 1
           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])
 
           fragments[rid].add_related_from(source_rid)
@@ -494,7 +462,7 @@ module JSONAPI
           end
 
           if connect_source_identity
-            related_relationship = resource_klass._relationships[relationship.inverse_relationship]
+            related_relationship = resource_klass._relationship(relationship.inverse_relationship)
             if related_relationship
               fragments[rid].add_related_identity(related_relationship.name, source_rid)
             end
@@ -506,14 +474,14 @@ module JSONAPI
 
       # 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)
+      def find_related_polymorphic_fragments(source_fragments, relationship, options, connect_source_identity)
         filters = options.fetch(:filters, {})
-        source_ids = source_rids.collect {|rid| rid.id}
+        source_ids = source_fragments.collect {|item| item.identity.id}
 
         resource_klass = relationship.resource_klass
-        include_directives = options[:include_directives] ? options[:include_directives].include_directives : {}
+        include_directives = options.fetch(:include_directives, {})
 
-        linkage_relationships = []
+        linkage_relationship_paths = []
 
         resource_types = relationship.resource_types
 
@@ -521,13 +489,13 @@ module JSONAPI
           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}"
+            linkage_relationship_paths << "##{resource_type}.#{r.name}"
           end
         end
 
-        join_manager = ActiveRelation::JoinManager.new(resource_klass: self,
+        join_manager = ActiveRelation::JoinManagerV10.new(resource_klass: self,
                                                        source_relationship: relationship,
-                                                       relationships: linkage_relationships,
+                                                       relationships: linkage_relationship_paths,
                                                        filters: filters)
 
         paginator = options[:paginator]
@@ -558,8 +526,6 @@ module JSONAPI
         relation_positions = {}
         relation_index = pluck_fields.length
 
-        attributes = options.fetch(:attributes, [])
-
         # Add resource specific fields
         if resource_types.nil? || resource_types.length == 0
           # :nocov:
@@ -579,27 +545,9 @@ module JSONAPI
               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 << sql_field_with_alias(table_alias, model_field[:name])
-              relation_index+= 1
-            end
-
-            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_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}
+                                        cache_offset: cache_offset}
           end
         end
 
@@ -607,7 +555,7 @@ module JSONAPI
         linkage_fields = []
         linkage_offset = relation_index
 
-        linkage_relationships.each do |linkage_relationship_path|
+        linkage_relationship_paths.each do |linkage_relationship_path|
           path = JSONAPI::Path.new(resource_klass: self,
                                    path_string: "#{relationship.name}#{linkage_relationship_path}",
                                    ensure_default_field: false)
@@ -648,7 +596,7 @@ module JSONAPI
             related_fragments[rid].add_related_from(source_rid)
 
             if connect_source_identity
-              related_relationship = related_klass._relationships[relationship.inverse_relationship]
+              related_relationship = related_klass._relationship(relationship.inverse_relationship)
               if related_relationship
                 related_fragments[rid].add_related_identity(related_relationship.name, source_rid)
               end
@@ -664,12 +612,6 @@ module JSONAPI
               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], 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)
@@ -686,7 +628,7 @@ module JSONAPI
       end
 
       def apply_request_settings_to_records(records:,
-                                            join_manager: ActiveRelation::JoinManager.new(resource_klass: self),
+                                            join_manager: ActiveRelation::JoinManagerV10.new(resource_klass: self),
                                             resource_klass: self,
                                             filters: {},
                                             primary_keys: nil,
@@ -791,18 +733,29 @@ module JSONAPI
         apply_sort(records, order_options, options)
       end
 
+      def sql_field_with_alias(table, field, quoted = true)
+        Arel.sql("#{concat_table_field(table, field, quoted)} AS #{alias_table_field(table, field, quoted)}")
+      end
+
       def concat_table_field(table, field, quoted = false)
-        if table.blank? || field.to_s.include?('.')
+        if table.blank?
+          split_table, split_field = field.to_s.split('.')
+          if split_table && split_field
+            table = split_table
+            field = split_field
+          end
+        end
+        if table.blank?
           # :nocov:
           if quoted
-            quote(field)
+            quote_column_name(field)
           else
             field.to_s
           end
           # :nocov:
         else
           if quoted
-            "#{quote(table)}.#{quote(field)}"
+            "#{quote_table_name(table)}.#{quote_column_name(field)}"
           else
             # :nocov:
             "#{table.to_s}.#{field.to_s}"
@@ -811,15 +764,11 @@ module JSONAPI
         end
       end
 
-      def sql_field_with_alias(table, field, quoted = true)
-        Arel.sql("#{concat_table_field(table, field, quoted)} AS #{alias_table_field(table, field, quoted)}")
-      end
-
       def alias_table_field(table, field, quoted = false)
         if table.blank? || field.to_s.include?('.')
           # :nocov:
           if quoted
-            quote(field)
+            quote_column_name(field)
           else
             field.to_s
           end
@@ -827,7 +776,7 @@ module JSONAPI
         else
           if quoted
             # :nocov:
-            quote("#{table.to_s}_#{field.to_s}")
+            quote_column_name("#{table.to_s}_#{field.to_s}")
             # :nocov:
           else
             "#{table.to_s}_#{field.to_s}"
@@ -835,10 +784,27 @@ module JSONAPI
         end
       end
 
-      def quote(field)
-        "\"#{field.to_s}\""
+      def quote_table_name(table_name)
+        if _model_class&.connection
+          _model_class.connection.quote_table_name(table_name)
+        else
+          quote(table_name)
+        end
       end
 
+      def quote_column_name(column_name)
+        return column_name if column_name == "*"
+        if _model_class&.connection
+          _model_class.connection.quote_column_name(column_name)
+        else
+          quote(column_name)
+        end
+      end
+
+      # fallback quote identifier when database adapter not available
+      def quote(field)
+        %{"#{field.to_s}"}
+      end
 
       def apply_filters(records, filters, options = {})
         if filters
@@ -873,12 +839,24 @@ module JSONAPI
           records = call_method_or_proc(strategy, records, value, options)
         else
           join_manager = options.dig(:_relation_helper_options, :join_manager)
-          field = join_manager ? get_aliased_field(filter, join_manager) : filter
+          field = join_manager ? get_aliased_field(filter, join_manager) : filter.to_s
           records = records.where(Arel.sql(field) => value)
         end
 
         records
       end
+
+      def warn_about_unused_methods
+        if Rails.env.development?
+          if !caching? && implements_class_method?(:records_for_populate)
+            warn "#{self}: The `records_for_populate` method is not used when caching is disabled."
+          end
+        end
+      end
+
+      def implements_class_method?(method_name)
+        methods(false).include?(method_name)
+      end
     end
   end
 end