jsonapi-resources 0.9.12 → 0.10.0.beta1

data/lib/jsonapi/resource_set.rb

@@ -0,0 +1,108 @@
+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)
+      @populated = false
+      @resource_klasses = flatten_resource_id_tree(resource_id_tree)
+    end
+
+    def populate!(serializer, context, find_options)
+      @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
+        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].each_pair 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])])
+          end
+
+          found_resources = CachedResponseFragment.fetch_cached_fragments(
+              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
+        else
+          missed_ids = @resource_klasses[resource_klass].keys
+        end
+
+        # fill in any missed resources
+        unless missed_ids.empty?
+          filters = {resource_klass._primary_key => missed_ids}
+          find_opts = {
+              context: context,
+              fields: find_options[:fields] }
+
+          found_resources = resource_klass.find(filters, 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
+          end
+        end
+      end
+      @populated = true
+      self
+    end
+
+    private
+    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/version.rb

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

data/lib/jsonapi/response_document.rb

@@ -1,86 +1,133 @@
 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]
-              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
-            links[link_name] = link unless link.blank?
+    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]
+            @top_level_links[link_name] = serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
+          else
+            @top_level_links[link_name] = serializer.query_link(query_params(params))
           end
         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)
@@ -101,40 +148,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::RelationshipOperationResult
-            @serializer.serialize_to_relationship_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,13 +18,7 @@ module ActionDispatch
 
         def jsonapi_resource(*resources, &_block)
           @resource_type = resources.first
-          res = JSONAPI::Resource.resource_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
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
 
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
@@ -39,8 +33,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
 
@@ -70,7 +64,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)
@@ -84,13 +78,7 @@ module ActionDispatch
 
         def jsonapi_resources(*resources, &_block)
           @resource_type = resources.first
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
-
-          res._routed = true
-
-          if res.singleton?
-            warn "Singleton resource #{res} should use `jsonapi_resource` instead."
-          end
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
 
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
@@ -114,8 +102,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
 
@@ -159,28 +147,24 @@ 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],
-                  as: "relationships/#{link_type}"
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
           end
 
           if res.mutable?
             if methods.include?(:update)
-              match "relationships/#{formatted_relationship_name}",
-                    controller: options[:controller],
+              match "relationships/#{formatted_relationship_name}", controller: options[:controller],
                     action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
-              match "relationships/#{formatted_relationship_name}",
-                    controller: options[:controller],
+              match "relationships/#{formatted_relationship_name}", controller: options[:controller],
                     action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
@@ -191,15 +175,14 @@ 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],
-                  as: "relationships/#{link_type}"
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
           end
 
           if res.mutable?
@@ -221,47 +204,41 @@ module ActionDispatch
         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],
-                as: "related/#{relationship_name}"
+                action: 'show_related_resource', via: [:get]
         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],
-                as: "related/#{relationship_name}"
+                action: 'index_related_resources', via: [:get]
         end
 
         protected
@@ -274,6 +251,7 @@ module ActionDispatch
           @scope = @scope.parent
         end
         # :nocov:
+
         private
 
         def resource_type_with_module_prefix(resource = nil)