jsonapi-resources 0.10.0.beta2 → 0.10.0.beta2.1

data/lib/jsonapi/active_relation_resource_finder/join_manager.rb

@@ -0,0 +1,297 @@
+module JSONAPI
+  module ActiveRelationResourceFinder
+
+  # 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
+      attr_reader :resource_klass,
+                  :source_relationship,
+                  :resource_join_tree,
+                  :join_details
+
+      def initialize(resource_klass:,
+                     source_relationship: nil,
+                     relationships: nil,
+                     filters: nil,
+                     sort_criteria: nil)
+
+        @resource_klass = resource_klass
+        @join_details = nil
+        @collected_aliases = Set.new
+
+        @resource_join_tree = {
+            root: {
+                join_type: :root,
+                resource_klasses: {
+                    resource_klass => {
+                        relationships: {}
+                    }
+                }
+            }
+        }
+        add_source_relationship(source_relationship)
+        add_sort_criteria(sort_criteria)
+        add_filters(filters)
+        add_relationships(relationships)
+      end
+
+      def join(records, options)
+        fail "can't be joined again" if @join_details
+        @join_details = {}
+        perform_joins(records, options)
+      end
+
+      # source details will only be on a relationship if the source_relationship is set
+      # this method gets the join details whether they are on a relationship or are just pseudo details for the base
+      # resource. Specify the resource type for polymorphic relationships
+      #
+      def source_join_details(type=nil)
+        if source_relationship
+          related_resource_klass = type ? resource_klass.resource_klass_for(type) : source_relationship.resource_klass
+          segment = PathSegment::Relationship.new(relationship: source_relationship, resource_klass: related_resource_klass)
+          details = @join_details[segment]
+        else
+          if type
+            details = @join_details["##{type}"]
+          else
+            details = @join_details['']
+          end
+        end
+        details
+      end
+
+      def join_details_by_polymorphic_relationship(relationship, type)
+        segment = PathSegment::Relationship.new(relationship: relationship, resource_klass: resource_klass.resource_klass_for(type))
+        @join_details[segment]
+      end
+
+      def join_details_by_relationship(relationship)
+        segment = PathSegment::Relationship.new(relationship: relationship, resource_klass: relationship.resource_klass)
+        @join_details[segment]
+      end
+
+      def self.get_join_arel_node(records, options = {})
+        init_join_sources = records.arel.join_sources
+        init_join_sources_length = init_join_sources.length
+
+        records = yield(records, options)
+
+        join_sources = records.arel.join_sources
+        if join_sources.length > init_join_sources_length
+          last_join = (join_sources - init_join_sources).last
+        else
+          # :nocov:
+          warn "get_join_arel_node: No join added"
+          last_join = nil
+          # :nocov:
+        end
+
+        return records, last_join
+      end
+
+      def self.alias_from_arel_node(node)
+        case node.left
+        when Arel::Table
+          node.left.name
+        when Arel::Nodes::TableAlias
+          node.left.right
+        when Arel::Nodes::StringJoin
+          # :nocov:
+          warn "alias_from_arel_node: Unsupported join type - use custom filtering and sorting"
+          nil
+          # :nocov:
+        end
+      end
+
+      private
+
+      def flatten_join_tree_by_depth(join_array = [], node = @resource_join_tree, level = 0)
+        join_array[level] = [] unless join_array[level]
+
+        node.each do |relationship, relationship_details|
+          relationship_details[:resource_klasses].each do |related_resource_klass, resource_details|
+            join_array[level] << { relationship: relationship,
+                                   relationship_details: relationship_details,
+                                   related_resource_klass: related_resource_klass}
+            flatten_join_tree_by_depth(join_array, resource_details[:relationships], level+1)
+          end
+        end
+        join_array
+      end
+
+      def add_join_details(join_key, details, check_for_duplicate_alias = true)
+        fail "details already set" if @join_details.has_key?(join_key)
+        @join_details[join_key] = details
+
+        # Joins are being tracked as they are added to the built up relation. If the same table is added to a
+        # relation more than once subsequent versions will be assigned an alias. Depending on the order the joins
+        # are made the computed aliases may change. The order this library performs the joins was chosen
+        # to prevent this. However if the relation is reordered it should result in reusing on of the earlier
+        # aliases (in this case a plain table name). The following check will catch this an raise an exception.
+        # An exception is appropriate because not using the correct alias could leak data due to filters and
+        # applied permissions being performed on the wrong data.
+        if check_for_duplicate_alias && @collected_aliases.include?(details[:alias])
+          fail "alias '#{details[:alias]}' has already been added. Possible relation reordering"
+        end
+
+        @collected_aliases << details[:alias]
+      end
+
+      def perform_joins(records, options)
+        join_array = flatten_join_tree_by_depth
+
+        join_array.each do |level_joins|
+          level_joins.each do |join_details|
+            relationship = join_details[:relationship]
+            relationship_details = join_details[:relationship_details]
+            related_resource_klass = join_details[:related_resource_klass]
+            join_type = relationship_details[:join_type]
+
+            if relationship == :root
+              unless source_relationship
+                add_join_details('', {alias: resource_klass._table_name, join_type: :root})
+              end
+              next
+            end
+
+           records, join_node = self.class.get_join_arel_node(records, options) {|records, options|
+              records  = related_resource_klass.join_relationship(
+                  records: records,
+                  resource_type: related_resource_klass._type,
+                  join_type: join_type,
+                  relationship: relationship,
+                  options: options)
+            }
+
+            details = {alias: self.class.alias_from_arel_node(join_node), join_type: join_type}
+
+            if relationship == source_relationship
+              if relationship.polymorphic? && relationship.belongs_to?
+                add_join_details("##{related_resource_klass._type}", details)
+              else
+                add_join_details('', details)
+              end
+            end
+
+            # We're adding the source alias with two keys. We only want the check for duplicate aliases once.
+            # See the note in `add_join_details`.
+            check_for_duplicate_alias = !(relationship == source_relationship)
+            add_join_details(PathSegment::Relationship.new(relationship: relationship, resource_klass: related_resource_klass), details, check_for_duplicate_alias)
+          end
+        end
+        records
+      end
+
+      def add_join(path, default_type = :inner, default_polymorphic_join_type = :left)
+        if source_relationship
+          if source_relationship.polymorphic?
+            # Polymorphic paths will come it with the resource_type as the first segment (for example `#documents.comments`)
+            # We just need to prepend the relationship portion the
+            sourced_path = "#{source_relationship.name}#{path}"
+          else
+            sourced_path = "#{source_relationship.name}.#{path}"
+          end
+        else
+          sourced_path = path
+        end
+
+        join_manager, _field = parse_path_to_tree(sourced_path, resource_klass, default_type, default_polymorphic_join_type)
+
+        @resource_join_tree[:root].deep_merge!(join_manager) { |key, val, other_val|
+          if key == :join_type
+            if val == other_val
+              val
+            else
+              :inner
+            end
+          end
+        }
+      end
+
+      def process_path_to_tree(path_segments, resource_klass, default_join_type, default_polymorphic_join_type)
+        node = {
+            resource_klasses: {
+                resource_klass => {
+                    relationships: {}
+                }
+            }
+        }
+
+        segment = path_segments.shift
+
+        if segment.is_a?(PathSegment::Relationship)
+          node[:resource_klasses][resource_klass][:relationships][segment.relationship] ||= {}
+
+          # join polymorphic as left joins
+          node[:resource_klasses][resource_klass][:relationships][segment.relationship][:join_type] ||=
+              segment.relationship.polymorphic? ? default_polymorphic_join_type : default_join_type
+
+          segment.relationship.resource_types.each do |related_resource_type|
+            related_resource_klass = resource_klass.resource_klass_for(related_resource_type)
+
+            # If the resource type was specified in the path segment we want to only process the next segments for
+            # that resource type, otherwise process for all
+            process_all_types = !segment.path_specified_resource_klass?
+
+            if process_all_types || related_resource_klass == segment.resource_klass
+              related_resource_tree = process_path_to_tree(path_segments.dup, related_resource_klass, default_join_type, default_polymorphic_join_type)
+              node[:resource_klasses][resource_klass][:relationships][segment.relationship].deep_merge!(related_resource_tree)
+            end
+          end
+        end
+        node
+      end
+
+      def parse_path_to_tree(path_string, resource_klass, default_join_type = :inner, default_polymorphic_join_type = :left)
+        path = JSONAPI::Path.new(resource_klass: resource_klass, path_string: path_string)
+
+        field = path.segments[-1]
+        return process_path_to_tree(path.segments, resource_klass, default_join_type, default_polymorphic_join_type), field
+      end
+
+      def add_source_relationship(source_relationship)
+        @source_relationship = source_relationship
+
+        if @source_relationship
+          resource_klasses = {}
+          source_relationship.resource_types.each do |related_resource_type|
+            related_resource_klass = resource_klass.resource_klass_for(related_resource_type)
+            resource_klasses[related_resource_klass] = {relationships: {}}
+          end
+
+          join_type = source_relationship.polymorphic? ? :left : :inner
+
+          @resource_join_tree[:root][:resource_klasses][resource_klass][:relationships][@source_relationship] = {
+              source: true, resource_klasses: resource_klasses, join_type: join_type
+          }
+        end
+      end
+
+      def add_filters(filters)
+        return if filters.blank?
+        filters.each_key do |filter|
+          # Do not add joins for filters with an apply callable. This can be overridden by setting perform_joins to true
+          next if resource_klass._allowed_filters[filter].try(:[], :apply) &&
+              !resource_klass._allowed_filters[filter].try(:[], :perform_joins)
+
+          add_join(filter, :left)
+        end
+      end
+
+      def add_sort_criteria(sort_criteria)
+        return if sort_criteria.blank?
+
+        sort_criteria.each do |sort|
+          add_join(sort[:field], :left)
+        end
+      end
+
+      def add_relationships(relationships)
+        return if relationships.blank?
+        relationships.each do |relationship|
+          add_join(relationship, :left)
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/cached_response_fragment.rb

@@ -1,22 +1,42 @@
 module JSONAPI
   class CachedResponseFragment
-    def self.fetch_cached_fragments(resource_klass, serializer_config_key, cache_ids, context)
-      context_json = resource_klass.attribute_caching_context(context).to_json
-      context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
-      context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
-
-      results = self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-
-      if JSONAPI.configuration.resource_cache_usage_report_function
-        miss_ids = results.select{|_k,v| v.nil? }.keys
-        JSONAPI.configuration.resource_cache_usage_report_function.call(
-            resource_klass.name,
-            cache_ids.size - miss_ids.size,
-            miss_ids.size
-        )
+
+    Lookup = Struct.new(:resource_klass, :serializer_config_key, :context, :context_key, :cache_ids) do
+
+      def type
+        resource_klass._type
       end
 
-      results
+      def keys
+        cache_ids.map do |(id, cache_key)|
+          [type, id, cache_key, serializer_config_key, context_key]
+        end
+      end
+    end
+
+    Write = Struct.new(:resource_klass, :resource, :serializer, :serializer_config_key, :context, :context_key, :relationship_data) do
+      def to_key_value
+
+        (id, cache_key) = resource.cache_id
+
+        json = serializer.object_hash(resource, relationship_data)
+
+        cr = CachedResponseFragment.new(
+          resource_klass,
+          id,
+          json['type'],
+          context,
+          resource.fetchable_fields,
+          json['relationships'],
+          json['links'],
+          json['attributes'],
+          json['meta']
+        )
+
+        key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
+
+        [key, cr]
+      end
     end
 
     attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
@@ -50,26 +70,46 @@ module JSONAPI
       }
     end
 
-    private
+    # @param [Lookup[]] lookups
+    # @return [Hash<Class<Resource>, Hash<ID, CachedResourceFragment>>]
+    def self.lookup(lookups, context)
+      type_to_klass = lookups.map {|l| [l.type, l.resource_klass]}.to_h
 
-    def self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-      type = resource_klass._type
+      keys = lookups.map(&:keys).flatten(1)
 
-      keys = cache_ids.map do |(id, cache_key)|
-        [type, id, cache_key, serializer_config_key, context_key]
-      end
+      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject {|_, v| v.nil?}
+
+      return keys.inject({}) do |hash, key|
+        (type, id, _, _) = key
+        resource_klass = type_to_klass[type]
+        hash[resource_klass] ||= {}
 
-      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject{|_,v| v.nil? }
-      return keys.each_with_object({}) do |key, hash|
-        (_, id, _, _) = key
         if hits.has_key?(key)
-          hash[id] = self.from_cache_value(resource_klass, context, hits[key])
+          hash[resource_klass][id] = self.from_cache_value(resource_klass, context, hits[key])
         else
-          hash[id] = nil
+          hash[resource_klass][id] = nil
         end
+
+        hash
       end
     end
 
+    # @param [Write[]] lookups
+    def self.write(writes)
+      key_values = writes.map(&:to_key_value)
+
+      to_write = key_values.map {|(k, v)| [k, v.to_cache_value]}.to_h
+
+      if JSONAPI.configuration.resource_cache.respond_to? :write_multi
+        JSONAPI.configuration.resource_cache.write_multi(to_write)
+      else
+        to_write.each do |key, value|
+          JSONAPI.configuration.resource_cache.write(key, value)
+        end
+      end
+
+    end
+
     def self.from_cache_value(resource_klass, context, h)
       new(
         resource_klass,
@@ -83,28 +123,5 @@ module JSONAPI
         h.fetch(:meta, nil)
       )
     end
-
-    def self.write(resource_klass, resource, serializer, serializer_config_key, context, context_key, relationship_data )
-      (id, cache_key) = resource.cache_id
-
-      json = serializer.object_hash(resource, relationship_data)
-
-      cr = self.new(
-        resource_klass,
-        id,
-        json['type'],
-        context,
-        resource.fetchable_fields,
-        json['relationships'],
-        json['links'],
-        json['attributes'],
-        json['meta']
-      )
-
-      key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
-      JSONAPI.configuration.resource_cache.write(key, cr.to_cache_value)
-      return [id, cr]
-    end
-
   end
 end

data/lib/jsonapi/path.rb

@@ -31,5 +31,13 @@ module JSONAPI
     def relationship_path_string
       relationship_segments.collect(&:to_s).join('.')
     end
+
+    def last_relationship
+      if @segments.last.is_a?(PathSegment::Relationship)
+        @segments.last
+      else
+        @segments[-2]
+      end
+    end
   end
 end