jsonapi-resources 0.9.0 → 0.10.6

data/lib/jsonapi/resource_set.rb

@@ -0,0 +1,176 @@
+module JSONAPI
+  # Contains a hash of resource types which contain a hash of resources, relationships and primary status keyed by
+  # resource id.
+  class ResourceSet
+
+    attr_reader :resource_klasses, :populated
+
+    def initialize(resource_id_tree = nil)
+      @populated = false
+      @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|
+
+        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("/", "_")}"
+
+        if resource_klass.caching?
+          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)
+            [k, resource_klass.hash_cache_field(v[:cache_id])]
+          end
+
+          lookups.push(
+            CachedResponseFragment::Lookup.new(
+              resource_klass,
+              serializer_config_key,
+              context,
+              context_key,
+              cache_ids
+            )
+          )
+        else
+          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
+
+
+      # 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
+
+      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|
+
+        resource_klass = resource_rid.resource_klass
+        id = resource_rid.id
+
+        flattened_tree[resource_klass] ||= {}
+
+        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|
+          flattened_tree[resource_klass][id][:relationships][relationship_name] ||= Set.new
+          flattened_tree[resource_klass][id][:relationships][relationship_name].merge(related_rids)
+        end
+      end
+
+      related_resource_id_trees = resource_id_tree.related_resource_id_trees
+      related_resource_id_trees.try(:each_value) do |related_resource_id_tree|
+        flatten_resource_id_tree(related_resource_id_tree, flattened_tree)
+      end
+
+      flattened_tree
+    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.9.0'
+    VERSION = '0.10.6'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -1,81 +1,138 @@
 module JSONAPI
   class ResponseDocument
-    def initialize(operation_results, serializer, options = {})
-      @operation_results = operation_results
-      @serializer = serializer
+    attr_reader :serialized_results
+
+    def initialize(options = {})
+      @serialized_results = []
+      @result_codes = []
+      @error_results = []
+      @global_errors = []
+
       @options = options
 
+      @top_level_meta = @options.fetch(:base_meta, {})
+      @top_level_links = @options.fetch(:base_links, {})
+
       @key_formatter = @options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
     end
 
-    def contents
-      hash = results_to_hash
+    def has_errors?
+      @error_results.length > 0 || @global_errors.length > 0
+    end
 
-      meta = top_level_meta
-      hash.merge!(meta: meta) unless meta.empty?
+    def add_result(result, operation)
+      if result.is_a?(JSONAPI::ErrorsOperationResult)
+        # Clear any serialized results
+        @serialized_results = []
 
-      links = top_level_links
-      hash.merge!(links: links) unless links.empty?
+        # In JSONAPI v1 we only have one operation so all errors can be kept together
+        result.errors.each do |error|
+          add_global_error(error)
+        end
+      else
+        @serialized_results.push result.to_hash(operation.options[:serializer])
+        @result_codes.push result.code.to_i
+        update_links(operation.options[:serializer], result)
+        update_meta(result)
+      end
+    end
 
-      hash
+    def add_global_error(error)
+      @global_errors.push error
     end
 
-    def status
-      if @operation_results.has_errors?
-        @operation_results.all_errors[0].status
+    def contents
+      if has_errors?
+        return { 'errors' => @global_errors }
       else
-        @operation_results.results[0].code
+        hash = @serialized_results[0]
+        meta = top_level_meta
+        hash.merge!('meta' => meta) unless meta.empty?
+
+        links = top_level_links
+        hash.merge!('links' => links) unless links.empty?
+
+        return hash
       end
     end
 
-    private
+    def status
+      status_codes = if has_errors?
+                       @global_errors.collect do |error|
+                         error.status.to_i
+                       end
+                     else
+                       @result_codes
+                     end
+
+      # Count the unique status codes
+      counts = status_codes.each_with_object(Hash.new(0)) { |code, counts| counts[code] += 1 }
+
+      # if there is only one status code we can return that
+      return counts.keys[0].to_i if counts.length == 1
+
+      # :nocov: not currently used
+
+      # if there are many we should return the highest general code, 200, 400, 500 etc.
+      max_status = 0
+      status_codes.each do |status|
+        code = status.to_i
+        max_status = code if max_status < code
+      end
+      return (max_status / 100).floor * 100
+      # :nocov:
+    end
 
-    # Rolls up the top level meta data from the base_meta, the set of operations,
-    # and the result of each operation. The keys are then formatted.
-    def top_level_meta
-      meta = @options.fetch(:base_meta, {})
+    private
 
-      meta.merge!(@operation_results.meta)
+    def update_meta(result)
+      @top_level_meta.merge!(result.meta)
 
-      @operation_results.results.each do |result|
-        meta.merge!(result.meta)
+      if JSONAPI.configuration.top_level_meta_include_record_count && result.respond_to?(:record_count)
+        @top_level_meta[JSONAPI.configuration.top_level_meta_record_count_key] = result.record_count
+      end
 
-        if JSONAPI.configuration.top_level_meta_include_record_count && result.respond_to?(:record_count)
-          meta[JSONAPI.configuration.top_level_meta_record_count_key] = result.record_count
-        end
+      if JSONAPI.configuration.top_level_meta_include_page_count && result.respond_to?(:page_count)
+        @top_level_meta[JSONAPI.configuration.top_level_meta_page_count_key] = result.page_count
+      end
 
-        if JSONAPI.configuration.top_level_meta_include_page_count && result.respond_to?(:page_count)
-          meta[JSONAPI.configuration.top_level_meta_page_count_key] = result.page_count
+      if result.warnings.any?
+        @top_level_meta[:warnings] = result.warnings.collect do |warning|
+          warning.to_hash
         end
       end
+    end
 
-      meta.as_json.deep_transform_keys { |key| @key_formatter.format(key) }
+    def top_level_meta
+      @top_level_meta.as_json.deep_transform_keys { |key| @key_formatter.format(key) }
     end
 
-    # Rolls up the top level links from the base_links, the set of operations,
-    # and the result of each operation. The keys are then formatted.
-    def top_level_links
-      links = @options.fetch(:base_links, {})
-
-      links.merge!(@operation_results.links)
-
-      @operation_results.results.each do |result|
-        links.merge!(result.links)
-
-        # Build pagination links
-        if result.is_a?(JSONAPI::ResourcesOperationResult) || result.is_a?(JSONAPI::RelatedResourcesOperationResult)
-            result.pagination_params.each_pair do |link_name, params|
-              if result.is_a?(JSONAPI::RelatedResourcesOperationResult)
-                relationship = result.source_resource.class._relationships[result._type.to_sym]
-                links[link_name] = @serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
-              else
-                links[link_name] = @serializer.query_link(query_params(params))
-              end
+    def update_links(serializer, result)
+      @top_level_links.merge!(result.links)
+
+      # Build pagination links
+      if result.is_a?(JSONAPI::ResourceSetOperationResult) ||
+          result.is_a?(JSONAPI::ResourcesSetOperationResult) ||
+          result.is_a?(JSONAPI::RelatedResourcesSetOperationResult)
+
+        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]
+            unless relationship.exclude_link?(link_name)
+              link = serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
+            end
+          else
+            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
 
-      links.deep_transform_keys { |key| @key_formatter.format(key) }
+    def top_level_links
+      @top_level_links.deep_transform_keys { |key| @key_formatter.format(key) }
     end
 
     def query_params(params)
@@ -96,40 +153,5 @@ module JSONAPI
 
       query_params
     end
-
-    def results_to_hash
-      if @operation_results.has_errors?
-        { errors: @operation_results.all_errors }
-      else
-        if @operation_results.results.length == 1
-          result = @operation_results.results[0]
-
-          case result
-          when JSONAPI::ResourceOperationResult
-            @serializer.serialize_to_hash(result.resource)
-          when JSONAPI::ResourcesOperationResult
-            @serializer.serialize_to_hash(result.resources)
-          when JSONAPI::LinksObjectOperationResult
-            @serializer.serialize_to_links_hash(result.parent_resource,
-                                               result.relationship)
-          when JSONAPI::OperationResult
-            {}
-          end
-
-        elsif @operation_results.results.length > 1
-          resources = []
-          @operation_results.results.each do |result|
-            case result
-            when JSONAPI::ResourceOperationResult
-              resources.push(result.resource)
-            when JSONAPI::ResourcesOperationResult
-              resources.concat(result.resources)
-            end
-          end
-
-          @serializer.serialize_to_hash(resources)
-        end
-      end
-    end
   end
 end

data/lib/jsonapi/routing_ext.rb

@@ -18,7 +18,13 @@ module ActionDispatch
 
         def jsonapi_resource(*resources, &_block)
           @resource_type = resources.first
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
+          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
@@ -33,8 +39,8 @@ module ActionDispatch
           end
 
           if res._immutable
-            options[:except] << :create  unless options[:except].include?(:create)  || options[:except].include?('create')
-            options[:except] << :update  unless options[:except].include?(:update)  || options[:except].include?('update')
+            options[:except] << :create unless options[:except].include?(:create) || options[:except].include?('create')
+            options[:except] << :update unless options[:except].include?(:update) || options[:except].include?('update')
             options[:except] << :destroy unless options[:except].include?(:destroy) || options[:except].include?('destroy')
           end
 
@@ -64,7 +70,7 @@ module ActionDispatch
         end
 
         def jsonapi_relationships(options = {})
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
           res._relationships.each do |relationship_name, relationship|
             if relationship.is_a?(JSONAPI::Relationship::ToMany)
               jsonapi_links(relationship_name, options)
@@ -78,7 +84,13 @@ module ActionDispatch
 
         def jsonapi_resources(*resources, &_block)
           @resource_type = resources.first
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
+          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
@@ -102,8 +114,8 @@ module ActionDispatch
           end
 
           if res._immutable
-            options[:except] << :create  unless options[:except].include?(:create)  || options[:except].include?('create')
-            options[:except] << :update  unless options[:except].include?(:update)  || options[:except].include?('update')
+            options[:except] << :create unless options[:except].include?(:create) || options[:except].include?('create')
+            options[:except] << :update unless options[:except].include?(:update) || options[:except].include?('update')
             options[:except] << :destroy unless options[:except].include?(:destroy) || options[:except].include?('destroy')
           end
 
@@ -147,25 +159,26 @@ module ActionDispatch
           formatted_relationship_name = format_route(link_type)
           options = links.extract_options!.dup
 
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options[:controller] ||= res._type.to_s
 
           methods = links_methods(options)
 
           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?
             if methods.include?(:update)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
@@ -175,69 +188,77 @@ module ActionDispatch
           formatted_relationship_name = format_route(link_type)
           options = links.extract_options!.dup
 
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options[:controller] ||= res._type.to_s
 
           methods = links_methods(options)
 
           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?
             if methods.include?(:create)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
+                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
             end
 
             if methods.include?(:update)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                          action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
 
         def jsonapi_related_resource(*relationship)
-          source = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          source = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options = relationship.extract_options!.dup
 
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
 
           if relationship.polymorphic?
             options[:controller] ||= relationship.class_name.underscore.pluralize
           else
-            related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore.pluralize))
+            related_resource = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(relationship.class_name.underscore.pluralize))
             options[:controller] ||= related_resource._type.to_s
           end
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resource', via: [:get]
+          match formatted_relationship_name, controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'show_related_resource', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         def jsonapi_related_resources(*relationship)
-          source = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          source = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options = relationship.extract_options!.dup
 
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
-          related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore))
+          related_resource = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(relationship.class_name.underscore))
           options[:controller] ||= related_resource._type.to_s
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resources', via: [:get]
+          match formatted_relationship_name,
+                controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'index_related_resources', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         protected
@@ -250,6 +271,7 @@ module ActionDispatch
           @scope = @scope.parent
         end
         # :nocov:
+
         private
 
         def resource_type_with_module_prefix(resource = nil)

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_resource_fragment'
+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'
@@ -17,11 +26,18 @@ require 'jsonapi/exceptions'
 require 'jsonapi/error'
 require 'jsonapi/error_codes'
 require 'jsonapi/request_parser'
-require 'jsonapi/operation_dispatcher'
 require 'jsonapi/processor'
 require 'jsonapi/relationship'
 require 'jsonapi/include_directives'
+require 'jsonapi/operation'
 require 'jsonapi/operation_result'
-require 'jsonapi/operation_results'
 require 'jsonapi/callbacks'
 require 'jsonapi/link_builder'
+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'
+require 'jsonapi/resource_set'
+require 'jsonapi/path'
+require 'jsonapi/path_segment'