sanger-jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Processor
     include Callbacks
@@ -17,30 +19,6 @@ module JSONAPI
                                        :remove_to_one_relationship,
                                        :operation
 
-    class << self
-      def processor_instance_for(resource_klass, operation_type, params)
-        _processor_from_resource_type(resource_klass).new(resource_klass, operation_type, params)
-      end
-
-      def _processor_from_resource_type(resource_klass)
-        processor = resource_klass.name.gsub(/Resource$/,'Processor').safe_constantize
-        if processor.nil?
-          processor = JSONAPI.configuration.default_processor_klass
-        end
-
-        return processor
-      end
-
-      def transactional_operation_type?(operation_type)
-        case operation_type
-          when :find, :show, :show_related_resource, :show_related_resources
-            return false
-          else
-            return true
-        end
-      end
-    end
-
     attr_reader :resource_klass, :operation_type, :params, :context, :result, :result_options
 
     def initialize(resource_klass, operation_type, params)
@@ -66,93 +44,124 @@ module JSONAPI
     def find
       filters = params[:filters]
       include_directives = params[:include_directives]
-      sort_criteria = params.fetch(:sort_criteria, [])
+      sort_criteria = params[:sort_criteria]
       paginator = params[:paginator]
       fields = params[:fields]
+      serializer = params[:serializer]
 
       verified_filters = resource_klass.verify_filters(filters, context)
-      find_options = {
+
+      options = {
         context: context,
-        include_directives: include_directives,
         sort_criteria: sort_criteria,
         paginator: paginator,
-        fields: fields
+        fields: fields,
+        filters: verified_filters,
+        include_directives: include_directives
       }
 
-      resource_records = if params[:cache_serializer]
-        resource_klass.find_serialized_with_caching(verified_filters,
-                                                    params[:cache_serializer],
-                                                    find_options)
-      else
-        resource_klass.find(verified_filters, find_options)
-      end
+      resource_set = find_resource_set(include_directives, options)
+
+      resource_set.populate!(serializer, context, options)
 
-      page_options = {}
-      if (JSONAPI.configuration.top_level_meta_include_record_count ||
-        (paginator && paginator.class.requires_record_count))
-        page_options[:record_count] = resource_klass.find_count(verified_filters,
-                                                                context: context,
-                                                                include_directives: include_directives)
+      page_options = result_options
+      if (JSONAPI.configuration.top_level_meta_include_record_count || (paginator && paginator.class.requires_record_count))
+        page_options[:record_count] = resource_klass.count(verified_filters,
+                                                           context: context,
+                                                           include_directives: include_directives)
       end
 
-      if (JSONAPI.configuration.top_level_meta_include_page_count && page_options[:record_count])
+      if (JSONAPI.configuration.top_level_meta_include_page_count && paginator && page_options[:record_count])
         page_options[:page_count] = paginator ? paginator.calculate_page_count(page_options[:record_count]) : 1
       end
 
       if JSONAPI.configuration.top_level_links_include_pagination && paginator
-        page_options[:pagination_params] = paginator.links_page_params(page_options)
+        page_options[:pagination_params] = paginator.links_page_params(page_options.merge(fetched_resources: resource_set))
       end
 
-      return JSONAPI::ResourcesOperationResult.new(:ok, resource_records, page_options)
+      JSONAPI::ResourcesSetOperationResult.new(:ok, resource_set, page_options)
     end
 
     def show
       include_directives = params[:include_directives]
       fields = params[:fields]
       id = params[:id]
+      serializer = params[:serializer]
 
       key = resource_klass.verify_key(id, context)
 
-      find_options = {
+      options = {
         context: context,
-        include_directives: include_directives,
-        fields: fields
+        fields: fields,
+        filters: { resource_klass._primary_key => key },
+        include_directives: include_directives
       }
 
-      resource_record = if params[:cache_serializer]
-        resource_klass.find_by_key_serialized_with_caching(key,
-                                                           params[:cache_serializer],
-                                                           find_options)
-      else
-        resource_klass.find_by_key(key, find_options)
-      end
+      resource_set = find_resource_set(include_directives, options)
 
-      return JSONAPI::ResourceOperationResult.new(:ok, resource_record)
+      fail JSONAPI::Exceptions::RecordNotFound.new(id) if resource_set.resource_klasses.empty?
+      resource_set.populate!(serializer, context, options)
+
+      JSONAPI::ResourceSetOperationResult.new(:ok, resource_set, result_options)
     end
 
     def show_relationship
       parent_key = params[:parent_key]
       relationship_type = params[:relationship_type].to_sym
+      paginator = params[:paginator]
+      sort_criteria = params[:sort_criteria]
+      include_directives = params[:include_directives]
+      fields = params[:fields]
 
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
-      return JSONAPI::LinksObjectOperationResult.new(:ok,
-                                                     parent_resource,
-                                                     resource_klass._relationship(relationship_type))
+      options = {
+        context: context,
+        sort_criteria: sort_criteria,
+        paginator: paginator,
+        fields: fields,
+        include_directives: include_directives
+      }
+
+      resource_tree = find_related_resource_tree(
+        parent_resource,
+        relationship_type,
+        options,
+        nil
+      )
+
+      JSONAPI::RelationshipOperationResult.new(:ok,
+                                               parent_resource,
+                                               resource_klass._relationship(relationship_type),
+                                               resource_tree.fragments.keys,
+                                               result_options)
     end
 
     def show_related_resource
+      include_directives = params[:include_directives]
       source_klass = params[:source_klass]
       source_id = params[:source_id]
-      relationship_type = params[:relationship_type].to_sym
+      relationship_type = params[:relationship_type]
+      serializer = params[:serializer]
       fields = params[:fields]
 
-      # TODO Should fetch related_resource from cache if caching enabled
+      options = {
+        context: context,
+        fields: fields,
+        filters: {},
+        include_directives: include_directives
+      }
+
       source_resource = source_klass.find_by_key(source_id, context: context, fields: fields)
 
-      related_resource = source_resource.public_send(relationship_type)
+      resource_set = find_related_resource_set(source_resource,
+                                               relationship_type,
+                                               include_directives,
+                                               options)
+
+      resource_set.populate!(serializer, context, options)
 
-      return JSONAPI::ResourceOperationResult.new(:ok, related_resource)
+      JSONAPI::ResourceSetOperationResult.new(:ok, resource_set, result_options)
     end
 
     def show_related_resources
@@ -164,11 +173,12 @@ module JSONAPI
       paginator = params[:paginator]
       fields = params[:fields]
       include_directives = params[:include_directives]
+      serializer = params[:serializer]
 
-      source_resource ||= source_klass.find_by_key(source_id, context: context, fields: fields)
+      verified_filters = resource_klass.verify_filters(filters, context)
 
-      rel_opts = {
-        filters:  filters,
+      options = {
+        filters: verified_filters,
         sort_criteria: sort_criteria,
         paginator: paginator,
         fields: fields,
@@ -176,62 +186,66 @@ module JSONAPI
         include_directives: include_directives
       }
 
-      related_resources = nil
-      if params[:cache_serializer]
-        # TODO Could also avoid instantiating source_resource as actual Resource by
-        # allowing LinkBuilder to accept CachedResourceFragment as source in
-        # relationships_related_link
-        scope = source_resource.public_send(:"records_for_#{relationship_type}", rel_opts)
-        relationship = source_klass._relationship(relationship_type)
-        related_resources = relationship.resource_klass.find_serialized_with_caching(
-          scope,
-          params[:cache_serializer],
-          rel_opts
-        )
-      else
-        related_resources = source_resource.public_send(relationship_type, rel_opts)
-      end
+      source_resource = source_klass.find_by_key(source_id, context: context, fields: fields)
 
+      resource_set = find_related_resource_set(source_resource,
+                                               relationship_type,
+                                               include_directives,
+                                               options)
+
+      resource_set.populate!(serializer, context, options)
+
+      opts = result_options
       if ((JSONAPI.configuration.top_level_meta_include_record_count) ||
-          (paginator && paginator.class.requires_record_count) ||
-          (JSONAPI.configuration.top_level_meta_include_page_count))
-        related_resource_records = source_resource.public_send("records_for_" + relationship_type)
-        records = resource_klass.filter_records(filters, {},
-                                                related_resource_records)
+        (paginator && paginator.class.requires_record_count) ||
+        (JSONAPI.configuration.top_level_meta_include_page_count))
 
-        record_count = resource_klass.count_records(records)
+        opts[:record_count] = source_resource.class.count_related(
+          source_resource,
+          relationship_type,
+          options)
       end
 
-      if (JSONAPI.configuration.top_level_meta_include_page_count && record_count)
-        page_count = paginator.calculate_page_count(record_count)
+      if (JSONAPI.configuration.top_level_meta_include_page_count && opts[:record_count])
+        opts[:page_count] = paginator.calculate_page_count(opts[:record_count])
       end
 
-      pagination_params = if paginator && JSONAPI.configuration.top_level_links_include_pagination
-                            page_options = {}
-                            page_options[:record_count] = record_count if paginator.class.requires_record_count
-                            paginator.links_page_params(page_options)
-                          else
-                            {}
-                          end
-
-      opts = {}
-      opts.merge!(pagination_params: pagination_params) if JSONAPI.configuration.top_level_links_include_pagination
-      opts.merge!(record_count: record_count) if JSONAPI.configuration.top_level_meta_include_record_count
-      opts.merge!(page_count: page_count) if JSONAPI.configuration.top_level_meta_include_page_count
-
-      return JSONAPI::RelatedResourcesOperationResult.new(:ok,
-                                                          source_resource,
-                                                          relationship_type,
-                                                          related_resources,
-                                                          opts)
+      opts[:pagination_params] = if paginator && JSONAPI.configuration.top_level_links_include_pagination
+                                   page_options = {}
+                                   page_options[:record_count] = opts[:record_count] if paginator.class.requires_record_count
+                                   paginator.links_page_params(page_options.merge(fetched_resources: resource_set))
+                                 else
+                                   {}
+                                 end
+
+      JSONAPI::RelatedResourcesSetOperationResult.new(:ok,
+                                                      source_resource,
+                                                      relationship_type,
+                                                      resource_set,
+                                                      opts)
     end
 
     def create_resource
+      include_directives = params[:include_directives]
+      fields = params[:fields]
+      serializer = params[:serializer]
+
       data = params[:data]
       resource = resource_klass.create(context)
       result = resource.replace_fields(data)
 
-      return JSONAPI::ResourceOperationResult.new((result == :completed ? :created : :accepted), resource)
+      options = {
+        context: context,
+        fields: fields,
+        filters: { resource_klass._primary_key => resource.id },
+        include_directives: include_directives
+      }
+
+      resource_set = find_resource_set(include_directives, options)
+
+      resource_set.populate!(serializer, context, options)
+
+      JSONAPI::ResourceSetOperationResult.new((result == :completed ? :created : :accepted), resource_set, result_options)
     end
 
     def remove_resource
@@ -240,17 +254,33 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.remove
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def replace_fields
       resource_id = params[:resource_id]
+      include_directives = params[:include_directives]
+      fields = params[:fields]
+      serializer = params[:serializer]
+
       data = params[:data]
 
       resource = resource_klass.find_by_key(resource_id, context: context)
+
       result = resource.replace_fields(data)
 
-      return JSONAPI::ResourceOperationResult.new(result == :completed ? :ok : :accepted, resource)
+      options = {
+        context: context,
+        fields: fields,
+        filters: { resource_klass._primary_key => resource.id },
+        include_directives: include_directives
+      }
+
+      resource_set = find_resource_set(include_directives, options)
+
+      resource_set.populate!(serializer, context, options)
+
+      JSONAPI::ResourceSetOperationResult.new((result == :completed ? :ok : :accepted), resource_set, result_options)
     end
 
     def replace_to_one_relationship
@@ -261,7 +291,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.replace_to_one_link(relationship_type, key_value)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def replace_polymorphic_to_one_relationship
@@ -273,7 +303,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.replace_polymorphic_to_one_link(relationship_type, key_value, key_type)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def create_to_many_relationships
@@ -284,7 +314,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.create_to_many_links(relationship_type, data)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def replace_to_many_relationships
@@ -295,7 +325,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.replace_to_many_links(relationship_type, data)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def remove_to_many_relationships
@@ -312,7 +342,7 @@ module JSONAPI
           complete = false
         end
       end
-      return JSONAPI::OperationResult.new(complete ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(complete ? :no_content : :accepted, result_options)
     end
 
     def remove_to_one_relationship
@@ -322,7 +352,55 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.remove_to_one_link(relationship_type)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+    end
+
+    def result_options
+      options = {}
+      options[:warnings] = params[:warnings] if params[:warnings]
+      options
+    end
+
+    def find_resource_set(include_directives, options)
+      include_related = include_directives[:include_related] if include_directives
+
+      resource_tree = find_resource_tree(options, include_related)
+
+      JSONAPI::ResourceSet.new(resource_tree)
+    end
+
+    def find_related_resource_set(resource, relationship_name, include_directives, options)
+      include_related = include_directives[:include_related] if include_directives
+
+      resource_tree = find_resource_tree_from_relationship(resource, relationship_name, options, include_related)
+
+      JSONAPI::ResourceSet.new(resource_tree)
+    end
+
+    def find_resource_tree(options, include_related)
+      options[:cache] = resource_klass.caching?
+
+      fragments = resource_klass.find_fragments(options[:filters], options)
+      PrimaryResourceTree.new(fragments: fragments, include_related: include_related, options: options)
+    end
+
+    def find_related_resource_tree(parent_resource, relationship_name, options, include_related)
+      options = options.except(:include_directives)
+      options[:cache] = resource_klass.caching?
+
+      fragments = resource_klass.find_included_fragments([parent_resource], relationship_name, options)
+      PrimaryResourceTree.new(fragments: fragments, include_related: include_related, options: options)
+    end
+
+    def find_resource_tree_from_relationship(resource, relationship_name, options, include_related)
+      relationship = resource.class._relationship(relationship_name)
+
+      options = options.except(:include_directives)
+      options[:cache] = relationship.resource_klass.caching?
+
+      fragments = resource.class.find_related_fragments([resource], relationship_name, options)
+
+      PrimaryResourceTree.new(fragments: fragments, include_related: include_related, options: options)
     end
   end
 end

data/lib/jsonapi/relationship.rb

@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+require_relative 'compatibility_helper'
 module JSONAPI
   class Relationship
     attr_reader :acts_as_set, :foreign_key, :options, :name,
-                :class_name, :polymorphic, :always_include_linkage_data,
-                :parent_resource, :eager_load_on_include
+                :class_name, :polymorphic, :always_include_optional_linkage_data,
+                :parent_resource, :eager_load_on_include, :custom_methods,
+                :inverse_relationship, :allow_include
+
+    attr_writer :allow_include
+
+    attr_accessor :_routed, :_warned_missing_route
 
     def initialize(name, options = {})
       @name = name.to_s
@@ -12,22 +19,66 @@ module JSONAPI
       @parent_resource = options[:parent_resource]
       @relation_name = options.fetch(:relation_name, @name)
       @polymorphic = options.fetch(:polymorphic, false) == true
-      @always_include_linkage_data = options.fetch(:always_include_linkage_data, false) == true
+      @polymorphic_types = options[:polymorphic_types]
+      if options[:polymorphic_relations]
+        JSONAPI::CompatibilityHelper.deprecation_warn('Use polymorphic_types instead of polymorphic_relations')
+        @polymorphic_types ||= options[:polymorphic_relations]
+      end
+
+      @always_include_optional_linkage_data = options.fetch(:always_include_optional_linkage_data, false) == true
       @eager_load_on_include = options.fetch(:eager_load_on_include, true) == true
+      @allow_include = options[:allow_include]
+      @class_name = nil
+      @inverse_relationship = nil
+
+      @_routed = false
+      @_warned_missing_route = false
+
+      exclude_links(options.fetch(:exclude_links, JSONAPI.configuration.default_exclude_links))
+
+      # Custom methods are reserved for future use
+      @custom_methods = options.fetch(:custom_methods, {})
     end
 
     alias_method :polymorphic?, :polymorphic
+    alias_method :parent_resource_klass, :parent_resource
 
     def primary_key
+      # :nocov:
       @primary_key ||= resource_klass._primary_key
+      # :nocov:
     end
 
     def resource_klass
-      @resource_klass ||= @parent_resource.resource_for(@class_name)
+      @resource_klass ||= @parent_resource.resource_klass_for(@class_name)
     end
 
     def table_name
+      # :nocov:
       @table_name ||= resource_klass._table_name
+      # :nocov:
+    end
+
+    def self.polymorphic_types(name)
+      @poly_hash ||= {}.tap do |hash|
+        ObjectSpace.each_object do |klass|
+          next unless Module === klass
+          if ActiveRecord::Base > klass
+            klass.reflect_on_all_associations(:has_many).select{|r| r.options[:as] }.each do |reflection|
+              (hash[reflection.options[:as]] ||= []) << klass.name.downcase
+            end
+          end
+        end
+      end
+      @poly_hash[name.to_sym]
+    end
+
+    def resource_types
+      if polymorphic? && belongs_to?
+        @polymorphic_types ||= self.class.polymorphic_types(@relation_name).collect {|t| t.pluralize}
+      else
+        [resource_klass._type.to_s.pluralize]
+      end
     end
 
     def type
@@ -47,17 +98,35 @@ module JSONAPI
       end
     end
 
-    def type_for_source(source)
-      if polymorphic?
-        resource = source.public_send(name)
-        resource.class._type if resource
-      else
-        type
+    def belongs_to?
+      # :nocov:
+      false
+      # :nocov:
+    end
+
+    def readonly?
+      @options[:readonly]
+    end
+
+    def exclude_links(exclude)
+      case exclude
+        when :default, "default"
+          @_exclude_links = [:self, :related]
+        when :none, "none"
+          @_exclude_links = []
+        when Array
+          @_exclude_links = exclude.collect {|link| link.to_sym}
+        else
+          fail "Invalid exclude_links"
       end
     end
 
-    def belongs_to?
-      false
+    def _exclude_links
+      @_exclude_links ||= []
+    end
+
+    def exclude_link?(link)
+      _exclude_links.include?(link.to_sym)
     end
 
     class ToOne < Relationship
@@ -68,27 +137,89 @@ module JSONAPI
         @class_name = options.fetch(:class_name, name.to_s.camelize)
         @foreign_key ||= "#{name}_id".to_sym
         @foreign_key_on = options.fetch(:foreign_key_on, :self)
+        if parent_resource
+          @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type)
+        end
+      end
+
+      def to_s
+        # :nocov: useful for debugging
+        "#{parent_resource}.#{name}(#{belongs_to? ? 'BelongsToOne' : 'ToOne'})"
+        # :nocov:
       end
 
       def belongs_to?
+        # :nocov:
         foreign_key_on == :self
+        # :nocov:
       end
 
       def polymorphic_type
         "#{name}_type" if polymorphic?
       end
+
+      def include_optional_linkage_data?
+        @always_include_optional_linkage_data || JSONAPI::configuration.always_include_to_one_linkage_data
+      end
+
+      def allow_include?(context = nil)
+        strategy = if @allow_include.nil?
+                     JSONAPI.configuration.default_allow_include_to_one
+                   else
+                     @allow_include
+                   end
+
+        if !!strategy == strategy #check for boolean
+          return strategy
+        elsif strategy.is_a?(Symbol) || strategy.is_a?(String)
+          parent_resource.send(strategy, context)
+        else
+          strategy.call(context)
+        end
+      end
     end
 
     class ToMany < Relationship
-      attr_reader :reflect, :inverse_relationship
+      attr_reader :reflect
 
       def initialize(name, options = {})
         super
         @class_name = options.fetch(:class_name, name.to_s.camelize.singularize)
         @foreign_key ||= "#{name.to_s.singularize}_ids".to_sym
         @reflect = options.fetch(:reflect, true) == true
-        @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type.to_s.singularize.to_sym) if parent_resource
+        if parent_resource
+          @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type.to_s.singularize.to_sym)
+        end
+      end
+
+      def to_s
+        # :nocov: useful for debugging
+        "#{parent_resource}.#{name}(ToMany)"
+        # :nocov:
+      end
+
+      def include_optional_linkage_data?
+        # :nocov:
+        @always_include_optional_linkage_data || JSONAPI::configuration.always_include_to_many_linkage_data
+        # :nocov:
       end
+
+      def allow_include?(context = nil)
+        strategy = if @allow_include.nil?
+                     JSONAPI.configuration.default_allow_include_to_many
+                   else
+                     @allow_include
+                   end
+
+        if !!strategy == strategy #check for boolean
+          return strategy
+        elsif strategy.is_a?(Symbol) || strategy.is_a?(String)
+          parent_resource.send(strategy, context)
+        else
+          strategy.call(context)
+        end
+      end
+
     end
   end
 end