sanger-jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/resource_set.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+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(source, include_related = nil, options = nil)
+      @populated = false
+      tree = if source.is_a?(JSONAPI::ResourceTree)
+               source
+             elsif source.class < JSONAPI::BasicResource
+               JSONAPI::PrimaryResourceTree.new(resource: source, include_related: include_related, options: options)
+             elsif source.is_a?(Array)
+               JSONAPI::PrimaryResourceTree.new(resources: source, include_related: include_related, options: options)
+             end
+
+      if tree
+        @resource_klasses = flatten_resource_tree(tree)
+      end
+    end
+
+    def populate!(serializer, context, options)
+      return if @populated
+
+      # 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_resource_ids[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
+          @resource_klasses[resource_klass].keys.each do |k|
+            if @resource_klasses[resource_klass][k][:resource].nil?
+              missed_resource_ids[resource_klass] << k
+            else
+              register_resource(resource_klass, @resource_klasses[resource_klass][k][:resource])
+            end
+          end
+        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].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|
+        next if ids.empty?
+
+        find_opts = {context: context, fields: 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_tree(resource_tree, flattened_tree = {})
+      resource_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 if fragment.cache
+        flattened_tree[resource_klass][id][:resource] ||= fragment.resource if fragment.resource
+
+        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_trees = resource_tree.related_resource_trees
+      related_resource_trees.try(:each_value) do |related_resource_tree|
+        flatten_resource_tree(related_resource_tree, flattened_tree)
+      end
+
+      flattened_tree
+    end
+  end
+end

data/lib/jsonapi/resource_tree.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module JSONAPI
+
+  # A tree structure representing the resource structure of the requested resource(s). This is an intermediate structure
+  # used to keep track of the resources, by identity, found at different included relationships. It will be flattened and
+  # the resource instances will be fetched from the cache or the record store.
+  class ResourceTree
+
+    attr_reader :fragments, :related_resource_trees
+
+    # Gets the related Resource Id Tree for a relationship, and creates it first if it does not exist
+    #
+    # @param relationship [JSONAPI::Relationship]
+    #
+    # @return [JSONAPI::RelatedResourceTree] the new or existing resource id tree for the requested relationship
+    def get_related_resource_tree(relationship)
+      relationship_name = relationship.name.to_sym
+      @related_resource_trees[relationship_name] ||= RelatedResourceTree.new(relationship, self)
+    end
+
+    # Adds each Resource Fragment to the Resources hash
+    #
+    # @param fragments [Hash]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragments(fragments, include_related)
+      fragments.each_value do |fragment|
+        add_resource_fragment(fragment, include_related)
+      end
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      init_included_relationships(fragment, include_related)
+
+      @fragments[fragment.identity] = fragment
+    end
+
+    # Adds each Resource to the fragments hash
+    #
+    # @param resource [Hash]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resources(resources, include_related)
+      resources.each do |resource|
+        add_resource_fragment(JSONAPI::ResourceFragment.new(resource.identity, resource: resource), include_related)
+      end
+    end
+
+    # Adds a Resource to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource(resource, include_related)
+      add_resource_fragment(JSONAPI::ResourceFragment.new(resource.identity, resource: resource), include_related)
+    end
+
+    private
+
+    def init_included_relationships(fragment, include_related)
+      include_related && include_related.each_key do |relationship_name|
+        fragment.initialize_related(relationship_name)
+      end
+    end
+
+    def load_included(resource_klass, source_resource_tree, include_related, options)
+       include_related.try(:each_key) do |key|
+        relationship = resource_klass._relationship(key)
+        relationship_name = relationship.name.to_sym
+
+        find_related_resource_options = options.except(:filters, :sort_criteria, :paginator)
+        find_related_resource_options[:sort_criteria] = relationship.resource_klass.default_sort
+        find_related_resource_options[:cache] = resource_klass.caching?
+
+        related_fragments = resource_klass.find_included_fragments(source_resource_tree.fragments.values,
+                                                                   relationship_name,
+                                                                   find_related_resource_options)
+
+        related_resource_tree = source_resource_tree.get_related_resource_tree(relationship)
+        related_resource_tree.add_resource_fragments(related_fragments, include_related[key][:include_related])
+
+        # Now recursively get the related resources for the currently found resources
+        load_included(relationship.resource_klass,
+                      related_resource_tree,
+                      include_related[relationship_name][:include_related],
+                      options)
+      end
+    end
+
+    def add_resources_to_tree(resource_klass,
+                              tree,
+                              resources,
+                              include_related,
+                              source_rid: nil,
+                              source_relationship_name: nil,
+                              connect_source_identity: true)
+      fragments = {}
+
+      resources.each do |resource|
+        next unless resource
+
+        # fragments[resource.identity] ||= ResourceFragment.new(resource.identity, resource: resource)
+        # resource_fragment = fragments[resource.identity]
+        # ToDo: revert when not needed for testing
+        resource_fragment = if fragments[resource.identity]
+                              fragments[resource.identity]
+                            else
+                              fragments[resource.identity] = ResourceFragment.new(resource.identity, resource: resource)
+                              fragments[resource.identity]
+                            end
+
+        if resource.class.caching?
+          resource_fragment.cache = resource.cache_field_value
+        end
+
+        linkage_relationships = resource_klass.to_one_relationships_for_linkage(resource.class, include_related)
+        linkage_relationships.each do |relationship_name|
+          related_resource = resource.send(relationship_name)
+          resource_fragment.add_related_identity(relationship_name, related_resource&.identity)
+        end
+
+        if source_rid && connect_source_identity
+          resource_fragment.add_related_from(source_rid)
+          source_klass = source_rid.resource_klass
+          related_relationship_name = source_klass._relationships[source_relationship_name].inverse_relationship
+          if related_relationship_name
+            resource_fragment.add_related_identity(related_relationship_name, source_rid)
+          end
+        end
+      end
+
+      tree.add_resource_fragments(fragments, include_related)
+    end
+  end
+
+  class PrimaryResourceTree < ResourceTree
+
+    # Creates a PrimaryResourceTree with no resources and no related ResourceTrees
+    def initialize(fragments: nil, resources: nil, resource: nil, include_related: nil, options: nil)
+      @fragments ||= {}
+      @related_resource_trees ||= {}
+      if fragments || resources || resource
+        if fragments
+          add_resource_fragments(fragments, include_related)
+        end
+
+        if resources
+          add_resources(resources, include_related)
+        end
+
+        if resource
+          add_resource(resource, include_related)
+        end
+
+        complete_includes!(include_related, options)
+      end
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      fragment.primary = true
+      super(fragment, include_related)
+    end
+
+    def complete_includes!(include_related, options)
+      # ToDo: can we skip if more than one resource_klass found?
+      resource_klasses = Set.new
+      @fragments.each_key { |identity| resource_klasses << identity.resource_klass }
+
+      resource_klasses.each { |resource_klass| load_included(resource_klass, self, include_related, options)}
+
+      self
+    end
+  end
+
+  class RelatedResourceTree < ResourceTree
+
+    attr_reader :parent_relationship, :source_resource_tree
+
+    # Creates a RelatedResourceTree with no resources and no related ResourceTrees. A connection to the parent
+    # ResourceTree is maintained.
+    #
+    # @param parent_relationship [JSONAPI::Relationship]
+    # @param source_resource_tree [JSONAPI::ResourceTree]
+    #
+    # @return [JSONAPI::RelatedResourceTree] the new or existing resource id tree for the requested relationship
+    def initialize(parent_relationship, source_resource_tree)
+      @fragments ||= {}
+      @related_resource_trees ||= {}
+
+      @parent_relationship = parent_relationship
+      @parent_relationship_name = parent_relationship.name.to_sym
+      @source_resource_tree = source_resource_tree
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      init_included_relationships(fragment, include_related)
+
+      fragment.related_from.each do |rid|
+        @source_resource_tree.fragments[rid].add_related_identity(parent_relationship.name, fragment.identity)
+      end
+
+      if @fragments[fragment.identity]
+        @fragments[fragment.identity].related_from.merge(fragment.related_from)
+        fragment.related.each_pair do |relationship_name, rids|
+          if rids
+            @fragments[fragment.identity].merge_related_identities(relationship_name, rids)
+          end
+        end
+      else
+        @fragments[fragment.identity] = fragment
+      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.1.1'
+    VERSION = '0.2.0'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -1,81 +1,140 @@
+# frozen_string_literal: true
+
 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.positive? || @global_errors.length.positive?
+    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 +155,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