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

data/lib/jsonapi/path_segment.rb

@@ -22,19 +22,27 @@ module JSONAPI
     end
 
     class Relationship
-      attr_reader :relationship
+      attr_reader :relationship, :resource_klass
 
-      def initialize(relationship:, resource_klass:)
+      def initialize(relationship:, resource_klass: nil)
         @relationship = relationship
         @resource_klass = resource_klass
       end
 
+      def eql?(other)
+        relationship == other.relationship && resource_klass == other.resource_klass
+      end
+
+      def hash
+        [relationship, resource_klass].hash
+      end
+
       def to_s
-        @resource_klass ? "#{relationship.name}##{resource_klass._type}" : "#{relationship.name}"
+        @resource_klass ? "#{relationship.parent_resource_klass._type}.#{relationship.name}##{resource_klass._type}" : "#{resource_klass._type}.#{relationship.name}"
       end
 
       def resource_klass
-        @resource_klass || @relationship.resource_klass
+        @resource_klass || relationship.resource_klass
       end
 
       def path_specified_resource_klass?
@@ -50,13 +58,17 @@ module JSONAPI
         @field_name = field_name
       end
 
+      def eql?(other)
+        field_name == other.field_name && resource_klass == other.resource_klass
+      end
+
       def delegated_field_name
         resource_klass._attribute_delegated_name(field_name)
       end
 
       def to_s
         # :nocov:
-        field_name.to_s
+        "#{resource_klass._type}.#{field_name.to_s}"
         # :nocov:
       end
     end

data/lib/jsonapi/relationship.rb

@@ -32,6 +32,7 @@ module JSONAPI
     end
 
     alias_method :polymorphic?, :polymorphic
+    alias_method :parent_resource_klass, :parent_resource
 
     def primary_key
       # :nocov:

data/lib/jsonapi/resource_set.rb

@@ -5,14 +5,25 @@ module JSONAPI
 
     attr_reader :resource_klasses, :populated
 
-    def initialize(resource_id_tree)
+    def initialize(resource_id_tree = nil)
       @populated = false
-      @resource_klasses = flatten_resource_id_tree(resource_id_tree)
+      @resource_klasses = resource_id_tree.nil? ? {} : flatten_resource_id_tree(resource_id_tree)
     end
 
     def populate!(serializer, context, find_options)
+      # For each resource klass we want to generate the caching key
+
+      # Hash for collecting types and ids
+      # @type [Hash<Class<Resource>, Id[]]]
+      missed_resource_ids = {}
+
+      # Array for collecting CachedResponseFragment::Lookups
+      # @type [Lookup[]]
+      lookups = []
+
+
+      # Step One collect all of the lookups for the cache, or keys that don't require cache access
       @resource_klasses.each_key do |resource_klass|
-        missed_ids = []
 
         serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
         context_json = resource_klass.attribute_caching_context(context).to_json
@@ -20,65 +31,124 @@ module JSONAPI
         context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
 
         if resource_klass.caching?
-          cache_ids = []
-
-          @resource_klasses[resource_klass].each_pair do |k, v|
+          cache_ids = @resource_klasses[resource_klass].map do |(k, v)|
             # Store the hashcode of the cache_field to avoid storing objects and to ensure precision isn't lost
             # on timestamp types (i.e. string conversions dropping milliseconds)
-            cache_ids.push([k, resource_klass.hash_cache_field(v[:cache_id])])
+            [k, resource_klass.hash_cache_field(v[:cache_id])]
           end
 
-          found_resources = CachedResponseFragment.fetch_cached_fragments(
+          lookups.push(
+            CachedResponseFragment::Lookup.new(
               resource_klass,
               serializer_config_key,
-              cache_ids,
-              context)
-
-          found_resources.each do |found_result|
-            resource = found_result[1]
-            if resource.nil?
-              missed_ids.push(found_result[0])
-            else
-              @resource_klasses[resource_klass][resource.id][:resource] = resource
-            end
-          end
+              context,
+              context_key,
+              cache_ids
+            )
+          )
         else
-          missed_ids = @resource_klasses[resource_klass].keys
+          missed_resource_ids[resource_klass] ||= {}
+          missed_resource_ids[resource_klass] = @resource_klasses[resource_klass].keys
         end
+      end
+
+      if lookups.any?
+        raise "You've declared some Resources as caching without providing a caching store" if JSONAPI.configuration.resource_cache.nil?
+
+        # Step Two execute the cache lookup
+        found_resources = CachedResponseFragment.lookup(lookups, context)
+      else
+        found_resources = {}
+      end
 
-        # fill in any missed resources
-        unless missed_ids.empty?
-          find_opts = {
-              context: context,
-              fields: find_options[:fields] }
-
-          found_resources = resource_klass.find_by_keys(missed_ids, find_opts)
-
-          found_resources.each do |resource|
-            relationship_data = @resource_klasses[resource_klass][resource.id][:relationships]
-
-            if resource_klass.caching?
-              (id, cr) = CachedResponseFragment.write(
-                  resource_klass,
-                  resource,
-                  serializer,
-                  serializer_config_key,
-                  context,
-                  context_key,
-                  relationship_data)
-
-              @resource_klasses[resource_klass][id][:resource] = cr
-            else
-              @resource_klasses[resource_klass][resource.id][:resource] = resource
-            end
+
+      # Step Three collect the results and collect hit/miss stats
+      stats = {}
+      found_resources.each do |resource_klass, resources|
+        resources.each do |id, cached_resource|
+          stats[resource_klass] ||= {}
+
+          if cached_resource.nil?
+            stats[resource_klass][:misses] ||= 0
+            stats[resource_klass][:misses] += 1
+
+            # Collect misses
+            missed_resource_ids[resource_klass] ||= []
+            missed_resource_ids[resource_klass].push(id)
+          else
+            stats[resource_klass][:hits] ||= 0
+            stats[resource_klass][:hits] += 1
+
+            register_resource(resource_klass, cached_resource)
           end
         end
       end
-      @populated = true
+
+      report_stats(stats)
+
+      writes = []
+
+      # Step Four find any of the missing resources and join them into the result
+      missed_resource_ids.each_pair do |resource_klass, ids|
+        find_opts = {context: context, fields: find_options[:fields]}
+        found_resources = resource_klass.find_by_keys(ids, find_opts)
+
+        found_resources.each do |resource|
+          relationship_data = @resource_klasses[resource_klass][resource.id][:relationships]
+
+          if resource_klass.caching?
+
+            serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
+            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("/", "_")}"
+
+            writes.push(CachedResponseFragment::Write.new(
+              resource_klass,
+              resource,
+              serializer,
+              serializer_config_key,
+              context,
+              context_key,
+              relationship_data
+            ))
+          end
+
+          register_resource(resource_klass, resource)
+        end
+      end
+
+      # Step Five conditionally write to the cache
+      CachedResponseFragment.write(writes) unless JSONAPI.configuration.resource_cache.nil?
+
+      mark_populated!
       self
     end
 
+    def mark_populated!
+      @populated = true
+    end
+
+    def register_resource(resource_klass, resource, primary = false)
+      @resource_klasses[resource_klass] ||= {}
+      @resource_klasses[resource_klass][resource.id] ||= {primary: resource.try(:primary) || primary, relationships: {}}
+      @resource_klasses[resource_klass][resource.id][:resource] = resource
+    end
+
     private
+
+    def report_stats(stats)
+      return unless JSONAPI.configuration.resource_cache_usage_report_function || JSONAPI.configuration.resource_cache.nil?
+
+      stats.each_pair do |resource_klass, stat|
+        JSONAPI.configuration.resource_cache_usage_report_function.call(
+          resource_klass.name,
+          stat[:hits] || 0,
+          stat[:misses] || 0
+        )
+      end
+    end
+
     def flatten_resource_id_tree(resource_id_tree, flattened_tree = {})
       resource_id_tree.fragments.each_pair do |resource_rid, fragment|
 
@@ -87,7 +157,7 @@ module JSONAPI
 
         flattened_tree[resource_klass] ||= {}
 
-        flattened_tree[resource_klass][id] ||= { primary: fragment.primary, relationships: {} }
+        flattened_tree[resource_klass][id] ||= {primary: fragment.primary, relationships: {}}
         flattened_tree[resource_klass][id][:cache_id] ||= fragment.cache
 
         fragment.related.try(:each_pair) do |relationship_name, related_rids|
@@ -104,4 +174,4 @@ module JSONAPI
       flattened_tree
     end
   end
-end
+end

data/lib/jsonapi/resources/railtie.rb

@@ -0,0 +1,9 @@
+module JSONAPI
+  module Resources
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load 'tasks/check_upgrade.rake'
+      end
+    end
+  end
+end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.10.0.beta2'
+    VERSION = '0.10.0.beta2.1'
   end
 end

data/lib/tasks/check_upgrade.rake

@@ -0,0 +1,52 @@
+require 'rake'
+require 'jsonapi-resources'
+
+namespace :jsonapi do
+  namespace :resources do
+    desc 'Checks application for orphaned overrides'
+    task :check_upgrade => :environment do
+      Rails.application.eager_load!
+
+      resource_klasses = ObjectSpace.each_object(Class).select { |klass| klass < JSONAPI::Resource}
+
+      puts "Checking #{resource_klasses.count} resources"
+
+      issues_found = 0
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:find_records) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `find_records`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `find_records` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:records_for) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `records_for`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `records_for` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:apply_includes) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `apply_includes`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `apply_includes` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      if issues_found > 0
+        puts "Finished inspection. #{issues_found} issues found that may impact upgrading. Please address these issues. "
+      else
+        puts "Finished inspection with no issues found. Note this is only a cursory check for method overrides that will no \n" \
+             "longer be called by JSONAPI::Resources. This check in no way assures your code will continue to function as \n" \
+             "it did before the upgrade. Please do adequate testing before using in production."
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.10.0.beta2
+  version: 0.10.0.beta2.1
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-11 00:00:00.000000000 Z
+date: 2019-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -178,7 +178,7 @@ files:
 - lib/jsonapi-resources.rb
 - lib/jsonapi/active_relation_resource_finder.rb
 - lib/jsonapi/active_relation_resource_finder/adapters/join_left_active_record_adapter.rb
-- lib/jsonapi/active_relation_resource_finder/join_tree.rb
+- lib/jsonapi/active_relation_resource_finder/join_manager.rb
 - lib/jsonapi/acts_as_resource_controller.rb
 - lib/jsonapi/cached_response_fragment.rb
 - lib/jsonapi/callbacks.rb
@@ -208,9 +208,11 @@ files:
 - lib/jsonapi/resource_identity.rb
 - lib/jsonapi/resource_serializer.rb
 - lib/jsonapi/resource_set.rb
+- lib/jsonapi/resources/railtie.rb
 - lib/jsonapi/resources/version.rb
 - lib/jsonapi/response_document.rb
 - lib/jsonapi/routing_ext.rb
+- lib/tasks/check_upgrade.rake
 homepage: https://github.com/cerebris/jsonapi-resources
 licenses:
 - MIT
@@ -230,8 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Easily support JSON API in Rails.

data/lib/jsonapi/active_relation_resource_finder/join_tree.rb

@@ -1,227 +0,0 @@
-module JSONAPI
-  module ActiveRelationResourceFinder
-    class JoinTree
-      # Stores relationship paths starting from the resource_klass. This allows consolidation of duplicate paths from
-      # relationships, filters and sorts. This enables the determination of table aliases as they are joined.
-
-      attr_reader :resource_klass, :options, :source_relationship, :resource_joins, :joins
-
-      def initialize(resource_klass:,
-                     options: {},
-                     source_relationship: nil,
-                     relationships: nil,
-                     filters: nil,
-                     sort_criteria: nil)
-
-        @resource_klass = resource_klass
-        @options = options
-
-        @resource_joins = {
-            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)
-
-        @joins = {}
-        construct_joins(@resource_joins)
-      end
-
-      private
-
-      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_tree, _field = parse_path_to_tree(sourced_path, resource_klass, default_type, default_polymorphic_join_type)
-
-        @resource_joins[:root].deep_merge!(join_tree) { |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_joins[: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)
-        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
-
-      # Create a nested set of hashes from an array of path components. This will be used by the `join` methods.
-      # [post, comments] => { post: { comments: {} }
-      def relation_join_hash(path, path_hash = {})
-        relation = path.shift
-        if relation
-          path_hash[relation] = {}
-          relation_join_hash(path, path_hash[relation])
-        end
-        path_hash
-      end
-
-      # Returns the paths from shortest to longest, allowing the capture of the table alias for earlier paths. For
-      # example posts, posts.comments and then posts.comments.author joined in that order will allow each
-      # alias to be determined whereas just joining posts.comments.author will only record the author alias.
-      # ToDo: Dependence on this specialized logic should be removed in the future, if possible.
-      def construct_joins(node, current_relation_path = [], current_relationship_path = [])
-        node.each do |relationship, relationship_details|
-          join_type = relationship_details[:join_type]
-          if relationship == :root
-            @joins[:root] = {alias: resource_klass._table_name, join_type: :root}
-
-            # alias to the default table unless a source_relationship is specified
-            unless source_relationship
-              @joins[''] = {alias: resource_klass._table_name, join_type: :root}
-            end
-
-            return construct_joins(relationship_details[:resource_klasses].values[0][:relationships],
-                                   current_relation_path,
-                                   current_relationship_path)
-          end
-
-          relationship_details[:resource_klasses].each do |resource_klass, resource_details|
-            if relationship.polymorphic? && relationship.belongs_to?
-              current_relationship_path << "#{relationship.name.to_s}##{resource_klass._type.to_s}"
-              relation_name = resource_klass._type.to_s.singularize
-            else
-              current_relationship_path << relationship.name.to_s
-              relation_name = relationship.relation_name(options).to_s
-            end
-
-            current_relation_path << relation_name
-
-            rel_path = calc_path_string(current_relationship_path)
-
-            @joins[rel_path] = {
-                alias: nil,
-                join_type: join_type,
-                relation_join_hash: relation_join_hash(current_relation_path.dup)
-            }
-
-            construct_joins(resource_details[:relationships],
-                            current_relation_path.dup,
-                            current_relationship_path.dup)
-
-            current_relation_path.pop
-            current_relationship_path.pop
-          end
-        end
-      end
-
-      def calc_path_string(path_array)
-        if source_relationship
-          if source_relationship.polymorphic?
-            _relationship_name, resource_name = path_array[0].split('#', 2)
-            path = path_array.dup
-            path[0] = "##{resource_name}"
-          else
-            path = path_array.dup.drop(1)
-          end
-        else
-          path = path_array.dup
-        end
-
-        path.join('.')
-      end
-    end
-  end
-end