jsonapi-resources 0.10.0.beta2 → 0.10.0

data/lib/jsonapi/resource_controller_metal.rb

@@ -10,6 +10,9 @@ module JSONAPI
       JSONAPI::ActsAsResourceController
     ].freeze
 
+    # Note, the url_helpers are not loaded. This will prevent links from being generated for resources, and warnings
+    # will be emitted. Link support can be added by including `Rails.application.routes.url_helpers`, and links
+    # can be disabled, and warning suppressed, for a resource with `exclude_links :default`
     MODULES.each do |mod|
       include mod
     end

data/lib/jsonapi/resource_serializer.rb

@@ -59,7 +59,7 @@ module JSONAPI
         end
       end
 
-      fail "To Many primary objects for show" if (primary_objects.count > 1)
+      fail "Too many primary objects for show" if (primary_objects.count > 1)
       primary_hash = { 'data' => primary_objects[0] }
 
       primary_hash['included'] = included_objects if included_objects.size > 0
@@ -93,24 +93,19 @@ module JSONAPI
       return serialize_resource_set_to_hash_plural(resource_set)
     end
 
-    def serialize_to_links_hash(source, requested_relationship, resource_ids)
+    def serialize_to_relationship_hash(source, requested_relationship, resource_ids)
       if requested_relationship.is_a?(JSONAPI::Relationship::ToOne)
         data = to_one_linkage(resource_ids[0])
       else
         data = to_many_linkage(resource_ids)
       end
 
-      {
-          'links' => {
-              'self' => self_link(source, requested_relationship),
-              'related' => related_link(source, requested_relationship)
-          },
-          'data' => data
-      }
-    end
+      rel_hash = { 'data': data }
+
+      links = default_relationship_links(source, requested_relationship)
+      rel_hash['links'] = links unless links.blank?
 
-    def query_link(query_params)
-      link_builder.query_link(query_params)
+      rel_hash
     end
 
     def format_key(key)
@@ -136,11 +131,10 @@ module JSONAPI
     def config_description(resource_klass)
       {
         class_name: self.class.name,
-        seriserialization_options: serialization_options.sort.map(&:as_json),
+        serialization_options: serialization_options.sort.map(&:as_json),
         supplying_attribute_fields: supplying_attribute_fields(resource_klass).sort,
         supplying_relationship_fields: supplying_relationship_fields(resource_klass).sort,
         link_builder_base_url: link_builder.base_url,
-        route_formatter_class: link_builder.route_formatter.uncached.class.name,
         key_formatter_class: key_formatter.uncached.class.name,
         always_include_to_one_linkage_data: always_include_to_one_linkage_data,
         always_include_to_many_linkage_data: always_include_to_many_linkage_data
@@ -165,7 +159,7 @@ module JSONAPI
         obj_hash['attributes'] = source.attributes_json if source.attributes_json
 
         relationships = cached_relationships_hash(source, fetchable_fields, relationship_data)
-        obj_hash['relationships'] = relationships unless relationships.nil? || relationships.empty?
+        obj_hash['relationships'] = relationships unless relationships.blank?
 
         obj_hash['meta'] = source.meta_json if source.meta_json
       else
@@ -184,7 +178,7 @@ module JSONAPI
         obj_hash['attributes'] = attributes unless attributes.empty?
 
         relationships = relationships_hash(source, fetchable_fields, relationship_data)
-        obj_hash['relationships'] = relationships unless relationships.nil? || relationships.empty?
+        obj_hash['relationships'] = relationships unless relationships.blank?
 
         meta = meta_hash(source)
         obj_hash['meta'] = meta unless meta.empty?
@@ -199,7 +193,7 @@ module JSONAPI
       @_supplying_attribute_fields.fetch resource_klass do
         attrs = Set.new(resource_klass._attributes.keys.map(&:to_sym))
         cur = resource_klass
-        while cur != JSONAPI::Resource
+        while !cur.root? # do not traverse beyond the first root resource
           if @fields.has_key?(cur._type)
             attrs &= @fields[cur._type]
             break
@@ -214,7 +208,7 @@ module JSONAPI
       @_supplying_relationship_fields.fetch resource_klass do
         relationships = Set.new(resource_klass._relationships.keys.map(&:to_sym))
         cur = resource_klass
-        while cur != JSONAPI::Resource
+        while !cur.root? # do not traverse beyond the first root resource
           if @fields.has_key?(cur._type)
             relationships &= @fields[cur._type]
             break
@@ -236,7 +230,7 @@ module JSONAPI
     end
 
     def custom_generation_options
-      {
+      @_custom_generation_options ||= {
         serializer: self,
         serialization_options: @serialization_options
       }
@@ -249,7 +243,9 @@ module JSONAPI
 
     def links_hash(source)
       links = custom_links_hash(source)
-      links['self'] = link_builder.self_link(source) unless links.key?('self')
+      if !links.key?('self') && !source.class.exclude_link?(:self)
+        links['self'] = link_builder.self_link(source)
+      end
       links.compact
     end
 
@@ -274,7 +270,8 @@ module JSONAPI
             end
           end
 
-          hash[format_key(name)] = link_object(source, relationship, rids, include_data)
+          ro = relationship_object(source, relationship, rids, include_data)
+          hash[format_key(name)] = ro unless ro.blank?
         end
       end
     end
@@ -323,6 +320,13 @@ module JSONAPI
       link_builder.relationships_related_link(source, relationship)
     end
 
+    def default_relationship_links(source, relationship)
+      links = {}
+      links['self'] = self_link(source, relationship) unless relationship.exclude_link?(:self)
+      links['related'] = related_link(source, relationship) unless relationship.exclude_link?(:related)
+      links.compact
+    end
+
     def to_many_linkage(rids)
       linkage = []
 
@@ -346,37 +350,39 @@ module JSONAPI
       }
     end
 
-    def link_object_to_one(source, relationship, rid, include_data)
+    def relationship_object_to_one(source, relationship, rid, include_data)
       link_object_hash = {}
-      link_object_hash['links'] = {}
-      link_object_hash['links']['self'] = self_link(source, relationship)
-      link_object_hash['links']['related'] = related_link(source, relationship)
+
+      links = default_relationship_links(source, relationship)
+
+      link_object_hash['links'] = links unless links.blank?
       link_object_hash['data'] = to_one_linkage(rid) if include_data
       link_object_hash
     end
 
-    def link_object_to_many(source, relationship, rids, include_data)
+    def relationship_object_to_many(source, relationship, rids, include_data)
       link_object_hash = {}
-      link_object_hash['links'] = {}
-      link_object_hash['links']['self'] = self_link(source, relationship)
-      link_object_hash['links']['related'] = related_link(source, relationship)
+
+      links = default_relationship_links(source, relationship)
+      link_object_hash['links'] = links unless links.blank?
       link_object_hash['data'] = to_many_linkage(rids) if include_data
       link_object_hash
     end
 
-    def link_object(source, relationship, rid, include_data)
+    def relationship_object(source, relationship, rid, include_data)
       if relationship.is_a?(JSONAPI::Relationship::ToOne)
-        link_object_to_one(source, relationship, rid, include_data)
+        relationship_object_to_one(source, relationship, rid, include_data)
       elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-        link_object_to_many(source, relationship, rid, include_data)
+        relationship_object_to_many(source, relationship, rid, include_data)
       end
     end
 
     def generate_link_builder(primary_resource_klass, options)
       LinkBuilder.new(
         base_url: options.fetch(:base_url, ''),
-        route_formatter: options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
         primary_resource_klass: primary_resource_klass,
+        route_formatter: options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
+        url_helpers: options.fetch(:url_helpers, options[:controller]),
       )
     end
   end

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_to_populate_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'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -118,10 +118,15 @@ module JSONAPI
         result.pagination_params.each_pair do |link_name, params|
           if result.is_a?(JSONAPI::RelatedResourcesSetOperationResult)
             relationship = result.source_resource.class._relationships[result._type.to_sym]
-            @top_level_links[link_name] = serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
+            unless relationship.exclude_link?(link_name)
+              link = serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
+            end
           else
-            @top_level_links[link_name] = serializer.query_link(query_params(params))
+            unless serializer.link_builder.primary_resource_klass.exclude_link?(link_name)
+              link = serializer.link_builder.query_link(query_params(params))
+            end
           end
+          @top_level_links[link_name] = link unless link.blank?
         end
       end
     end

data/lib/jsonapi/routing_ext.rb

@@ -20,6 +20,12 @@ module ActionDispatch
           @resource_type = resources.first
           res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
 
+          res._routed = true
+
+          unless res.singleton?
+            warn "Singleton routes created for non singleton resource #{res}. Links may not be generated correctly."
+          end
+
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
           options.merge!(res.routing_resource_options)
@@ -80,6 +86,12 @@ module ActionDispatch
           @resource_type = resources.first
           res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
 
+          res._routed = true
+
+          if res.singleton?
+            warn "Singleton resource #{res} should use `jsonapi_resource` instead."
+          end
+
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
           options.merge!(res.routing_resource_options)
@@ -154,7 +166,8 @@ module ActionDispatch
 
           if methods.include?(:show)
             match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
@@ -182,7 +195,8 @@ module ActionDispatch
 
           if methods.include?(:show)
             match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
@@ -210,6 +224,8 @@ module ActionDispatch
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
 
           if relationship.polymorphic?
@@ -221,7 +237,8 @@ module ActionDispatch
 
           match formatted_relationship_name, controller: options[:controller],
                 relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                action: 'show_related_resource', via: [:get]
+                action: 'show_related_resource', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         def jsonapi_related_resources(*relationship)
@@ -231,6 +248,8 @@ module ActionDispatch
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
           related_resource = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(relationship.class_name.underscore))
           options[:controller] ||= related_resource._type.to_s
@@ -238,7 +257,8 @@ module ActionDispatch
           match formatted_relationship_name,
                 controller: options[:controller],
                 relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                action: 'index_related_resources', via: [:get]
+                action: 'index_related_resources', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         protected

data/lib/jsonapi-resources.rb

@@ -1,10 +1,19 @@
+require 'jsonapi/resources/railtie'
 require 'jsonapi/naive_cache'
 require 'jsonapi/compiled_json'
+require 'jsonapi/basic_resource'
+require 'jsonapi/active_relation_resource'
 require 'jsonapi/resource'
 require 'jsonapi/cached_response_fragment'
 require 'jsonapi/response_document'
 require 'jsonapi/acts_as_resource_controller'
-require 'jsonapi/resource_controller'
+if Rails::VERSION::MAJOR >= 6
+  ActiveSupport.on_load(:action_controller_base) do
+    require 'jsonapi/resource_controller'
+  end
+else
+  require 'jsonapi/resource_controller'
+end
 require 'jsonapi/resource_controller_metal'
 require 'jsonapi/resources/version'
 require 'jsonapi/configuration'
@@ -24,8 +33,8 @@ require 'jsonapi/operation'
 require 'jsonapi/operation_result'
 require 'jsonapi/callbacks'
 require 'jsonapi/link_builder'
-require 'jsonapi/active_relation_resource_finder'
-require 'jsonapi/active_relation_resource_finder/join_tree'
+require 'jsonapi/active_relation/adapters/join_left_active_record_adapter'
+require 'jsonapi/active_relation/join_manager'
 require 'jsonapi/resource_identity'
 require 'jsonapi/resource_fragment'
 require 'jsonapi/resource_id_tree'

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